server1/Server/ThreadRecord/CreateRecordFileThread.cpp

#include "CreateRecordFileThread.h"

#include "AudioData.h"
#include "GlobalInfo.h"
#include "spdlog.h"
#include <cstring>
#include <mutex>
#include <qt5/QtCore/qchar.h>



CreateRecordFileThread::CreateRecordFileThread(RecordThreadInfo_t& threadInfo)
    : BaseRecordThread(threadInfo)
{
    m_logger = spdlog::get("RecordAudio");
    if(m_logger == nullptr)
    {
        fmt::print("RecordThread: RecordAudio Logger not found.\n");
        return;
    }
    /* 初始化数据 */
    initData();
}

CreateRecordFileThread::~CreateRecordFileThread()
{

}


/* 设置数据 */
bool CreateRecordFileThread::setData(const AudioSrcData& srcData)
{
    if(srcData.pData == nullptr || srcData.dataSize == 0)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 设置数据失败，srcData为空或dataSize为0", m_logBase);
        return false;
    }

    /* ------------------------------------------------------------------------------- */
    /* 先写入记录报警文件的环形缓冲区 */
    {
        std::lock_guard<std::mutex> lock(m_ringQueue.mutex);
        auto oldData = m_ringQueue.push(new AudioSrcData(srcData));
        /* 新的元素数加1 */
        m_numNewAlarmSeconds++;
        if(oldData != nullptr)
        {
            delete oldData;
            oldData = nullptr;
        }
    }
    
    /* ------------------------------------------------------------------------------- */
    if(m_isRequireRecord.load() == false)
    {
        /* 如果不需要录音，则直接返回 */
        return true;
    }
    /* 锁定长文件录音缓冲区 */
    std::lock_guard<std::mutex> lock(m_mutexBuffer);
    /* 如果缓冲区没有分配内存，先分配 */
    if(m_bufferData.pData == nullptr)
    {
        if(!m_bufferData.allocateMemory(m_writeCriticalSize * 3))
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 分配缓冲区内存失败", m_logBase);
            return false;
        }
    }
    /* 添加数据到缓冲区 */
    int32_t writtenSize = m_bufferData.appendData(srcData.pData, srcData.dataSize);
    if(writtenSize == 0)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 添加数据到缓冲区失败", m_logBase);
        return false;
    }
    /* 记录日期 */
    if(m_bufferData.startTime.isNull() || m_bufferData.startTime.isValid())
    {
        m_bufferData.startTime = srcData.startTime;
    }
    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;
}


/* 开始录制长文件 */
bool CreateRecordFileThread::startRecordLongFile(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))
    {
        return true;
    }
    m_listCompareItemRoadInfo.append(compareItemRoadInfo);
    m_isRequireRecord.store(true); // 设置为需要录音状态

    return true;
}

/* 停止录制长文件 */
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;
}



/* 开启录制 */
bool CreateRecordFileThread::startRecordAlarmFile(const AlarmInfo_t& alarmInfo)
{
    std::lock_guard<std::mutex> lock(m_mutexAlarmFile);
    /* 先检查是否已经在队列中了 */
    AlarmKey_t key = {alarmInfo.CompareItemID, alarmInfo.RoadInfo.nCompareRoadNum, 
                        alarmInfo.AlarmType, alarmInfo.StartTime};
    if(m_mapAlarmFile.find(key) != m_mapAlarmFile.end())
    {
        SPDLOG_LOGGER_WARN(m_logger, "{} 通道:{}, {}, 报警类型: {}, 已经在报警录制队列中，无法重复添加", m_logBase, 
                                        alarmInfo.CompareItemID, alarmInfo.strCompareItemName, static_cast<int>(alarmInfo.AlarmType));
        return true;
    }

    /* 将数据值插入map中 */
    AlarmValue_t value;
    value.alarmType = alarmInfo.AlarmType;
    value.startTime = alarmInfo.StartTime;
    value.endTime = alarmInfo.EndTime;
    value.numConpareItemID = alarmInfo.CompareItemID;
    value.strCompareItemName = QString::fromStdString(alarmInfo.strCompareItemName);
    value.itemRoadInfo = alarmInfo.RoadInfo;

    m_mapAlarmFile.insert({key, value});

    return true;
}

/* 停止录制，alarmInfo既是传入参数，也是传出参数，传出文件路径和开始位置 */
bool CreateRecordFileThread::stopRecordAlarmFile(AlarmInfo_t& alarmInfo)
{
    std::lock_guard<std::mutex> lock(m_mutexAlarmFile);
    for(auto& it : m_mapAlarmFile)
    {
        if(it.first.compareItemID == alarmInfo.CompareItemID &&
           it.first.roadNum == alarmInfo.RoadInfo.nCompareRoadNum &&
           it.first.alarmType == alarmInfo.AlarmType &&
           it.second.startTime == alarmInfo.StartTime )
        {
            /* 找到对应的报警信息 */
            AlarmValue_t& value = it.second;
            value.endTime = alarmInfo.EndTime; // 设置结束时间
            value.state = eRecordState::eAlarm_Stopped; // 设置为停止状态
            value.fileNameEnd = generateAlarmFileName(value, false); // 生成结束文件名
            alarmInfo.strAlarmFilePath = value.fileNameEnd.toStdString(); // 返回文件路径
            alarmInfo.AlarmStartPos = value.alarmStartPos; // 返回开始位置
            SPDLOG_LOGGER_INFO(m_logger, "{} 停止录制报警文件: {}, 开始位置: {} 秒", 
                m_logBase, value.fileNameEnd.toStdString(), value.alarmStartPos);
            return true;
        }
    }

    return true;
}





/**
 * @brief   生成长文件的线程函数，文件生成逻辑如下
 *          1、这里有一个缓冲区，存储音频数据，缓冲区大小是2分钟的数据
 *          2、每分钟写入一次文件，文件名格式为：ChannelX_yyyyMMdd_hhmmss-yyyyMMdd_hhmmss.wav
 *          3、文件总长度是1小时的数据，超过1小时则重新开始记录一个新的文件
 * 
 */
void CreateRecordFileThread::task()
{
    SPDLOG_LOGGER_INFO(m_logger, "➢ {} 开启记录文件线程 ", m_logBase);
    /* 计算一小时的文件大小 */

    while(m_isRunning)
    {
        /* 线程休眠100ms */
        std::this_thread::sleep_for(std::chrono::milliseconds(100));

        /*--------------------------------------------------------------
        * 写入报警文件
        *--------------------------------------------------------------*/
        writeAlarmFile();
        
        /*--------------------------------------------------------------
        * 写入长记录文件
        *--------------------------------------------------------------*/
        /* 判断是否需要录音 */
        std::lock_guard<std::mutex> lock(m_mutexCompareItemRoadInfo);
        if(m_isRequireRecord.load() == false)
        {
            /* 没有对比项信息，不进行录音 */
            continue;
        }
        writeLongRecordFile();
        
    }
    SPDLOG_LOGGER_WARN(m_logger, "➢ {} 记录长文件线程结束运行", m_logBase);
}



/* 初始化一些数据 */
bool CreateRecordFileThread::initData()
{
    m_logBase = fmt::format("录音通道 {}:{} - 记录长文件线程", 
        m_threadInfo.cardRoadInfo.strSoundCardName.toStdString(),
        m_threadInfo.cardRoadInfo.roadInfo.nRoadNum);
    /* 获取全局数据 */
    m_sampleRate = GInfo.sampleRate();          /* 采样率 */
    m_numChannels = GInfo.numChannels();        /* 声道数 */
    m_bitsPerSample = GInfo.bitsPerSample();    /* 每个采样点的位数 */

    /* 一秒的数据大小 */
    m_oneSecondSize = m_sampleRate * m_numChannels * (m_bitsPerSample / 8);
    /* 一分钟数据大小 */
    m_writeCriticalSize = m_oneSecondSize * 60;
    /* 一小时数据大小 */
    m_oneHourSize = m_writeCriticalSize * 60;
    /* 给缓存分配空间 */
    m_bufferData.allocateMemory(m_writeCriticalSize * 3);
    m_srcData.allocateMemory(m_writeCriticalSize * 3);

    /* 设置环形队列大小 */
    m_ringQueue.setQueueCapacity(GInfo.queueElementCount());

    return true;
}

/* 清理数据 */
void CreateRecordFileThread::clearData()
{
    /* 清理缓存数据 */
    std::lock_guard<std::mutex> lock(m_mutexBuffer);
    m_bufferData.clear();
}

/* 写入长记录文件 */
bool CreateRecordFileThread::writeLongRecordFile()
{
    /* 判断缓存是否达到1分钟数据临界值 */
    {
        std::lock_guard<std::mutex> lock(m_mutexBuffer);
        if(m_bufferData.dataSize < m_writeCriticalSize)
        {
            return true; // 缓存数据不足，继续等待
        }
        /* 数据足够了将缓冲区数据拷贝出来 */
        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());
    /*--------------------------------------------------------------
     * 打开文件。写入的时候判断是否到达了整点，如果到达了整点，则关闭文件
     * 重新创建一个新的文件
     *--------------------------------------------------------------*/
    bool isNewFile = false;
    if(m_writtenSize == 0)
    {
        /* 如果没有写入过数据，则是新文件 */
        isNewFile = true;
        m_writtenStartTime = m_srcData.startTime; // 记录开始时间
        m_writtenNowTime = m_writtenStartTime; // 记录当前时间
    }
    /* 设置今日目录 */
    if(!setTodayPath(isNewFile))
    {
        return false;
    }
    
    /* 打开文件 */
    QFile wavFile;
    if(!openFile(wavFile, isNewFile))
    {
        if(m_openFileErrorSize >= 3)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 打开文件失败次数过多，重新开始记录", m_logBase);
            m_writtenSize = 0;
            m_writtenStartTime = QDateTime::currentDateTime(); // 重新开始时间
            m_writtenNowTime = m_writtenStartTime; // 重新开始时间
            m_wavFileName.clear(); // 清空文件名
            m_srcData.clear(); // 清空缓冲区数据
            m_openFileErrorSize = 0; // 重置错误次数
            return false; // 重新开始记录
        }
    }
    /*--------------------------------------------------------------
     * 将数据写入文件，并记录其携带的时间和写入的数据大小
     *--------------------------------------------------------------*/
    int64_t wSize = 0;
    {
        std::lock_guard<std::mutex> lock(m_mutexBuffer);
        wSize = wavFile.write(m_srcData.pData, m_srcData.dataSize);
        /* 更新结束时间 */
        m_writtenNowTime = m_srcData.endTime;
        /* 清空缓冲区 */
        m_srcData.clear();
    }
    if(wSize < 0)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 写入WAV文件失败: {}", m_logBase, wavFile.errorString().toStdString());
        SPDLOG_LOGGER_WARN(m_logger, "文件路径:{}", m_wavFileName.toStdString());
        wavFile.close();
        return false;
    } else {
        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);

    /*--------------------------------------------------------------
     * 对该文件进行其他操作，判断是否已经过了一个整点，修改其文件名称
     * 现在这里的时间是这一分钟的开始时间，现在需要根据开始时间求出已写入
     * 数据大小对应的结束时间
     *--------------------------------------------------------------*/
    m_writtenSize += wSize;
    
    /* 修改文件名称 */
    QString newFileName = generateFileName(m_writtenStartTime, m_writtenNowTime);
    if(modifyFileName(m_wavFileName, newFileName))
    {
        m_wavFileName = newFileName;
    }
    
    /* 判断是否过了整点 */
    if(isOneHourPassed())
    {
        /* 修改文件头中记录的数据大小 */
        m_wavHeader.setDataSize(m_writtenSize);
        m_wavHeader.calculateDerivedFields();
        modifyWavFileHeader(m_wavFileName, m_wavHeader);
        SPDLOG_LOGGER_INFO(m_logger, "{} 结束记录一个文件: {}, 已写入大小: {} 字节", 
            m_logBase, m_wavFileName.toStdString(), m_writtenSize);
        /* 重置已写入大小 */
        m_writtenSize = 0;
        m_writtenStartTime = QDateTime();       // 重新开始时间
        m_writtenNowTime = m_writtenStartTime;  // 重新开始时间
        m_wavFileName.clear();                  // 清空文件名
        m_openFileErrorSize = 0;                // 重置错误次数
    }

    return true;
}

/* 设置今日目录 */
bool CreateRecordFileThread::setTodayPath(bool isNewFile)
{
    if(!isNewFile)
    {
        return true;
    }

    /* 判断现在日期是否还是当天日期 */
    QDate today = QDate::currentDate();
    if(m_todayDateRecord == today)
    {
        return true;
    }
    m_todayDateRecord = today;
    /* 先检查现在的日期文件夹是否存在，因为其他线程可能已经创建了 */
    QString todayDirName = QString("%1/%2").arg(GInfo.longWavPath()).arg(m_todayDateRecord.toString("yyyy-MM-dd"));
    m_todayDir.setPath(todayDirName);
    if(!m_todayDir.exists())
    {
        if(!m_todayDir.mkpath(todayDirName))
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 创建今日目录失败: {}", m_logBase, todayDirName.toStdString());
            return false; // 创建目录失败
        } else {
            SPDLOG_LOGGER_INFO(m_logger, "{} 创建今日目录成功: {}", m_logBase, todayDirName.toStdString());
        }
    }

    /* 创建这个通道的文件夹，文件夹格式: AudioPCI-0 */
    QString roadDirName = QString("%1/%2-%3")
        .arg(todayDirName)
        .arg(m_threadInfo.cardRoadInfo.strSoundCardID)
        .arg(QString::number(m_threadInfo.cardRoadInfo.roadInfo.nRoadNum));
    m_todayDir.setPath(roadDirName);
    if(!m_todayDir.exists())
    {
        SPDLOG_LOGGER_WARN(m_logger, "{} 记录文件目录不存在: {}", m_logBase, roadDirName.toStdString());
        if(!m_todayDir.mkpath(roadDirName))
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 创建目录失败: {}", m_logBase, roadDirName.toStdString());
            return false;
        } else {
            SPDLOG_LOGGER_INFO(m_logger, "{} 创建目录成功: {}", m_logBase, roadDirName.toStdString());
        }
    }
    
    return true;
}

/* 打开文件 */
bool CreateRecordFileThread::openFile(QFile& wavFile, bool isNewFile)
{
    if(isNewFile)
    {
        /* 如果没有写入过数据，则生成一个新的文件名 */
        m_wavFileName = generateFileName(m_writtenStartTime, m_writtenNowTime);
        m_wavHeader.setSampleRate(m_sampleRate);
        m_wavHeader.setNumChannels(m_numChannels);
        m_wavHeader.setBitsPerSample(m_bitsPerSample);
        m_wavHeader.setDataSize(m_writtenSize);
        m_wavHeader.calculateDerivedFields();

        wavFile.setFileName(m_wavFileName);
        if(!wavFile.open(QIODevice::WriteOnly | QIODevice::Truncate))
        {
            m_openFileErrorSize ++;
            SPDLOG_LOGGER_ERROR(m_logger, "{} 打开WAV文件失败: {}", m_logBase, m_wavFileName.toStdString());
            SPDLOG_LOGGER_ERROR(m_logger, "错误原因: {}", wavFile.errorString().toStdString());
            return false;
        }
        wavFile.write(reinterpret_cast<const char*>(&m_wavHeader), sizeof(WavHeader));
    } else 
    {
        /* 不是新文件 */
        wavFile.setFileName(m_wavFileName);
        if(!wavFile.open(QIODevice::WriteOnly | QIODevice::Append))
        {
            m_openFileErrorSize ++;
            SPDLOG_LOGGER_ERROR(m_logger, "{} 打开WAV文件失败: {}", m_logBase, m_wavFileName.toStdString());
            SPDLOG_LOGGER_ERROR(m_logger, "错误原因: {}", wavFile.errorString().toStdString());
            return false;
        }
    }
    
    m_openFileErrorSize = 0;
    return true;
}

/* 写入音频数据到文件 */
bool CreateRecordFileThread::writeAudioDataToFile(const AudioSrcData& audioData, const QString& fileName)
{

    return true;
}

/* 生成文件名 */
QString CreateRecordFileThread::generateFileName(const QDateTime& startTime, const QDateTime& endTime) const
{
    // 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"))
        .arg(endTime.toString("yyyyMMdd_hhmmss"));
    /* 通过目录获取文件的全路径，dir不会检查文件是否存在 */
    return m_todayDir.filePath(fileName);
}


/* 判断是否过了整点 */
bool CreateRecordFileThread::isOneHourPassed()
{
    if(m_writtenSize >= m_oneHourSize)
    {
        return true; // 已经写入的数据大小超过了一小时的大小
    }
    /* 下面是判断刚启动的时候，到下一个整点不足1小时，也会保存文件 */
    int minute = m_writtenNowTime.time().minute();
    bool isPassed = false;
    /* 如果当前时间的分钟数小于等于2，并且已经写入的大小超过2分钟的大小 */
    if(minute <= 2 && m_writtenSize >= m_writeCriticalSize * 2)
    {
        isPassed = true;
    }
    /* 或者已经写入的数据大小超过了一小时的大小，则认为过了整点 */
    if(m_writtenSize >= m_oneHourSize)
    {
        isPassed = true;
    }

    return isPassed;
}


/* 生成报警文件名 */
QString CreateRecordFileThread::generateAlarmFileName(const AlarmValue_t& value, bool isNewFile)
{
    QString retFileName;
    if(isNewFile)
    {
        /* 先检查是否已经过了一天了，设置日期文件夹 */
        setTodayAlarmPath();

        /* 检查这个对比项的报警文件夹是否存在 */
        // QString itemDirName = m_todayDirAlarm.filePath(QString("CompareItemID_%1").arg(QString::number(value.numConpareItemID)));
        QString itemDirName = QString("CompareItemID_%1").arg(QString::number(value.numConpareItemID));
        QDir itemDir(m_todayDirAlarm.filePath(itemDirName));
        if(!itemDir.exists())
        {
            SPDLOG_LOGGER_WARN(m_logger, "{} 对比项报警文件夹不存在: {}", m_logBase, itemDir.path().toStdString());
            if(!itemDir.mkpath("."))
            {
                SPDLOG_LOGGER_ERROR(m_logger, "{} 创建对比项报警文件夹失败: {}", m_logBase, itemDir.path().toStdString());
                return QString(); // 创建目录失败
            } else {
                SPDLOG_LOGGER_INFO(m_logger, "{} 创建对比项报警文件夹成功: {}", m_logBase, itemDir.path().toStdString());
            }
        }
        /* 生成文件名, 格式: Alarm_RoadNum_AlarmType_yyyyMMdd_hhmmss-yyyyMMdd_hhmmss.wav
           这里创建的录音文件只有开始日期，没有结束日期，等报警结束之后才会有结束日期 */
        QString fileName = QString("Road%1_%2_%3-.wav")
            .arg(QString::number(value.itemRoadInfo.nCompareRoadNum))
            .arg(getAlarmTypeString(value.alarmType))
            .arg(value.startTime.toString("yyyyMMdd_hhmmss"));
        
        /* 拼接文件夹路径 */
        retFileName = itemDir.filePath(fileName);
    }else 
    {
        /* 已有的文件，是报警结束的文件名 */
        retFileName = QString::fromStdString(value.fileName.toStdString());
        /* 这里的文件名格式是：Alarm_CompareItemID_RoadNum_AlarmType_yyyyMMdd_hhmmss-yyyyMMdd_hhmmss.wav，
           这里带上结束时间 */
        QString endTimeStr = value.endTime.toString("yyyyMMdd_hhmmss");
        /* 替换掉原来的结束时间 */
        retFileName.replace("-.wav", QString("-%1.wav").arg(endTimeStr));
    }

    return retFileName;
}


/* 写入报警文件 */
void CreateRecordFileThread::writeAlarmFile()
{
    const int writeSeconds = 2;
    const int newAlarmSeconds = 10;
    /* 新文件，从报警时间往前推10秒写入 */
    std::list<AudioSrcData*> newDataList;
    /* 给已经写入的问价使用 */
    std::list<AudioSrcData*> dataList;
    {
        /* 先判断环形队列中数据是否足够的秒数，不一定是每一秒都会写的 */
        std::lock_guard<std::mutex> lock(m_ringQueue.mutex);
        /* 目前暂定2秒写一次 */
        if(m_numNewAlarmSeconds < writeSeconds)
        {
            /* 不够两秒时间，退出 */
            return;
        }
        /* 取出环形队列中的数据 */
        int size = m_ringQueue.QueueSize();
        for(int i = size - writeSeconds; i < size; ++i)
        {
            AudioSrcData* data = m_ringQueue[i];
            if(data != nullptr)
            {
                dataList.push_back(data);
            }
        }
        int start = size - newAlarmSeconds;
        if(start < 0)
        {
            start = 0; // 防止越界
        }
        /* 取出新数据，往前推10秒 */
        for(int i = start; i < size; ++i)
        {
            AudioSrcData* data = m_ringQueue[i];
            if(data != nullptr)
            {
                newDataList.push_back(data);
            }
        }
    }

    std::lock_guard<std::mutex> lock(m_mutexAlarmFile);
    /* 将数据循环写入到文件中 */
    for(auto& alarmInfo : m_mapAlarmFile)
    {
        /* 获取报警信息 */
        // const AlarmKey_t& key = alarmInfo.first;
        AlarmValue_t& value = alarmInfo.second;
        /* 判断是新否是新录音的文件 */
        if(value.state == eRecordState::eAlarm_Init)
        {
            /* 创建新的文件，并写入wav头文件 */
            createNewAlarmFile(value, newDataList);
        } else
        {
            /* 已经存在的文件，直接写入新录制的文件 */
            /* 打开文件 */
            QFile wavFile(value.fileName);
            if(!wavFile.open(QIODevice::WriteOnly | QIODevice::Append))
            {
                SPDLOG_LOGGER_ERROR(m_logger, "{} 打开报警文件失败: {}", m_logBase, value.fileName.toStdString());
                SPDLOG_LOGGER_ERROR(m_logger, "错误原因: {}", wavFile.errorString().toStdString());
                continue;
            }
            /* 写入音频数据到文件 */
            for(auto& audioData : dataList)
            {
                if(audioData == nullptr || audioData->pData == nullptr || audioData->dataSize == 0)
                {
                    continue; // 跳过空数据
                }
                auto writeSize = wavFile.write(reinterpret_cast<const char*>(audioData->pData), audioData->dataSize);
                if(writeSize < 0)
                {
                    SPDLOG_LOGGER_ERROR(m_logger, "{} 写入报警文件失败: {}", m_logBase, value.fileName.toStdString());
                    SPDLOG_LOGGER_ERROR(m_logger, "错误原因: {}", wavFile.errorString().toStdString());
                    break; // 写入失败，跳出循环
                }else 
                {
                    value.writtenSize += writeSize; // 累加写入大小
                }
            }
            wavFile.close();
        }
        
    }

    /* 处理已经结束的报警，修改文件名，并将其移除队列中 */
    for(auto it = m_mapAlarmFile.begin(); it != m_mapAlarmFile.end(); )
    {
        AlarmValue_t& value = it->second;
        if(value.state == eRecordState::eAlarm_Stopped)
        {
            /* 修改wav头文件，修改吸入的数据大小 */
            value.wavHeader.setDataSize(value.writtenSize);
            value.wavHeader.calculateDerivedFields();
            modifyWavFileHeader(value.fileName, value.wavHeader);
            /* 已经结束的报警，修改文件名 */
            modifyFileName(value.fileName, value.fileNameEnd);
            /* 移除这个报警 */
            it = m_mapAlarmFile.erase(it);
        } else {
            ++it; // 继续下一个
        }
    }


    /* 清空标志位 */
    m_numNewAlarmSeconds = 0;
    
}


/* 创建新的文件 */
void CreateRecordFileThread::createNewAlarmFile(AlarmValue_t& value, const std::list<AudioSrcData*>& dataList)
{
    /* 新的报警录音，生成文件名 */
    value.fileName = generateAlarmFileName(value, true);
    value.state = eRecordState::eAlarm_Recording; // 设置为录音状态
    SPDLOG_LOGGER_INFO(m_logger, "{} 开始写入报警文件: {}", m_logBase, value.fileName.toStdString());
    
    /* 计算出报警开始位置在报警文件中的偏移，这个偏移值在设置结束的时候取出 */
    for(const auto& audioData : dataList)
    {
        if(audioData == nullptr || audioData->pData == nullptr || audioData->dataSize == 0)
        {
            continue; // 跳过空数据
        }
        if(audioData->startTime <= value.startTime)
        {
            /* 计算报警开始位置 */
            value.alarmStartPos = audioData->startTime.secsTo(value.startTime);
        }
    }
    
    /* 打开文件 */
    QFile wavFile(value.fileName);
    if(!wavFile.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 打开报警文件失败: {}", m_logBase, value.fileName.toStdString());
        SPDLOG_LOGGER_ERROR(m_logger, "错误原因: {}", wavFile.errorString().toStdString());
        return;
    }
    /* 先写入wav头文件 */
    value.wavHeader.setSampleRate(m_sampleRate);
    value.wavHeader.setNumChannels(m_numChannels);
    value.wavHeader.setBitsPerSample(m_bitsPerSample);
    value.wavHeader.setDataSize(m_writtenSize);
    value.wavHeader.calculateDerivedFields();

    wavFile.write(reinterpret_cast<const char*>(&value.wavHeader), sizeof(WavHeader));

    /* 写入音频数据到文件 */
    for(auto& audioData : dataList)
    {
        if(audioData == nullptr || audioData->pData == nullptr || audioData->dataSize == 0)
        {
            continue; // 跳过空数据
        }
        auto writeSize = wavFile.write(reinterpret_cast<const char*>(audioData->pData), audioData->dataSize);
        if(writeSize < 0)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 写入报警文件失败: {}", m_logBase, value.fileName.toStdString());
            SPDLOG_LOGGER_ERROR(m_logger, "错误原因: {}", wavFile.errorString().toStdString());
        }else 
        {
            value.writtenSize += writeSize; // 累加写入大小
        }
    }
    wavFile.close();
}


/* 设置今日报警文件夹 */
bool CreateRecordFileThread::setTodayAlarmPath()
{
    /* 先检查当天日期文件夹是否存在，因为其他线程可能已经创建了 */
    QDate today = QDate::currentDate();
    if(today == m_todayDateAlarm)
    {
        return true; // 今天的目录已经存在
    }
    m_todayDateAlarm = today;
    /* 创建今日报警目录 */
    /* 格式: Application/2025-07-21 */
    QString todayDirName = QString("%1/%2").arg(GInfo.alarmWavPath()).arg(today.toString("yyyy-MM-dd"));
    m_todayDirAlarm.setPath(todayDirName);
    if(!m_todayDirAlarm.exists())
    {
        if(!m_todayDirAlarm.mkpath(todayDirName))
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 创建今日报警目录失败: {}", m_logBase, todayDirName.toStdString());
            return false; // 创建目录失败
        } else {
            SPDLOG_LOGGER_INFO(m_logger, "{} 创建今日报警目录成功: {}", m_logBase, todayDirName.toStdString());
        }
    }

    /* 设置目录 */
    m_todayDirAlarm.setPath(todayDirName);
    QString yesterdayDirName = QString("%1/%2").arg(GInfo.alarmWavPath()).arg(QDate::currentDate().addDays(-1).toString("yyyy-MM-dd"));
    m_yesterdayDir.setPath(yesterdayDirName);

    return true;
}

/* 根据报警类型的枚举获取字符 */
QString CreateRecordFileThread::getAlarmTypeString(EAlarmType type) const
{
    switch(type)
    {
        case EAlarmType::EAT_Silent:
            return "Silent";
        case EAlarmType::EAT_Overload:
            return "Overload";
        case EAlarmType::EAT_Reversed:
            return "Reversed";
        case EAlarmType::EAR_Consistency:
            return "Consistency";
        case EAlarmType::EAT_Noise:
            return "Noise";
        default:
            return "Unknown";
    }
}