V0.2

1、修改完成了服务与动态库的统一，可以编译通过

RTPServer/RtpOneRoadThread.cpp

@@ -13,7 +13,8 @@ RTPOneRoadThread::RTPOneRoadThread(RecordThreadInfo_t& threadInfo)
         fmt::print("RTPServer 日志记录器未初始化，请先初始化日志记录器");
         return;
     }
-    m_logBase = fmt::format("录音通道: {}", static_cast<int>(m_threadInfo.RoadInfo.roadID));
+    m_logBase = fmt::format("录音通道: {}:{}", static_cast<int>(m_threadInfo.cardRoadInfo.strSoundCardName.toStdString(), 
+                            m_threadInfo.cardRoadInfo.roadInfo.nRoadNum));
     
     m_isRunning.store(true); // 设置为运行状态
 }

RTPServer/RtpServer.cpp

@@ -138,7 +138,7 @@ void RTPServer::handleLogout(RtpSendClientInfo_t& clientInfo)
 
 
 /* 获取发送UDP数据的指针 */
-bool RTPServer::getSendUdpSocketPtr(ERoadID roadID)
+bool RTPServer::getSendUdpSocketPtr(SoundCardRoadInfo_t roadID)
 {
     
     return true;

RTPServer/RtpServer.h

@@ -51,7 +51,7 @@ private:
     void handleLogout(RtpSendClientInfo_t& clientInfo);
 
     /* 获取发送UDP数据的指针 */
-    bool getSendUdpSocketPtr(ERoadID roadID);
+    bool getSendUdpSocketPtr(SoundCardRoadInfo_t roadInfo);
 
 private:
     std::shared_ptr<spdlog::logger> m_logger = nullptr;     /* 日志记录器 */
@@ -61,7 +61,7 @@ private:
     QList<QTcpSocket*> m_listClients;       /* 客户端连接列表，用于管理多个客户端连接 */
 
     /* 录音通道线程列表，键为录音通道ID，值为对应的RTP线程对象 */
-    QMap<ERoadID, RTPOneRoadThread*> m_mapRoadThreads;
+    QMap<SoundCardRoadInfo_t, RTPOneRoadThread*> m_mapRoadThreads;
 };
 
 

Server/DataStruct/AlarmInfo.cpp

@@ -10,8 +10,7 @@ AlarmInfo_t& AlarmInfo_t::operator=(const AlarmInfo_t& obj)
     isAlarm = obj.isAlarm;
     CompareItemID = obj.CompareItemID;
     strCompareItemName = obj.strCompareItemName;
-    RoadID = obj.RoadID;
-    strRoadName = obj.strRoadName;
+    RoadInfo = obj.RoadInfo;
     RoadType = obj.RoadType;
     AlarmType = obj.AlarmType;
     StartTime = obj.StartTime;
@@ -27,7 +26,7 @@ AlarmInfo_t& AlarmInfo_t::operator=(const AlarmInfo_t& obj)
 bool AlarmInfo_t::operator==(const AlarmInfo_t& other) const
 {
     return (isAlarm == other.isAlarm) &&
-           (RoadID == other.RoadID) &&
+           (RoadInfo == other.RoadInfo) &&
            (AlarmType == other.AlarmType) &&
            (StartTime == other.StartTime) &&
            (EndTime == other.EndTime);

Server/DataStruct/AlarmInfo.h

@@ -43,8 +43,7 @@ struct AlarmInfo_t
     int CompareItemID = 0;          /* 对比项ID */
     std::string strCompareItemName; /* 对比项名称 */
 
-    ERoadID RoadID;                 /* 录音通道编号 */
-    std::string strRoadName;        /* 录音通道名称 */
+    CompareItemRoadInfo_t RoadInfo; /* 录音通道信息 */
     ERoadType RoadType;             /* 录音通道类型 */
 
     EAlarmType AlarmType = EAlarmType::EAT_None; /* 报警类型 */

Server/DataStruct/CalculateAudio.cpp

@@ -3,10 +3,24 @@
 #include "spdlog/spdlog.h"
 
 #include "AudioData.h"
+#include <string>
+
+
+StAudioNum::StAudioNum()
+{
+	nTotal = 0;
+	nLDataNum = 0;
+	nLUnDataNum = 0;
+	nRDataNum = 0;
+	nRUnDataNum = 0;
+
+}
+
+
 
 StAudioNum& StAudioNum::operator=(const StAudioNum& obj)
 {
-	nRoadId = obj.nRoadId;
+	roadInfo = obj.roadInfo;
 	nTotal = obj.nTotal;
 	nLDataNum = obj.nLDataNum;
 	nLUnDataNum = obj.nLUnDataNum;
@@ -17,6 +31,7 @@ StAudioNum& StAudioNum::operator=(const StAudioNum& obj)
 
 bool StAudioNum::AudioIsError(int nDataNum, int nUnDataNum, bool bLeft)
 {
+	std::string strRoadName = roadInfo.strSoundCardName.toStdString() + ":" + std::to_string(roadInfo.roadInfo.nRoadNum);
 	if (nDataNum > 0 && nUnDataNum > 0 && pcmErrorPercent > 0)
 	{
 		int nMax = nDataNum > nUnDataNum ? nDataNum : nUnDataNum;
@@ -27,10 +42,10 @@ bool StAudioNum::AudioIsError(int nDataNum, int nUnDataNum, bool bLeft)
 		{
 			if (bLeft)
 			{
-				SPDLOG_INFO("通道{}: 左声道数据不对称，判断为噪音, Left: {}, {}", static_cast<int>(nRoadId), nLDataNum, nLUnDataNum);
+				SPDLOG_INFO("通道{}: 左声道数据不对称，判断为噪音, Left: {}, {}", strRoadName, nLDataNum, nLUnDataNum);
 			} else
 			{
-				SPDLOG_INFO("通道{}: 右声道数据不对称，判断为噪音, Right: {}, {}", static_cast<int>(nRoadId), nRDataNum, nRUnDataNum);
+				SPDLOG_INFO("通道{}: 右声道数据不对称，判断为噪音, Right: {}, {}", strRoadName, nRDataNum, nRUnDataNum);
 			}
 			return true;
 		}
@@ -41,6 +56,7 @@ bool StAudioNum::AudioIsError(int nDataNum, int nUnDataNum, bool bLeft)
 // 有问题的音频
 bool StAudioNum::IsErrorAudio()
 {
+	std::string strRoadName = roadInfo.strSoundCardName.toStdString() + ":" + std::to_string(roadInfo.roadInfo.nRoadNum);
 	const int nMute = 200;
 	if (nLDataNum > nMute || nLUnDataNum > nMute || nRDataNum > nMute || nRUnDataNum > nMute)
 	{
@@ -49,20 +65,20 @@ bool StAudioNum::IsErrorAudio()
 			const int nMinTotal = nTotal / pcmLessPercent;
 			if ((nLDataNum > 0 || nLUnDataNum > 0) && (nLDataNum < nMinTotal || nLUnDataNum < nMinTotal) )
 			{
-				SPDLOG_INFO("通道{}: 左声道数据很少, Left: {}, {}, Right: {}, {}", static_cast<int>(nRoadId), nLDataNum, nLUnDataNum, nRDataNum, nRUnDataNum);
+				SPDLOG_INFO("通道{} : 左声道数据很少, Left: {}, {}, Right: {}, {}", strRoadName, nLDataNum, nLUnDataNum, nRDataNum, nRUnDataNum);
                 // 不是静音，但数据很少，直接判断为有误
 				return true;
 			}
 			if ((nRDataNum > 0 || nRUnDataNum > 0) && (nRDataNum < nMinTotal || nRUnDataNum < nMinTotal))
 			{
-				SPDLOG_INFO("通道{}: 右声道数据很少, Left: {}, {}, Right: {}, {}", static_cast<int>(nRoadId), nLDataNum, nLUnDataNum, nRDataNum, nRUnDataNum);
+				SPDLOG_INFO("通道{} : 右声道数据很少, Left: {}, {}, Right: {}, {}", strRoadName, nLDataNum, nLUnDataNum, nRDataNum, nRUnDataNum);
                 // 不是静音，但数据很少，直接判断为有误
 				return true;
 			}
 		}
 	} else
 	{
-		SPDLOG_INFO("通道{}: 静音了, Left: {}, {}, Right: {}, {}", static_cast<int>(nRoadId), nLDataNum, nLUnDataNum, nRDataNum, nRUnDataNum);
+		SPDLOG_INFO("通道 {} : 静音了, Left: {}, {}, Right: {}, {}", strRoadName, nLDataNum, nLUnDataNum, nRDataNum, nRUnDataNum);
 		return false; // 静音了
 	}
 	if (AudioIsError(nLDataNum, nLUnDataNum, true))

Server/DataStruct/CalculateAudio.h

@@ -16,10 +16,10 @@ struct OneSecondData;
  */
 struct StAudioNum
 {
-	StAudioNum() : nRoadId(ERoadID::RoadID_None), nTotal(0), nLDataNum(0), nLUnDataNum(0), nRDataNum(0), nRUnDataNum(0) {}
+	StAudioNum();
 	StAudioNum(const StAudioNum& obj) { *this = obj; }
 
-	ERoadID nRoadId; 	/* 通道ID */
+	SoundCardRoadInfo_t roadInfo; 	/* 通道ID */
 	int nTotal;             /* 总数据包数 */
 	int nLDataNum;          // 音频数据正数个数
 	int nLUnDataNum;        // 音频数据负数个数
@@ -31,6 +31,8 @@ struct StAudioNum
     int pcmErrorPercent = 0;    // 音频不对称百分比
     int pcmLessPercent = 0;     // 音频少于百分比
 
+	// std::string strRoadName; // 通道名称
+
 	StAudioNum& operator=(const StAudioNum& obj);
 
 	bool AudioIsError(int nDataNum, int nUnDataNum, bool bLeft);

Server/DataStruct/CompareResult.cpp

@@ -1,7 +1,7 @@
 #include "CompareResult.h"
 
 OneRoadVolume_t::OneRoadVolume_t()
-    : RoadID(ERoadID::RoadID_None), Road_num(0), isSilence(false), isOverload(false), 
+    : isSilence(false), isOverload(false), 
       isReversed(false), isNoise(false), isNoiseWarning(false), similarity(0.0),
       leftRealTimeDB(0), rightRealTimeDB(0)
 {
@@ -17,9 +17,9 @@ OneRoadVolume_t& OneRoadVolume_t::operator=(const OneRoadVolume_t &obj)
     if(this == &obj)
         return *this; // 防止自赋值
 
-    RoadID = obj.RoadID;
-    strRoadName = obj.strRoadName;
-    Road_num = obj.Road_num;
+    roadInfo = obj.roadInfo; // 录音通道信息
+    // strRoadName = obj.strRoadName;
+    // Road_num = obj.Road_num;
     isSilence = obj.isSilence;
     isOverload = obj.isOverload;
     isReversed = obj.isReversed;

Server/DataStruct/CompareResult.h

@@ -12,9 +12,9 @@
  */
 struct OneRoadVolume_t
 {
-    ERoadID RoadID = ERoadID::RoadID_None;  /* 录音通道ID */
-    std::string strRoadName;                /* 录音通道名称 */
-    int Road_num = 0;                       /* 录音通道编号 */
+    CompareItemRoadInfo_t roadInfo;         /* 录音通道ID */
+    // std::string strRoadName;                /* 录音通道名称 */
+    // int Road_num = 0;                       /* 录音通道编号 */
     bool isSilence = false;                 /* 是否静音 */
     bool isOverload = false;                /* 是否过载 */
     bool isReversed = false;                /* 是否反相 */

Server/DataStruct/SendStruct.h

@@ -12,23 +12,23 @@
  * @brief 对比项信息结构体
  * 
  */
-struct StCompareItemInfo
-{
-	int compareItemID;          		/* 对比项ID */
-	std::string compareItemName; 		/* 对比项名称 */
-
-	std::map<ERoadID, std::string> mapRoad; /* 录音通道 */
-
-	/* 静音检测条件 */
-	bool isSilentSwitch;          		/* 静音开关 */
-	int silentThreshold;         		/* 静音阈值，单位：DB */
-	int silentDuration;          		/* 静音持续时间，单位：秒 */
-
-	/* 过载检测条件 */
-	bool isOverloadSwitch;        		/* 过载开关 */
-	int overloadThreshold;       		/* 过载阈值，单位：DB */
-	int overloadDuration;        		/* 过载持续时间，单位：秒 */
-};
+// struct StCompareItemInfo
+// {
+// 	int compareItemID;          		/* 对比项ID */
+// 	std::string compareItemName; 		/* 对比项名称 */
+
+// 	std::map<ERoadID, std::string> mapRoad; /* 录音通道 */
+
+// 	/* 静音检测条件 */
+// 	bool isSilentSwitch;          		/* 静音开关 */
+// 	int silentThreshold;         		/* 静音阈值，单位：DB */
+// 	int silentDuration;          		/* 静音持续时间，单位：秒 */
+
+// 	/* 过载检测条件 */
+// 	bool isOverloadSwitch;        		/* 过载开关 */
+// 	int overloadThreshold;       		/* 过载阈值，单位：DB */
+// 	int overloadDuration;        		/* 过载持续时间，单位：秒 */
+// };
 
 
 

Server/ThreadCalculate/BaseCalculateThread.cpp

@@ -20,7 +20,7 @@ BaseCalculateThread::BaseCalculateThread(CalculateThreadInfo_t& threadInfo)
 void BaseCalculateThread::threadTask()
 {
     m_logBase = fmt::format("对比项: {} 线程类型: {}", 
-                            m_threadInfo.compareItemInfo.strName,
+                            m_threadInfo.compareItemInfo.strName.toStdString(),
                             static_cast<int>(m_threadInfo.threadType));
     m_threadInfo.threadState = EThreadState::State_Running;
     m_isStop = false;

Server/ThreadCalculate/CalculateDBPhaseThread.cpp

@@ -109,10 +109,11 @@ void CalculateDBPhaseThread::task()
 bool CalculateDBPhaseThread::initData()
 {
     /* 对于单个录音通道的线程来说，直接取map中的第一个通道 */
-    m_roadInfo = m_threadInfo.compareItemInfo.mapRoad.begin()->scRoadInfo;
-    m_roadName = m_threadInfo.compareItemInfo.mapRoad.begin()->strCompareRoadName;
+    auto begin = m_threadInfo.compareItemInfo.mapRoad.begin();
+    m_roadInfo = begin.value(); // 获取第一个通道的信息
+    m_roadName = m_roadInfo.strCompareRoadName.toStdString();
 
-    m_threadCreateDBPhase = ThreadMan.getCreateDBPhaseThread(m_roadInfo.roadID);
+    m_threadCreateDBPhase = ThreadMan.getCreateDBPhaseThread(m_roadInfo.scRoadInfo.nSoundCardNum, m_roadInfo.scRoadInfo.roadInfo.nRoadNum);
     if (m_threadCreateDBPhase == nullptr)
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 获取创建音量线程失败", m_logBase);
@@ -191,8 +192,8 @@ void CalculateDBPhaseThread::processSilence()
         {
             /* 开启静音报警 */
             m_alarmSilence.isAlarm = true;
-            m_alarmSilence.RoadID = m_roadInfo.roadID;
-            m_alarmSilence.strRoadName = m_roadName;
+            m_alarmSilence.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
+            m_alarmSilence.RoadInfo = m_roadInfo; // 设置通道信息
             m_alarmSilence.AlarmType = EAlarmType::EAT_Silent; // 静音报警
             /* 计算开始时间，往前推判断静音需要的时间 */
             QDateTime startTime;
@@ -255,8 +256,8 @@ void CalculateDBPhaseThread::processOverload()
         {
             /* 开启过载报警 */
             m_alarmOverload.isAlarm = true;
-            m_alarmOverload.RoadID = m_roadInfo.roadID;
-            m_alarmOverload.strRoadName = m_roadName;
+            m_alarmOverload.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
+            m_alarmOverload.RoadInfo = m_roadInfo; // 设置通道信息
             m_alarmOverload.AlarmType = EAlarmType::EAT_Overload; // 过载报警
             /* 计算开始时间，往前推设置的过载时长 */
             QDateTime startTime;
@@ -320,8 +321,8 @@ void CalculateDBPhaseThread::processPhase()
         {
             /* 开启反相报警 */
             m_alarmPhase.isAlarm = true;
-            m_alarmPhase.RoadID = m_roadInfo.roadID;
-            m_alarmPhase.strRoadName = m_roadName;
+            m_alarmPhase.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
+            m_alarmPhase.RoadInfo = m_roadInfo; // 设置通道信息
             m_alarmPhase.AlarmType = EAlarmType::EAT_Reversed; // 反相报警
             /* 计算开始时间，往前推设置的反相时长 */
             QDateTime startTime;
@@ -378,7 +379,7 @@ void CalculateDBPhaseThread::processPhase()
 std::string CalculateDBPhaseThread::generateAlarmFilePath(const AlarmInfo_t& alarmInfo)
 {
     std::string filePath = fmt::format("Alarm_{}_{}_{}.wav", 
-        alarmInfo.strRoadName, 
+        alarmInfo.strCompareItemName, 
         static_cast<int>(alarmInfo.AlarmType), 
         alarmInfo.StartTime.toString("yyyyMMdd_hhmmss").toStdString());
     return filePath;

Server/ThreadCalculate/CalculateDBPhaseThread.h

@@ -11,7 +11,7 @@
 
 
 /**
- *  这个线程类进行静音、过载和反相等报警的计算
+ *  这个线程类进行静音、过载和反相等报警的计算，这个线程和对比项相关，需要对比项中的参数，由对比项线程创建
  *      1、计算静音、过载和反相
  *      2、将报警结果得出的报警信息发送给写数据库线程，写入到数据库中
  *      3、将报警结果发送给截取报警文件的线程，截取出报警时间段的音频文件
@@ -29,7 +29,7 @@ public:
     ~CalculateDBPhaseThread() override;
 
     /* 获取线程通道信息 */
-    RoadNumberInfo_t getRoadInfo() const { return m_roadInfo; }
+    CompareItemRoadInfo_t getRoadInfo() const { return m_roadInfo; }
 
     /* 获取结果，这个线程计算出静音、过载、反相和音量包信息 */
     OneRoadVolume_t getVolumeInfo();
@@ -63,7 +63,7 @@ private:
 
 private:
     /* 录音通道信息 */
-    SoundCardRoadInfo_t  m_roadInfo;                        /* 录音通道编号 */
+    CompareItemRoadInfo_t  m_roadInfo;                      /* 录音通道编号，带有对比项信息 */
     std::string m_roadName;                                 /* 录音通道名称 */
     /* 计算结果 */
     std::mutex m_mutexVolumeInfo;                           /* 保护音量信息的互斥锁 */

Server/ThreadCalculate/CompareDoubleThread.cpp

@@ -89,14 +89,18 @@ void CompareDoubleThread::task()
 /* 初始化数据 */
 bool CompareDoubleThread::initData()
 {
-    if(m_threadInfo.vecRoad.size() < 2)
+    if(m_threadInfo.compareItemInfo.mapRoad.size() < 2)
     {
-        SPDLOG_LOGGER_WARN(m_logger, "{} 对比项信息错误，通道数量小于2", m_threadInfo.strCompareItemName);
+        SPDLOG_LOGGER_WARN(m_logger, "{} 对比项信息错误，录音通道数量小于2", m_threadInfo.compareItemInfo.strName.toStdString());
         return false;
     }
-    m_roadInfo1 = m_threadInfo.vecRoad[0];
-    m_roadInfo2 = m_threadInfo.vecRoad[1]; // 录音通道2信息
-    m_logBase = fmt::format("{} 对比项: {}-{}", m_threadInfo.strCompareItemName, m_roadInfo1.roadNum, m_roadInfo2.roadNum);
+    auto begin = m_threadInfo.compareItemInfo.mapRoad.begin();
+    m_roadInfo1 = begin->scRoadInfo;
+    begin++; // 移动到下一个元素
+    m_roadInfo2 = begin->scRoadInfo; // 录音通道2信息
+    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(); // 获取计算需要的秒数
@@ -108,8 +112,8 @@ bool CompareDoubleThread::initData()
     m_nIsSameBothMinDBWaitNum = GInfo.nIsSameBothMinDBWaitNum(); // 获取是否需要等待静音状态
 
     /* 获取生成音量的线程 */
-    m_threadCreateDBPhase1 = ThreadMan.getCreateDBPhaseThread(m_roadInfo1.roadID);
-    m_threadCreateDBPhase2 = ThreadMan.getCreateDBPhaseThread(m_roadInfo2.roadID);
+    m_threadCreateDBPhase1 = ThreadMan.getCreateDBPhaseThread(m_roadInfo1.nSoundCardNum, m_roadInfo1.roadInfo.nRoadNum);
+    m_threadCreateDBPhase2 = ThreadMan.getCreateDBPhaseThread(m_roadInfo2.nSoundCardNum, m_roadInfo2.roadInfo.nRoadNum);
     if(m_threadCreateDBPhase1 == nullptr || m_threadCreateDBPhase2 == nullptr)
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 获取生成音量的线程失败", m_logBase);

Server/ThreadCalculate/CompareDoubleThread.h

@@ -88,8 +88,8 @@ private:
 
 private:
     /* ----------------- 基础成员变量 ------------------ */
-    RoadNumberInfo_t m_roadInfo1;                           /* 录音通道1信息 */
-    RoadNumberInfo_t m_roadInfo2;                           /* 录音通道2信息 */
+    SoundCardRoadInfo_t m_roadInfo1;                        /* 录音通道1信息 */
+    SoundCardRoadInfo_t m_roadInfo2;                        /* 录音通道2信息 */
 
     /* 生成音量数据的线程 */
     CreateDBPhaseThread* m_threadCreateDBPhase1 = nullptr;  /* 生成通道1音量数据的线程 */

Server/ThreadCalculate/CompareItemThread.cpp

@@ -22,12 +22,12 @@ CompareItemThread::~CompareItemThread()
 /* 线程功能函数 */
 void CompareItemThread::task()
 {
-    m_logBase = fmt::format("对比项: {}", m_threadInfo.strCompareItemName);
+    m_logBase = fmt::format("对比项: {}", m_threadInfo.compareItemInfo.strName.toStdString());
     SPDLOG_LOGGER_INFO(m_logger, "{} 线程开始运行, 对比通道: ", m_logBase);
-    for(const auto& road : m_threadInfo.vecRoad)
+    for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
     {
-        SPDLOG_LOGGER_INFO(m_logger, "通道ID: {}, 名称: {}, 编号: {}",
-                           static_cast<int>(road.roadID), road.strRoadName, road.roadNum);
+        SPDLOG_LOGGER_INFO(m_logger, "通道名称: {}, 通道编号: {}, 声卡通道: {}:{}",
+                           road.strCompareRoadName.toStdString(), road.nCompareRoadNum, road.scRoadInfo.strSoundCardName.toStdString(), road.scRoadInfo.roadInfo.nRoadNum);
     }
 
     /* 初始化数据 */
@@ -69,21 +69,22 @@ void CompareItemThread::task()
 bool CompareItemThread::initData()
 {
     /* 获取计算音量信息的线程指针 */
-    for(const auto& road : m_threadInfo.vecRoad)
+    for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
     {
-        CalculateDBPhaseThread* pThread = ThreadMan.getCalculateDBPhaseThread(road);
-        if(pThread == nullptr)
-        {
-            SPDLOG_LOGGER_ERROR(m_logger, "{} 获取计算音量信息线程失败", m_logBase);
-            return false; // 获取线程失败
-        }
-        m_vecCalculateDBPhaseThreads.push_back(pThread);
+        /* 创建计算音量的线程 */
+        // CalculateDBPhaseThread* pThread = ThreadMan.getCalculateDBPhaseThread();
+        // if(pThread == nullptr)
+        // {
+        //     SPDLOG_LOGGER_ERROR(m_logger, "{} 获取计算音量信息线程失败", m_logBase);
+        //     return false; // 获取线程失败
+        // }
+        // m_vecCalculateDBPhaseThreads.push_back(pThread);
     }
 
     /* 获取计算噪音的线程 */
-    for(const auto& road : m_threadInfo.vecRoad)
+    for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
     {
-        NoiseDetectThread* pThread = ThreadMan.getNoiseDetectThread(road);
+        NoiseDetectThread* pThread = ThreadMan.getNoiseDetectThread(road.scRoadInfo);
         if(pThread == nullptr)
         {
             SPDLOG_LOGGER_ERROR(m_logger, "{} 获取噪音检测线程失败", m_logBase);
@@ -99,35 +100,34 @@ bool CompareItemThread::initData()
     }
 
     /* 初始化存储结果的数据结构 */
-    m_compareResult.compareItemID = m_threadInfo.CompareItemID;
-    m_compareResult.compareItemName = m_threadInfo.strCompareItemName;
+    m_compareResult.compareItemID = m_threadInfo.compareItemInfo.nID;
+    m_compareResult.compareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
     m_compareResult.dateTime = QDateTime::currentDateTime();
     m_compareResult.isClientAlarm = false; // 默认不报警
     m_compareResult.vecRoadVolumes.clear(); // 清空之前的数据
-    for(const auto& road : m_threadInfo.vecRoad)
+    for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
     {
         OneRoadVolume_t oneRoadVolume;
-        oneRoadVolume.RoadID = road.roadID;
-        oneRoadVolume.strRoadName = road.strRoadName;
-        oneRoadVolume.Road_num = road.roadNum;
+        oneRoadVolume.roadInfo = road; // 设置通道信息
         oneRoadVolume.dateTime = QDateTime::currentDateTime(); // 初始化时间
         m_compareResult.vecRoadVolumes.push_back(oneRoadVolume);
     }
 
-    m_vecCDBPhaseUpdated.reserve(m_threadInfo.vecRoad.size());
-    for(size_t i = 0; i < m_threadInfo.vecRoad.size(); ++i)
+    int roadCount = m_threadInfo.compareItemInfo.mapRoad.size();
+    m_vecCDBPhaseUpdated.reserve(roadCount);
+    for(int i = 0; i < m_threadInfo.compareItemInfo.mapRoad.size(); ++i)
     {
         m_vecCDBPhaseUpdated.push_back(false); // 初始化为未更新
     }
 
     /* 初始化报警信息 */
-    m_vecAlarmSilence.reserve(m_threadInfo.vecRoad.size());
-    m_vecAlarmOverload.reserve(m_threadInfo.vecRoad.size());
-    m_vecAlarmPhase.reserve(m_threadInfo.vecRoad.size());
+    m_vecAlarmSilence.reserve(roadCount);
+    m_vecAlarmOverload.reserve(roadCount);
+    m_vecAlarmPhase.reserve(roadCount);
 
-    m_vecAlarmSilenceLast.reserve(m_threadInfo.vecRoad.size());
-    m_vecAlarmOverloadLast.reserve(m_threadInfo.vecRoad.size());
-    m_vecAlarmPhaseLast.reserve(m_threadInfo.vecRoad.size());
+    m_vecAlarmSilenceLast.reserve(roadCount);
+    m_vecAlarmOverloadLast.reserve(roadCount);
+    m_vecAlarmPhaseLast.reserve(roadCount);
 
     return true;
 }
@@ -152,20 +152,22 @@ void CompareItemThread::clearData()
 /* 创建两个对比线程，主通道是第一个通道，其他都需要和主通道进行对比 */
 bool CompareItemThread::dispatchCompareThreads()
 {
-    auto mainRoad = m_threadInfo.vecRoad[0];
-    uint64_t size = m_threadInfo.vecRoad.size();
+    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++;
         CalculateThreadInfo_t compareThreadInfo;
-        compareThreadInfo.CompareItemID = m_threadInfo.CompareItemID;
-        compareThreadInfo.strCompareItemName = m_threadInfo.strCompareItemName;
-        compareThreadInfo.vecRoad.push_back(mainRoad); // 主通道
-        compareThreadInfo.vecRoad.push_back(m_threadInfo.vecRoad[i]); // 对比通道
+        compareThreadInfo.compareItemInfo = m_threadInfo.compareItemInfo;
+        compareThreadInfo.compareItemInfo.mapRoad.clear(); // 清空通道信息
+        compareThreadInfo.compareItemInfo.mapRoad.insert(mainRoad.nCompareRoadNum, mainRoad);   // 添加主通道
+        compareThreadInfo.compareItemInfo.mapRoad.insert(it.key(), it.value());                 // 添加当前通道
         compareThreadInfo.threadState = EThreadState::State_Inited;
         CompareDoubleThread* pThread = new CompareDoubleThread(compareThreadInfo);
         if(pThread == nullptr)
         {
-            SPDLOG_LOGGER_ERROR(m_logger, "{} 创建对比线程 {}-{} 失败", m_logBase, mainRoad.strRoadName, m_threadInfo.vecRoad[i].strRoadName);
+            SPDLOG_LOGGER_ERROR(m_logger, "{} 创建对比线程 {} - {} 失败", m_logBase, mainRoad.strCompareRoadName.toStdString(), it.value().strCompareRoadName.toStdString());
             return false;
         }
         m_vecCompareDoubleThreads.push_back(pThread);
@@ -185,7 +187,7 @@ bool CompareItemThread::dispatchCompareThreads()
  */
 bool CompareItemThread::updateResultData()
 {
-    const int size = m_threadInfo.vecRoad.size();
+    const int size = m_threadInfo.compareItemInfo.mapRoad.size();
     /* 先从音量计算数据中获取音量包信息和报警信息 */
     for(int i = 0; i < size; ++i)
     {
@@ -277,8 +279,8 @@ void CompareItemThread::processAlarmData()
             {
                 continue; // 和上次的报警信息一样，不需要处理
             }else {
-                nowAlarm.CompareItemID = m_threadInfo.CompareItemID;
-                nowAlarm.strCompareItemName = m_threadInfo.strCompareItemName;
+                nowAlarm.CompareItemID = m_threadInfo.compareItemInfo.nID;
+                nowAlarm.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
                 m_listAlarm.push_back(nowAlarm);
                 m_vecAlarmSilenceLast[i] = nowAlarm;
             }
@@ -296,8 +298,8 @@ void CompareItemThread::processAlarmData()
             {
                 continue; // 和上次的报警信息一样，不需要处理
             }else {
-                nowAlarm.CompareItemID = m_threadInfo.CompareItemID;
-                nowAlarm.strCompareItemName = m_threadInfo.strCompareItemName;
+                nowAlarm.CompareItemID = m_threadInfo.compareItemInfo.nID;
+                nowAlarm.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
                 m_listAlarm.push_back(nowAlarm);
                 m_vecAlarmOverloadLast[i] = nowAlarm;
             }
@@ -315,8 +317,8 @@ void CompareItemThread::processAlarmData()
             {
                 continue; // 和上次的报警信息一样，不需要处理
             }else {
-                nowAlarm.CompareItemID = m_threadInfo.CompareItemID;
-                nowAlarm.strCompareItemName = m_threadInfo.strCompareItemName;
+                nowAlarm.CompareItemID = m_threadInfo.compareItemInfo.nID;
+                nowAlarm.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
                 m_listAlarm.push_back(nowAlarm);
                 m_vecAlarmPhaseLast[i] = nowAlarm;
             }

Server/ThreadCalculate/ConsistencyCompareThread.cpp

@@ -24,18 +24,22 @@ StConsistencyResult ConsistencyCompareThread::getConsistencyResult()
 }
 
 /* 判断录音通道是否相等 */
-bool ConsistencyCompareThread::isRoadEqual(const RoadNumberInfo_t& roadInfo1, const RoadNumberInfo_t& roadInfo2)
+bool ConsistencyCompareThread::isRoadEqual(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2)
 {
-    /* r1对比r1，r2对比r2 */
-    if(roadInfo1.roadID == roadInfo2.roadID && roadInfo2.roadID == roadInfo1.roadID)
+    /* r1对比m_r1，r2对比M_r2 */
+    if( roadInfo1.nSoundCardNum == m_roadInfo1.nSoundCardNum && roadInfo1.roadInfo.nRoadNum == m_roadInfo1.roadInfo.nRoadNum &&
+        roadInfo2.nSoundCardNum == m_roadInfo2.nSoundCardNum && roadInfo2.roadInfo.nRoadNum == m_roadInfo2.roadInfo.nRoadNum )
     {
         return true;
     }
+    
     /* 反过来对比一下 */
-    if(roadInfo1.roadID == roadInfo2.roadID && roadInfo2.roadID == roadInfo1.roadID)
+    if( roadInfo1.nSoundCardNum == m_roadInfo2.nSoundCardNum && roadInfo1.roadInfo.nRoadNum == m_roadInfo2.roadInfo.nRoadNum &&
+        roadInfo2.nSoundCardNum == m_roadInfo1.nSoundCardNum && roadInfo2.roadInfo.nRoadNum == m_roadInfo1.roadInfo.nRoadNum )
     {
         return true;
     }
+
     return false;
 }
 
@@ -88,12 +92,23 @@ void ConsistencyCompareThread::task()
 /* 初始化数据 */
 bool ConsistencyCompareThread::initData()
 {
-    m_roadInfo1 = m_threadInfo.vecRoad[0]; // 录音通道1信息
-    m_roadInfo2 = m_threadInfo.vecRoad[1]; // 录音通道2信息
-    m_logBase = fmt::format("对比通道 {}-{}", m_roadInfo1.strRoadName, m_roadInfo2.strRoadName);
+    if(m_threadInfo.compareItemInfo.mapRoad.size() < 2)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "{} 录音通道信息不足，至少需要两个通道", m_logBase);
+        return false;
+    }
+    /* 获取两个录音通道的信息 */
+    auto it = m_threadInfo.compareItemInfo.mapRoad.begin();
+    m_roadInfo1 = it.value().scRoadInfo; // 第一个通道
+    it++;
+    m_roadInfo2 = it.value().scRoadInfo; // 第二个通道
+
+    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.roadID);
-    m_pCreateWAVThread2 = ThreadMan.getCreateWAVThread(m_roadInfo2.roadID);
+    m_pCreateWAVThread1 = ThreadMan.getCreateWAVThread(m_roadInfo1.nSoundCardNum, m_roadInfo1.roadInfo.nRoadNum);
+    m_pCreateWAVThread2 = ThreadMan.getCreateWAVThread(m_roadInfo2.nSoundCardNum, m_roadInfo2.roadInfo.nRoadNum);
 
     if(m_pCreateWAVThread1 == nullptr || m_pCreateWAVThread2 == nullptr)
     {

Server/ThreadCalculate/ConsistencyCompareThread.h

@@ -14,6 +14,7 @@ class CreateWAVThread;
 
 /**
  * @brief 计算一致性的线程类
+ *          1、一致性对比线程是调用动态库对比，没有对比参数，不和对比项有关联
  * 
  */
 class ConsistencyCompareThread : public BaseCalculateThread
@@ -26,7 +27,7 @@ public:
     StConsistencyResult getConsistencyResult();
 
     /* 判断录音通道是否相等 */
-    bool isRoadEqual(const RoadNumberInfo_t& roadInfo1, const RoadNumberInfo_t& roadInfo2);
+    bool isRoadEqual(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2);
 
 protected:
     /* 线程功能函数 */
@@ -42,8 +43,8 @@ private:
 
 private:
     /* 两个录音通道的信息 */
-    RoadNumberInfo_t m_roadInfo1;                     /* 录音通道1信息，这里不使用通道num */
-    RoadNumberInfo_t m_roadInfo2;                     /* 录音通道2信息 */
+    SoundCardRoadInfo_t m_roadInfo1;                     /* 录音通道1信息，这里不使用通道num */
+    SoundCardRoadInfo_t m_roadInfo2;                     /* 录音通道2信息 */
     /* 两个录音通道的线程指针，直接通过录音类获取最新的数据 */
     CreateWAVThread* m_pCreateWAVThread1 = nullptr; /* 通道1的录音线程 */
     CreateWAVThread* m_pCreateWAVThread2 = nullptr; /* 通道2的录音线程 */

Server/ThreadCalculate/NoiseDetectThread.cpp

@@ -68,11 +68,12 @@ void NoiseDetectThread::task()
 /* 初始化数据 */
 bool NoiseDetectThread::initData()
 {
-    m_roadInfo = m_threadInfo.vecRoad[0];
-    m_roadName = m_threadInfo.vecRoad.begin()->strRoadName;
-    m_logBase = fmt::format("噪音检测通道 {}", m_roadInfo.strRoadName);
+    auto begin =  m_threadInfo.compareItemInfo.mapRoad.begin(); // 获取第一个通道的信息
+    m_roadInfo = begin->scRoadInfo; // 录音通道信息
+    m_roadName = fmt::format("{}:{}", m_roadInfo.strSoundCardName.toStdString(), m_roadInfo.roadInfo.nRoadNum);
+    m_logBase = fmt::format("噪音检测通道 {}:", m_roadName);
 
-    m_pWAVThread = ThreadMan.getCreateWAVThread(m_roadInfo.roadID);
+    m_pWAVThread = ThreadMan.getCreateWAVThread(m_roadInfo.nSoundCardNum, m_roadInfo.roadInfo.nRoadNum);
     if(m_pWAVThread == nullptr)
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 获取数据生成线程失败", m_logBase);

Server/ThreadCalculate/NoiseDetectThread.h

@@ -9,6 +9,12 @@ class CreateWAVThread;
 
 
 
+/**
+ * @brief 噪音检测线程类
+ *          1、噪音检测线程是调用动态库检测噪音
+ *          2、噪音检测线程参数和对比项无关，是公共的参数，这里没有对比项信息
+ * 
+ */
 class NoiseDetectThread : public BaseCalculateThread
 {
 
@@ -17,7 +23,7 @@ public:
     ~NoiseDetectThread() override;
 
     /* 获取通道信息 */
-    RoadNumberInfo_t getRoadInfo() const { return m_roadInfo; }
+    SoundCardRoadInfo_t getRoadInfo() const { return m_roadInfo; }
     /* 获取噪音结果 */
     bool isNoise() const { return m_isNoise.load(); }
 
@@ -37,7 +43,7 @@ private:
 
 
 private:
-    RoadNumberInfo_t m_roadInfo;                    /* 录音通道编号 */
+    SoundCardRoadInfo_t m_roadInfo;                 /* 录音通道编号 */
     std::string m_roadName;                         /* 录音通道名称 */
     CreateWAVThread* m_pWAVThread = nullptr;        /* WAV小文件生成线程指针 */
 

Server/ThreadManager/ThreadManager.cpp

@@ -5,6 +5,7 @@
 
 #include "CalculateDBPhaseThread.h"
 #include "ConsistencyCompareThread.h"
+#include "GlobalVariable.h"
 #include "NoiseDetectThread.h"
 #include "RtpOneRoadThread.h"
 
@@ -47,8 +48,8 @@ BaseRecordThread* ThreadManager::findRecordThread(EThreadType type, int cardID,
         case EThreadType::Type_RecordSrc:           /* 录音线程 */
             for (auto& pThread : m_recordThreads)
             {
-                if (pThread->getThreadInfo().RoadInfo.roadInfo.nRoadNum == recordID &&
-                    pThread->getThreadInfo().RoadInfo.nSoundCardNum == cardID)
+                if (pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID &&
+                    pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID)
                 {
                     return pThread;
                 }
@@ -57,8 +58,8 @@ BaseRecordThread* ThreadManager::findRecordThread(EThreadType type, int cardID,
         case EThreadType::Type_CreateWAV:           /* 创建wav小文件和分离左右声道的线程 */
             for (auto& pThread : m_createWAVThreads)
             {
-                if (pThread->getThreadInfo().RoadInfo.nSoundCardNum == cardID &&
-                    pThread->getThreadInfo().RoadInfo.roadInfo.nRoadNum == recordID)
+                if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
+                    pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                 {
                     return pThread;
                 }
@@ -67,8 +68,8 @@ BaseRecordThread* ThreadManager::findRecordThread(EThreadType type, int cardID,
         case EThreadType::Type_CalculateDBAndPhase:      /* 计算音量和反相的线程 */
             for (auto& pThread : m_createDBPhaseThreads)
             {
-                if (pThread->getThreadInfo().RoadInfo.nSoundCardNum == cardID &&
-                    pThread->getThreadInfo().RoadInfo.roadInfo.nRoadNum == recordID)
+                if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
+                    pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                 {
                     return pThread;
                 }
@@ -77,8 +78,8 @@ BaseRecordThread* ThreadManager::findRecordThread(EThreadType type, int cardID,
         case EThreadType::Type_CreateLongWAV:           /* 创建长文件的线程 */
             for (auto& pThread : m_createLongWAVThreads)
             {
-                if (pThread->getThreadInfo().RoadInfo.nSoundCardNum == cardID &&
-                    pThread->getThreadInfo().RoadInfo.roadInfo.nRoadNum == recordID)
+                if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
+                    pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                 {
                     return pThread;
                 }
@@ -87,8 +88,8 @@ BaseRecordThread* ThreadManager::findRecordThread(EThreadType type, int cardID,
         case EThreadType::Type_AssignSrcData:           /* 分派数据线程 */
             for (auto& pThread : m_assignSrcDataThreads)
             {
-                if (pThread->getThreadInfo().RoadInfo.nSoundCardNum == cardID &&
-                    pThread->getThreadInfo().RoadInfo.roadInfo.nRoadNum == recordID)
+                if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
+                    pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                 {
                     return pThread;
                 }
@@ -96,8 +97,8 @@ BaseRecordThread* ThreadManager::findRecordThread(EThreadType type, int cardID,
         case EThreadType::Type_RtpSend:               /* RTP发送线程 */
             for (auto& pThread : m_rtpSendThreads)
             {
-                if (pThread->getThreadInfo().RoadInfo.nSoundCardNum == cardID &&
-                    pThread->getThreadInfo().RoadInfo.roadInfo.nRoadNum == recordID)
+                if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
+                    pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                 {
                     return pThread;
                 }
@@ -118,8 +119,8 @@ CreateWAVThread* ThreadManager::getCreateWAVThread(int cardID, int recordID)
 {
     for(auto& pThread : m_createWAVThreads)
     {
-        if(pThread->getThreadInfo().RoadInfo.nSoundCardNum == cardID &&
-           pThread->getThreadInfo().RoadInfo.roadInfo.nRoadNum == recordID)
+        if(pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
+           pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
         {
             return dynamic_cast<CreateWAVThread*>(pThread);
         }
@@ -132,8 +133,8 @@ CreateDBPhaseThread* ThreadManager::getCreateDBPhaseThread(int cardID, int recor
 {
     for(auto& pThread : m_createDBPhaseThreads)
     {
-        if(pThread->getThreadInfo().RoadInfo.nSoundCardNum == cardID &&
-           pThread->getThreadInfo().RoadInfo.roadInfo.nRoadNum == recordID)
+        if(pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
+           pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
         {
             return dynamic_cast<CreateDBPhaseThread*>(pThread);
         }
@@ -146,8 +147,8 @@ RTPOneRoadThread* ThreadManager::getRtpSendThread(int cardID, int recordID)
 {
     for(auto& pThread : m_rtpSendThreads)
     {
-        if(pThread->getThreadInfo().RoadInfo.nSoundCardNum == cardID &&
-           pThread->getThreadInfo().RoadInfo.roadInfo.nRoadNum == recordID)
+        if(pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
+           pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
         {
             return dynamic_cast<RTPOneRoadThread*>(pThread);
         }
@@ -162,7 +163,7 @@ RTPOneRoadThread* ThreadManager::getRtpSendThread(int cardID, int recordID)
  * -------------------------------------------------------------------------------------------- */
 
 /* 获取一致性比对线程，线程不存在则创建 */
-ConsistencyCompareThread* ThreadManager::getConsistencyCompareThread(const CompareItemRoadInfo_t& roadInfo1, const CompareItemRoadInfo_t& roadInfo2)
+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)
@@ -173,9 +174,16 @@ ConsistencyCompareThread* ThreadManager::getConsistencyCompareThread(const Compa
         }
     }
     /* 没找到该线程，创建新的线程 */
+    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(roadInfo1.nCompareRoadNum, roadInfo1);
-    threadInfo.compareItemInfo.mapRoad.insert(roadInfo2.nCompareRoadNum, roadInfo2);
+    threadInfo.compareItemInfo.mapRoad.insert(item1.nCompareRoadNum, item1);
+    threadInfo.compareItemInfo.mapRoad.insert(item2.nCompareRoadNum, item2);
     ConsistencyCompareThread* newThread = new ConsistencyCompareThread(threadInfo);
     
     if(newThread == nullptr)
@@ -192,7 +200,7 @@ ConsistencyCompareThread* ThreadManager::getConsistencyCompareThread(const Compa
 }
 
 /* 去掉线程，线程使用的计数减一，计数为0则销毁该线程 */
-bool ThreadManager::removeConsistencyCompareThread(RoadNumberInfo_t& roadInfo1, RoadNumberInfo_t& roadInfo2)
+bool ThreadManager::removeConsistencyCompareThread(SoundCardRoadInfo_t& roadInfo1, SoundCardRoadInfo_t& roadInfo2)
 {
     std::lock_guard<std::mutex> lock(m_mutexConsistencyCompareThreads);
     ConsistencyCompareThread* pThreadToRemove = nullptr;
@@ -206,7 +214,8 @@ bool ThreadManager::removeConsistencyCompareThread(RoadNumberInfo_t& roadInfo1,
     }
     if(pThreadToRemove == nullptr)
     {
-        SPDLOG_LOGGER_WARN(m_logger, "{}-{} 一致性比对线程未找到", roadInfo1.strRoadName, roadInfo2.strRoadName);
+        SPDLOG_LOGGER_WARN(m_logger, "{}:{} - {}:{} 一致性比对线程未找到", roadInfo1.strSoundCardName.toStdString(), roadInfo1.roadInfo.nRoadNum,
+            roadInfo2.strSoundCardName.toStdString(), roadInfo2.roadInfo.nRoadNum);
         return false; // 没找到该线程
     }
     m_referCountConsistencyCompare--; // 引用计数减一
@@ -217,26 +226,32 @@ bool ThreadManager::removeConsistencyCompareThread(RoadNumberInfo_t& roadInfo1,
         delete pThreadToRemove; // 删除线程
         pThreadToRemove = nullptr;
         m_referCountConsistencyCompare = 0; // 重置引用计数
-        SPDLOG_LOGGER_INFO(m_logger, "{}-{} 一致性比对线程已销毁", roadInfo1.strRoadName, roadInfo2.strRoadName);
+        SPDLOG_LOGGER_WARN(m_logger, "{}:{} - {}:{} 一致性比对线程已销毁", roadInfo1.strSoundCardName.toStdString(), roadInfo1.roadInfo.nRoadNum,
+            roadInfo2.strSoundCardName.toStdString(), roadInfo2.roadInfo.nRoadNum);
     }
 
     return true;
 }
 
 /* 获取噪音检测线程 */
-NoiseDetectThread* ThreadManager::getNoiseDetectThread(const RoadNumberInfo_t& roadInfo)
+NoiseDetectThread* ThreadManager::getNoiseDetectThread(const SoundCardRoadInfo_t& roadInfo)
 {
     std::lock_guard<std::mutex> lock(m_mutexNoiseDetectThreads);
     for(const auto pThread : m_listNoiseDetectThreads)
     {
-        if(pThread->getRoadInfo().roadID == roadInfo.roadID)
+        const SoundCardRoadInfo_t& threadRoadInfo = pThread->getRoadInfo();
+        if(threadRoadInfo.nSoundCardNum == roadInfo.nSoundCardNum &&
+           threadRoadInfo.roadInfo.nRoadNum == roadInfo.roadInfo.nRoadNum)
         {
             return pThread; // 找到相同的线程，直接返回
         }
     }
     /* 没找到该线程，创建新的线程 */
     CalculateThreadInfo_t threadInfo;
-    threadInfo.vecRoad.push_back(roadInfo);
+    CompareItemRoadInfo_t item;
+    item.nCompareRoadNum = 1; // 假设噪音检测线程
+    item.scRoadInfo = roadInfo;
+    threadInfo.compareItemInfo.mapRoad.insert(item.nCompareRoadNum, item);
     NoiseDetectThread* newThread = new NoiseDetectThread(threadInfo);
     if(newThread == nullptr)
     {
@@ -251,13 +266,15 @@ NoiseDetectThread* ThreadManager::getNoiseDetectThread(const RoadNumberInfo_t& r
 }
 
 /* 去掉噪音检测线程，线程使用的计数减一，计数为0则销毁该线程 */
-bool ThreadManager::removeNoiseDetectThread(RoadNumberInfo_t& roadInfo)
+bool ThreadManager::removeNoiseDetectThread(SoundCardRoadInfo_t& roadInfo)
 {
     std::lock_guard<std::mutex> lock(m_mutexNoiseDetectThreads);
     NoiseDetectThread* pThreadToRemove = nullptr;
     for(const auto pThread : m_listNoiseDetectThreads)
     {
-        if(pThread->getRoadInfo().roadID == roadInfo.roadID)
+        const SoundCardRoadInfo_t& threadRoadInfo = pThread->getRoadInfo();
+        if(threadRoadInfo.nSoundCardNum == roadInfo.nSoundCardNum &&
+           threadRoadInfo.roadInfo.nRoadNum == roadInfo.roadInfo.nRoadNum)
         {
             pThreadToRemove = pThread; // 找到相同的线程，直接返回
             break;
@@ -265,7 +282,7 @@ bool ThreadManager::removeNoiseDetectThread(RoadNumberInfo_t& roadInfo)
     }
     if(pThreadToRemove == nullptr)
     {
-        SPDLOG_LOGGER_WARN(m_logger, "{} 噪音检测线程未找到", roadInfo.strRoadName);
+        SPDLOG_LOGGER_WARN(m_logger, "{}:{} 噪音检测线程未找到", roadInfo.strSoundCardName.toStdString(), roadInfo.roadInfo.nRoadNum);
         return false; // 没找到该线程
     }
     m_referCountNoiseDetect--; // 引用计数减一
@@ -276,70 +293,76 @@ bool ThreadManager::removeNoiseDetectThread(RoadNumberInfo_t& roadInfo)
         delete pThreadToRemove; // 删除线程
         pThreadToRemove = nullptr;
         m_referCountNoiseDetect = 0; // 重置引用计数
-        SPDLOG_LOGGER_INFO(m_logger, "{} 噪音检测线程已销毁", roadInfo.strRoadName);
+        SPDLOG_LOGGER_INFO(m_logger, "{}:{} 噪音检测线程已销毁", roadInfo.strSoundCardName.toStdString(), roadInfo.roadInfo.nRoadNum);
     }
 
     return true;
 }
 
-/* 获取音量报警线程 */
-CalculateDBPhaseThread* ThreadManager::getCalculateDBPhaseThread(const RoadNumberInfo_t& roadInfo)
-{
-    std::lock_guard<std::mutex> lock(m_mutexCalculateDBPhaseThreads);
-    for(const auto pThread : m_listCalculateDBPhaseThreads)
-    {
-        if(pThread->getRoadInfo().roadID == roadInfo.roadID)
-        {
-            return pThread; // 找到相同的线程，直接返回
-        }
-    }
-    /* 没找到该线程，创建新的线程 */
-    CalculateThreadInfo_t threadInfo;
-    threadInfo.vecRoad.push_back(roadInfo);
-    CalculateDBPhaseThread* newThread = new CalculateDBPhaseThread(threadInfo);
+// /* 获取音量报警线程 */
+// CalculateDBPhaseThread* ThreadManager::getCalculateDBPhaseThread(const SoundCardRoadInfo_t& roadInfo)
+// {
+//     std::lock_guard<std::mutex> lock(m_mutexCalculateDBPhaseThreads);
+//     for(const auto pThread : m_listCalculateDBPhaseThreads)
+//     {
+//         const SoundCardRoadInfo_t& threadRoadInfo = pThread->getRoadInfo();
+//         if(threadRoadInfo.nSoundCardNum == roadInfo.nSoundCardNum &&
+//            threadRoadInfo.roadInfo.nRoadNum == roadInfo.roadInfo.nRoadNum)
+//         {
+//             return pThread; // 找到相同的线程，直接返回
+//         }
+//     }
+        
+//     /* 没找到该线程，创建新的线程 */
+//     CompareItemRoadInfo_t item;
+//     item.nCompareRoadNum = 1; // 假设音量报警线程
+//     item.scRoadInfo = roadInfo;
     
-    if(newThread == nullptr)
-    {
-        SPDLOG_LOGGER_ERROR(m_logger, "创建音量报警线程失败");
-        return nullptr; // 创建失败
-    }
-    CPPTP.add_task(&CalculateDBPhaseThread::threadTask, newThread);
-
-    m_listCalculateDBPhaseThreads.push_back(newThread);
-    m_referCountCalculateDBPhase++; // 引用计数加一
+//     threadInfo.compareItemInfo.mapRoad.insert(item.nCompareRoadNum, item);
+//     CalculateDBPhaseThread* newThread = new CalculateDBPhaseThread(threadInfo);
+    
+//     if(newThread == nullptr)
+//     {
+//         SPDLOG_LOGGER_ERROR(m_logger, "创建音量报警线程失败");
+//         return nullptr; // 创建失败
+//     }
+//     CPPTP.add_task(&CalculateDBPhaseThread::threadTask, newThread);
 
-    return newThread;
-}
+//     m_listCalculateDBPhaseThreads.push_back(newThread);
+//     m_referCountCalculateDBPhase++; // 引用计数加一
 
-/* 去掉音量报警线程，线程使用的计数减一，计数为0则销毁该线程 */
-bool ThreadManager::removeCalculateDBPhaseThread(RoadNumberInfo_t& roadInfo)
-{
-    std::lock_guard<std::mutex> lock(m_mutexCalculateDBPhaseThreads);
-    CalculateDBPhaseThread* pThreadToRemove = nullptr;
-    for(const auto pThread : m_listCalculateDBPhaseThreads)
-    {
-        if(pThread->getRoadInfo().roadID == roadInfo.roadID)
-        {
-            pThreadToRemove = pThread; // 找到相同的线程，直接返回
-            break;
-        }
-    }
-    if(pThreadToRemove == nullptr)
-    {
-        SPDLOG_LOGGER_WARN(m_logger, "{} 音量报警线程未找到", roadInfo.strRoadName);
-        return false; // 没找到该线程
-    }
-    m_referCountCalculateDBPhase--; // 引用计数减一
-    if(m_referCountCalculateDBPhase <= 0)
-    {
-        pThreadToRemove->stopThread(); // 停止线程
-        m_listCalculateDBPhaseThreads.remove(pThreadToRemove); // 从列表中移除
-        delete pThreadToRemove; // 删除线程
-        pThreadToRemove = nullptr;
-        m_referCountCalculateDBPhase = 0; // 重置引用计数
-        SPDLOG_LOGGER_INFO(m_logger, "{} 音量报警线程已销毁", roadInfo.strRoadName);
-    }
+//     return newThread;
+// }
 
-    return true;
-}
+// /* 去掉音量报警线程，线程使用的计数减一，计数为0则销毁该线程 */
+// bool ThreadManager::removeCalculateDBPhaseThread(RoadNumberInfo_t& roadInfo)
+// {
+//     std::lock_guard<std::mutex> lock(m_mutexCalculateDBPhaseThreads);
+//     CalculateDBPhaseThread* pThreadToRemove = nullptr;
+//     for(const auto pThread : m_listCalculateDBPhaseThreads)
+//     {
+//         if(pThread->getRoadInfo().roadID == roadInfo.roadID)
+//         {
+//             pThreadToRemove = pThread; // 找到相同的线程，直接返回
+//             break;
+//         }
+//     }
+//     if(pThreadToRemove == nullptr)
+//     {
+//         SPDLOG_LOGGER_WARN(m_logger, "{} 音量报警线程未找到", roadInfo.strRoadName);
+//         return false; // 没找到该线程
+//     }
+//     m_referCountCalculateDBPhase--; // 引用计数减一
+//     if(m_referCountCalculateDBPhase <= 0)
+//     {
+//         pThreadToRemove->stopThread(); // 停止线程
+//         m_listCalculateDBPhaseThreads.remove(pThreadToRemove); // 从列表中移除
+//         delete pThreadToRemove; // 删除线程
+//         pThreadToRemove = nullptr;
+//         m_referCountCalculateDBPhase = 0; // 重置引用计数
+//         SPDLOG_LOGGER_INFO(m_logger, "{} 音量报警线程已销毁", roadInfo.strRoadName);
+//     }
+
+//     return true;
+// }
 

Server/ThreadManager/ThreadManager.h

@@ -63,9 +63,11 @@ public:
     /* -------------------------------------------------------------------------------------------
      * 获取计算线程，如果该线程不存在则创建该线程
      * 当不需要此线程后，调用remove()函数去掉该线程
+     * 补充：
+     *      1、能在这里获取的线程是为了尽可能复用线程，这些都是和对比项无关的计算线程
      * -------------------------------------------------------------------------------------------- */
     /* 获取一致性比对线程，线程不存在则创建 */
-    ConsistencyCompareThread* getConsistencyCompareThread(const CompareItemRoadInfo_t& roadInfo1, const CompareItemRoadInfo_t& roadInfo2);
+    ConsistencyCompareThread* getConsistencyCompareThread(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2);
     /* 去掉线程，线程使用的计数减一，计数为0则销毁该线程 */
     bool removeConsistencyCompareThread(SoundCardRoadInfo_t& roadInfo1, SoundCardRoadInfo_t& roadInfo2);
 
@@ -74,10 +76,10 @@ public:
     /* 去掉噪音检测线程，线程使用的计数减一，计数为0则销毁该线程 */
     bool removeNoiseDetectThread(SoundCardRoadInfo_t& roadInfo);
 
-    /* 获取音量报警线程，如果不存在，则创建线程 */
-    CalculateDBPhaseThread* getCalculateDBPhaseThread(const SoundCardRoadInfo_t& roadInfo);
-    /* 去掉音量报警线程，线程使用的计数减一，计数为0则销毁该线程 */
-    bool removeCalculateDBPhaseThread(SoundCardRoadInfo_t& roadInfo);
+    // /* 获取音量报警线程，如果不存在，则创建线程 */
+    // CalculateDBPhaseThread* getCalculateDBPhaseThread(const SoundCardRoadInfo_t& roadInfo);
+    // /* 去掉音量报警线程，线程使用的计数减一，计数为0则销毁该线程 */
+    // bool removeCalculateDBPhaseThread(SoundCardRoadInfo_t& roadInfo);
 
 private:
     /* 录音线程队列 */
@@ -104,9 +106,9 @@ private:
     std::list<NoiseDetectThread*> m_listNoiseDetectThreads;
 
     /* 音量计算线程 */
-    std::mutex m_mutexCalculateDBPhaseThreads;   /* 互斥锁，保护音量计算线程列表 */
-    int m_referCountCalculateDBPhase = 0;      /* 音量计算线程的引用计数 */
-    std::list<CalculateDBPhaseThread*> m_listCalculateDBPhaseThreads;
+    // std::mutex m_mutexCalculateDBPhaseThreads;   /* 互斥锁，保护音量计算线程列表 */
+    // int m_referCountCalculateDBPhase = 0;      /* 音量计算线程的引用计数 */
+    // std::list<CalculateDBPhaseThread*> m_listCalculateDBPhaseThreads;
 
 private:
     std::shared_ptr<spdlog::logger> m_logger = nullptr; /* 日志记录器 */

Server/ThreadRecord/AssignSrcDataThread.cpp

@@ -182,25 +182,25 @@ bool AssignSrcDataThread::getDispatchThread()
     /* 根据生成数据文件的类型顺序获取 */
 
     /* 先获取生成wav小文件的线程 */
-    auto pWavThread = ThreadMan.findRecordThread(EThreadType::Type_CreateWAV, m_threadInfo.RoadInfo.roadID);
+    auto pWavThread = ThreadMan.findRecordThread(EThreadType::Type_CreateWAV, m_threadInfo.cardRoadInfo.nSoundCardNum, m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
     if(pWavThread != nullptr)
     {
         m_listDispatchThreads.push_back(dynamic_cast<BaseRecordThread*>(pWavThread));
     }
     /* 获取生成音量和反相数据的线程 */
-    auto pDBAndPhaseThread = ThreadMan.findRecordThread(EThreadType::Type_CheckDBAndPhase, m_threadInfo.RoadInfo.roadID);
+    auto pDBAndPhaseThread = ThreadMan.findRecordThread(EThreadType::Type_CheckDBAndPhase, m_threadInfo.cardRoadInfo.nSoundCardNum, m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
     if(pDBAndPhaseThread != nullptr)
     {
         m_listDispatchThreads.push_back(dynamic_cast<BaseRecordThread*>(pDBAndPhaseThread));
     }
     /* 获取生成长文件的线程 */
-    auto pLongFileThread = ThreadMan.findRecordThread(EThreadType::Type_CreateLongWAV, m_threadInfo.RoadInfo.roadID);
+    auto pLongFileThread = ThreadMan.findRecordThread(EThreadType::Type_CreateLongWAV, m_threadInfo.cardRoadInfo.nSoundCardNum, m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
     if(pLongFileThread != nullptr )
     {
         m_listDispatchThreads.push_back(dynamic_cast<BaseRecordThread*>(pLongFileThread));
     }
 
-    m_rtpSenderThread = ThreadMan.findRecordThread(EThreadType::Type_RtpSend, m_threadInfo.RoadInfo.roadID);
+    m_rtpSenderThread = ThreadMan.findRecordThread(EThreadType::Type_RtpSend, m_threadInfo.cardRoadInfo.nSoundCardNum, m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
     if(m_rtpSenderThread == nullptr)
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 获取RTP发送线程失败", m_logBase);

Server/ThreadRecord/BaseRecordThread.cpp

@@ -6,7 +6,8 @@
 BaseRecordThread::BaseRecordThread(RecordThreadInfo_t& threadInfo)
     : m_threadInfo(threadInfo)
 {
-    m_logBase = fmt::format("录音通道: {}", static_cast<int>(m_threadInfo.RoadInfo.roadID));
+    m_logBase = fmt::format("录音通道: {}:{}", m_threadInfo.cardRoadInfo.strSoundCardName.toStdString(), 
+                            m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
 }
 
 BaseRecordThread::~BaseRecordThread()

Server/ThreadRecord/CreateDBPhaseThread.cpp

@@ -251,7 +251,7 @@ bool CreateDBPhaseThread::CreateDBPhase(AudioSrcData* audioData, OneSecondData*
     const int oneDBSize = m_oneDBLengthOfSrcData;;
 
     StAudioNum audioInfo;
-    audioInfo.nRoadId = m_threadInfo.RoadInfo.roadID;
+    audioInfo.roadInfo = m_threadInfo.cardRoadInfo; // 设置通道信息
     audioInfo.nTotal = m_singleDataLength;
     int iCurPos = 0;
     /* 存储结果 */

Server/ThreadRecord/CreateWAVThread.cpp

@@ -197,7 +197,7 @@ bool CreateWAVThread::initData()
     m_bitsPerSample = GInfo.bitsPerSample(); // 每个采样点的位数
     
     QString wavPath = GInfo.wavPath();
-    wavPath = wavPath + QString("/Record%1").arg(static_cast<int>(m_threadInfo.RoadInfo.roadID));
+    wavPath = wavPath + QString("/Record%1-%2").arg(m_threadInfo.cardRoadInfo.nSoundCardNum).arg(m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
     m_wavDir.setPath(wavPath);
     if(!m_wavDir.exists())
     {
@@ -260,8 +260,8 @@ bool CreateWAVThread::createWAVFile(int secondCount)
         SPDLOG_LOGGER_WARN(m_logger, "{} 从环形队列中取出数据失败!", m_logBase);
         return false;
     }
-    QString strFileName = QString("WAV_%1_%2.wav")
-        .arg(static_cast<int>(static_cast<int>(m_threadInfo.RoadInfo.roadID)))
+    QString strFileName = QString("WAV_%1-%2_%3.wav")
+        .arg(m_threadInfo.cardRoadInfo.nSoundCardNum).arg(m_threadInfo.cardRoadInfo.roadInfo.nRoadNum)
         .arg(audioData->startTime.toString("yyyyMMdd_hhmmss.zzz"));
     QString fileName = m_wavDir.filePath(strFileName);
     

Server/ThreadRecord/RecordLongFileThread.cpp

@@ -212,9 +212,10 @@ bool RecordLongFileThread::setTodayPath(bool isNewFile)
 {
     if(isNewFile)
     {
-        QString todayDirName = QString("%1/Record%3/%4")
+        QString todayDirName = QString("%1/Record%2-%3/%4")
             .arg(m_recordPath)
-            .arg(static_cast<int>(m_threadInfo.RoadInfo.roadID))
+            .arg(m_threadInfo.cardRoadInfo.nSoundCardNum)
+            .arg(m_threadInfo.cardRoadInfo.roadInfo.nRoadNum)
             .arg(QDate::currentDate().toString("yyyy-MM-dd"));
         m_todayDir.setPath(todayDirName);
         if(!m_todayDir.exists())
@@ -280,7 +281,7 @@ bool RecordLongFileThread::writeAudioDataToFile(const AudioSrcData& audioData, c
 /* 生成文件名 */
 QString RecordLongFileThread::generateFileName(const QDateTime& startTime, const QDateTime& endTime) const
 {
-    QString chnannelStr = QString("RecordRoad") + QString::number(static_cast<int>(m_threadInfo.RoadInfo.roadID));
+    QString chnannelStr = QString("RecordRoad%1-%2").arg(m_threadInfo.cardRoadInfo.nSoundCardNum).arg(m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
     QString fileName = QString("%1_%2-%3.wav")
         .arg(chnannelStr)
         .arg(startTime.toString("yyyyMMdd_hhmmss"))

Server/ThreadRecord/RecordThread.cpp

@@ -122,7 +122,7 @@ void RecordThread::clearData()
 /* 获取AssignSrcDataThread线程 */
 AssignSrcDataThread* RecordThread::getAssignSrcDataThread()
 {
-    auto pThread = ThreadMan.findRecordThread(EThreadType::Type_AssignSrcData, m_threadInfo.RoadInfo.roadID);
+    auto pThread = ThreadMan.findRecordThread(EThreadType::Type_AssignSrcData, m_threadInfo.cardRoadInfo.nSoundCardNum, m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
     if(pThread != nullptr)
     {
         return dynamic_cast<AssignSrcDataThread*>(pThread);

common/GlobalInfo/GlobalVariable.h

@@ -62,7 +62,7 @@ struct OnePlan_t
 /* 单个录音通道信息，带有频道信息 */
 struct OneRoadInfo_t
 {
-    int nRoadNum = -1;              /* 录音通道编号 */
+    int nRoadNum = -1;              /* 录音通道编号，是声卡在系统中的物理编号 */
     int nChannelID = -1;            /* 频道ID */
     QString strChannelName;         /* 频道名称 */
 };
@@ -175,6 +175,7 @@ struct CompareItemInfo_t
     bool isEqualBase(const CompareItemInfo_t &other) const;
     /* 判断对比项的通道是否相同 */
     bool isEqualRoads(const CompareItemInfo_t &other) const;
+    
 };
 
 /* =============================================================================
@@ -220,75 +221,75 @@ struct NoDetectPlanApply_t
  * 线程信息相关枚举和结构体
  * =========================================================================================*/
 
-enum class ERoadID
-{
-    RoadID_None = 0,      /* 无通道 */
-    RoadID_1 = 1,         /* 通道1 */
-    RoadID_2,             /* 通道2 */
-    RoadID_3,             /* 通道3 */
-    RoadID_4,             /* 通道4 */
-    RoadID_5,             /* 通道5 */
-    RoadID_6,             /* 通道6 */
-    RoadID_7,             /* 通道7 */
-    RoadID_8,             /* 通道8 */
-    RoadID_9,             /* 通道9 */
-    RoadID_10,            /* 通道10 */
-    RoadID_11,            /* 通道11 */
-    RoadID_12,            /* 通道12 */
-    RoadID_13,            /* 通道13 */
-    RoadID_14,            /* 通道14 */
-    RoadID_15,            /* 通道15 */
-    RoadID_16,            /* 通道16 */
-    RoadID_17,            /* 通道17 */
-    RoadID_18,            /* 通道18 */
-    RoadID_19,            /* 通道19 */
-    RoadID_20,            /* 通道20 */
-    RoadID_21,            /* 通道21 */
-    RoadID_22,            /* 通道22 */
-    RoadID_23,            /* 通道23 */
-    RoadID_24,            /* 通道24 */
-    RoadID_25,            /* 通道25 */
-    RoadID_26,            /* 通道26 */
-    RoadID_27,            /* 通道27 */
-    RoadID_28,            /* 通道28 */
-    RoadID_29,            /* 通道29 */
-    RoadID_30,            /* 通道30 */
-    RoadID_31,            /* 通道31 */
-    RoadID_32,            /* 通道32 */
-    RoadID_33,            /* 通道33 */
-    RoadID_34,            /* 通道34 */
-    RoadID_35,            /* 通道35 */
-    RoadID_36,            /* 通道36 */
-    RoadID_37,            /* 通道37 */
-    RoadID_38,            /* 通道38 */
-    RoadID_39,            /* 通道39 */
-    RoadID_40,            /* 通道40 */
-    RoadID_41,            /* 通道41 */
-    RoadID_42,            /* 通道42 */
-    RoadID_43,            /* 通道43 */
-    RoadID_44,            /* 通道44 */
-    RoadID_45,            /* 通道45 */
-    RoadID_46,            /* 通道46 */
-    RoadID_47,            /* 通道47 */
-    RoadID_48,            /* 通道48 */
-    RoadID_49,            /* 通道49 */
-    RoadID_50,            /* 通道50 */
-    RoadID_51,            /* 通道51 */
-    RoadID_52,            /* 通道52 */
-    RoadID_53,            /* 通道53 */
-    RoadID_54,            /* 通道54 */
-    RoadID_55,            /* 通道55 */
-    RoadID_56,            /* 通道56 */
-    RoadID_57,            /* 通道57 */
-    RoadID_58,            /* 通道58 */
-    RoadID_59,            /* 通道59 */
-    RoadID_60,            /* 通道60 */
-    RoadID_61,            /* 通道61 */
-    RoadID_62,            /* 通道62 */
-    RoadID_63,            /* 通道63 */
-    RoadID_64,            /* 通道64 */
-    RoadID_MAX = RoadID_64, /* 最大通道数 */
-};
+// enum class ERoadID
+// {
+//     RoadID_None = 0,      /* 无通道 */
+//     RoadID_1 = 1,         /* 通道1 */
+//     RoadID_2,             /* 通道2 */
+//     RoadID_3,             /* 通道3 */
+//     RoadID_4,             /* 通道4 */
+//     RoadID_5,             /* 通道5 */
+//     RoadID_6,             /* 通道6 */
+//     RoadID_7,             /* 通道7 */
+//     RoadID_8,             /* 通道8 */
+//     RoadID_9,             /* 通道9 */
+//     RoadID_10,            /* 通道10 */
+//     RoadID_11,            /* 通道11 */
+//     RoadID_12,            /* 通道12 */
+//     RoadID_13,            /* 通道13 */
+//     RoadID_14,            /* 通道14 */
+//     RoadID_15,            /* 通道15 */
+//     RoadID_16,            /* 通道16 */
+//     RoadID_17,            /* 通道17 */
+//     RoadID_18,            /* 通道18 */
+//     RoadID_19,            /* 通道19 */
+//     RoadID_20,            /* 通道20 */
+//     RoadID_21,            /* 通道21 */
+//     RoadID_22,            /* 通道22 */
+//     RoadID_23,            /* 通道23 */
+//     RoadID_24,            /* 通道24 */
+//     RoadID_25,            /* 通道25 */
+//     RoadID_26,            /* 通道26 */
+//     RoadID_27,            /* 通道27 */
+//     RoadID_28,            /* 通道28 */
+//     RoadID_29,            /* 通道29 */
+//     RoadID_30,            /* 通道30 */
+//     RoadID_31,            /* 通道31 */
+//     RoadID_32,            /* 通道32 */
+//     RoadID_33,            /* 通道33 */
+//     RoadID_34,            /* 通道34 */
+//     RoadID_35,            /* 通道35 */
+//     RoadID_36,            /* 通道36 */
+//     RoadID_37,            /* 通道37 */
+//     RoadID_38,            /* 通道38 */
+//     RoadID_39,            /* 通道39 */
+//     RoadID_40,            /* 通道40 */
+//     RoadID_41,            /* 通道41 */
+//     RoadID_42,            /* 通道42 */
+//     RoadID_43,            /* 通道43 */
+//     RoadID_44,            /* 通道44 */
+//     RoadID_45,            /* 通道45 */
+//     RoadID_46,            /* 通道46 */
+//     RoadID_47,            /* 通道47 */
+//     RoadID_48,            /* 通道48 */
+//     RoadID_49,            /* 通道49 */
+//     RoadID_50,            /* 通道50 */
+//     RoadID_51,            /* 通道51 */
+//     RoadID_52,            /* 通道52 */
+//     RoadID_53,            /* 通道53 */
+//     RoadID_54,            /* 通道54 */
+//     RoadID_55,            /* 通道55 */
+//     RoadID_56,            /* 通道56 */
+//     RoadID_57,            /* 通道57 */
+//     RoadID_58,            /* 通道58 */
+//     RoadID_59,            /* 通道59 */
+//     RoadID_60,            /* 通道60 */
+//     RoadID_61,            /* 通道61 */
+//     RoadID_62,            /* 通道62 */
+//     RoadID_63,            /* 通道63 */
+//     RoadID_64,            /* 通道64 */
+//     RoadID_MAX = RoadID_64, /* 最大通道数 */
+// };
 
 
 
@@ -353,7 +354,7 @@ enum class EThreadType
  */
 struct RecordThreadInfo_t
 {
-    SoundCardRoadInfo_t RoadInfo;               /* 录音通道信息 */
+    SoundCardRoadInfo_t cardRoadInfo;           /* 录音通道信息 */
     EThreadType threadType;                     /* 线程类型 */
     EThreadState threadState;                   /* 线程状态 */
     // BaseRecordThread* pThread = nullptr;        /* 线程对象 */