V0.5.2

1、应用了对比项通道的录音设置

Server/ThreadCalculate/CompareItemThread.cpp

@@ -1,6 +1,7 @@
 #include "CompareItemThread.h"
 
 #include "ChannelParam.h"
+#include "CreateRecordFileThread.h"
 #include "FromMQTT.h"
 #include "GlobalInfo.h"
 #include "SystemConfig.h"
@@ -231,16 +232,12 @@ bool CompareItemThread::initData()
         // SPDLOG_LOGGER_ERROR(m_logger, "{} 获取创建实时音量线程失败", m_logBase);
         return false;
     }
-    // for(const auto& pThread : m_mapCreateDBThreads)
-    // {
-    //     if(pThread.second == nullptr)
-    //     {
-    //         SPDLOG_LOGGER_ERROR(m_logger, "{} 获取创建实时音量线程失败，通道: {}", m_logBase, pThread.first);
-    //     }else {
-    //         SPDLOG_LOGGER_INFO(m_logger, "{} 获取创建实时音量线程成功，通道: {}", m_logBase, pThread.first);
-    //     }
-    // }
-
+    
+    /* 获取录音线程 */
+    startOrStopRecord(false); // 停止录音
+    getRecordThread();
+    /* 开始录音 */
+    startOrStopRecord(true);
     
 
     /* 初始化存储结果的数据结构 */
@@ -380,6 +377,29 @@ bool CompareItemThread::getCreateDBThread()
     }
 }
 
+/* 获取录音线程，这个属于录音线程，不需要移除释放  */
+void CompareItemThread::getRecordThread()
+{
+    m_mapRecordThreads.clear();
+    /* 获取录音通道，不需要录音的不获取 */
+    for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
+    {
+        if(road.isEnableRecord == false)
+        {
+            continue; // 不需要录音的通道，不获取录音线程
+        }
+        CreateRecordFileThread* pThread = ThreadMan.getCreateRecordFileThread(road.scRoadInfo.nSoundCardNum, road.scRoadInfo.roadInfo.nRoadNum);
+        if(pThread != nullptr)
+        {
+            m_mapRecordThreads.insert({road.nCompareRoadNum, pThread});
+            // SPDLOG_LOGGER_INFO(m_logger, "{} 获取录音线程成功，通道: {}:{}", m_logBase, road.scRoadInfo.strSoundCardName.toStdString(), road.scRoadInfo.roadInfo.nRoadNum);
+        } else
+        {
+            SPDLOG_LOGGER_WARN(m_logger, "{} 获取录音线程失败，通道: {}:{}", m_logBase, road.scRoadInfo.strSoundCardName.toStdString(), road.scRoadInfo.roadInfo.nRoadNum);
+        }
+    }
+}
+
 
 
 /* 创建两个对比线程，主通道是第一个通道，其他都需要和主通道进行对比 */
@@ -529,44 +549,6 @@ void CompareItemThread::destroyNoiseDetectThreads()
     SPDLOG_LOGGER_INFO(m_logger, "{} 噪音检测线程销毁完成", m_logBase);
 }
 
-/* 获取噪音检测的线程 */
-// bool CompareItemThread::getNoiseDetectThreads()
-// {
-//     for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
-//     {
-//         NoiseDetectThread* pThread = ThreadMan.getNoiseDetectThread(road.scRoadInfo, m_threadInfo.compareItemInfo.nID);
-//         if(pThread == nullptr)
-//         {
-//             SPDLOG_LOGGER_ERROR(m_logger, "{} 获取噪音检测线程失败", m_logBase);
-//             return false; // 获取线程失败
-//         }
-//         /* 向噪音检测线程写入对比项通道信息 */
-//         pThread->startCompareItemNoiseAlarm(m_threadInfo.compareItemInfo.nID, m_threadInfo.compareItemInfo.strName, road);
-//         m_mapNoiseDetectThreads.insert({road.nCompareRoadNum, pThread});
-//     }
-
-//     return true;
-// }
-
-/* 移除噪音检测的线程 */
-// void CompareItemThread::removeNoiseDetectThreads()
-// {
-//     if(m_mapNoiseDetectThreads.size() == 0)
-//     {
-//         return; // 没有噪音检测线程
-//     }
-//     SPDLOG_LOGGER_INFO(m_logger, "{} 移除噪音检测线程", m_logBase);
-//     for(auto& pair : m_mapNoiseDetectThreads)
-//     {
-//         if(pair.second != nullptr)
-//         {
-//             ThreadMan.removeNoiseDetectThread(pair.second->getRoadInfo(), m_threadInfo.compareItemInfo.nID);
-//         }
-//     }
-//     m_mapNoiseDetectThreads.clear();
-//     SPDLOG_LOGGER_INFO(m_logger, "{} 噪音检测线程移除完成", m_logBase);
-// }
-
 
 /**
     音量包更新逻辑：
@@ -916,3 +898,32 @@ bool CompareItemThread::checkDetectPeriod()
     return true;
 }
 
+
+/* 开启或结束录音 */
+void CompareItemThread::startOrStopRecord(bool isStart)
+{
+    for(auto& pair : m_mapRecordThreads)
+    {
+        CreateRecordFileThread* pThread = pair.second;
+        if(pThread == nullptr)
+        {
+            SPDLOG_LOGGER_ERROR(m_logger, "{} 录音线程失效，通道: {}", m_logBase, pair.first);
+            continue;
+        }
+        OneCompareItemRoadInfo_t itemRoadInfo;
+        itemRoadInfo.nCompareItemID = m_threadInfo.compareItemInfo.nID;
+        itemRoadInfo.nCompareRoadNum = pair.first;
+        itemRoadInfo.nSoundCardNum = m_threadInfo.compareItemInfo.mapRoad[pair.first].scRoadInfo.nSoundCardNum;
+        itemRoadInfo.nSoundCardRoadNum = m_threadInfo.compareItemInfo.mapRoad[pair.first].scRoadInfo.roadInfo.nRoadNum;
+        if(isStart)
+        {
+            pThread->startRecordLongFile(itemRoadInfo);
+            // SPDLOG_LOGGER_INFO(m_logger, "{} 开始录音，通道: {}", m_logBase, pair.first);
+        }else {
+            pThread->stopRecordLongFile(itemRoadInfo);
+            // SPDLOG_LOGGER_INFO(m_logger, "{} 停止录音，通道: {}", m_logBase, pair.first);
+        }
+    }
+}
+
+

Server/ThreadCalculate/CompareItemThread.h

@@ -18,6 +18,7 @@ class CalculateDBThread;
 class NoiseDetectThread;
 class CompareDoubleThread;
 class CreateDBThread;
+class CreateRecordFileThread;
 
 
 /**
@@ -79,6 +80,8 @@ private slots:
 private:
     /* 获取创建实时音量的线程，这个线程属于录音线程，不需要在这里移除和销毁 */
     bool getCreateDBThread();
+    /* 获取录音线程，这个属于录音线程，不需要移除释放  */
+    void getRecordThread();
 
     /* 创建两个对比线程，主通道是第一个通道，其他都需要和主通道进行对比 */
     bool createCompareThreads();
@@ -95,11 +98,6 @@ private:
     void destroyNoiseDetectThreads();
 
 
-    /* 获取噪音检测的线程 */
-    // bool getNoiseDetectThreads();
-    /* 移除噪音检测的线程 */
-    // void removeNoiseDetectThreads();
-
 
     /* 更新数据 */
     bool updateResultData();
@@ -114,6 +112,9 @@ private:
     /* 检查是否在检测时间段内，更新其他检测功能的检测时间，对比项是否启用由外部控制 */
     bool checkDetectPeriod();
 
+    /* 开启或结束录音 */
+    void startOrStopRecord(bool isStart);
+
 private:
     /* 事件循环 */
     QEventLoop m_eventLoop;
@@ -157,6 +158,10 @@ private:
 
     /* 噪音检测参数 */
     NoiseDetectBaseConfig_t m_noiseDetectConfig;
+
+    /* ---------------------- 录音线程 ---------------------- */
+    /* 录音线程指针，int是录音通道号 */
+    std::map<int, CreateRecordFileThread*> m_mapRecordThreads;
 };
 
 

Server/ThreadRecord/CreateRecordFileThread.cpp

@@ -4,6 +4,7 @@
 #include "GlobalInfo.h"
 #include "spdlog.h"
 #include <cstring>
+#include <mutex>
 #include <qt5/QtCore/qchar.h>
 
 
@@ -51,7 +52,12 @@ bool CreateRecordFileThread::setData(const AudioSrcData& srcData)
     }
     
     /* ------------------------------------------------------------------------------- */
-    /* 锁定缓冲区 */
+    if(m_isRequireRecord.load() == false)
+    {
+        /* 如果不需要录音，则直接返回 */
+        return true;
+    }
+    /* 锁定长文件录音缓冲区 */
     std::lock_guard<std::mutex> lock(m_mutexBuffer);
     /* 如果缓冲区没有分配内存，先分配 */
     if(m_bufferData.pData == nullptr)
@@ -87,7 +93,7 @@ bool CreateRecordFileThread::setData(const AudioSrcData& srcData)
 bool CreateRecordFileThread::startRecordLongFile(const OneCompareItemRoadInfo_t& compareItemRoadInfo)
 {
     if(compareItemRoadInfo.nSoundCardNum != m_threadInfo.cardRoadInfo.nSoundCardNum ||
-       compareItemRoadInfo.nRoadNum != m_threadInfo.cardRoadInfo.roadInfo.nRoadNum)
+       compareItemRoadInfo.nSoundCardRoadNum != m_threadInfo.cardRoadInfo.roadInfo.nRoadNum)
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 开始录制音频文件失败，通道信息不匹配", m_logBase);
         return false;
@@ -97,6 +103,8 @@ bool CreateRecordFileThread::startRecordLongFile(const OneCompareItemRoadInfo_t&
     {
         return true;
     }
+    m_listCompareItemRoadInfo.append(compareItemRoadInfo);
+    m_isRequireRecord.store(true); // 设置为需要录音状态
 
     return true;
 }
@@ -104,7 +112,27 @@ bool CreateRecordFileThread::startRecordLongFile(const OneCompareItemRoadInfo_t&
 /* 停止录制长文件 */
 bool CreateRecordFileThread::stopRecordLongFile(const OneCompareItemRoadInfo_t& compareItemRoadInfo)
 {
+    if(compareItemRoadInfo.nSoundCardNum != m_threadInfo.cardRoadInfo.nSoundCardNum ||
+       compareItemRoadInfo.nSoundCardRoadNum != m_threadInfo.cardRoadInfo.roadInfo.nRoadNum)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "{} 结束录制音频文件失败，通道信息不匹配", m_logBase);
+        return false;
+    }
+    std::lock_guard<std::mutex> lock(m_mutexCompareItemRoadInfo);
+    if(!m_listCompareItemRoadInfo.contains(compareItemRoadInfo))
+    {
+        // SPDLOG_LOGGER_WARN(m_logger, "{} 停止录制音频文件失败，通道信息不在列表中", m_logBase);
+        return true;
+    }
+    /* 从列表中移除 */
+    m_listCompareItemRoadInfo.removeAll(compareItemRoadInfo);
 
+    if(m_listCompareItemRoadInfo.isEmpty())
+    {
+        /* 如果没有对比项信息了，则设置为不需要录音状态 */
+        m_isRequireRecord.store(false);
+        clearData();
+    }
 
     return true;
 }
@@ -194,6 +222,13 @@ void CreateRecordFileThread::task()
         /*--------------------------------------------------------------
         * 写入长记录文件
         *--------------------------------------------------------------*/
+        /* 判断是否需要录音 */
+        std::lock_guard<std::mutex> lock(m_mutexCompareItemRoadInfo);
+        if(m_isRequireRecord.load() == false)
+        {
+            /* 没有对比项信息，不进行录音 */
+            continue;
+        }
         writeLongRecordFile();
         
     }
@@ -233,6 +268,7 @@ bool CreateRecordFileThread::initData()
 void CreateRecordFileThread::clearData()
 {
     /* 清理缓存数据 */
+    std::lock_guard<std::mutex> lock(m_mutexBuffer);
     m_bufferData.clear();
 }
 

Server/ThreadRecord/CreateRecordFileThread.h

@@ -7,6 +7,7 @@
 #include "RingQueue.hpp"
 #include "RingQueueManualMutex.hpp"
 
+#include <atomic>
 #include <mutex>
 #include <QFile>
 #include <QDir>
@@ -168,6 +169,7 @@ private:
     /* 对比项通道信息列表，记录当前对比项的通道信息，如果没有对比项信息就停止录音 */
     std::mutex m_mutexCompareItemRoadInfo;
     QList<OneCompareItemRoadInfo_t> m_listCompareItemRoadInfo;
+    std::atomic_bool m_isRequireRecord = false;    /* 是否需要录音 */
 
 
     /* 临时缓存数据, 一分钟写入一次，给这个分配2分钟的数据大小 */

common/GlobalInfo/GlobalVariable.cpp

@@ -70,7 +70,7 @@ OneCompareItemRoadInfo_t& OneCompareItemRoadInfo_t::operator=(const OneCompareIt
     nCompareItemID = other.nCompareItemID;
     nCompareRoadNum = other.nCompareRoadNum;
     nSoundCardNum = other.nSoundCardNum;
-    nRoadNum = other.nRoadNum;
+    nSoundCardRoadNum = other.nSoundCardRoadNum;
     return *this;
 }
 
@@ -79,7 +79,7 @@ bool OneCompareItemRoadInfo_t::operator==(const OneCompareItemRoadInfo_t &other)
     return (nCompareItemID == other.nCompareItemID &&
             nCompareRoadNum == other.nCompareRoadNum &&
             nSoundCardNum == other.nSoundCardNum &&
-            nRoadNum == other.nRoadNum);
+            nSoundCardRoadNum == other.nSoundCardRoadNum);
 }
 
 

common/GlobalInfo/GlobalVariable.h

@@ -186,7 +186,7 @@ struct OneCompareItemRoadInfo_t
     int nCompareItemID = -1;                /* 对比项ID */
     int nCompareRoadNum = -1;               /* 对比项通道编号 */
     int nSoundCardNum = -1;                 /* 声卡编号 */
-    int nRoadNum = -1;                      /* 声卡通道编号 */
+    int nSoundCardRoadNum = -1;             /* 声卡通道编号 */
 
     OneCompareItemRoadInfo_t() = default;
     OneCompareItemRoadInfo_t(const OneCompareItemRoadInfo_t &other);