server1/Server/ThreadCalculate/CalculateDBThread.cpp

#include "CalculateDBThread.h"
#include "spdlog.h"

#include "ThreadManager.h"
#include "GlobalInfo.h"


CalculateDBThread::CalculateDBThread(CalculateThreadInfo_t& threadInfo)
    : BaseCalculateThread(threadInfo)
{

}

CalculateDBThread::~CalculateDBThread()
{

}

/* 获取结果 */
OneRoadVolume_t CalculateDBThread::getVolumeInfo()
{
    std::lock_guard<std::mutex> lock(m_mutexVolumeInfo);
    return m_roadVolumeInfo;
}

/* 获取最新的结果
 * 结果包括：静音、过载、反相和音量包信息
 */
bool CalculateDBThread::getlastVolumeInfo(OneRoadVolume_t& volumeInfo)
{
    std::lock_guard<std::mutex> lock(m_mutexVolumeInfo);
    if(m_caculateDBData.ringQueue.isEmpty())
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 获取最新的音量数据失败，环形队列为空", m_logBase);
        return false; // 环形队列为空，无法获取最新数据
    }
    /* 根据时间判断是否是最新的 */
    if(volumeInfo.dateTime == m_roadVolumeInfo.dateTime)
    {
        return false;
    }
    volumeInfo.isSilence = m_roadVolumeInfo.isSilence;
    volumeInfo.isOverload = m_roadVolumeInfo.isOverload;
    volumeInfo.isReversed = m_roadVolumeInfo.isReversed;
    memcpy(volumeInfo.vecleftDB, m_roadVolumeInfo.vecleftDB, VOLUME_INFO_NUM);
    memcpy(volumeInfo.vecrightDB, m_roadVolumeInfo.vecrightDB, VOLUME_INFO_NUM);

    return true;
}

/* 获取报警数据 */
const AlarmInfo_t& CalculateDBThread::getAlarm(EAlarmType alarmType)
{
    std::lock_guard<std::mutex> lock(m_mutexVolumeInfo);
    switch(alarmType)
    {
        case EAlarmType::EAT_Silent:
            return m_alarmLastSilence;
        case EAlarmType::EAT_Overload:
            return m_alarmLastOverload;
        case EAlarmType::EAT_Reversed:
            return m_alarmLastPhase;
        default:
            SPDLOG_LOGGER_ERROR(m_logger, "{} 获取报警数据失败，未知报警类型: {}", m_logBase, static_cast<int>(alarmType));
            return m_alarmNull; // 返回一个空的报警信息
    }
}

/* 线程功能函数 */
void CalculateDBThread::task()
{
    SPDLOG_LOGGER_INFO(m_logger, "{} 开启计算静音、过载和反相等报警的线程", m_logBase);
    /* 初始化数据 */
    if(!initData())
    {
        return;
    }

    while(m_isRunning)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        /* 判断是否是需要计算的时间段 */

        /* --------------------------------------------------------------------------------
         * 更新最新数据
         * --------------------------------------------------------------------------------*/
        /* 获取最新数据 */
        if(!m_threadCreateDBPhase->getLatestResult(m_caculateDBData.ringQueue))
        {
            // SPDLOG_LOGGER_DEBUG(m_logger, "{} 获取最新的音量数据失败", m_logBase);
            continue; // 没有获取到最新数据，继续等待
        }
        // 获取最新的一秒钟数据
        m_currSecondData = *m_caculateDBData.ringQueue.back();

        /* --------------------------------------------------------------------------------
         * 计算数据
         * --------------------------------------------------------------------------------*/
        calcuDBPhase();
    }

    /* 清理数据 */
    clearData();

    SPDLOG_LOGGER_INFO(m_logger, "{} 计算静音、过载和反相等报警的线程结束", m_logBase);
}

/* 初始化数据 */
bool CalculateDBThread::initData()
{
    /* 对于单个录音通道的线程来说，直接取map中的第一个通道 */
    auto begin = m_threadInfo.compareItemInfo.mapRoad.begin();
    m_roadInfo = begin.value(); // 获取第一个通道的信息
    m_roadName = m_roadInfo.strCompareRoadName.toStdString();

    m_threadCreateDBPhase = ThreadMan.getCreateDBThread(m_roadInfo.scRoadInfo.nSoundCardNum, m_roadInfo.scRoadInfo.roadInfo.nRoadNum);
    if (m_threadCreateDBPhase == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 获取创建音量线程失败", m_logBase);
        return false;
    }

    m_avgCalculateDBSeconds = GInfo.avgDBCalculateSeconds();
    
    m_numQueueSeconds = GInfo.queueElementCount();
    m_caculateDBData.ringQueue.setQueueCapacity(m_numQueueSeconds);


    return true;
}

/* 清理数据 */
void CalculateDBThread::clearData()
{

}

/* 计算静音过载反相 */
void CalculateDBThread::calcuDBPhase()
{
    /* 有最新数据，进行计算 */
    m_mutexVolumeInfo.lock();
    
    for(int i = 0; i < VOLUME_INFO_NUM; ++i)
    {
        m_roadVolumeInfo.vecleftDB[i] = m_currSecondData.aryLeftDB[i];
        m_roadVolumeInfo.vecrightDB[i] = m_currSecondData.aryRightDB[i];
    }

    /* 计算静音 */
    m_roadVolumeInfo.isSilence = m_caculateDBData.calculateSilent(m_volumeParam, m_avgCalculateDBSeconds, 
                                    m_silentStartPos, m_silentEndPos);
    /* 计算过载 */
    m_roadVolumeInfo.isOverload = m_caculateDBData.calculateOverload(m_volumeParam, m_avgCalculateDBSeconds, 
                                    m_overloadStartPos, m_overloadEndPos, m_bLastOverload);
    /* 计算反相 */
    m_roadVolumeInfo.isReversed = m_caculateDBData.calculatePhase(m_volumeParam, m_avgCalculateDBSeconds, 
                                    m_phaseStartPos, m_phaseEndPos, m_bLastReversed);
    
    /* 处理报警信息 */
    processAlarm();
    m_mutexVolumeInfo.unlock();
}

/**
 * @brief 判断是否报警
 *        1、这里报警信息不包含对比项的信息，对比项信息在对比项线程里自己添加
 *        2、报警信息只包含通道编号、通道名称、报警类型等信息
 *        3、静音、过载、反相的判断需要连续多个秒满足才会判断报警，因此报警的开始时间其实
 *           比真正静音的开始时间要晚，差距就是判断报警时长的秒数SilentDuration、OverloadDuration和PhaseDuration
 *           所以需要真正计算出静音开始的时间
 * 
 */
void CalculateDBThread::processAlarm()
{
    /* ----------------------- 处理静音报警 ----------------------- */
    processAlarm();
    /* ----------------------- 处理过载报警 ----------------------- */
    processOverload();
    /* ----------------------- 处理反相报警 ----------------------- */
    processPhase();
    
}

/* 处理静音报警 */
void CalculateDBThread::processSilence()
{
    if(m_roadVolumeInfo.isSilence)
    {
        /* 这次是静音，判断静音报警是否已经开启 */
        if(!m_alarmSilence.isAlarm)
        {
            /* 开启静音报警 */
            m_alarmSilence.isAlarm = true;
            m_alarmSilence.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
            m_alarmSilence.RoadInfo = m_roadInfo; // 设置通道信息
            m_alarmSilence.AlarmType = EAlarmType::EAT_Silent; // 静音报警
            /* 计算开始时间，往前推判断静音需要的时间 */
            QDateTime startTime;
            if(m_silentStartPos > 0)
            {
                /* 上面计算出来的静音开始位置有效，往前推设置的静音时长 */
                startTime = m_caculateDBData.ringQueue.at(m_silentStartPos)->startTime;
                startTime = startTime.addSecs(- m_volumeParam.GetSilentDuration());
            }else 
            {
                startTime = m_currSecondData.endTime.addSecs(- m_volumeParam.GetSilentDuration());
            }
            m_alarmSilence.StartTime = startTime; // 静音开始时间
            m_alarmSilence.EndTime = m_currSecondData.endTime;
        }else 
        {
            /* 静音报警已经开启，更新结束时间 */
            m_alarmSilence.EndTime = m_currSecondData.endTime;
        }
    }else 
    {
        /* 这次不是静音，判断静音报警是否已经开启 */
        if(m_alarmSilence.isAlarm)
        {
            /* 静音报警已经开启，结束静音报警 */
            if(m_silentEndPos > 0)
            {
                auto endData = m_caculateDBData.ringQueue.at(m_silentEndPos);
                if(endData != nullptr)
                {
                    m_alarmSilence.EndTime = endData->endTime.addSecs(- m_volumeParam.GetSilentDuration());
                }
            }else 
            {
                m_alarmSilence.EndTime = m_currSecondData.endTime.addSecs(- m_volumeParam.GetSilentDuration());
            }
            m_alarmSilence.strAlarmFilePath = generateAlarmFilePath(m_alarmSilence); // 生成报警文件路径
            /* 保存报警信息 */
            m_alarmLastSilence = m_alarmSilence;
            m_alarmSilence = AlarmInfo_t(); // 清空报警信息
            /* 将报警信息给截取报警文件的线程 */

            /* 打印日志 */
            SPDLOG_LOGGER_INFO(m_logger, "{} 静音报警结束，开始时间：{}，结束时间：{}，文件路径：{}",
                m_logBase, 
                m_alarmLastSilence.StartTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(),
                m_alarmLastSilence.EndTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(),
                m_alarmLastSilence.strAlarmFilePath);
        }
    }
}

/* 处理过载报警 */
void CalculateDBThread::processOverload()
{
    if(m_roadVolumeInfo.isOverload)
    {
        /* 这次是过载，判断过载报警是否已经开启 */
        if(!m_alarmOverload.isAlarm)
        {
            /* 开启过载报警 */
            m_alarmOverload.isAlarm = true;
            m_alarmOverload.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
            m_alarmOverload.RoadInfo = m_roadInfo; // 设置通道信息
            m_alarmOverload.AlarmType = EAlarmType::EAT_Overload; // 过载报警
            /* 计算开始时间，往前推设置的过载时长 */
            QDateTime startTime;
            if(m_overloadStartPos > 0)
            {
                /* 上面计算出来的过载开始位置有效，往前推设置的过载时长 */
                startTime = m_caculateDBData.ringQueue.at(m_overloadStartPos)->startTime;
                startTime = startTime.addSecs(- m_volumeParam.GetOverloadDuration());
            }else 
            {
                startTime = m_currSecondData.endTime.addSecs(- m_volumeParam.GetOverloadDuration());
            }
            m_alarmOverload.StartTime = startTime; // 过载开始时间
            m_alarmOverload.EndTime = m_currSecondData.endTime;
        }else 
        {
            /* 过载报警已经开启，更新结束时间 */
            m_alarmOverload.EndTime = m_currSecondData.endTime;
        }
    }else 
    {
        /* 这次不是过载，判断过载报警是否已经开启 */
        if(m_alarmOverload.isAlarm)
        {
            /* 过载报警已经开启，结束过载报警 */
            if(m_overloadEndPos > 0)
            {
                auto endData = m_caculateDBData.ringQueue.at(m_overloadEndPos);
                if(endData != nullptr)
                {
                    m_alarmOverload.EndTime = endData->endTime.addSecs(- m_volumeParam.GetOverloadDuration());
                }
            }else 
            {
                m_alarmOverload.EndTime = m_currSecondData.endTime.addSecs(- m_volumeParam.GetOverloadDuration());
            }
            m_alarmOverload.strAlarmFilePath = generateAlarmFilePath(m_alarmOverload); // 生成报警文件路径
            /* 保存报警信息 */
            m_alarmLastOverload = m_alarmOverload;
            m_alarmOverload = AlarmInfo_t(); // 清空报警信息
            /* 将报警信息给截取报警文件的线程 */

            /* 打印日志 */
            SPDLOG_LOGGER_INFO(m_logger, "{} 过载报警结束，开始时间：{}，结束时间：{}，文件路径：{}",
                m_logBase, 
                m_alarmLastOverload.StartTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(),
                m_alarmLastOverload.EndTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(),
                m_alarmLastOverload.strAlarmFilePath);
        }
    }
    
}

/* 处理反相报警 */
void CalculateDBThread::processPhase()
{
    if(m_roadVolumeInfo.isReversed)
    {
        /* 这次是反相，判断反相报警是否已经开启 */
        if(!m_alarmPhase.isAlarm)
        {
            /* 开启反相报警 */
            m_alarmPhase.isAlarm = true;
            m_alarmPhase.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
            m_alarmPhase.RoadInfo = m_roadInfo; // 设置通道信息
            m_alarmPhase.AlarmType = EAlarmType::EAT_Reversed; // 反相报警
            /* 计算开始时间，往前推设置的反相时长 */
            QDateTime startTime;
            if(m_phaseStartPos > 0)
            {
                /* 上面计算出来的反相开始位置有效，往前推设置的反相时长 */
                startTime = m_caculateDBData.ringQueue.at(m_phaseStartPos)->startTime;
                startTime = startTime.addSecs(- m_volumeParam.GetPhaseDuration());
            }else 
            {
                startTime = m_currSecondData.endTime.addSecs(- m_volumeParam.GetPhaseDuration());
            }
            m_alarmPhase.StartTime = startTime; // 反相开始时间
            m_alarmPhase.EndTime = m_currSecondData.endTime;
        }else 
        {
            /* 反相报警已经开启，更新结束时间 */
            m_alarmPhase.EndTime = m_currSecondData.endTime;
        }
    }else 
    {
        /* 这次不是反相，判断反相报警是否已经开启 */
        if(m_alarmPhase.isAlarm)
        {
            /* 反相报警已经开启，结束反相报警 */
            if(m_phaseEndPos > 0)
            {
                auto endData = m_caculateDBData.ringQueue.at(m_phaseEndPos);
                if(endData != nullptr)
                {
                    m_alarmPhase.EndTime = endData->endTime.addSecs(- m_volumeParam.GetPhaseDuration());
                }
            }else 
            {
                m_alarmPhase.EndTime = m_currSecondData.endTime.addSecs(- m_volumeParam.GetPhaseDuration());
            }
            m_alarmPhase.strAlarmFilePath = generateAlarmFilePath(m_alarmPhase); // 生成报警文件路径
            /* 保存报警信息 */
            m_alarmLastPhase = m_alarmPhase;
            m_alarmPhase = AlarmInfo_t(); // 清空报警信息
            /* 将报警信息给截取报警文件的线程 */
            /* 打印日志 */
            SPDLOG_LOGGER_INFO(m_logger, "{} 反相报警结束，开始时间：{}，结束时间：{}，文件路径：{}",
                m_logBase, 
                m_alarmPhase.StartTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(),
                m_alarmPhase.EndTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(),
                m_alarmPhase.strAlarmFilePath);
        }
    }
}


/* 生成报警文件路径 */
std::string CalculateDBThread::generateAlarmFilePath(const AlarmInfo_t& alarmInfo)
{
    std::string filePath = fmt::format("Alarm_{}_{}_{}.wav", 
        alarmInfo.strCompareItemName, 
        static_cast<int>(alarmInfo.AlarmType), 
        alarmInfo.StartTime.toString("yyyyMMdd_hhmmss").toStdString());
    return filePath;
}