server1/Server/ThreadRecord/CreateWAVThread.cpp

#include "CreateWAVThread.h"

#include "GlobalInfo.h"
#include "SystemConfig.h"
#include "spdlog.h"

#include <QFile>
#include <QDir>
#include <random>


CreateWAVThread::CreateWAVThread(RecordThreadInfo_t& threadInfo)
    : BaseRecordThread(threadInfo)
{
    m_logger = spdlog::get("RecordAudio");
    if(m_logger == nullptr)
    {
        fmt::print("RecordThread: RecordAudio Logger not found.\n");
        return;
    }
}
    
CreateWAVThread::~CreateWAVThread()
{

}


/**
 * @brief 设置数据，传入的都是1秒钟的数据
 * 
 * @param srcData 
 * @param dataSize 
 * @param dateTime 这段音频结束时间
 * @return true 
 * @return false 
 */
bool CreateWAVThread::setData(const AudioSrcData& srcData)
{
    AudioSrcData* newData1 = new AudioSrcData(srcData);
    /* -------------------------- 入队WAV环形队列 ---------------------------- */
    if(m_queueWavSrcData.isFull())
    {
        /* 出队一个最早的元素 */
        AudioSrcData* oldData = m_queueWavSrcData.front_pop();
        SPDLOG_LOGGER_TRACE(m_logger, "{} 环形队列已满，出队一个元素，时间: {}, 大小: {}", 
            m_logBase, oldData->startTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(), oldData->dataSize);
        if(oldData != nullptr){
            delete oldData;
            oldData = nullptr;
        }
        m_queueWavSrcData.push(newData1);
    } else 
    {
        m_queueWavSrcData.push(newData1);
    }
    

    /* -------------------------- 入队LeftRight环形队列 ---------------------------- */
    AudioSrcData* newData2 = new AudioSrcData(srcData);
    if(!m_queueLeftRightSrcData.isFull())
    {
        m_queueLeftRightSrcData.push(newData2);
    } else
    {
        AudioSrcData* oldData = m_queueLeftRightSrcData.front_pop();
        SPDLOG_LOGGER_TRACE(m_logger, "{} 左右声道环形队列已满，出队一个元素，时间: {}, 大小: {}", 
            m_logBase, oldData->startTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(), oldData->dataSize);
        delete oldData;
        oldData = nullptr;
        m_queueLeftRightSrcData.push(newData2);
    }

    return true;
}

/* 获取最新的数据 */
bool CreateWAVThread::getLatestFileName(WavFilePath& wavName)
{
    if(m_queueWavFileName->isEmpty())
    {
        // SPDLOG_LOGGER_TRACE(m_logger, "{} WAV文件路径队列为空", m_logBase);
        return false;
    }
    m_queueWavFileName->mutex.lock();
    wavName = m_queueWavFileName->back();
    m_queueWavFileName->mutex.unlock();
    return true;
}

/* 获取最新的左右声道数据 */
bool CreateWAVThread::getLatestLeftRightData(AudioLeftRightData& leftRightData)
{
    if(m_queueLeftRightData.isEmpty())
    {
        // SPDLOG_LOGGER_TRACE(m_logger, "{} 左右声道数据队列为空", m_logBase);
        return false;
    }
    std::lock_guard<std::mutex> lock(m_queueLeftRightData.mutex);
    auto pData = m_queueLeftRightData.back();
    if(pData == nullptr)
    {
        SPDLOG_LOGGER_WARN(m_logger, "{} 获取左右声道数据失败", m_logBase);
        return false;
    }
    /* 判断数据是否相同 */
    if(pData->isSameData(leftRightData))
    {
        return false;
    }
    leftRightData = *pData;

    return true;
}


/* 生成WAV文件的线程函数 */
void CreateWAVThread::task()
{
    SPDLOG_LOGGER_INFO(m_logger, "➢ {} 开启生成WAV文件线程 ", m_logBase);
    /* 初始化数据 */
    if(!initData())
    {
        return;
    }
    SPDLOG_LOGGER_INFO(m_logger, "WAV文件队列容量: {}, 每个元素大小: {}", GInfo.queueElementCount(), m_oneSecondSize);

    m_isRunning = true;
    while(m_isRunning)
    {
        /* 睡眠一定时间 */
        std::this_thread::sleep_for(std::chrono::milliseconds(100));

        /*--------------------------------------------------------------
        * 分离左右声道
        *--------------------------------------------------------------*/
        splitLeftRightChannel();

        /*--------------------------------------------------------------
        * 生成wav小文件
        *--------------------------------------------------------------*/
        /* 如果环形队列中有数据，生成WAV文件 */
        if(m_queueWavSrcData.QueueSize() < m_wavFileDuration)
        {
            // SPDLOG_LOGGER_TRACE(m_logger, "{} 录音文件缓存不足，无法生成WAV文件，当前数据量: {}, 需要: {}", 
            //     m_logBase, m_queueWavSrcData.QueueSize(), m_wavFileDuration);
            continue;
        }
        /* 创建wav小文件 */
        if(!createWAVFile(m_wavFileDuration))
        {
            SPDLOG_LOGGER_WARN(m_logger, "{} 生成WAV文件失败", m_logBase);
            continue;
        }

        /* 将文件名加入到新的队列中，给对比线程使用 */
        WavFilePath wavFilePath;
        wavFilePath.fileName = m_newFileName;
        wavFilePath.startDateTime = m_newFileStartTime;
        m_queueWavFileName->mutex.lock();
        if(m_queueWavFileName->isFull())
        {
            auto wavFile = m_queueWavFileName->front_pop();
            m_listDeleteFile.push_back(wavFile);
        }
        m_queueWavFileName->push(wavFilePath);
        m_queueWavFileName->mutex.unlock();

        /*------------------------------------------------------------------------
         * 删除多余的文件，保留最新的60个文件
         *------------------------------------------------------------------------*/
        // deleteWAVFile(m_filePathNum);
        removeWAVFileFromList(m_listDeleteFile);
    }
    /* 清理数据 */
    clearData();
    SPDLOG_LOGGER_WARN(m_logger, "➢ {} 生成WAV文件线程结束", m_logBase);
    m_isRunning = false;
}




/* 初始化数据 */
bool CreateWAVThread::initData()
{
    /* 环形队列大小，默认是3分钟大小 */
    int queueSize = GInfo.queueElementCount();
    m_queueWavSrcData.clearQueue();
    m_queueWavSrcData.setQueueCapacity(queueSize);
    m_queueLeftRightSrcData.clearQueue();
    m_queueLeftRightSrcData.setQueueCapacity(queueSize);

    m_queueWavSrcData.setDefaultValue(nullptr);
    m_queueLeftRightSrcData.setDefaultValue(nullptr);

    /* 获取基础音频数据 */
    m_sampleRate = GInfo.sampleRate();  // 采样率
    m_numChannels = GInfo.numChannels(); // 声道数
    m_bitsPerSample = GInfo.bitsPerSample(); // 每个采样点的位数

    /* 计算出一秒数据大小 */
    m_oneSecondSize = m_sampleRate * m_numChannels * (m_bitsPerSample / 8);
    /* 获取对比项数据参数 */
    auto aiSetting = SysConfig.getAICompareConfig();
    m_wavFileDuration = aiSetting.nAiComputeDuration;

    /* 获取噪音检测参数，这里的噪音判断时长不知道是超过这个时长是噪音，还是传入的文件到大小
        这里需要的是传入检测文件的大小 */
    // auto noiseSetting = SysConfig.getNoiseDetectParam();
    // m_noiseElementDuration = noiseSetting.nNoiseDetectDuration / 1000; // 转换为秒
    m_noiseElementDuration = GInfo.noiseElementDuration();
    
    QString wavPath = GInfo.wavPath();
    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())
    {
        if(!m_wavDir.mkpath(m_wavDir.path()))
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 创建WAV目录失败: {}", m_logBase, m_wavDir.path().toStdString());
            return false;
        } else {
            SPDLOG_LOGGER_INFO(m_logger, "{} 创建WAV目录成功: {}", m_logBase, m_wavDir.path().toStdString());
        }
    }
    m_filePathNum = 60;
    m_queueWavFileName = new RingQueueManualMutex<WavFilePath>(m_filePathNum);
    m_queueLeftRightData.setQueueCapacity(m_filePathNum);

    m_listDeleteFile.clear();

    return true;
}


/* 清理数据 */
void CreateWAVThread::clearData()
{
    /* 清理环形队列 */
    while(!m_queueWavSrcData.isEmpty())
    {
        AudioSrcData* data = m_queueWavSrcData.front_pop();
        if(data != nullptr)
        {
            delete data;
            data = nullptr;
        }
    }
    while(!m_queueLeftRightSrcData.isEmpty())
    {
        AudioSrcData* data = m_queueLeftRightSrcData.front_pop();
        if(data != nullptr)
        {
            delete data;
            data = nullptr;
        }
    }
}

/**
 * @brief 生成wav小文件，这里AudioSrcData中的时间是真的开始时间
 * 
 * @param secondCount 
 * @return QString 
 */
bool CreateWAVThread::createWAVFile(int secondCount)
{
    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 开始生成WAV文件，秒数: {}", m_logBase, secondCount);
    m_newFileName.clear();
    m_newFileStartTime = QDateTime();
    /* 生成wav文件名 */
    AudioSrcData* audioData = m_queueWavSrcData.front();
    if(audioData == nullptr )
    {
        SPDLOG_LOGGER_WARN(m_logger, "{} 从环形队列中取出数据失败!", m_logBase);
        return false;
    }
    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"));
    QString fileName = m_wavDir.filePath(strFileName);

    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 开始打开文件", m_logBase);
    QFile wavFile(fileName);
    if(!wavFile.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 打开WAV文件失败: {}", m_logBase, fileName.toStdString());
        return false;
    }
    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 生成WAV文件: {}", m_logBase, fileName.toStdString());

    /* 写入WAV文件头 */
    WavHeader tmpHeader;
    tmpHeader.setSampleRate(m_sampleRate);
    tmpHeader.setNumChannels(m_numChannels);
    tmpHeader.setBitsPerSample(m_bitsPerSample);
    tmpHeader.setDataSize(m_oneSecondSize * secondCount);  
    tmpHeader.calculateDerivedFields();
    wavFile.write(reinterpret_cast<const char*>(&tmpHeader), sizeof(WavHeader));

    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 开始写入音频数据", m_logBase);
    /* 写入音频数据 */
    for(int i = 0; i < secondCount; ++i)
    {
        AudioSrcData* data = m_queueWavSrcData.front_pop();
        if(data == nullptr)
        {
            SPDLOG_LOGGER_WARN(m_logger, "{} 从WAV源数据环形队列中取出数据失败!", m_logBase);
            continue;
        }
        wavFile.write(data->pData, data->dataSize);
        delete data;
        data = nullptr;
    }
    wavFile.close();

    m_newFileName = fileName.toStdString();
    m_newFileStartTime = audioData->startTime;

    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 数据写入完成", m_logBase);

    return true;
}

/**
 * @brief 删除wav小文件，传入留下的个数
 * 
 * @param remainCount 需要剩余的个数，如果等于0，则删除所有文件
 */
void CreateWAVThread::deleteWAVFile(int remainCount)
{
    /* 删除多余的文件，保留最新的remainCount个文件 */
    QStringList fileList = m_wavDir.entryList(QStringList("WAV_*.wav"), QDir::Files);
    if(fileList.size() <= remainCount)
    {
        SPDLOG_LOGGER_INFO(m_logger, "{} 删除WAV文件操作不需要执行，当前文件数量: {}, 保留数量: {}", 
            m_logBase, fileList.size(), remainCount);
        return;
    }

    /* 按照时间排序，删除最早的文件 */
    std::sort(fileList.begin(), fileList.end(), [](const QString& a, const QString& b) {
        return a < b; // 按照文件名排序，假设文件名中包含时间戳
    });

    for(int i = 0; i < fileList.size() - remainCount; ++i)
    {
        QString filePath = m_wavDir.filePath(fileList[i]);
        if(QFile::remove(filePath))
        {
            SPDLOG_LOGGER_DEBUG(m_logger, "{} 删除WAV文件: {}", m_logBase, filePath.toStdString());
        } else
        {
            SPDLOG_LOGGER_WARN(m_logger, "{} 删除WAV文件失败: {}", m_logBase, filePath.toStdString());
        }
    }
}

/* 从删除列表中删除wav小文件 */
void CreateWAVThread::removeWAVFileFromList(std::list<WavFilePath>& listDeleteFile)
{
    if(listDeleteFile.empty())
    {
        return;
    }
    for(auto& wavFile : listDeleteFile)
    {
        if(QFile::remove(QString::fromStdString(wavFile.fileName)))
        {
            SPDLOG_LOGGER_DEBUG(m_logger, "{} 删除WAV文件: {}", m_logBase, wavFile.fileName);
        } else
        {
            SPDLOG_LOGGER_WARN(m_logger, "{} 删除WAV文件失败: {}", m_logBase, wavFile.fileName);
        }
    }
    listDeleteFile.clear();
}


/* 将每秒的数据拆解成两个声道，给噪音检测线程使用 */
bool CreateWAVThread::splitLeftRightChannel()
{
    if(m_queueLeftRightSrcData.QueueSize() < m_noiseElementDuration)
    {
        // SPDLOG_LOGGER_TRACE(m_logger, "{} 左右声道环形队列数据不足，当前数据量: {}, 需要: {}", 
        //     m_logBase, m_queueLeftRightSrcData.QueueSize(), m_noiseElementDuration);
        return false;
    }

    /* 分离左右声道 / 2，转换成short / 2 */
    bool isStart = false;
    AudioLeftRightData* pLeftRightData = new AudioLeftRightData(m_noiseElementDuration * m_oneSecondSize / 4);
    for(int32_t i = 0; i < m_noiseElementDuration; ++i)
    {
        AudioSrcData* data = m_queueLeftRightSrcData.front_pop();
        if(data == nullptr)
        {
            SPDLOG_LOGGER_WARN(m_logger, "{} 从左右声道环形队列中取出数据失败!", m_logBase);
            continue;
        }
        if(isStart)
        {
            pLeftRightData->startTime = data->startTime; // 设置开始时间戳
            pLeftRightData->endTime = data->endTime; // 设置结束时间戳
            isStart = false; // 只设置一次
        }
        /* 先将char类型转换成short，然后转换成double */
        int dec = data->dataSize % 4;
        int oneChannelSize = (data->dataSize - dec) / 2; // 确保是4的倍数
        for(int j = 0; j < oneChannelSize; ++j)
        {
            int16_t sample = *reinterpret_cast<int16_t*>(data->pData + j * 2);
            double sampleDouble = static_cast<double>(sample);
            if(j % 2 == 0) // 左声道
            {
                pLeftRightData->vecLeftData.push_back(sampleDouble);
            } else // 右声道
            {
                pLeftRightData->vecRightData.push_back(sampleDouble);
            }
            // fmt::print(" |{} {}, short: {}, double: {:.2f}", static_cast<uint8_t>(*(data->pData + j)), static_cast<uint8_t>(*(data->pData + 1001)), sample, sampleDouble);
            
        }
        pLeftRightData->numMSecond += 1000; // 每次处理1秒的数据，增加1000毫秒

        /* 更新结束时间戳 */
        pLeftRightData->endTime = data->endTime;

        delete data;
        data = nullptr;
    }

    /* 测试数据 */
        // std::vector<double> audio_signal(m_sampleRate);
        // std::random_device rd;
        // std::mt19937 gen(rd());
        // std::normal_distribution<> dist(0.0, 1.0);
        
        // for (auto& sample : audio_signal) {
        //     sample = dist(gen);
        // }
        // pLeftRightData->vecLeftData = audio_signal; // 左声道数据
        // pLeftRightData->vecRightData = audio_signal; // 右声道数据


    /* 将分离完成的数据添加到环形队列中 */
    m_queueLeftRightData.mutex.lock();
    auto tmp = m_queueLeftRightData.push(pLeftRightData);
    m_queueLeftRightData.mutex.unlock();
    if(tmp != nullptr)
    {
        SPDLOG_LOGGER_INFO(m_logger, "{} 左右声道环形队列已满，出队一个元素", m_logBase);
        delete tmp; // 删除出队的元素
        tmp = nullptr;
    }

    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 分离左右声道数据完成，左声道数据大小: {}, 右声道数据大小: {}", 
    //     m_logBase, pLeftRightData->vecLeftData.size(), pLeftRightData->vecRightData.size());

    return true;
}