V0.2.4

1、完成了所有的录音线程功能

Server/DataStruct/AudioData.cpp

@@ -4,6 +4,7 @@
 #include "GlobalInfo.h"
 
 #include <QFile>
+#include <cstring>
 
 
 /* =========================================================================================

Server/ThreadCalculate/CalculateDBThread.cpp

@@ -49,7 +49,7 @@ bool CalculateDBThread::getlastVolumeInfo(OneRoadVolume_t& volumeInfo)
 }
 
 /* 获取报警数据 */
-AlarmInfo_t CalculateDBThread::getAlarm(EAlarmType alarmType)
+const AlarmInfo_t& CalculateDBThread::getAlarm(EAlarmType alarmType)
 {
     std::lock_guard<std::mutex> lock(m_mutexVolumeInfo);
     switch(alarmType)
@@ -62,7 +62,7 @@ AlarmInfo_t CalculateDBThread::getAlarm(EAlarmType alarmType)
             return m_alarmLastPhase;
         default:
             SPDLOG_LOGGER_ERROR(m_logger, "{} 获取报警数据失败，未知报警类型: {}", m_logBase, static_cast<int>(alarmType));
-            return AlarmInfo_t(); // 返回一个空的报警信息
+            return m_alarmNull; // 返回一个空的报警信息
     }
 }
 

Server/ThreadCalculate/CalculateDBThread.h

@@ -36,7 +36,7 @@ public:
     /* 获取最新的结果 */
     bool getlastVolumeInfo(OneRoadVolume_t& volumeInfo);
     /* 获取报警数据 */
-    AlarmInfo_t getAlarm(EAlarmType alarmType);
+    const AlarmInfo_t& getAlarm(EAlarmType alarmType);
 
 protected:
     /* 线程功能函数 */
@@ -97,6 +97,7 @@ private:
     AlarmInfo_t m_alarmLastSilence;                         /* 上一次静音报警信息 */
     AlarmInfo_t m_alarmLastOverload;                        /* 上一次过载报警信息 */
     AlarmInfo_t m_alarmLastPhase;                           /* 上一次反相报警信息 */
+    AlarmInfo_t m_alarmNull;                                /* 空报警信息 */
 };
 
 

Server/ThreadCalculate/CompareItemThread.cpp

@@ -5,6 +5,7 @@
 #include "NoiseDetectThread.h"
 #include "CompareDoubleThread.h"
 #include "ThreadPool.h"
+#include "spdlog.h"
 
 
 CompareItemThread::CompareItemThread(CalculateThreadInfo_t& threadInfo)
@@ -33,14 +34,14 @@ void CompareItemThread::task()
     SPDLOG_LOGGER_INFO(m_logger, "----------------------------------------------------------------");
 
     /* 测试录音通道用 */
-    for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
-    {
-        ThreadMan.createRecordThread(road.scRoadInfo, m_threadInfo.compareItemInfo.nID);
-    }
-    while(true)
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
+    // for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
+    // {
+    //     ThreadMan.createRecordThread(road.scRoadInfo, m_threadInfo.compareItemInfo.nID);
+    // }
+    // while(true)
+    // {
+    //     std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    // }
 
 
     /* 初始化数据 */
@@ -52,8 +53,8 @@ void CompareItemThread::task()
 
     while (m_isRunning)
     {
-        /* 睡眠10ms */
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        /* 睡眠100ms */
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
         /* -------------------------------------------------------------------------------------
          * 更新对比项信息
@@ -61,7 +62,8 @@ void CompareItemThread::task()
         if(updateThreadInfoInternal())
         {
             SPDLOG_LOGGER_INFO(m_logger, "{} 暂停对比检测，更新对比项信息");
-
+            m_threadInfo.compareItemInfo = m_threadInfoNew.compareItemInfo;
+            initData();
             SPDLOG_LOGGER_INFO(m_logger, "{} 更新对比项信息完成，继续检测对比");
         }
 
@@ -78,10 +80,10 @@ void CompareItemThread::task()
          * ------------------------------------------------------------------------------------- */
         processAlarmData();
 
-         /* -------------------------------------------------------------------------------------
+        /* -------------------------------------------------------------------------------------
          * 将音量包数据发送到MQTT中
          * ------------------------------------------------------------------------------------- */
-        
+        sendResultData();
     }
     /* 清理数据 */
     clearData();
@@ -106,12 +108,14 @@ bool CompareItemThread::initData()
     getNoiseDetectThreads();
 
     /* 创建两个对比线程，主通道是第一个通道，其他都需要和主通道进行对比 */
+    destroyCompareThreads();
     if(!createCompareThreads())
     {
         return false;
     }
 
     /* 初始化存储结果的数据结构 */
+    m_compareResult = CompareResult_t();
     m_compareResult.compareItemID = m_threadInfo.compareItemInfo.nID;
     m_compareResult.compareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
     m_compareResult.dateTime = QDateTime::currentDateTime();
@@ -126,17 +130,24 @@ bool CompareItemThread::initData()
     }
 
     int roadCount = m_threadInfo.compareItemInfo.mapRoad.size();
-    m_vecCDBPhaseUpdated.reserve(roadCount);
+    m_vecCDBUpdated.clear();
+    m_vecCDBUpdated.reserve(roadCount);
     for(int i = 0; i < m_threadInfo.compareItemInfo.mapRoad.size(); ++i)
     {
-        m_vecCDBPhaseUpdated.push_back(false); // 初始化为未更新
+        m_vecCDBUpdated.push_back(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);
@@ -199,6 +210,28 @@ bool CompareItemThread::createCompareThreads()
     return true;
 }
 
+/* 销毁两两对比线程 */
+void CompareItemThread::destroyCompareThreads()
+{
+    if(m_vecCompareDoubleThreads.size() == 0)
+    {
+        return; // 没有对比线程
+    }
+    SPDLOG_LOGGER_INFO(m_logger, "{} 销毁对比线程", m_logBase);
+    for(auto& thread : m_vecCompareDoubleThreads)
+    {
+        if(thread != nullptr)
+        {
+            thread->stopThreadBlock(); // 停止线程
+            delete thread;             // 删除线程
+            thread = nullptr;          // 设置为nullptr
+        }
+    }
+    m_vecCompareDoubleThreads.clear();
+    m_vecCDBUpdated.clear(); // 清空更新标志位
+    SPDLOG_LOGGER_INFO(m_logger, "{} 对比线程销毁完成", m_logBase);
+}
+
 /* 创建计算音量报警的线程 */
 bool CompareItemThread::createCalculateDBThreads()
 {
@@ -215,6 +248,7 @@ bool CompareItemThread::createCalculateDBThreads()
             SPDLOG_LOGGER_ERROR(m_logger, "{} 创建音量计算线程失败", m_logBase);
             // return false; // 获取线程失败
         }
+        CPPTP.add_task(&CalculateDBThread::threadTask, pThread);
         m_vecCalculateDBThreads.push_back(pThread);
     }
 
@@ -224,6 +258,11 @@ bool CompareItemThread::createCalculateDBThreads()
 /* 销毁音量计算的线程 */
 void CompareItemThread::destroyCalculateDBThreads()
 {
+    if(m_vecCalculateDBThreads.size() == 0)
+    {
+        return; // 没有音量计算线程
+    }
+    SPDLOG_LOGGER_INFO(m_logger, "{} 销毁音量计算线程", m_logBase);
     for(auto& thread : m_vecCalculateDBThreads)
     {
         if(thread != nullptr)
@@ -234,7 +273,9 @@ void CompareItemThread::destroyCalculateDBThreads()
         }
     }
     m_vecCalculateDBThreads.clear();
-    m_vecCDBPhaseUpdated.clear(); // 清空更新标志位
+    m_vecCDBUpdated.clear(); // 清空更新标志位
+
+    SPDLOG_LOGGER_INFO(m_logger, "{} 音量计算线程销毁完成", m_logBase);
 }
 
 /* 获取噪音检测的线程 */
@@ -257,6 +298,11 @@ bool CompareItemThread::getNoiseDetectThreads()
 /* 移除噪音检测的线程 */
 void CompareItemThread::removeNoiseDetectThreads()
 {
+    if(m_vecNoiseDetectThreads.size() == 0)
+    {
+        return; // 没有噪音检测线程
+    }
+    SPDLOG_LOGGER_INFO(m_logger, "{} 移除噪音检测线程", m_logBase);
     for(auto& thread : m_vecNoiseDetectThreads)
     {
         if(thread != nullptr)
@@ -265,6 +311,7 @@ void CompareItemThread::removeNoiseDetectThreads()
         }
     }
     m_vecNoiseDetectThreads.clear();
+    SPDLOG_LOGGER_INFO(m_logger, "{} 噪音检测线程移除完成", m_logBase);
 }
 
 
@@ -278,10 +325,13 @@ void CompareItemThread::removeNoiseDetectThreads()
 bool CompareItemThread::updateResultData()
 {
     const int size = m_threadInfo.compareItemInfo.mapRoad.size();
-    /* 先从音量计算数据中获取音量包信息和报警信息 */
+
+    /* -------------------------------------------------------------------------------------
+     * 先从音量计算数据中获取音量包信息和报警信息（静音、过载、反相）
+     * ------------------------------------------------------------------------------------- */
     for(int i = 0; i < size; ++i)
     {
-        if(m_vecCDBPhaseUpdated[i] == true)
+        if(m_vecCDBUpdated[i] == true)
         {
             continue; // 已经更新过了
         }
@@ -294,7 +344,7 @@ bool CompareItemThread::updateResultData()
         /* 获取最新的音量数据 */
         if(pThread->getlastVolumeInfo(m_compareResult.vecRoadVolumes[i]))
         {
-            m_vecCDBPhaseUpdated[i] = true; // 标记为已更新
+            m_vecCDBUpdated[i] = true; // 标记为已更新
         }
         /* 更新报警信息 */
         m_vecAlarmSilence[i] = pThread->getAlarm(EAlarmType::EAT_Silent);
@@ -304,14 +354,16 @@ bool CompareItemThread::updateResultData()
     /* 判断是否全部更新，如果没有则返回，等待下次再次获取 */
     for(int i = 0; i < size; ++i)
     {
-        if(m_vecCDBPhaseUpdated[i] == false)
+        if(m_vecCDBUpdated[i] == false)
         {
             // SPDLOG_LOGGER_DEBUG(m_logger, "{} 音量计算线程数据未全部更新，等待下次获取", m_logBase);
             return false;
         }
     }
 
-    /* 获取噪音计算的结果 */
+    /* -------------------------------------------------------------------------------------
+     * 获取噪音计算的结果
+     * ------------------------------------------------------------------------------------- */
     for(int i = 0; i < size; ++i)
     {
         NoiseDetectThread* pThread = m_vecNoiseDetectThreads[i];
@@ -324,14 +376,16 @@ bool CompareItemThread::updateResultData()
         m_compareResult.vecRoadVolumes[i].isNoise = pThread->isNoise();
     }
 
-    /* 从对比项中获取核对过后的结果 */
+    /* -------------------------------------------------------------------------------------
+     * 从对比项中获取核对过后的一致性结果
+     * ------------------------------------------------------------------------------------- */
     for(int i = 1; i < size; ++i)
     {
         CompareDoubleThread* pThread = m_vecCompareDoubleThreads[i-1];
         if(pThread == nullptr)
         {
             SPDLOG_LOGGER_ERROR(m_logger, "{} 获取对比线程失败", m_logBase);
-            continue; // 跳过这个线程
+            continue;
         }
         /* 获取最新的一致性结果 */
         OneRoadVolume_t roadVolume;

Server/ThreadCalculate/CompareItemThread.h

@@ -36,8 +36,11 @@ protected:
     void clearData() override;
 
 private:
-    /* 创建两两对比线程 */
+    /* 创建两个对比线程，主通道是第一个通道，其他都需要和主通道进行对比 */
     bool createCompareThreads();
+    /* 销毁两两对比线程 */
+    void destroyCompareThreads();
+    
     /* 创建计算音量报警的线程 */
     bool createCalculateDBThreads();
     /* 销毁音量计算的线程 */
@@ -54,13 +57,13 @@ private:
     /* 发送数据 */
     void sendResultData();
 
-    /* 处理报警数据 */
+    /* 处理报警数据，写入数据库 */
     void processAlarmData();
 
 private:
     /* 计算音量信息的线程指针，第一个是主通道线程 */
     std::vector<CalculateDBThread*> m_vecCalculateDBThreads;
-    std::vector<bool> m_vecCDBPhaseUpdated;             /* 音量包更新标志位 */
+    std::vector<bool> m_vecCDBUpdated;             /* 音量包更新标志位 */
     /* 计算噪音的线程指针 */
     std::vector<NoiseDetectThread*> m_vecNoiseDetectThreads;
     /* 对比项信息线程，这个线程在这里创建，不会和其他对比项复用 */

Server/ThreadManager/ThreadManager.cpp

@@ -120,18 +120,18 @@ bool ThreadManager::createRecordThread(const SoundCardRoadInfo_t& roadInfo, int
     }
     
     /* 创建发送RTP数据的线程 */
-    // threadInfo.threadType = EThreadType::Type_RtpSend;
-    // RTPOneRoadThread* pRtpSendThread = new RTPOneRoadThread(threadInfo);
-    // if(pRtpSendThread == nullptr) 
-    // {
-    //     SPDLOG_LOGGER_ERROR(m_logger, "{}:{} 创建发送RTP数据线程失败", roadInfo.strSoundCardName.toStdString(), roadInfo.roadInfo.nRoadNum);
-    //     // return false; // 创建失败
-    // }else 
-    // {
-    //     CPPTP.add_task(&RTPOneRoadThread::threadTask, pRtpSendThread);
-    //     std::lock_guard<std::mutex> lock(m_mutexRtpSendThreads);
-    //     m_rtpSendThreads.push_back(pRtpSendThread);
-    // }
+    threadInfo.threadType = EThreadType::Type_RtpSend;
+    RTPOneRoadThread* pRtpSendThread = new RTPOneRoadThread(threadInfo);
+    if(pRtpSendThread == nullptr) 
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "{}:{} 创建发送RTP数据线程失败", roadInfo.strSoundCardName.toStdString(), roadInfo.roadInfo.nRoadNum);
+        // return false; // 创建失败
+    }else 
+    {
+        CPPTP.add_task(&RTPOneRoadThread::threadTask, pRtpSendThread);
+        std::lock_guard<std::mutex> lock(m_mutexRtpSendThreads);
+        m_rtpSendThreads.push_back(pRtpSendThread);
+    }
 
     /* 创建录音线程 */
     threadInfo.threadType = EThreadType::Type_RecordSrc;

Server/ThreadRecord/CreateLongFileThread.cpp

@@ -1,6 +1,9 @@
 #include "CreateLongFileThread.h"
 
 #include "GlobalInfo.h"
+#include "spdlog.h"
+#include <cstring>
+#include <qt5/QtCore/qchar.h>
 
 
 
@@ -31,6 +34,8 @@ bool CreateLongFileThread::setData(const AudioSrcData& srcData)
         SPDLOG_LOGGER_ERROR(m_logger, "{} 设置数据失败，srcData为空或dataSize为0", m_logBase);
         return false;
     }
+
+    
     /* 锁定缓冲区 */
     std::lock_guard<std::mutex> lock(m_mutexBuffer);
     /* 如果缓冲区没有分配内存，先分配 */
@@ -49,12 +54,15 @@ bool CreateLongFileThread::setData(const AudioSrcData& srcData)
         SPDLOG_LOGGER_ERROR(m_logger, "{} 添加数据到缓冲区失败", m_logBase);
         return false;
     }
-    /* 这里记录的是开始时间 */
-    if(m_bufferData.startTime.isValid())
+    /* 记录日期 */
+    if(m_bufferData.startTime.isNull() || m_bufferData.startTime.isValid())
     {
         m_bufferData.startTime = srcData.startTime;
-        m_bufferData.endTime = srcData.endTime;  /* 结束时间 */
     }
+    m_bufferData.endTime = srcData.endTime;
+
+    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 设置数据，dataSize: {}, startTime: {}, endTime: {}",
+    //     m_logBase, m_bufferData.dataSize, m_bufferData.startTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(), m_bufferData.endTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
 
     return true;
 }
@@ -83,7 +91,16 @@ void CreateLongFileThread::task()
             {
                 continue; // 缓存数据不足，继续等待
             }
+            /* 数据足够了将缓冲区数据拷贝出来 */
+            memcpy(m_srcData.pData, m_bufferData.pData, m_bufferData.dataSize);
+            m_srcData.dataSize = m_bufferData.dataSize;
+            m_srcData.startTime = m_bufferData.startTime;
+            m_srcData.endTime = m_bufferData.endTime;
+            /* 清空缓冲区数据 */
+            m_bufferData.clear();
         }
+        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 设置数据，dataSize: {}, startTime: {}, endTime: {}",
+        // m_logBase, m_srcData.dataSize, m_srcData.startTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(), m_srcData.endTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
 
         /*--------------------------------------------------------------
          * 打开文件。写入的时候判断是否到达了整点，如果到达了整点，则关闭文件
@@ -94,6 +111,8 @@ void CreateLongFileThread::task()
         {
             /* 如果没有写入过数据，则是新文件 */
             isNewFile = true;
+            m_writtenStartTime = m_srcData.startTime; // 记录开始时间
+            m_writtenNowTime = m_writtenStartTime; // 记录当前时间
         }
         /* 设置今日目录 */
         if(!setTodayPath(isNewFile))
@@ -112,7 +131,7 @@ void CreateLongFileThread::task()
                 m_writtenStartTime = QDateTime::currentDateTime(); // 重新开始时间
                 m_writtenNowTime = m_writtenStartTime; // 重新开始时间
                 m_wavFileName.clear(); // 清空文件名
-                m_bufferData.clear(); // 清空缓冲区数据
+                m_srcData.clear(); // 清空缓冲区数据
                 m_openFileErrorSize = 0; // 重置错误次数
                 continue; // 重新开始记录
             }
@@ -120,14 +139,14 @@ void CreateLongFileThread::task()
         /*--------------------------------------------------------------
          * 将数据写入文件，并记录其携带的时间和写入的数据大小
          *--------------------------------------------------------------*/
-        QDateTime startTime;
         int64_t wSize = 0;
         {
             std::lock_guard<std::mutex> lock(m_mutexBuffer);
-            startTime = m_bufferData.startTime;
-            wSize = wavFile.write(m_bufferData.pData, m_bufferData.dataSize);
+            wSize = wavFile.write(m_srcData.pData, m_srcData.dataSize);
+            /* 更新结束时间 */
+            m_writtenNowTime = m_srcData.endTime;
             /* 清空缓冲区 */
-            m_bufferData.clear();
+            m_srcData.clear();
         }
         if(wSize < 0)
         {
@@ -136,11 +155,11 @@ void CreateLongFileThread::task()
             wavFile.close();
             continue;
         } else {
-            SPDLOG_LOGGER_DEBUG(m_logger, "{} 写入WAV文件成功: {}, 大小: {} 字节", m_logBase, m_wavFileName.toStdString(), wSize);
+            SPDLOG_LOGGER_TRACE(m_logger, "{} 写入WAV文件成功: {}, 大小: {} 字节", m_logBase, m_wavFileName.toStdString(), wSize);
         }
         wavFile.close();
-        SPDLOG_LOGGER_DEBUG(m_logger, "{} 写入WAV文件完成: {}, 大小: {} 字节", 
-            m_logBase, m_wavFileName.toStdString(), wSize);
+        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 写入WAV文件完成: {}, 大小: {} 字节", 
+        //     m_logBase, m_wavFileName.toStdString(), wSize);
     
         /*--------------------------------------------------------------
          * 对该文件进行其他操作，判断是否已经过了一个整点，修改其文件名称
@@ -148,11 +167,7 @@ void CreateLongFileThread::task()
          * 数据大小对应的结束时间
          *--------------------------------------------------------------*/
         m_writtenSize += wSize;
-        if(isNewFile)
-        {
-            m_writtenStartTime = startTime;
-        }
-        m_writtenNowTime = nextTime(startTime, wSize);
+        
         /* 修改文件名称 */
         QString newFileName = generateFileName(m_writtenStartTime, m_writtenNowTime);
         if(modifyFileName(m_wavFileName, newFileName))
@@ -203,6 +218,7 @@ bool CreateLongFileThread::initData()
     m_oneHourSize = m_writeCriticalSize * 60;
     /* 给缓存分配空间 */
     m_bufferData.allocateMemory(m_writeCriticalSize * 3);
+    m_srcData.allocateMemory(m_writeCriticalSize * 3);
     /* 获取记录文件的位置 */
     m_recordPath = GInfo.longWavPath();
 
@@ -290,7 +306,11 @@ bool CreateLongFileThread::writeAudioDataToFile(const AudioSrcData& audioData, c
 /* 生成文件名 */
 QString CreateLongFileThread::generateFileName(const QDateTime& startTime, const QDateTime& endTime) const
 {
-    QString chnannelStr = QString("RecordRoad%1-%2").arg(m_threadInfo.cardRoadInfo.nSoundCardNum).arg(m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
+    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 生成文件名: 开始时间: {}, 结束时间: {}", 
+    //     m_logBase, startTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(), 
+    //     endTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
+    QString chnannelStr = QString("%1-%2").arg(m_threadInfo.cardRoadInfo.strSoundCardID)
+                                            .arg(QString::number(m_threadInfo.cardRoadInfo.roadInfo.nRoadNum));
     QString fileName = QString("%1_%2-%3.wav")
         .arg(chnannelStr)
         .arg(startTime.toString("yyyyMMdd_hhmmss"))
@@ -302,6 +322,11 @@ QString CreateLongFileThread::generateFileName(const QDateTime& startTime, const
 /* 判断是否过了整点 */
 bool CreateLongFileThread::isOneHourPassed()
 {
+    if(m_writtenSize >= m_oneHourSize)
+    {
+        return true; // 已经写入的数据大小超过了一小时的大小
+    }
+    /* 下面是判断刚启动的时候，到下一个整点不足1小时，也会保存文件 */
     int minute = m_writtenNowTime.time().minute();
     bool isPassed = false;
     /* 如果当前时间的分钟数小于等于2，并且已经写入的大小超过2分钟的大小 */

Server/ThreadRecord/CreateLongFileThread.h

@@ -49,6 +49,8 @@ private:
     std::mutex m_mutexBuffer;
     AudioSrcData m_bufferData;
 
+    AudioSrcData m_srcData;             /* 当前的音频数据 */
+
     int32_t m_writeCriticalSize = 0;  /* 写入文件的临界大小，单位：字节，缓存超过这个大小就写入文件 */
     int32_t m_oneHourSize = 0;       /* 一小时的音频数据大小 */
 
@@ -57,7 +59,7 @@ private:
     QDir m_todayDir;                /* 今日目录 */
     QString m_wavFileName;          /* wav文件对象 */
     WavHeader m_wavHeader;          /* 当前wav文件头信息 */
-    int64_t m_writtenSize = 0;     /* 已经写入的数据大小 */
+    int64_t m_writtenSize = 0;      /* 已经写入的数据大小 */
     QDateTime m_writtenStartTime;   /* 已经写入数据的开始时间点 */
     QDateTime m_writtenNowTime;     /* 已经写入数据的最后时间点 */
 };