server1/Server/ThreadRecord/RecordLongFileThread.cpp

#include "RecordLongFileThread.h"

#include "GlobalInfo.h"



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

RecordLongFileThread::~RecordLongFileThread()
{

}

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

    while(m_isRunning)
    {
        /* 线程休眠1秒 */
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        
        /* 判断缓存是否达到1分钟数据临界值 */
        {
            std::lock_guard<std::mutex> lock(m_mutexBuffer);
            if(m_bufferData.dataSize < m_writeCriticalSize)
            {
                continue; // 缓存数据不足，继续等待
            }
        }

        /*--------------------------------------------------------------
         * 打开文件。写入的时候判断是否到达了整点，如果到达了整点，则关闭文件
         * 重新创建一个新的文件
         *--------------------------------------------------------------*/
        bool isNewFile = false;
        if(m_writtenSize == 0)
        {
            /* 如果没有写入过数据，则是新文件 */
            isNewFile = true;
        }
        /* 设置今日目录 */
        if(setTodayPath(isNewFile))
        {
            continue;
        }
        
        /* 打开文件 */
        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_bufferData.clear(); // 清空缓冲区数据
                m_openFileErrorSize = 0; // 重置错误次数
                continue; // 重新开始记录
            }
        }
        /*--------------------------------------------------------------
         * 将数据写入文件，并记录其携带的时间和写入的数据大小
         *--------------------------------------------------------------*/
        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);
            /* 清空缓冲区 */
            m_bufferData.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();
            continue;
        } else {
            SPDLOG_LOGGER_DEBUG(m_logger, "{} 写入WAV文件成功: {}, 大小: {} 字节", m_logBase, m_wavFileName.toStdString(), wSize);
        }
        wavFile.close();
    
        /*--------------------------------------------------------------
         * 对该文件进行其他操作，判断是否已经过了一个整点，修改其文件名称
         * 现在这里的时间是这一分钟的开始时间，现在需要根据开始时间求出已写入
         * 数据大小对应的结束时间
         *--------------------------------------------------------------*/
        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))
        {
            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;                // 重置错误次数
        }
        
    }
}

/* 设置数据 */
bool RecordLongFileThread::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_mutexBuffer);
    /* 如果缓冲区没有分配内存，先分配 */
    if(m_bufferData.pData == nullptr)
    {
        if(!m_bufferData.allocateMemory(m_writeCriticalSize * 3))
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 分配缓冲区内存失败", m_logBase);
            return false;
        }
    }
    /* 添加数据到缓冲区 */
    uint32_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.isValid())
    {
        m_bufferData.startTime = srcData.startTime;
        m_bufferData.endTime = srcData.endTime;  /* 结束时间 */
    }

    return true;
}


/* 初始化一些数据 */
bool RecordLongFileThread::initData()
{
    /* 获取全局数据 */
    m_sampleRate = GInfo.sampleRate();          /* 采样率 */
    m_numChannels = GInfo.numChannels();        /* 声道数 */
    m_bitsPerSample = GInfo.bitsPerSample();    /* 每个采样点的位数 */

    /* 一分钟数据大小 */
    m_writeCriticalSize = m_sampleRate * m_numChannels * (m_bitsPerSample / 8) * 60;
    /* 一小时数据大小 */
    m_oneHourSize = m_writeCriticalSize * 60;
    /* 给缓存分配空间 */
    m_bufferData.allocateMemory(m_writeCriticalSize * 2);
    /* 获取记录文件的位置 */
    m_recordPath = GInfo.longWavPath();

    return true;
}

/* 清理数据 */
void RecordLongFileThread::clearData()
{
    /* 清理缓存数据 */
    m_bufferData.clear();
}

/* 设置今日目录 */
bool RecordLongFileThread::setTodayPath(bool isNewFile)
{
    if(isNewFile)
    {
        QString todayDirName = QString("%1/Record%2-%3/%4")
            .arg(m_recordPath)
            .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())
        {
            if(!m_todayDir.mkpath(todayDirName))
            {
                SPDLOG_LOGGER_ERROR(m_logger, "{} 创建目录失败: {}", m_logBase, todayDirName.toStdString());
            } else {
                SPDLOG_LOGGER_INFO(m_logger, "{} 创建目录成功: {}", m_logBase, todayDirName.toStdString());
            }
        }
    }

    return m_todayDir.exists();
}

/* 打开文件 */
bool RecordLongFileThread::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 RecordLongFileThread::writeAudioDataToFile(const AudioSrcData& audioData, const QString& fileName)
{

    return true;
}

/* 生成文件名 */
QString RecordLongFileThread::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);
    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 RecordLongFileThread::isOneHourPassed()
{
    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;
}