V0.2.5

1、验证成完成了音量计算、一致性对比功能，噪音检测功能还未完成

SQL/ACAServer.sql

@@ -1,4 +1,4 @@
--- Active: 1749101595433@@192.1.2.61@5236@EQM_CESHI
+-- Active: 1752718919967@@192.1.2.61@5236
 
 
 #对比项
@@ -22,9 +22,6 @@ FROM tACADetectPeriod;
 
 
 
-
-
-
 #记录文件
 SELECT *
 FROM tACARecordFile;
@@ -63,4 +60,6 @@ FROM tACAAlarmLog
 
 #报警文件信息
 SELECT *
-FROM tACAAlarmFile;
+FROM tACAAlarmFile;
+
+

Server/ACAServer.cpp

@@ -92,6 +92,15 @@ bool ACAServer::initGlobalInfo()
     /* 初始化全局参数信息 */
     GInfo.initGlobalInfo();
 
+    /*------------------------------------------------------------------------------------*/
+    SPDLOG_LOGGER_INFO(m_logger, "=========================================================================================");
+    /* 打印一些基础参数 */
+    SPDLOG_LOGGER_INFO(m_logger, "MQTT服务器地址: {}, 端口: {}", m_mqttIP.toStdString(), m_mqttPort);
+    SPDLOG_LOGGER_INFO(m_logger, "WebAPI地址: {}, ID: {}", m_webAPIUrl.toStdString(), m_webAPIID.toStdString());
+    SPDLOG_LOGGER_INFO(m_logger, "录音参数: ");
+    SPDLOG_LOGGER_INFO(m_logger, "      采样率: {}, 通道数: {}, 位深: {}", 
+                        GInfo.m_sampleRate, GInfo.m_numChannels, GInfo.m_bitsPerSample);
+    SPDLOG_LOGGER_INFO(m_logger, "=========================================================================================");
 
     return true;
 }
@@ -132,6 +141,15 @@ bool ACAServer::readConfigFile()
     m_mqttPort = settings.value("MQTT_PORT", 1883).toInt();
     settings.endGroup();
 
+    settings.beginGroup("Audio");
+    int sampleRate = settings.value("SampleRate", 48000).toInt();
+    int channelCount = settings.value("ChannelCount", 1).toInt();
+    int bitDepth = settings.value("BitDepth", 16).toInt();
+    settings.endGroup();
+    GInfo.m_sampleRate = sampleRate;
+    GInfo.m_numChannels = channelCount;
+    GInfo.m_bitsPerSample = bitDepth;
+
     return true;
 }
 

Server/DataStruct/CompareResult.cpp

@@ -58,7 +58,7 @@ CompareResult_t& CompareResult_t::operator=(const CompareResult_t &obj)
     compareItemName = obj.compareItemName;
     isClientAlarm = obj.isClientAlarm;
     dateTime = obj.dateTime;
-    vecRoadVolumes = obj.vecRoadVolumes;
+    mapRoadVolumes = obj.mapRoadVolumes;
 
     return *this;
 }

Server/DataStruct/CompareResult.h

@@ -47,7 +47,7 @@ struct CompareResult_t
     std::string compareItemName;                /* 对比项名称 */
     bool isClientAlarm = false;                 /* 是否客户端报警 */
     QDateTime dateTime;                         /* 对比时间 */
-    std::vector<OneRoadVolume_t> vecRoadVolumes;/* 录音通道音量包列表 */
+    std::map<int, OneRoadVolume_t> mapRoadVolumes;/* 录音通道音量包列表 */
 
     CompareResult_t() = default;
     ~CompareResult_t() = default;

Server/GlobalInfo/GlobalInfo.cpp

@@ -70,18 +70,26 @@ void GlobalInfo::initDirectories()
 /* 初始化默认数据 */
 void GlobalInfo::initData()
 {
-    m_sampleRate = 48000;          /* 采样率 */
-    m_numChannels = 2;             /* 声道数 */
-    m_bitsPerSample = 16;          /* 每个采样点的位数 */
-    m_oneSecondCount = m_sampleRate * m_numChannels * 2; /* 48khz * 2字节/采样点 * 2声道 */
-    m_wavFileDuration = 60;        /* 默认是1分钟数据 */
+    // m_sampleRate = 48000;          /* 采样率 */
+    // m_numChannels = 2;             /* 声道数 */
+    // m_bitsPerSample = 16;          /* 每个采样点的位数 */
+    // m_oneSecondCount = m_sampleRate * m_numChannels * 2; /* 48khz * 2字节/采样点 * 2声道 */
+    // m_wavFileDuration = 60;        /* 默认是1分钟数据 */
 
     /* 初始化环形队列元素数目 */
-    m_queueElementCount = 180;    /* 默认是3分钟数据 */
+    // m_queueElementCount = 180;    /* 默认是3分钟数据 */
 
     /* 噪音检测元素的大小，默认是2秒 */
-    m_noiseElementDuration = 2;
+    // m_noiseElementDuration = 2;
 
-    m_pcmErrorPercent = 10;         /* 音频不对称百分比 */
-    m_pcmLessPercent = 0;           /* 音频少于百分比，默认不开放这个功能 */
+    /* 平均音量计算所需要的秒数 */
+    // m_avgDBCalculateSeconds = 5;   /* 默认计算音量的平均值是5秒 */
+
+    // m_pcmErrorPercent = 10;         /* 音频不对称百分比 */
+    // m_pcmLessPercent = 0;           /* 音频少于百分比，默认不开放这个功能 */
+
+    /* 静音、过载、反相灵敏度，不知道为什么还要这里设置一个，在对比项参数里已经有这方面的东西了 */
+    // m_silentSensitivity = 100;
+    // m_iPhaseSensitivity = 100;
+    // m_overloadSensitivity = 100;
 }

Server/GlobalInfo/GlobalInfo.h

@@ -28,7 +28,7 @@ class ReadConfig;
 
 class GlobalInfo
 {
-    friend class ReadConfig; // 允许ReadConfig访问私有成员
+    friend class ACAServer; // 允许ReadConfig访问私有成员
     GlobalInfo() = default;
     GlobalInfo(const GlobalInfo&) = delete; // 禁止拷贝构造
     GlobalInfo& operator=(const GlobalInfo&) = delete; // 禁止赋值操作
@@ -65,7 +65,7 @@ public:
     /* 获取环形队列元素数目 */
     int32_t queueElementCount() const {return m_queueElementCount;}
     /* 获取一秒音频字节大小 */
-    int32_t oneSecondCount() const {return m_oneSecondCount;}
+    // int32_t oneSecondCount() const {return m_oneSecondCount;}
     /* 获取wav文件时长 */
     int32_t wavFileDuration() const {return m_wavFileDuration;}
     /* 获取噪音检测元素大小，单位：秒 */
@@ -157,11 +157,10 @@ private:
     uint16_t m_bitsPerSample = 16;              /* 每个采样点的位数 */
 
     /******************** 一些默认的设置 *********************/
-    int32_t m_oneSecondCount = 0;              /* 这里使用一秒音频的字节个数 */
-    int32_t m_queueElementCount = 0;           /* 默认缓冲区的大小，也就是音频处理线程的环形队列的大小，单位是秒 */
-    int32_t m_wavFileDuration = 0;             /* 一个wav小文件有多少秒的数据 */
-    int32_t m_noiseElementDuration = 0;        /* 噪音检测元素大小，单位：秒 */
-    // int32_t m_DBQueueElementCount = 180;       /* 计算音量和反相的环形队列元素数目 */
+    // int32_t m_oneSecondCount = 0;              /* 这里使用一秒音频的字节个数 */
+    int32_t m_queueElementCount = 180;          /* 默认缓冲区的大小，也就是音频处理线程的环形队列的大小，单位是秒 */
+    int32_t m_wavFileDuration = 60;             /* 一个wav小文件有多少秒的数据 */
+    int32_t m_noiseElementDuration = 2;         /* 噪音检测元素大小，单位：秒 */
 
     /* 相关的文件夹 */
     const QString m_dirWav = "WAV";             /* wav文件存储目录 */
@@ -175,7 +174,7 @@ private:
     // QString m_configPath;                       /* 配置文件存储路径 */
 
     /* 比对计算相关参数 */
-    int m_pcmErrorPercent = 0;                  /* PCM数据不对称少于多少百分比，就判断为噪音，0表示不判断 */
+    int m_pcmErrorPercent = 10;                 /* PCM数据不对称少于多少百分比，就判断为噪音，0表示不判断 */
     int m_pcmLessPercent = 0;                   /* PCM数据少于多少百分比，就判断为噪音，0表示不用这个算法判断噪音 */
 
     /* 偏移量，通道1和通道2可能会有偏移，如果通道1是发射出去，通道2是结束过来，之间可能会有
@@ -186,12 +185,12 @@ private:
 
     
     /* 静音反相过载相关参数 */
-    int m_silentSensitivity;                    /* 静音灵敏度 */
-    int m_iPhaseSensitivity;                    /* 反相灵敏度 */
-    int m_overloadSensitivity;                  /* 过载灵敏度 */
+    int m_silentSensitivity = 100;              /* 静音灵敏度 */
+    int m_iPhaseSensitivity = 100;              /* 反相灵敏度 */
+    int m_overloadSensitivity = 100;            /* 过载灵敏度 */
 
-    int m_calculateDataSeconds;                 /* 一致性、静音、反相等计算所需要的秒数 */
-    int m_avgDBCalculateSeconds = 0;            /* 平均音量计算所需要的秒数 */
+    int m_calculateDataSeconds = 0;             /* 一致性、静音、反相等计算所需要的秒数 */
+    int m_avgDBCalculateSeconds = 5;            /* 平均音量计算所需要的秒数 */
     int m_sinSeconds = 0;                       /* 正弦波计算所需要的时长，单位秒 */
     int m_sinEffectiveNum = 0;                  /* 正弦波有效数据个数，比这个数字大就表示是正弦波，最大30 */
 
@@ -205,20 +204,20 @@ private:
     bool m_isAINotConsistencyAlone = false;
     /* 因为音频播放存在时间偏移，判断两个都是静音，或者判断一个静音一个非静音时，
      * 需要有延时时间(次数)，CalcRefreshDataThread线程一秒一次 */
-    int m_nIsSameBothMinDBWaitNum;
+    int m_nIsSameBothMinDBWaitNum = 3;
 
     // 一致性对比时间间隔（单位毫秒）；8000采样时建议1000毫秒，48000采样时建议3000；DoubleCompare比较时时间会自动翻倍
-    int m_nCompareTimeSpan = 0;
+    int m_nCompareTimeSpan = 2000;
 
     /******************** AI比对参数（动态库比对参数） *********************/
     // AI对比持续次数
-    int m_nAICMPThresholdNum;
+    int m_nAICMPThresholdNum = 3;
     // AI对比相似度阀值，比这个阀值小，就表示不一致性
-    float m_fAICMPThresholdNot;
+    float m_fAICMPThresholdNot = 0.6;
     // 音频错位百分比(比如0.5就是错位不能超过一半，超过一半判断为不一致)：
-    float m_fAICMPOffset;
+    float m_fAICMPOffset = 0.5;
     // AI对比相似度阀值，比这个阀值大，就表示一致性
-    float m_fAICMPThreshold;
+    float m_fAICMPThreshold = 0.7;
 
     
 };

Server/ThreadCalculate/BaseCalculateThread.cpp

@@ -4,10 +4,10 @@
 BaseCalculateThread::BaseCalculateThread(CalculateThreadInfo_t& threadInfo)
     : m_threadInfo(threadInfo)
 {
-    m_logger = spdlog::get("ACAServer");
+    m_logger = spdlog::get("Calculate");
     if (m_logger == nullptr)
     {
-        fmt::print("没有名为“ACAServer”的记录器\n");
+        fmt::print("BaseCalculateThread: Calculate Logger not found.\n");
         return;
     }
 

Server/ThreadCalculate/CalculateDBThread.cpp

@@ -31,7 +31,7 @@ bool CalculateDBThread::getlastVolumeInfo(OneRoadVolume_t& volumeInfo)
     std::lock_guard<std::mutex> lock(m_mutexVolumeInfo);
     if(m_caculateDBData.ringQueue.isEmpty())
     {
-        SPDLOG_LOGGER_ERROR(m_logger, "{} 获取最新的音量数据失败，环形队列为空", m_logBase);
+        // SPDLOG_LOGGER_TRACE(m_logger, "{} 获取最新的音量数据，环形队列为空", m_logBase);
         return false; // 环形队列为空，无法获取最新数据
     }
     /* 根据时间判断是否是最新的 */
@@ -45,6 +45,9 @@ bool CalculateDBThread::getlastVolumeInfo(OneRoadVolume_t& volumeInfo)
     memcpy(volumeInfo.vecleftDB, m_roadVolumeInfo.vecleftDB, VOLUME_INFO_NUM);
     memcpy(volumeInfo.vecrightDB, m_roadVolumeInfo.vecrightDB, VOLUME_INFO_NUM);
 
+    /* 更新时间 */
+    volumeInfo.dateTime = m_roadVolumeInfo.dateTime;
+
     return true;
 }
 
@@ -69,13 +72,12 @@ const AlarmInfo_t& CalculateDBThread::getAlarm(EAlarmType alarmType)
 /* 线程功能函数 */
 void CalculateDBThread::task()
 {
-    SPDLOG_LOGGER_INFO(m_logger, "{} 开启计算静音、过载和反相等报警的线程", m_logBase);
     /* 初始化数据 */
     if(!initData())
     {
         return;
     }
-
+    SPDLOG_LOGGER_INFO(m_logger, " ****************** {} 开启计算静音、过载和反相等报警的线程 ****************** ", m_logBase);
     while(m_isRunning)
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -102,30 +104,70 @@ void CalculateDBThread::task()
     /* 清理数据 */
     clearData();
 
-    SPDLOG_LOGGER_INFO(m_logger, "{} 计算静音、过载和反相等报警的线程结束", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ****************** {} 计算静音、过载和反相等报警的线程结束 ****************** ", m_logBase);
 }
 
 /* 初始化数据 */
 bool CalculateDBThread::initData()
 {
+    m_logBase = fmt::format("对比项: {}, 通道: {}",
+                            m_threadInfo.compareItemInfo.strName.toStdString(),
+                            m_threadInfo.compareItemInfo.mapRoad.begin().value().strCompareRoadName.toStdString());
     /* 对于单个录音通道的线程来说，直接取map中的第一个通道 */
     auto begin = m_threadInfo.compareItemInfo.mapRoad.begin();
     m_roadInfo = begin.value(); // 获取第一个通道的信息
     m_roadName = m_roadInfo.strCompareRoadName.toStdString();
 
-    m_threadCreateDBPhase = ThreadMan.getCreateDBThread(m_roadInfo.scRoadInfo.nSoundCardNum, m_roadInfo.scRoadInfo.roadInfo.nRoadNum);
+    /* 获取线程，设置10秒超时 */
+    auto m_startTime = std::chrono::steady_clock::now(); // 记录开始时间
+    while(true)
+    {
+        m_threadCreateDBPhase = ThreadMan.getCreateDBThread(m_roadInfo.scRoadInfo.nSoundCardNum, m_roadInfo.scRoadInfo.roadInfo.nRoadNum);
+        if(m_threadCreateDBPhase != nullptr)
+        {
+            break; // 获取到线程，跳出循环
+        }
+        /* 超过10秒还没有获取到线程，返回失败 */
+        if(std::chrono::steady_clock::now() - m_startTime > std::chrono::seconds(10))
+        {
+            break;
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        
+    }
     if (m_threadCreateDBPhase == nullptr)
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 获取创建音量线程失败", m_logBase);
         return false;
     }
-
+    
+    /* 初始化参数，这些参数从外面传进来的 */
     m_avgCalculateDBSeconds = GInfo.avgDBCalculateSeconds();
     
     m_numQueueSeconds = GInfo.queueElementCount();
     m_caculateDBData.ringQueue.setQueueCapacity(m_numQueueSeconds);
 
 
+    /* 设置静音、过载、反相的计算参数 */
+    const auto& silentParam = m_threadInfo.compareItemInfo.paramMute;
+    m_volumeParam.SetSilentSwitch(silentParam.isEnable);
+    m_volumeParam.SetSilentDuration(silentParam.nLen);
+    m_volumeParam.SetSilentThreshold(silentParam.threshold.nThreshold);
+    m_volumeParam.SetSilentSensitivity(silentParam.nSensitivity);
+
+    const auto& overloadParam = m_threadInfo.compareItemInfo.paramOverload;
+    m_volumeParam.SetOverloadSwitch(overloadParam.isEnable);
+    m_volumeParam.SetOverloadDuration(overloadParam.nLen);
+    m_volumeParam.SetOverloadThreshold(overloadParam.threshold.nThreshold);
+    m_volumeParam.SetOverloadSensitivity(overloadParam.nSensitivity);
+
+    const auto& phaseParam = m_threadInfo.compareItemInfo.paramPhase;
+    m_volumeParam.SetPhaseSwitch(phaseParam.isEnable);
+    m_volumeParam.SetPhaseDuration(phaseParam.nLen);
+    m_volumeParam.SetPhaseThreshold(phaseParam.threshold.dThreshold);
+    m_volumeParam.SetPhaseSensitivity(phaseParam.nSensitivity);
+
+
     return true;
 }
 
@@ -159,6 +201,10 @@ void CalculateDBThread::calcuDBPhase()
     
     /* 处理报警信息 */
     processAlarm();
+
+    /* 更新时间信息 */
+    m_roadVolumeInfo.dateTime = m_currSecondData.startTime;
+
     m_mutexVolumeInfo.unlock();
 }
 
@@ -174,7 +220,7 @@ void CalculateDBThread::calcuDBPhase()
 void CalculateDBThread::processAlarm()
 {
     /* ----------------------- 处理静音报警 ----------------------- */
-    processAlarm();
+    processSilence();
     /* ----------------------- 处理过载报警 ----------------------- */
     processOverload();
     /* ----------------------- 处理反相报警 ----------------------- */

Server/ThreadCalculate/CalculateDBThread.h

@@ -29,7 +29,7 @@ public:
     ~CalculateDBThread() override;
 
     /* 获取线程通道信息 */
-    CompareItemRoadInfo_t getRoadInfo() const { return m_roadInfo; }
+    const CompareItemRoadInfo_t& getRoadInfo() const { return m_roadInfo; }
 
     /* 获取结果，这个线程计算出静音、过载、反相和音量包信息 */
     OneRoadVolume_t getVolumeInfo();
@@ -70,7 +70,7 @@ private:
     OneRoadVolume_t m_roadVolumeInfo;                       /* 一个录音通道的音量信息这个是计算结果 */
 
     /* 生成音量的线程 */
-    CreateDBThread* m_threadCreateDBPhase = nullptr;   /* 生成音量的线程 */
+    CreateDBThread* m_threadCreateDBPhase = nullptr;        /* 生成音量的线程 */
     OneSecondData m_currSecondData;                         /* 最新一秒的数据 */
     StVolumeParam m_volumeParam;                            /* 音量计算的参数 */
 

Server/ThreadCalculate/CompareDoubleThread.cpp

@@ -6,7 +6,7 @@
 #include "GlobalInfo.h"
 #include "ThreadManager.h"
 #include "ConsistencyCompareThread.h"
-
+#include "ThreadPool.h"
 
 
 
@@ -62,6 +62,7 @@ void CompareDoubleThread::task()
         SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
         return;
     }
+    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 计算一致性对比的线程开始运行 ******************* ", m_logBase);
     while(m_isRunning)
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -71,16 +72,21 @@ void CompareDoubleThread::task()
         {
             continue; // 数据不足，继续等待
         }
+        // SPDLOG_LOGGER_INFO(m_logger, "{} 更新数据成功，开始计算音量数据", m_logBase);
         
-        /* 计算音量和反相数据 */
+        /* 计算音量数据 */
         calculateData();
 
-        /* 保存结果 */
+        /* 保存结果，结果已经在上面那个函数中保存了 */
+
+        /* 清除标志位 */
+        m_isUpdated1 = false;
+        m_isUpdated2 = false;
     }
 
     /* 清理数据 */
     clearData();
-    SPDLOG_LOGGER_INFO(m_logger, "{} 计算双通道对比的线程结束", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 计算双通道对比的线程结束 ******************* ", m_logBase);
     m_threadInfo.threadState = EThreadState::State_Stopped; // 更新线程状态
 }
 
@@ -101,9 +107,10 @@ bool CompareDoubleThread::initData()
     m_logBase = fmt::format("{} 对比项: {}:{} - {}:{}", m_threadInfo.compareItemInfo.strName.toStdString(), 
                                 m_roadInfo1.strSoundCardName.toStdString(), m_roadInfo1.roadInfo.nRoadNum, 
                                 m_roadInfo2.strSoundCardName.toStdString(), m_roadInfo2.roadInfo.nRoadNum);
+    
 
     m_offsetMSeconds = GInfo.offsetMSeconds(); // 获取偏移量
-    m_calculateSeconds = GInfo.calculateDataSeconds(); // 获取计算需要的秒数
+    // m_calculateSeconds = GInfo.calculateDataSeconds(); // 获取计算需要的秒数
     m_avgDBCalculateSeconds = GInfo.avgDBCalculateSeconds(); // 获取计算平均音量所需要的时长
     m_silentThreshold = GInfo.silentThreshold(); // 获取静音阈值
     m_sinSeconds = GInfo.sinSeconds(); // 获取正弦波计算所需要的时长
@@ -111,16 +118,46 @@ bool CompareDoubleThread::initData()
     m_isAINotConsistencyAlone = GInfo.isAINotConsistencyAlone(); // 获取杭州台是否按上面的逻辑来
     m_nIsSameBothMinDBWaitNum = GInfo.nIsSameBothMinDBWaitNum(); // 获取是否需要等待静音状态
 
-    /* 获取生成音量的线程 */
-    m_threadCreateDBPhase1 = ThreadMan.getCreateDBThread(m_roadInfo1.nSoundCardNum, m_roadInfo1.roadInfo.nRoadNum);
-    m_threadCreateDBPhase2 = ThreadMan.getCreateDBThread(m_roadInfo2.nSoundCardNum, m_roadInfo2.roadInfo.nRoadNum);
-    if(m_threadCreateDBPhase1 == nullptr || m_threadCreateDBPhase2 == nullptr)
+    /* 获取生成音量的线程，循环等待获取 */
+    auto startTime = std::chrono::steady_clock::now(); // 记录开始时间
+    while(true)
+    {
+        if(m_threadCreateDB1 == nullptr)
+        {
+            m_threadCreateDB1 = ThreadMan.getCreateDBThread(m_roadInfo1.nSoundCardNum, m_roadInfo1.roadInfo.nRoadNum);
+        }
+        if(m_threadCreateDB2 == nullptr)
+        {
+            m_threadCreateDB2 = ThreadMan.getCreateDBThread(m_roadInfo2.nSoundCardNum, m_roadInfo2.roadInfo.nRoadNum);
+        }
+        if(m_threadCreateDB1 != nullptr && m_threadCreateDB2 != nullptr)
+        {
+            break; // 获取到两个线程，跳出循环
+        }
+        /* 超过10秒还没有获取到线程，返回失败 */
+        if(std::chrono::steady_clock::now() - startTime > std::chrono::seconds(10))
+        {
+            SPDLOG_LOGGER_ERROR(m_logger, "{} 获取生成音量的线程超时",  m_logBase);
+            return false;
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+    
+    if(m_threadCreateDB1 == nullptr || m_threadCreateDB2 == nullptr)
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 获取生成音量的线程失败", m_logBase);
         return false;
     }
-    /* 获取一致性比较的线程 */
-    m_pConsistencyCompareThread = ThreadMan.getConsistencyCompareThread(m_roadInfo1, m_roadInfo2);
+    
+    /* 创建一致性比较的线程 */
+    m_pConsistencyCompareThread = new ConsistencyCompareThread(m_threadInfo);
+    if(m_pConsistencyCompareThread == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "{} 创建一致性比较线程失败", m_logBase);
+        return false;
+    }
+    CPPTP.add_task(&ConsistencyCompareThread::threadTask, m_pConsistencyCompareThread);
+
 
     return true;
 }
@@ -128,42 +165,51 @@ bool CompareDoubleThread::initData()
 /* 清理数据 */
 void CompareDoubleThread::clearData()
 {
-
+    if(m_pConsistencyCompareThread != nullptr)
+    {
+        m_pConsistencyCompareThread->stopThreadBlock(); // 停止线程
+        delete m_pConsistencyCompareThread; 
+        m_pConsistencyCompareThread = nullptr;
+    }
 }
 
 /* 更新数据 */
 bool CompareDoubleThread::updateData()
 {
-    /* 获取一致性线程计算的结果 */
-    m_consistencyResult = m_pConsistencyCompareThread->getConsistencyResult();
-    
-
     /* 获取原始的音量值 */
     if(m_isUpdated1 == false)
     {
-        if(m_threadCreateDBPhase1->getLatestResult(m_localData1.ringQueue) == false)
+        if(m_threadCreateDB1->getLatestResult(m_localData1.ringQueue) == false)
         {
-            SPDLOG_LOGGER_DEBUG(m_logger, "{} 获取通道1最新数据失败", m_logBase);
+            // SPDLOG_LOGGER_TRACE(m_logger, "{} 未获取通道1最新数据", m_logBase);
             return false; // 没有获取到最新数据，继续等待
         }
         m_isUpdated1 = true;
     }
     if(m_isUpdated2 == false)
     {
-        if(m_threadCreateDBPhase2->getLatestResult(m_localData2.ringQueue) == false)
+        if(m_threadCreateDB2->getLatestResult(m_localData2.ringQueue) == false)
         {
-            SPDLOG_LOGGER_DEBUG(m_logger, "{} 获取通道2最新数据失败", m_logBase);
+            // SPDLOG_LOGGER_DEBUG(m_logger, "{} 未获取通道2最新数据", m_logBase);
             return false; // 没有获取到最新数据，继续等待
         }
         m_isUpdated2 = true;
     }
+    if(m_isUpdated1 == false || m_isUpdated2 == false)
+    {
+        // SPDLOG_LOGGER_TRACE(m_logger, "{} 队列数据未更新，等待数据更新", m_logBase);
+        return false;
+    }
     
     if(m_localData1.isEmpty() || m_localData2.isEmpty())
     {
-        SPDLOG_LOGGER_DEBUG(m_logger, "{} 队列数据不足，等待数据更新", m_logBase);
-        return false;;
+        SPDLOG_LOGGER_TRACE(m_logger, "{} 队列数据不足，等待数据更新", m_logBase);
+        return false;
     }
 
+    /* 获取一致性线程计算的结果 */
+    m_consistencyResult = m_pConsistencyCompareThread->getConsistencyResult();
+
     return true;
 }
 
@@ -299,7 +345,7 @@ bool CompareDoubleThread::getLatestConsistencyStatus(OneRoadVolume_t& oneRoad)
     {
         initMiniArray();
 
-        SPDLOG_LOGGER_INFO(m_logger, "{}: 非对比时间时，默认为一致", m_chnName);
+        // SPDLOG_LOGGER_DEBUG(m_logger, "{}: 非对比时间时，默认为一致", m_chnName);
 
         oneRoad.isConsistency = true;
         return true;

Server/ThreadCalculate/CompareDoubleThread.h

@@ -5,7 +5,6 @@
 #include "ChannelParam.h"
 #include "CompareResult.h"
 #include "CreateDBThread.h"
-#include "SendStruct.h"
 #include "ConsistencyResult.h"
 #include "CalculateAudio.h"
 #include "spdlog/spdlog.h"
@@ -92,8 +91,8 @@ private:
     SoundCardRoadInfo_t m_roadInfo2;                        /* 录音通道2信息 */
 
     /* 生成音量数据的线程 */
-    CreateDBThread* m_threadCreateDBPhase1 = nullptr;  /* 生成通道1音量数据的线程 */
-    CreateDBThread* m_threadCreateDBPhase2 = nullptr;  /* 生成通道2音量数据的线程 */
+    CreateDBThread* m_threadCreateDB1 = nullptr;            /* 生成通道1音量数据的线程 */
+    CreateDBThread* m_threadCreateDB2 = nullptr;            /* 生成通道2音量数据的线程 */
     bool m_isUpdated1 = false;                              /* 通道1数据是否更新 */
     bool m_isUpdated2 = false;                              /* 通道2数据是否更新 */
     /* 本地存储音量数据的环形队列 */
@@ -138,7 +137,7 @@ private:
      * 负数是通道2向后偏移几秒 */
     long m_offsetMSeconds = 0;
 
-    int m_calculateSeconds = 0;             /* 计算需要的的秒数 */
+    // int m_calculateSeconds = 0;             /* 计算需要的的秒数 */
     int m_avgDBCalculateSeconds = 0;        /* 计算平均音量所需要的时长 */
     int m_silentThreshold = 0;              /* 静音阈值 */
 

Server/ThreadCalculate/CompareItemThread.cpp

@@ -54,7 +54,7 @@ void CompareItemThread::task()
     while (m_isRunning)
     {
         /* 睡眠100ms */
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
 
         /* -------------------------------------------------------------------------------------
          * 更新对比项信息
@@ -84,6 +84,10 @@ void CompareItemThread::task()
          * 将音量包数据发送到MQTT中
          * ------------------------------------------------------------------------------------- */
         sendResultData();
+
+        /* 清除标志位 */
+        clearUpdateFlags();
+        SPDLOG_LOGGER_WARN(m_logger, "{} 发送对比项数据到MQTT中", m_logBase);
     }
     /* 清理数据 */
     clearData();
@@ -102,17 +106,14 @@ bool CompareItemThread::initData()
     /* 创建计算音量报警信息的线程指针 */
     destroyCalculateDBThreads(); // 清理之前的线程
     createCalculateDBThreads();
-    
-    /* 获取计算噪音的线程 */
-    removeNoiseDetectThreads(); // 清理之前的噪音检测线程
-    getNoiseDetectThreads();
 
     /* 创建两个对比线程，主通道是第一个通道，其他都需要和主通道进行对比 */
     destroyCompareThreads();
-    if(!createCompareThreads())
-    {
-        return false;
-    }
+    createCompareThreads();
+
+    /* 获取计算噪音的线程 */
+    removeNoiseDetectThreads(); // 清理之前的噪音检测线程
+    getNoiseDetectThreads();
 
     /* 初始化存储结果的数据结构 */
     m_compareResult = CompareResult_t();
@@ -120,37 +121,41 @@ bool CompareItemThread::initData()
     m_compareResult.compareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
     m_compareResult.dateTime = QDateTime::currentDateTime();
     m_compareResult.isClientAlarm = false; // 默认不报警
-    m_compareResult.vecRoadVolumes.clear(); // 清空之前的数据
+    m_compareResult.mapRoadVolumes.clear(); // 清空之前的数据
     for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
     {
         OneRoadVolume_t oneRoadVolume;
         oneRoadVolume.roadInfo = road; // 设置通道信息
         oneRoadVolume.dateTime = QDateTime::currentDateTime(); // 初始化时间
-        m_compareResult.vecRoadVolumes.push_back(oneRoadVolume);
+        m_compareResult.mapRoadVolumes.insert({road.nCompareRoadNum, oneRoadVolume});
     }
 
-    int roadCount = m_threadInfo.compareItemInfo.mapRoad.size();
-    m_vecCDBUpdated.clear();
-    m_vecCDBUpdated.reserve(roadCount);
-    for(int i = 0; i < m_threadInfo.compareItemInfo.mapRoad.size(); ++i)
+    m_mapCDBUpdated.clear();
+    for(auto it : m_threadInfo.compareItemInfo.mapRoad)
     {
-        m_vecCDBUpdated.push_back(false); // 初始化为未更新
+        m_mapCDBUpdated.insert({it.nCompareRoadNum, false}); // 初始化更新标志位为false
     }
 
     /* 初始化报警信息 */
-    m_vecAlarmSilence.clear();
-    m_vecAlarmOverload.clear();
-    m_vecAlarmPhase.clear();
-    m_vecAlarmSilence.reserve(roadCount);
-    m_vecAlarmOverload.reserve(roadCount);
-    m_vecAlarmPhase.reserve(roadCount);
-
-    m_vecAlarmSilenceLast.clear();
-    m_vecAlarmOverloadLast.clear();
-    m_vecAlarmPhaseLast.clear();
-    m_vecAlarmSilenceLast.reserve(roadCount);
-    m_vecAlarmOverloadLast.reserve(roadCount);
-    m_vecAlarmPhaseLast.reserve(roadCount);
+    m_mapAlarmSilence.clear();
+    m_mapAlarmOverload.clear();
+    m_mapAlarmPhase.clear();
+    for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
+    {
+        m_mapAlarmSilence.insert({road.nCompareRoadNum, AlarmInfo_t()});
+        m_mapAlarmOverload.insert({road.nCompareRoadNum, AlarmInfo_t()});
+        m_mapAlarmPhase.insert({road.nCompareRoadNum, AlarmInfo_t()});
+    }
+
+    m_mapAlarmSilenceLast.clear();
+    m_mapAlarmOverloadLast.clear();
+    m_mapAlarmPhaseLast.clear();
+    for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
+    {
+        m_mapAlarmSilenceLast.insert({road.nCompareRoadNum, AlarmInfo_t()});
+        m_mapAlarmOverloadLast.insert({road.nCompareRoadNum, AlarmInfo_t()});
+        m_mapAlarmPhaseLast.insert({road.nCompareRoadNum, AlarmInfo_t()});
+    }
 
     return true;
 }
@@ -159,16 +164,16 @@ bool CompareItemThread::initData()
 void CompareItemThread::clearData()
 {
     /* 停止所有的比对线程 */
-    for(auto& thread : m_vecCompareDoubleThreads)
+    for(auto& pair : m_mapCompareDoubleThreads)
     {
-        if(thread != nullptr)
+        if(pair.second != nullptr)
         {
-            thread->stopThreadBlock();
-            delete thread;
-            thread = nullptr;
+            pair.second->stopThreadBlock();
+            delete pair.second;
+            pair.second = nullptr;
         }
     }
-    m_vecCompareDoubleThreads.clear();
+    m_mapCompareDoubleThreads.clear();
     /* 移除使用到的录音通道 */
     for(auto& it : m_threadInfo.compareItemInfo.mapRoad)
     {
@@ -186,10 +191,10 @@ bool CompareItemThread::createCompareThreads()
 {
     auto it = m_threadInfo.compareItemInfo.mapRoad.begin();
     auto mainRoad = it.value(); // 主通道信息
-    uint64_t size = m_threadInfo.compareItemInfo.mapRoad.size();
-    for(uint64_t i = 1; i < size; ++i)
+    it++; // 移动到下一个通道
+    // uint64_t size = m_threadInfo.compareItemInfo.mapRoad.size();
+    for(; it != m_threadInfo.compareItemInfo.mapRoad.end(); it++)
     {
-        it++;
         CalculateThreadInfo_t compareThreadInfo;
         compareThreadInfo.compareItemInfo = m_threadInfo.compareItemInfo;
         compareThreadInfo.compareItemInfo.mapRoad.clear(); // 清空通道信息
@@ -202,7 +207,7 @@ bool CompareItemThread::createCompareThreads()
             SPDLOG_LOGGER_ERROR(m_logger, "{} 创建对比线程 {} - {} 失败", m_logBase, mainRoad.strCompareRoadName.toStdString(), it.value().strCompareRoadName.toStdString());
             return false;
         }
-        m_vecCompareDoubleThreads.push_back(pThread);
+        m_mapCompareDoubleThreads.insert({it.key(), pThread}); // 保存线程指针
         /* 开始运行 */
         CPPTP.add_task(&CompareDoubleThread::threadTask, pThread);
     }
@@ -213,22 +218,22 @@ bool CompareItemThread::createCompareThreads()
 /* 销毁两两对比线程 */
 void CompareItemThread::destroyCompareThreads()
 {
-    if(m_vecCompareDoubleThreads.size() == 0)
+    if(m_mapCompareDoubleThreads.size() == 0)
     {
         return; // 没有对比线程
     }
     SPDLOG_LOGGER_INFO(m_logger, "{} 销毁对比线程", m_logBase);
-    for(auto& thread : m_vecCompareDoubleThreads)
+    for(auto& pair : m_mapCompareDoubleThreads)
     {
-        if(thread != nullptr)
+        if(pair.second != nullptr)
         {
-            thread->stopThreadBlock(); // 停止线程
-            delete thread;             // 删除线程
-            thread = nullptr;          // 设置为nullptr
+            pair.second->stopThreadBlock(); // 停止线程
+            delete pair.second;             // 删除线程
+            pair.second = nullptr;          // 设置为nullptr
         }
     }
-    m_vecCompareDoubleThreads.clear();
-    m_vecCDBUpdated.clear(); // 清空更新标志位
+    m_mapCompareDoubleThreads.clear();
+    m_mapCDBUpdated.clear(); // 清空更新标志位
     SPDLOG_LOGGER_INFO(m_logger, "{} 对比线程销毁完成", m_logBase);
 }
 
@@ -249,7 +254,7 @@ bool CompareItemThread::createCalculateDBThreads()
             // return false; // 获取线程失败
         }
         CPPTP.add_task(&CalculateDBThread::threadTask, pThread);
-        m_vecCalculateDBThreads.push_back(pThread);
+        m_mapCalculateDBThreads.insert({road.nCompareRoadNum, pThread}); // 保存线程指针
     }
 
     return true;
@@ -258,22 +263,22 @@ bool CompareItemThread::createCalculateDBThreads()
 /* 销毁音量计算的线程 */
 void CompareItemThread::destroyCalculateDBThreads()
 {
-    if(m_vecCalculateDBThreads.size() == 0)
+    if(m_mapCalculateDBThreads.size() == 0)
     {
         return; // 没有音量计算线程
     }
     SPDLOG_LOGGER_INFO(m_logger, "{} 销毁音量计算线程", m_logBase);
-    for(auto& thread : m_vecCalculateDBThreads)
+    for(auto& pair : m_mapCalculateDBThreads)
     {
-        if(thread != nullptr)
+        if(pair.second != nullptr)
         {
-            thread->stopThreadBlock(); // 停止线程
-            delete thread;             // 删除线程
-            thread = nullptr;          // 设置为nullptr
+            pair.second->stopThreadBlock(); // 停止线程
+            delete pair.second;             // 删除线程
+            pair.second = nullptr;          // 设置为nullptr
         }
     }
-    m_vecCalculateDBThreads.clear();
-    m_vecCDBUpdated.clear(); // 清空更新标志位
+    m_mapCalculateDBThreads.clear();
+    m_mapCDBUpdated.clear(); // 清空更新标志位
 
     SPDLOG_LOGGER_INFO(m_logger, "{} 音量计算线程销毁完成", m_logBase);
 }
@@ -289,7 +294,7 @@ bool CompareItemThread::getNoiseDetectThreads()
             SPDLOG_LOGGER_ERROR(m_logger, "{} 获取噪音检测线程失败", m_logBase);
             return false; // 获取线程失败
         }
-        m_vecNoiseDetectThreads.push_back(pThread);
+        m_mapNoiseDetectThreads.insert({road.nCompareRoadNum, pThread});
     }
 
     return true;
@@ -298,19 +303,19 @@ bool CompareItemThread::getNoiseDetectThreads()
 /* 移除噪音检测的线程 */
 void CompareItemThread::removeNoiseDetectThreads()
 {
-    if(m_vecNoiseDetectThreads.size() == 0)
+    if(m_mapNoiseDetectThreads.size() == 0)
     {
         return; // 没有噪音检测线程
     }
     SPDLOG_LOGGER_INFO(m_logger, "{} 移除噪音检测线程", m_logBase);
-    for(auto& thread : m_vecNoiseDetectThreads)
+    for(auto& pair : m_mapNoiseDetectThreads)
     {
-        if(thread != nullptr)
+        if(pair.second != nullptr)
         {
-            ThreadMan.removeNoiseDetectThread(thread->getRoadInfo(), m_threadInfo.compareItemInfo.nID);
+            ThreadMan.removeNoiseDetectThread(pair.second->getRoadInfo(), m_threadInfo.compareItemInfo.nID);
         }
     }
-    m_vecNoiseDetectThreads.clear();
+    m_mapNoiseDetectThreads.clear();
     SPDLOG_LOGGER_INFO(m_logger, "{} 噪音检测线程移除完成", m_logBase);
 }
 
@@ -324,99 +329,94 @@ void CompareItemThread::removeNoiseDetectThreads()
  */
 bool CompareItemThread::updateResultData()
 {
-    const int size = m_threadInfo.compareItemInfo.mapRoad.size();
-
     /* -------------------------------------------------------------------------------------
      * 先从音量计算数据中获取音量包信息和报警信息（静音、过载、反相）
      * ------------------------------------------------------------------------------------- */
-    for(int i = 0; i < size; ++i)
+    for(auto& pair : m_mapCDBUpdated)
     {
-        if(m_vecCDBUpdated[i] == true)
+        if(pair.second == true)
         {
-            continue; // 已经更新过了
+            /* 已经更新过了 */
+            continue;
         }
-        CalculateDBThread* pThread = m_vecCalculateDBThreads[i];
+        CalculateDBThread* pThread = m_mapCalculateDBThreads[pair.first];
         if(pThread == nullptr)
         {
-            SPDLOG_LOGGER_ERROR(m_logger, "{} 获取音量计算线程失败", m_logBase);
-            continue; // 跳过这个线程
+            SPDLOG_LOGGER_ERROR(m_logger, "{} 音量计算线程失效", m_logBase);
+            continue;
         }
         /* 获取最新的音量数据 */
-        if(pThread->getlastVolumeInfo(m_compareResult.vecRoadVolumes[i]))
+        if(!pThread->getlastVolumeInfo(m_compareResult.mapRoadVolumes[pair.first]))
         {
-            m_vecCDBUpdated[i] = true; // 标记为已更新
+            continue; // 没有获取到最新数据，继续等待
         }
         /* 更新报警信息 */
-        m_vecAlarmSilence[i] = pThread->getAlarm(EAlarmType::EAT_Silent);
-        m_vecAlarmOverload[i] = pThread->getAlarm(EAlarmType::EAT_Overload);
-        m_vecAlarmPhase[i] = pThread->getAlarm(EAlarmType::EAT_Reversed);
+        m_mapAlarmSilence[pair.first] = pThread->getAlarm(EAlarmType::EAT_Silent);
+        m_mapAlarmOverload[pair.first] = pThread->getAlarm(EAlarmType::EAT_Overload);
+        m_mapAlarmPhase[pair.first] = pThread->getAlarm(EAlarmType::EAT_Reversed);
+
+        pair.second = true; // 设置更新标志位为true
     }
     /* 判断是否全部更新，如果没有则返回，等待下次再次获取 */
-    for(int i = 0; i < size; ++i)
+    for(auto& pair : m_mapCDBUpdated)
     {
-        if(m_vecCDBUpdated[i] == false)
+        if(false == pair.second)
         {
             // SPDLOG_LOGGER_DEBUG(m_logger, "{} 音量计算线程数据未全部更新，等待下次获取", m_logBase);
             return false;
         }
     }
 
+
     /* -------------------------------------------------------------------------------------
      * 获取噪音计算的结果
      * ------------------------------------------------------------------------------------- */
-    for(int i = 0; i < size; ++i)
+    for(auto& pair : m_mapNoiseDetectThreads)
     {
-        NoiseDetectThread* pThread = m_vecNoiseDetectThreads[i];
+        NoiseDetectThread* pThread = pair.second;
         if(pThread == nullptr)
         {
-            SPDLOG_LOGGER_ERROR(m_logger, "{} 获取噪音检测线程失败", m_logBase);
+            SPDLOG_LOGGER_ERROR(m_logger, "{} 噪音检测线程失效", m_logBase);
             continue; // 跳过这个线程
         }
         /* 获取最新的噪音数据，噪音报警那个标志位貌似没用到 */
-        m_compareResult.vecRoadVolumes[i].isNoise = pThread->isNoise();
+        m_compareResult.mapRoadVolumes[pair.first].isNoise = pThread->isNoise();
     }
 
     /* -------------------------------------------------------------------------------------
      * 从对比项中获取核对过后的一致性结果
      * ------------------------------------------------------------------------------------- */
-    for(int i = 1; i < size; ++i)
+    for(auto& pair : m_mapCompareDoubleThreads)
     {
-        CompareDoubleThread* pThread = m_vecCompareDoubleThreads[i-1];
+        CompareDoubleThread* pThread = pair.second;
         if(pThread == nullptr)
         {
-            SPDLOG_LOGGER_ERROR(m_logger, "{} 获取对比线程失败", m_logBase);
+            SPDLOG_LOGGER_ERROR(m_logger, "{} 一致性对比线程失效", m_logBase);
             continue;
         }
         /* 获取最新的一致性结果 */
         OneRoadVolume_t roadVolume;
         if(pThread->getlastVolumeInfo(roadVolume))
         {
-            m_compareResult.vecRoadVolumes[i].isConsistency = roadVolume.isConsistency;
-            m_compareResult.vecRoadVolumes[i].isNotConsistencyWarning = roadVolume.isNotConsistencyWarning;
+            m_compareResult.mapRoadVolumes[pair.first].isConsistency = roadVolume.isConsistency;
+            m_compareResult.mapRoadVolumes[pair.first].isNotConsistencyWarning = roadVolume.isNotConsistencyWarning;
         }
     }
 
     return true;
 }
 
-/* 发送数据 */
-void CompareItemThread::sendResultData()
-{
-    /* 生成json数据 */
-
-    /* 发送到mqtt中 */
 
-}
 
 /* 处理报警数据，主要是和之前的数据尽情对比，是否是一样的 */
 void CompareItemThread::processAlarmData()
 {
     m_listAlarm.clear();
     /* 处理静音报警数据 */
-    for(size_t i = 0; i < m_vecAlarmSilence.size(); ++i)
+    for(auto& pair : m_mapAlarmSilence)
     {
-        auto& nowAlarm = m_vecAlarmSilence[i];
-        auto& lastAlarm = m_vecAlarmSilenceLast[i];
+        auto& nowAlarm = pair.second;
+        auto& lastAlarm = m_mapAlarmSilenceLast[pair.first];
         if(nowAlarm.isAlarm)
         {
             if(lastAlarm == nowAlarm)
@@ -426,16 +426,16 @@ void CompareItemThread::processAlarmData()
                 nowAlarm.CompareItemID = m_threadInfo.compareItemInfo.nID;
                 nowAlarm.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
                 m_listAlarm.push_back(nowAlarm);
-                m_vecAlarmSilenceLast[i] = nowAlarm;
+                m_mapAlarmSilenceLast[pair.first] = nowAlarm;
             }
         }
     }
 
     /* 处理过载报警数据 */
-    for(size_t i = 0; i < m_vecAlarmOverload.size(); ++i)
+    for(auto& pair : m_mapAlarmOverload)
     {
-        auto& nowAlarm = m_vecAlarmOverload[i];
-        auto& lastAlarm = m_vecAlarmOverloadLast[i];
+        auto& nowAlarm = pair.second;
+        auto& lastAlarm = m_mapAlarmOverloadLast[pair.first];
         if(nowAlarm.isAlarm)
         {
             if(lastAlarm == nowAlarm)
@@ -445,16 +445,16 @@ void CompareItemThread::processAlarmData()
                 nowAlarm.CompareItemID = m_threadInfo.compareItemInfo.nID;
                 nowAlarm.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
                 m_listAlarm.push_back(nowAlarm);
-                m_vecAlarmOverloadLast[i] = nowAlarm;
+                m_mapAlarmOverloadLast[pair.first] = nowAlarm;
             }
         }
     }
 
     /* 处理反相报警数据 */
-    for(size_t i = 0; i < m_vecAlarmPhase.size(); ++i)
+    for(auto& pair : m_mapAlarmPhase)
     {
-        auto& nowAlarm = m_vecAlarmPhase[i];
-        auto& lastAlarm = m_vecAlarmPhaseLast[i];
+        auto& nowAlarm = pair.second;
+        auto& lastAlarm = m_mapAlarmPhaseLast[pair.first];
         if(nowAlarm.isAlarm)
         {
             if(lastAlarm == nowAlarm)
@@ -464,7 +464,7 @@ void CompareItemThread::processAlarmData()
                 nowAlarm.CompareItemID = m_threadInfo.compareItemInfo.nID;
                 nowAlarm.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
                 m_listAlarm.push_back(nowAlarm);
-                m_vecAlarmPhaseLast[i] = nowAlarm;
+                m_mapAlarmPhaseLast[pair.first] = nowAlarm;
             }
         }
     }
@@ -472,3 +472,22 @@ void CompareItemThread::processAlarmData()
     /* 将报警列表写入到处理报警数据的线程中 */
 }
 
+/* 发送数据 */
+void CompareItemThread::sendResultData()
+{
+    /* 生成json数据 */
+
+    /* 发送到mqtt中 */
+
+}
+
+/* 清除标志更新位 */
+void CompareItemThread::clearUpdateFlags()
+{
+    for(auto& pair : m_mapCDBUpdated)
+    {
+        pair.second = false; // 清除更新标志位
+    }
+}
+
+

Server/ThreadCalculate/CompareItemThread.h

@@ -1,6 +1,7 @@
 #ifndef _COMPAREITEMTHREAD_H_
 #define _COMPAREITEMTHREAD_H_
 
+#include <map>
 
 #include "BaseCalculateThread.h"
 #include "CompareResult.h"
@@ -53,34 +54,35 @@ private:
 
     /* 更新数据 */
     bool updateResultData();
-
+    /* 处理报警数据，写入数据库 */
+    void processAlarmData();
     /* 发送数据 */
     void sendResultData();
 
-    /* 处理报警数据，写入数据库 */
-    void processAlarmData();
+    /* 清除标志更新位 */
+    void clearUpdateFlags();
 
 private:
-    /* 计算音量信息的线程指针，第一个是主通道线程 */
-    std::vector<CalculateDBThread*> m_vecCalculateDBThreads;
-    std::vector<bool> m_vecCDBUpdated;             /* 音量包更新标志位 */
+    /* 计算音量信息的线程指针，第一个是主通道线程，int是对比项中的通道号 */
+    std::map<int, CalculateDBThread*> m_mapCalculateDBThreads;
+    std::map<int, bool> m_mapCDBUpdated;             /* 音量包更新标志位 */
     /* 计算噪音的线程指针 */
-    std::vector<NoiseDetectThread*> m_vecNoiseDetectThreads;
-    /* 对比项信息线程，这个线程在这里创建，不会和其他对比项复用 */
-    std::vector<CompareDoubleThread*> m_vecCompareDoubleThreads;
+    std::map<int, NoiseDetectThread*> m_mapNoiseDetectThreads;
+    /* 对比项信息线程，这个线程在这里创建，不会和其他对比项复用，int是第二路对比通道的编号 */
+    std::map<int, CompareDoubleThread*> m_mapCompareDoubleThreads;
 
 
     /* 计算的数据结果 */
     CompareResult_t m_compareResult;
 
     /* 存储报警信息 */
-    std::vector<AlarmInfo_t> m_vecAlarmSilence;         /* 静音报警信息 */
-    std::vector<AlarmInfo_t> m_vecAlarmOverload;        /* 过载报警信息 */
-    std::vector<AlarmInfo_t> m_vecAlarmPhase;           /* 反相报警信息 */
+    std::map<int, AlarmInfo_t> m_mapAlarmSilence;           /* 静音报警信息 */
+    std::map<int, AlarmInfo_t> m_mapAlarmOverload;          /* 过载报警信息 */
+    std::map<int, AlarmInfo_t> m_mapAlarmPhase;             /* 反相报警信息 */
 
-    std::vector<AlarmInfo_t> m_vecAlarmSilenceLast;     /* 上一次静音报警信息 */
-    std::vector<AlarmInfo_t> m_vecAlarmOverloadLast;    /* 上一次过载报警信息 */
-    std::vector<AlarmInfo_t> m_vecAlarmPhaseLast;       /* 上一次反相报警信息 */
+    std::map<int, AlarmInfo_t> m_mapAlarmSilenceLast;       /* 上一次静音报警信息 */
+    std::map<int, AlarmInfo_t> m_mapAlarmOverloadLast;      /* 上一次过载报警信息 */
+    std::map<int, AlarmInfo_t> m_mapAlarmPhaseLast;         /* 上一次反相报警信息 */
 
     /* 要写入到数据库的报警信息 */
     std::list<AlarmInfo_t> m_listAlarm;;

Server/ThreadCalculate/ConsistencyCompareThread.cpp

@@ -54,12 +54,13 @@ void ConsistencyCompareThread::task()
         SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
         return;
     }
-    m_threadInfo.threadState = EThreadState::State_Running;
-    /* 更新全局线程的状态 */
+
+    SPDLOG_LOGGER_INFO(m_logger, "******************* {} 一致性对比线程(调用动态库)开始运行 ******************* ", m_logBase);
+    
 
     while(m_isRunning)
     {
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
         /*--------------------------------------------------------------
          * 更新最新数据
@@ -86,7 +87,8 @@ void ConsistencyCompareThread::task()
         m_prevWavFilePath2 = m_wavFilePath2; // 更新上一个wav文件路径
     }
     clearData();
-    /* 线程结束，更新线程状态 */
+    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 一致性对比线程(调用动态库)已结束运行 ******************* ", m_logBase);
+    
 }
 
 /* 初始化数据 */
@@ -106,9 +108,31 @@ bool ConsistencyCompareThread::initData()
     m_logBase = fmt::format("对比通道 {}:{} - {}:{}", 
                     m_roadInfo1.strSoundCardName.toStdString(), m_roadInfo1.roadInfo.nRoadNum, 
                     m_roadInfo2.strSoundCardName.toStdString(), m_roadInfo2.roadInfo.nRoadNum);
+    
     /* 获取创建wav文件的指针 */
-    m_pCreateWAVThread1 = ThreadMan.getCreateWAVThread(m_roadInfo1.nSoundCardNum, m_roadInfo1.roadInfo.nRoadNum);
-    m_pCreateWAVThread2 = ThreadMan.getCreateWAVThread(m_roadInfo2.nSoundCardNum, m_roadInfo2.roadInfo.nRoadNum);
+    auto startTime = std::chrono::steady_clock::now(); // 记录开始时间
+    while(true)
+    {
+        if(m_pCreateWAVThread1 == nullptr)
+        {
+            m_pCreateWAVThread1 = ThreadMan.getCreateWAVThread(m_roadInfo1.nSoundCardNum, m_roadInfo1.roadInfo.nRoadNum);
+        }
+        if(m_pCreateWAVThread2 == nullptr)
+        {
+            m_pCreateWAVThread2 = ThreadMan.getCreateWAVThread(m_roadInfo2.nSoundCardNum, m_roadInfo2.roadInfo.nRoadNum);
+        }
+        if(m_pCreateWAVThread1 != nullptr && m_pCreateWAVThread2 != nullptr)
+        {
+            break; // 获取到两个线程，跳出循环
+        }
+        /* 超过10秒还没有获取到线程，返回失败 */
+        if(std::chrono::steady_clock::now() - startTime > std::chrono::seconds(10))
+        {
+            SPDLOG_LOGGER_ERROR(m_logger, "{} 获取生成音量的线程超时",  m_logBase);
+            return false;
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
 
     if(m_pCreateWAVThread1 == nullptr || m_pCreateWAVThread2 == nullptr)
     {
@@ -128,12 +152,19 @@ void ConsistencyCompareThread::clearData()
 /* 比对两个wav文件的一致性 */
 bool ConsistencyCompareThread::compareConsistency()
 {
+    /* 计算比对需要的时间 */
+    std::chrono::steady_clock::time_point startTime = std::chrono::steady_clock::now();
     CompareResult* result = LHCompare(m_wavFilePath1.fileName.c_str(), m_wavFilePath2.fileName.c_str(), m_sensitivity);
     if(result == nullptr)
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 一致性比对失败，可能是文件格式不支持或动态库加载失败", m_logBase);
         return false;
     }
+    /* 计算比对耗时 */
+    std::chrono::steady_clock::time_point endTime = std::chrono::steady_clock::now();
+    std::chrono::duration<double> duration = endTime - startTime;
+    SPDLOG_LOGGER_DEBUG(m_logger, "{} 一致性比对耗时: {}ms", m_logBase, 
+        std::chrono::duration_cast<std::chrono::milliseconds>(duration).count());
     /* 如果高相似度小于1，将两个通道反过来对比一下 */
     if(result->highest_similarity < 1)
     {
@@ -147,7 +178,7 @@ bool ConsistencyCompareThread::compareConsistency()
             return false;
         }
     }
-    SPDLOG_LOGGER_INFO(m_logger, "{} 一致性比对结果: 源文件: {}, 目标文件: {}, 最高相似度: {:.3f}, 平均相似度: {:.3f}",
+    SPDLOG_LOGGER_DEBUG(m_logger, "{} 一致性比对结果: 源文件: {}, 目标文件: {}, 最高相似度: {:.3f}, 平均相似度: {:.3f}",
         m_logBase, m_wavFilePath1.fileName, m_wavFilePath2.fileName, result->highest_similarity, result->average_similarity);
 
     /* 保存结果 */

Server/ThreadCalculate/NoiseDetectThread.cpp

@@ -35,6 +35,8 @@ void NoiseDetectThread::task()
         SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
         return;
     }
+
+    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 噪音检测线程开始运行 ******************* ", m_logBase);
     while(m_isRunning)
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -42,11 +44,11 @@ void NoiseDetectThread::task()
         /*------------------------------------------------------------------------
          * 获取最新的左右声道数据
          *------------------------------------------------------------------------*/
-        if(m_pWAVThread->getLatestLeftRightData(m_leftRightData))
+        if(!m_pWAVThread->getLatestLeftRightData(m_leftRightData))
         {
             continue;
         }
-
+        SPDLOG_LOGGER_ERROR(m_logger, "{} 获取最新的左右声道数据成功，开始调用动态库计算噪音------------------------------------------ ", m_logBase);
         /*------------------------------------------------------------------------
          * 计算数据
          *------------------------------------------------------------------------*/
@@ -56,13 +58,14 @@ void NoiseDetectThread::task()
         }
 
         /*------------------------------------------------------------------------
-         * 处理结果，写噪音报警信息到数据库
+         * 处理结果，写噪音报警信息到数据库（这里不写数据库，只计算结果返回给对比项）
+         * 上面那个函数已经把结果保存了
          *------------------------------------------------------------------------*/
-        saveResult();
+        // saveResult();
 
     }
     clearData(); // 清理数据
-    SPDLOG_LOGGER_INFO(m_logger, "{} 噪音检测线程结束", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 噪音检测线程结束 ******************* ", m_logBase);
 }
 
 /* 初始化数据 */
@@ -70,7 +73,7 @@ bool NoiseDetectThread::initData()
 {
     auto begin =  m_threadInfo.compareItemInfo.mapRoad.begin(); // 获取第一个通道的信息
     m_roadInfo = begin->scRoadInfo; // 录音通道信息
-    m_roadName = fmt::format("{}:{}", m_roadInfo.strSoundCardName.toStdString(), m_roadInfo.roadInfo.nRoadNum);
+    m_roadName = fmt::format("{}:{}", m_roadInfo.strSoundCardID.toStdString(), m_roadInfo.roadInfo.nRoadNum);
     m_logBase = fmt::format("噪音检测通道 {}:", m_roadName);
 
     m_pWAVThread = ThreadMan.getCreateWAVThread(m_roadInfo.nSoundCardNum, m_roadInfo.roadInfo.nRoadNum);
@@ -95,6 +98,7 @@ void NoiseDetectThread::clearData()
 /* 调用动态库检测噪音 */
 bool NoiseDetectThread::detectNoise()
 {
+    auto startTime = std::chrono::steady_clock::now();
     bool isNoiseLeft = false; /* 是否检测到左声道噪音 */
     bool isNoiseRight = false; /* 是否检测到右声道噪音 */
     try
@@ -140,6 +144,12 @@ bool NoiseDetectThread::detectNoise()
         return false;
     }
 
+    std::chrono::duration<double> duration = std::chrono::steady_clock::now() - startTime;
+    std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
+    SPDLOG_LOGGER_DEBUG(m_logger, "{} 调用动态库检测噪音耗时: {}ms", m_logBase, ms.count());
+
+    SPDLOG_LOGGER_DEBUG(m_logger, "{} 左声道噪音检测结果: {}, 右声道噪音检测结果: {}", m_logBase, isNoiseLeft, isNoiseRight);
+
     /* -------------------------- 和以往的结果对比 --------------------------*/
     m_isNoiseLast = m_isNoise.load(); /* 上一次的噪音检测结果 */
     m_isNoise.store(isNoiseLeft || isNoiseRight); /* 是否检测到噪音 */

Server/ThreadManager/ThreadCompareItemManager.cpp

@@ -55,6 +55,7 @@ void ThreadCompareItemManager::thread_CompareItemManager()
             threadSleepTime = 10;
         }
         /* ------------------------------ 处理对比项信息 ------------------------------ */
+        /* 获取对比项信息 */
         if(!m_fromWebAPI.getCompareItemInfo(m_listNewItems))
         {
             SPDLOG_LOGGER_DEBUG(m_logger, "ThreadCompareItemManager: 获取对比项失败");

Server/ThreadManager/ThreadManager.cpp

@@ -606,82 +606,82 @@ RTPOneRoadThread* ThreadManager::getRtpSendThread(int cardID, int recordID)
  * -------------------------------------------------------------------------------------------- */
 
 /* 获取一致性比对线程，线程不存在则创建 */
-ConsistencyCompareThread* ThreadManager::getConsistencyCompareThread(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2)
-{
-    std::lock_guard<std::mutex> lock(m_mutexConsistencyCompareThreads);
-    for(const auto pThread : m_listConsistencyCompareThreads)
-    {
-        if(pThread->isRoadEqual(roadInfo1, roadInfo2))
-        {
-            return pThread; // 找到相同的线程，直接返回
-        }
-    }
-    /* 没找到该线程，创建新的线程 */
-    CompareItemRoadInfo_t item1;
-    item1.nCompareRoadNum = 1;
-    item1.scRoadInfo = roadInfo1;
-    CompareItemRoadInfo_t item2;
-    item2.nCompareRoadNum = 2;
-    item2.scRoadInfo = roadInfo2;
-
-    CalculateThreadInfo_t threadInfo;
-    threadInfo.compareItemInfo.mapRoad.insert(item1.nCompareRoadNum, item1);
-    threadInfo.compareItemInfo.mapRoad.insert(item2.nCompareRoadNum, item2);
-    ConsistencyCompareThread* newThread = new ConsistencyCompareThread(threadInfo);
+// ConsistencyCompareThread* ThreadManager::getConsistencyCompareThread(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2)
+// {
+//     std::lock_guard<std::mutex> lock(m_mutexConsistencyCompareThreads);
+//     for(const auto pThread : m_listConsistencyCompareThreads)
+//     {
+//         if(pThread->isRoadEqual(roadInfo1, roadInfo2))
+//         {
+//             return pThread; // 找到相同的线程，直接返回
+//         }
+//     }
+//     /* 没找到该线程，创建新的线程 */
+//     CompareItemRoadInfo_t item1;
+//     item1.nCompareRoadNum = 1;
+//     item1.scRoadInfo = roadInfo1;
+//     CompareItemRoadInfo_t item2;
+//     item2.nCompareRoadNum = 2;
+//     item2.scRoadInfo = roadInfo2;
+
+//     CalculateThreadInfo_t threadInfo;
+//     threadInfo.compareItemInfo.mapRoad.insert(item1.nCompareRoadNum, item1);
+//     threadInfo.compareItemInfo.mapRoad.insert(item2.nCompareRoadNum, item2);
+//     ConsistencyCompareThread* newThread = new ConsistencyCompareThread(threadInfo);
     
-    if(newThread == nullptr)
-    {
-        SPDLOG_LOGGER_ERROR(m_logger, "创建一致性比对线程失败");
-        return nullptr; // 创建失败
-    }
-    CPPTP.add_task(&ConsistencyCompareThread::threadTask, newThread);
+//     if(newThread == nullptr)
+//     {
+//         SPDLOG_LOGGER_ERROR(m_logger, "创建一致性比对线程失败");
+//         return nullptr; // 创建失败
+//     }
+//     CPPTP.add_task(&ConsistencyCompareThread::threadTask, newThread);
 
-    m_listConsistencyCompareThreads.push_back(newThread);
-    m_referCountConsistencyCompare++; // 引用计数加一
+//     m_listConsistencyCompareThreads.push_back(newThread);
+//     m_referCountConsistencyCompare++; // 引用计数加一
 
-    return newThread;
-}
+//     return newThread;
+// }
 
 /* 去掉线程，线程使用的计数减一，计数为0则销毁该线程 */
-bool ThreadManager::removeConsistencyCompareThread(SoundCardRoadInfo_t& roadInfo1, SoundCardRoadInfo_t& roadInfo2)
-{
-    std::lock_guard<std::mutex> lock(m_mutexConsistencyCompareThreads);
-    ConsistencyCompareThread* pThreadToRemove = nullptr;
-    for(const auto pThread : m_listConsistencyCompareThreads)
-    {
-        if(pThread->isRoadEqual(roadInfo1, roadInfo2))
-        {
-            pThreadToRemove = pThread; // 找到相同的线程，直接返回
-            break;
-        }
-    }
-    if(pThreadToRemove == nullptr)
-    {
-        SPDLOG_LOGGER_WARN(m_logger, "{}:{} - {}:{} 一致性比对线程未找到", roadInfo1.strSoundCardName.toStdString(), roadInfo1.roadInfo.nRoadNum,
-            roadInfo2.strSoundCardName.toStdString(), roadInfo2.roadInfo.nRoadNum);
-        return false; // 没找到该线程
-    }
-    m_referCountConsistencyCompare--; // 引用计数减一
-    if(m_referCountConsistencyCompare <= 0)
-    {
-        /* 停止线程，并一直等待其停止 */
-        pThreadToRemove->stopThreadBlock();
-        m_listConsistencyCompareThreads.remove(pThreadToRemove); // 从列表中移除
-        delete pThreadToRemove; // 删除线程
-        pThreadToRemove = nullptr;
-        m_referCountConsistencyCompare = 0; // 重置引用计数
-        SPDLOG_LOGGER_WARN(m_logger, "{}:{} - {}:{} 一致性比对线程已销毁", roadInfo1.strSoundCardName.toStdString(), roadInfo1.roadInfo.nRoadNum,
-            roadInfo2.strSoundCardName.toStdString(), roadInfo2.roadInfo.nRoadNum);
-    }
+// bool ThreadManager::removeConsistencyCompareThread(SoundCardRoadInfo_t& roadInfo1, SoundCardRoadInfo_t& roadInfo2)
+// {
+//     std::lock_guard<std::mutex> lock(m_mutexConsistencyCompareThreads);
+//     ConsistencyCompareThread* pThreadToRemove = nullptr;
+//     for(const auto pThread : m_listConsistencyCompareThreads)
+//     {
+//         if(pThread->isRoadEqual(roadInfo1, roadInfo2))
+//         {
+//             pThreadToRemove = pThread; // 找到相同的线程，直接返回
+//             break;
+//         }
+//     }
+//     if(pThreadToRemove == nullptr)
+//     {
+//         SPDLOG_LOGGER_WARN(m_logger, "{}:{} - {}:{} 一致性比对线程未找到", roadInfo1.strSoundCardName.toStdString(), roadInfo1.roadInfo.nRoadNum,
+//             roadInfo2.strSoundCardName.toStdString(), roadInfo2.roadInfo.nRoadNum);
+//         return false; // 没找到该线程
+//     }
+//     m_referCountConsistencyCompare--; // 引用计数减一
+//     if(m_referCountConsistencyCompare <= 0)
+//     {
+//         /* 停止线程，并一直等待其停止 */
+//         pThreadToRemove->stopThreadBlock();
+//         m_listConsistencyCompareThreads.remove(pThreadToRemove); // 从列表中移除
+//         delete pThreadToRemove; // 删除线程
+//         pThreadToRemove = nullptr;
+//         m_referCountConsistencyCompare = 0; // 重置引用计数
+//         SPDLOG_LOGGER_WARN(m_logger, "{}:{} - {}:{} 一致性比对线程已销毁", roadInfo1.strSoundCardName.toStdString(), roadInfo1.roadInfo.nRoadNum,
+//             roadInfo2.strSoundCardName.toStdString(), roadInfo2.roadInfo.nRoadNum);
+//     }
 
-    return true;
-}
+//     return true;
+// }
 
 /* 获取噪音检测线程 */
 NoiseDetectThread* ThreadManager::getNoiseDetectThread(const SoundCardRoadInfo_t& roadInfo, int compareItemID)
 {
-    NoiseDetectThread* pNoiseDetectThread = nullptr;
     std::lock_guard<std::mutex> lock(m_mutexNoiseDetectThreads);
+    NoiseDetectThread* pNoiseDetectThread = nullptr;
     for(const auto pThread : m_listNoiseDetectThreads)
     {
         const SoundCardRoadInfo_t& threadRoadInfo = pThread->getRoadInfo();

Server/ThreadManager/ThreadManager.h

@@ -82,10 +82,10 @@ public:
      *      1、能在这里获取的线程是为了尽可能复用线程，这些都是和对比项无关的计算线程
      *      2、和对比项有关的计算线程由对比项线程启动和管理
      * -------------------------------------------------------------------------------------------- */
-    /* 获取一致性比对线程，线程不存在则创建 */
-    ConsistencyCompareThread* getConsistencyCompareThread(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2);
-    /* 去掉线程，线程使用的计数减一，计数为0则销毁该线程 */
-    bool removeConsistencyCompareThread(SoundCardRoadInfo_t& roadInfo1, SoundCardRoadInfo_t& roadInfo2);
+    // /* 获取一致性比对线程，线程不存在则创建 */
+    // ConsistencyCompareThread* getConsistencyCompareThread(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2);
+    // /* 去掉线程，线程使用的计数减一，计数为0则销毁该线程 */
+    // bool removeConsistencyCompareThread(SoundCardRoadInfo_t& roadInfo1, SoundCardRoadInfo_t& roadInfo2);
 
     /* 获取噪音检测线程，如果不存在，则创建线程 */
     NoiseDetectThread* getNoiseDetectThread(const SoundCardRoadInfo_t& roadInfo, int compareItemID);
@@ -122,9 +122,9 @@ private:
     std::list<BaseRecordThread*> m_rtpSendThreads;
 
     /* 一致性比对的线程 */
-    std::mutex m_mutexConsistencyCompareThreads;    /* 互斥锁，保护一致性比对线程列表 */
-    int m_referCountConsistencyCompare = 0;         /* 一致性比对线程的引用计数 */
-    std::list<ConsistencyCompareThread*> m_listConsistencyCompareThreads;
+    // std::mutex m_mutexConsistencyCompareThreads;    /* 互斥锁，保护一致性比对线程列表 */
+    // int m_referCountConsistencyCompare = 0;         /* 一致性比对线程的引用计数 */
+    // std::list<ConsistencyCompareThread*> m_listConsistencyCompareThreads;
 
     /* 噪音检测线程 */
     std::mutex m_mutexNoiseDetectThreads;           /* 互斥锁，保护噪音检测线程列表 */

Server/ThreadRecord/AssignSrcDataThread.cpp

@@ -148,7 +148,7 @@ bool AssignSrcDataThread::initData()
     m_numChannels = GInfo.numChannels();        /* 声道数 */
     m_bitsPerSample = GInfo.bitsPerSample();    /* 每个采样点的位数 */
 
-    m_oneSecondSize = GInfo.oneSecondCount();   /* 每秒钟的音频数据大小 */
+    m_oneSecondSize = m_sampleRate * m_numChannels * (m_bitsPerSample / 8); /* 1秒数据大小 */
 
     m_dispatchSrcData = new AudioSrcData(m_oneSecondSize);
 

Server/ThreadRecord/BaseRecordThread.h

@@ -54,6 +54,7 @@ protected:
     int32_t m_sampleRate = 44100;              /* 采样率 */
     uint16_t m_numChannels = 2;                 /* 声道数 */
     uint16_t m_bitsPerSample = 16;              /* 每个采样点的位数 */
+    
 };
 
 

Server/ThreadRecord/CreateDBThread.cpp

@@ -89,12 +89,13 @@ bool CreateDBThread::getLatestResult(RingQueueManualMutex<OneSecondData*>& resul
     std::lock_guard<std::mutex> lock(m_queueResultData->mutex);
     if(m_queueResultData->isEmpty())
     {
-        SPDLOG_LOGGER_ERROR(m_logger, "{} 获取最新数据失败，数据队列为空", m_logBase);
+        // SPDLOG_LOGGER_TRACE(m_logger, "{} 获取最新数据，数据队列为空", m_logBase);
         return false;
     }
     /* 目标队列为空，全部拷贝 */
     if(resultQueue.isEmpty())
     {
+        SPDLOG_LOGGER_DEBUG(m_logger, "{} 获取最新数据，目标队列为空，拷贝整个结果队列", m_logBase);
         for(int i = 0; i < m_queueResultData->QueueSize(); ++i)
         {
             OneSecondData* data = m_queueResultData->at(i);
@@ -128,7 +129,35 @@ bool CreateDBThread::getLatestResult(RingQueueManualMutex<OneSecondData*>& resul
     }
     if(index < 0)
     {
-        SPDLOG_LOGGER_ERROR(m_logger, "{} 获取最新数据失败，未找到相等的时间戳", m_logBase);
+        SPDLOG_LOGGER_WARN(m_logger, "{} 获取最新数据失败，未找到相等的时间戳，将清空队列，拷贝全部数据", m_logBase);
+        SPDLOG_LOGGER_WARN(m_logger, "队列大小: {}, 目标队列大小: {}", m_queueResultData->QueueSize(), resultQueue.QueueSize());
+        /* 清空目标队列，将所有的数据全部拷贝 */
+        while(!resultQueue.isEmpty())
+        {
+            OneSecondData* data = resultQueue.front_pop();
+            if(data != nullptr)
+            {
+                delete data;
+                data = nullptr;
+            }
+        }
+        /* 拷贝全部数据 */
+        for(int i = 0; i < m_queueResultData->QueueSize(); ++i)
+        {
+            OneSecondData* data = m_queueResultData->at(i);
+            if(data != nullptr)
+            {
+                OneSecondData* newData = new OneSecondData(*data); // 深拷贝
+                resultQueue.push(newData);
+            }
+        }
+
+        return true;
+    }
+    else if(index == m_queueResultData->QueueSize() - 1)
+    {
+        // 已经是最新的数据了，不需要拷贝
+        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 获取最新数据，已经是最新的数据了", m_logBase);
         return false;
     }
     /* 拷贝数据 */
@@ -155,7 +184,7 @@ bool CreateDBThread::getLatestResult(RingQueueManualMutex<OneSecondData*>& resul
 /* 计算音量和反相的线程函数 */
 void CreateDBThread::task()
 {
-    SPDLOG_LOGGER_INFO(m_logger, " ------------- {} 开始计算音量和反相线程 ------------- ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ------------- {} 开始计算音量线程 ------------- ", m_logBase);
     /* 初始化一些数据 */
     if(!initData())
     {
@@ -167,6 +196,8 @@ void CreateDBThread::task()
     {
         /* 取出一个数据，没有数据则阻塞住 */
         AudioSrcData* audioData = m_queueAudioData.front_pop();
+        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 从环形队列中取出数据，队列大小: {}", m_logBase, m_queueAudioData.QueueSize());
+
         if(audioData == nullptr)
         {
             SPDLOG_LOGGER_WARN(m_logger, "{} 从环形队列中取出数据失败，可能是队列为空", m_logBase);
@@ -195,12 +226,12 @@ void CreateDBThread::task()
         delete audioData; // 释放内存
         audioData = nullptr;
         
-        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 计算音量和反相线程处理数据完成，队列大小: {}", 
+        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 创建音量的线程处理数据完成，队列大小: {}", 
         //     m_logBase, m_queueResultData->QueueSize());
     }
     /* 清理数据 */
     clearData();
-    SPDLOG_LOGGER_INFO(m_logger, " ------------- {} 计算音量和反相线程结束 ------------- ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ------------- {} 计算音量线程结束 ------------- ", m_logBase);
     
 }
 

Server/ThreadRecord/CreateWAVThread.cpp

@@ -77,7 +77,7 @@ bool CreateWAVThread::getLatestFileName(WavFilePath& wavName)
 {
     if(m_queueWavFileName->isEmpty())
     {
-        SPDLOG_LOGGER_WARN(m_logger, "{} WAV文件路径队列为空", m_logBase);
+        // SPDLOG_LOGGER_TRACE(m_logger, "{} WAV文件路径队列为空", m_logBase);
         return false;
     }
     m_queueWavFileName->mutex.lock();
@@ -91,12 +91,11 @@ bool CreateWAVThread::getLatestLeftRightData(AudioLeftRightData& leftRightData)
 {
     if(m_queueLeftRightData.isEmpty())
     {
-        SPDLOG_LOGGER_WARN(m_logger, "{} 左右声道数据队列为空", m_logBase);
+        SPDLOG_LOGGER_TRACE(m_logger, "{} 左右声道数据队列为空", m_logBase);
         return false;
     }
-    m_queueLeftRightData.mutex.lock();
+    std::lock_guard<std::mutex> lock(m_queueLeftRightData.mutex);
     auto pData = m_queueLeftRightData.back();
-    m_queueLeftRightData.mutex.unlock();
     if(pData == nullptr)
     {
         SPDLOG_LOGGER_WARN(m_logger, "{} 获取左右声道数据失败", m_logBase);
@@ -108,6 +107,7 @@ bool CreateWAVThread::getLatestLeftRightData(AudioLeftRightData& leftRightData)
         return false;
     }
     leftRightData = *pData;
+
     return true;
 }
 

Server/ThreadRecord/RecordThread.cpp

@@ -43,7 +43,7 @@ void RecordThread::setAssignSrcDataThread(AssignSrcDataThread* pThread)
 /* 录制功能线程函数 */
 void RecordThread::task()
 {
-    SPDLOG_LOGGER_INFO(m_logger, "{} 开始录音线程", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " --------------------- {} 开始录音线程 --------------------- ", m_logBase);
 
     /* 先初始化数据 */
     if(!initData())
@@ -75,12 +75,14 @@ void RecordThread::task()
     m_isRunning = true;
     while(m_isRunning)
     {
+        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 开始录音", m_logBase);
         /* 获取音频数据，读取的帧数就是采样率，也就是一秒钟数据 */
-        if(!m_audioRecord.recordAudio(m_pRecordBuffer, m_recordBufferSize, m_sampleRate))
+        if(!m_audioRecord.recordAudio(m_pRecordBuffer, m_recordBufferSize, m_oneRecordSize))
         {
             SPDLOG_LOGGER_ERROR(m_logger, "{} 录音失败，可能是声卡被占用或其他错误", m_logBase);
             break;  /* 录音失败，退出循环 */
         }
+        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 录音完成，数据大小: {}", m_logBase, m_recordBufferSize);
 
         QDateTime currentTime = QDateTime::currentDateTime();
         /* 将音频数据拷贝给分派数据的线程 */
@@ -89,9 +91,10 @@ void RecordThread::task()
             m_assignThread->setSrcData(m_pRecordBuffer, m_recordBufferSize, currentTime);
         }
         memset(m_pRecordBuffer, 0, m_recordBufferSize);  /* 清空缓存，准备下一次录音 */
+        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 录音数据已分派给AssignSrcDataThread线程", m_logBase);
     }
 
-    SPDLOG_LOGGER_INFO(m_logger, "{} 结束录音", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " --------------------- {} 结束录音 --------------------- ", m_logBase);
     m_isRunning = false;
 }
 
@@ -113,7 +116,9 @@ bool RecordThread::initData()
 
     m_oneSecondSize = m_sampleRate * m_numChannels * (m_bitsPerSample / 8); /* 每秒钟的音频数据大小 */
 
-    m_recordBufferSize = m_oneSecondSize;       /* 每秒钟的音频数据大小 */
+    /* 每次录音的音频数据大小，这里是100ms去一次数据，监听的时候延迟会小一些 */
+    m_recordBufferSize = m_oneSecondSize / 10;
+    m_oneRecordSize = m_sampleRate / 10;
     m_pRecordBuffer = new char[m_recordBufferSize] {0};  /* 录音数据缓存 */
 
     /* 初始化录制类的参数 */

Server/ThreadRecord/RecordThread.h

@@ -51,7 +51,8 @@ private:
     AudioRecord m_audioRecord;          /* 音频录制类 */
     std::string m_audioRecordDesc;      /* 声卡描述符 */
     char* m_pRecordBuffer = nullptr;    /* 录音数据缓存 */
-    int32_t m_recordBufferSize = 0;    /* 录音数据缓存大小 */
+    int32_t m_recordBufferSize = 0;     /* 录音数据缓存大小 */
+    int32_t m_oneRecordSize = 0;        /* 每次录音的音频数据大小，单位音频帧，位深度 * 通道数 */
 
     AssignSrcDataThread* m_assignThread = nullptr; /* 分派数据线程指针 */
 };

Server/common/LHLog/LHLogInit.cpp

@@ -75,8 +75,10 @@ void initLog(QString ModuleName, CLHQLogApi& lhQLog)
         auto logger_webapi = std::make_shared<spdlog::logger>("FromWebAPI",begin(sinks),end(sinks));
         /* 创建一个ACAServer记录器 */
         auto logger_acaserver = std::make_shared<spdlog::logger>("ACAServer",begin(sinks),end(sinks));
-        /* 创建一个录音功能记录器 */
+        /* 创建一个录音线程记录器 */
         auto logger_record = std::make_shared<spdlog::logger>("RecordAudio",begin(sinks),end(sinks));
+        /* 创建一个计算线程记录器 */
+        auto logger_caculate = std::make_shared<spdlog::logger>("Calculate",begin(sinks),end(sinks));
 
         /* 创建一个RTP服务的logger */
         auto logger_rtpserver = std::make_shared<spdlog::logger>("RTPServer",begin(sinks),end(sinks));
@@ -91,6 +93,7 @@ void initLog(QString ModuleName, CLHQLogApi& lhQLog)
         spdlog::register_logger(logger_record);
         spdlog::register_logger(logger_rtpserver);
         spdlog::register_logger(logger_compareitem);
+        spdlog::register_logger(logger_caculate);
 
 
         /* 设置spdlog输出级别，默认的估计不输出debug这个级别

Server/main.cpp

@@ -30,16 +30,23 @@ int main(int argc, char* argv[])
         fmt::print("main logger is nullptr");
         return -1;
     }
-    SPDLOG_LOGGER_INFO(logger, "★  ★  ★  ★  ★  ★  ☆  ☆  ACAServer  ☆  ☆  ★  ★  ★  ★  ★  ★");
+    SPDLOG_LOGGER_INFO(logger, "★  ★  ★  ★  ★  ★  ★  ☆  ACAServer  ☆  ★  ★  ★  ★  ★  ★  ★");
     SPDLOG_LOGGER_INFO(logger, "ACServer Version: {}", "6.0.0.0");
     /* 设置线程池最大线程个数 */
     CPPTP.setThreadMaxNum(1024);
 
     /* 加载第三方库 */
-    void LoadLibrary();
+    /* 加载一致性比对动态库 */
+    if(LoadCompareLibrary())
+    {
+        SPDLOG_INFO("一致性对比动态库加载成功!");
+    }else {
+        SPDLOG_ERROR("一致性对比动态库加载失败!");
+    }
+    SPDLOG_LOGGER_DEBUG(logger, "☆ 初始化噪音检测服务");
     /* 初始化噪音检测功能 */
     signalstats_wrapper::initialize();
-
+    SPDLOG_LOGGER_DEBUG(logger, "★ 噪音检测服务初始化完成");
 
     ACAServer acas;
     /* 初始化一些系统信息 */
@@ -72,16 +79,6 @@ int main(int argc, char* argv[])
     return result;
 }
 
-/* 加载第三方动态库 */
-void LoadLibrary()
-{
-    /* 加载一致性比对动态库 */
-    if(LoadCompareLibrary())
-    {
-        SPDLOG_INFO("动态库加载成功!");
-    }
-}
-
 
 void test()
 {

common/DataManager/SystemConfig.h

@@ -150,7 +150,7 @@ public:
     
 
 private:
-    /* 基础配置未被修改版本 */
+    /* 基础配置 */
     BaseConfig_t m_baseConfigSrc;
     /* ai对比需要的参数 */
     AICompareConfig_t m_aiCompareConfig;