server1/Server/ThreadCalculate/CalculateDBThread.cpp

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

#include "ThreadManager.h"
#include "GlobalInfo.h"
#include "ThreadWriteDBManager.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;
}

/**
 * @brief   获取最新的结果
 *          结果包括：静音、过载、反相和音量包信息
 * 
 * @param volumeInfo 
 * @return true 结果更新成功
 * @return false 没有更新结果，可能是没有，也可能传入的已经是最新的结果了
 */
bool CalculateDBThread::getlastVolumeInfo(OneRoadVolume_t& volumeInfo)
{
    std::lock_guard<std::mutex> lock(m_mutexVolumeInfo);
    if(m_caculateDBData.ringQueue.isEmpty())
    {
        // SPDLOG_LOGGER_TRACE(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 * sizeof(volumeInfo.vecleftDB[0]));
    memcpy(volumeInfo.vecrightDB, m_roadVolumeInfo.vecrightDB, VOLUME_INFO_NUM * sizeof(volumeInfo.vecleftDB[0]));

    // const OneRoadVolume_t& volume = m_roadVolumeInfo;
    //     for(int i = 0; i < VOLUME_INFO_NUM; ++i)
    //     {
    //         fmt::print("LDB:{}, RDB:{}\n", volume.vecleftDB[i], volume.vecrightDB[i]);
    //     }

    // const OneRoadVolume_t& volume1 = volumeInfo;
    //     for(int i = 0; i < VOLUME_INFO_NUM; ++i)
    //     {
    //         fmt::print("LDB1:{}, RDB1:{}\n", volume1.vecleftDB[i], volume1.vecrightDB[i]);
    //     }

    /* 更新时间 */
    volumeInfo.dateTime = m_roadVolumeInfo.dateTime;

    return true;
}


/* 获取最新的静音、过载等报警信息，不包含音量包信息 */
bool CalculateDBThread::getAlarmInfo(OneRoadVolume_t& oneVolumeInfo)
{
    std::lock_guard<std::mutex> lock(m_mutexVolumeInfo);
    oneVolumeInfo.isSilence = m_roadVolumeInfo.isSilence;
    oneVolumeInfo.isOverload = m_roadVolumeInfo.isOverload;
    oneVolumeInfo.isReversed = m_roadVolumeInfo.isReversed;
    oneVolumeInfo.isNoise = false;                  // 没有噪音信息
    oneVolumeInfo.isConsistency = false;            // 没有一致性信息
    oneVolumeInfo.isNotConsistencyWarning = false;  // 没有不一致性警告信息

    return true;
}



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

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

        /* --------------------------------------------------------------------------------
         * 计算数据
         * --------------------------------------------------------------------------------*/
        
        calcuDBData();

        // std::chrono::steady_clock::time_point endTime = std::chrono::steady_clock::now();
        // std::chrono::microseconds duration = std::chrono::duration_cast<std::chrono::microseconds>(endTime - startTime);
        // SPDLOG_LOGGER_TRACE(m_logger, "{} 计算静音、过载和反相结束, 线程耗时: {}us", m_logBase, duration.count());
    }
    /* 停止所有的报警 */
    endAllAlarm();
    /* 清理数据 */
    clearData();

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

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

    /* 获取线程，设置10秒超时 */
    auto m_startTime = std::chrono::steady_clock::now(); // 记录开始时间
    while(true)
    {
        /* 获取计算音量的线程 */
        if(m_threadCreateDB == nullptr)
        {
            m_threadCreateDB = ThreadMan.getCreateDBThread(m_roadInfo.scRoadInfo.nSoundCardNum, m_roadInfo.scRoadInfo.roadInfo.nRoadNum);
        }
        if(m_threadCreateAlarmFile == nullptr)
        {
            m_threadCreateAlarmFile = ThreadMan.getCreateRecordFileThread(m_roadInfo.scRoadInfo.nSoundCardNum, m_roadInfo.scRoadInfo.roadInfo.nRoadNum);
        }
        
        if(m_threadCreateDB != nullptr && m_threadCreateAlarmFile != nullptr)
        {
            break; // 获取到线程，跳出循环
        }
        /* 超过10秒还没有获取到线程，返回失败 */
        if(std::chrono::steady_clock::now() - m_startTime > std::chrono::seconds(10))
        {
            break;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        
    }
    if (m_threadCreateDB == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 获取创建音量线程失败", m_logBase);
        return false;
    }
    
    /* 初始化参数，这些参数从外面传进来的 */
    m_avgCalculateDBSeconds = GInfo.avgDBCalculateSeconds();
    
    m_numQueueSeconds = GInfo.queueElementCount();
    m_caculateDBData.ringQueue.setQueueCapacity(m_numQueueSeconds);


    /* 设置静音、过载、反相的计算参数 */
    const auto& silentParam = m_threadInfo.compareItemInfo.paramMute;
    m_volumeParam.SetSilentSwitch(silentParam.isEnable);
    m_volumeParam.SetSilentDuration(silentParam.nLen);
    m_volumeParam.SetSilentThreshold(silentParam.threshold.nThreshold);
    m_volumeParam.SetSilentSensitivity(silentParam.nSensitivity);

    const auto& overloadParam = m_threadInfo.compareItemInfo.paramOverload;
    m_volumeParam.SetOverloadSwitch(overloadParam.isEnable);
    m_volumeParam.SetOverloadDuration(overloadParam.nLen);
    m_volumeParam.SetOverloadThreshold(overloadParam.threshold.nThreshold);
    m_volumeParam.SetOverloadSensitivity(overloadParam.nSensitivity);

    const auto& phaseParam = m_threadInfo.compareItemInfo.paramPhase;
    m_volumeParam.SetPhaseSwitch(phaseParam.isEnable);
    m_volumeParam.SetPhaseDuration(phaseParam.nLen);
    m_volumeParam.SetPhaseThreshold(phaseParam.threshold.dThreshold);
    m_volumeParam.SetPhaseSensitivity(phaseParam.nSensitivity);


    return true;
}

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

}

/**
    计算静音过载反相，如果不是在某一项的计算时间段内，那么这个项目无需计算，全部为false，
    报警检测依旧是要继续的，为了结束可能还存在的报警
 */
void CalculateDBThread::calcuDBData()
{
    
    /* 有最新数据，进行计算 */
    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];
        // fmt::print("LDB:{}, RDB:{}\n", m_roadVolumeInfo.vecleftDB[i], m_roadVolumeInfo.vecrightDB[i]);
    }

    /* 更新时间信息 */
    m_roadVolumeInfo.dateTime = m_currSecondData.startTime;

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

    m_mutexVolumeInfo.unlock();
}

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

/* 处理静音报警 */
void CalculateDBThread::processSilence()
{
    if(m_roadVolumeInfo.isSilence)
    {
        /* 这次是静音，判断静音报警是否已经开启 */
        if(!m_alarmSilence.isAlarm)
        {
            /* 开启静音报警 */
            m_alarmSilence.CompareItemID = m_threadInfo.compareItemInfo.nID;
            m_alarmSilence.strCompareItemName = m_threadInfo.compareItemInfo.strName;
            m_alarmSilence.RoadInfo = m_roadInfo; // 设置通道信息
            
            if(m_alarmSilence.CompareItemID == 1)
            {
                m_alarmSilence.RoadType = ERoadType::RoadType_Main;
            }else {
                m_alarmSilence.RoadType = ERoadType::RoadType_SpaceReceive;
            }

            m_alarmSilence.isAlarm = true;
            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;

            /* 开启录音 */
            if(!m_threadCreateAlarmFile->startRecordAlarmFile(m_alarmSilence))
            {
                /* 开启录制报警音频失败 */
                SPDLOG_LOGGER_WARN(m_logger, "{} 开启录制静音报警音频失败", m_logBase);
            }
        }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_alarmLastSilence = m_alarmSilence;
            
            /* 停止录制报警音频 */
            if(!m_threadCreateAlarmFile->stopRecordAlarmFile(m_alarmSilence))
            {
                SPDLOG_LOGGER_WARN(m_logger, "{} 停止录制静音报警音频失败", m_logBase);
            }

            /* 将报警信息发送给写入报警信息的线程 */
            WriteDB.addAlarmInfo(m_alarmSilence);

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

            /* 清空报警信息 */
            m_alarmSilence = AlarmInfo_t();
        }
    }

}

/* 处理过载报警 */
void CalculateDBThread::processOverload()
{
    if(m_roadVolumeInfo.isOverload)
    {
        /* 这次是过载，判断过载报警是否已经开启 */
        if(!m_alarmOverload.isAlarm)
        {
            /* 开启过载报警 */
            m_alarmOverload.CompareItemID = m_threadInfo.compareItemInfo.nID;
            m_alarmOverload.strCompareItemName = m_threadInfo.compareItemInfo.strName;
            m_alarmOverload.RoadInfo = m_roadInfo; // 设置通道信息

            if(m_alarmOverload.CompareItemID == 1)
            {
                m_alarmOverload.RoadType = ERoadType::RoadType_Main;
            }else {
                m_alarmOverload.RoadType = ERoadType::RoadType_SpaceReceive;
            }

            m_alarmOverload.isAlarm = true;
            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;

            /* 开启录音 */
            if(!m_threadCreateAlarmFile->startRecordAlarmFile(m_alarmOverload))
            {
                /* 开启录制报警音频失败 */
                SPDLOG_LOGGER_WARN(m_logger, "{} 开启录制过载报警音频失败", m_logBase);
            }
            SPDLOG_LOGGER_TRACE(m_logger, "{} 开启过载报警，通道信息:{}:{}，开始时间：{}，结束时间：{}",
                m_logBase, m_threadInfo.compareItemInfo.nID, m_roadInfo.nCompareRoadNum,
                m_alarmOverload.StartTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(),
                m_alarmOverload.EndTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());

        }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_alarmLastOverload = m_alarmOverload;
            
            /* 停止录制报警音频 */
            if(!m_threadCreateAlarmFile->stopRecordAlarmFile(m_alarmOverload))
            {
                SPDLOG_LOGGER_WARN(m_logger, "{} 停止录制过载报警音频失败", m_logBase);
            }

            /* 将报警信息发送给写入报警信息的线程 */
            WriteDB.addAlarmInfo(m_alarmOverload);


            /* 打印日志 */
            SPDLOG_LOGGER_INFO(m_logger, "{} 过载报警结束，开始时间：{}，结束时间：{}",
                m_logBase, 
                m_alarmOverload.StartTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(),
                m_alarmOverload.EndTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
            
            /* 清空报警信息 */
            m_alarmOverload = AlarmInfo_t();
        }
    }
    
}

/* 处理反相报警 */
void CalculateDBThread::processPhase()
{
    if(m_roadVolumeInfo.isReversed)
    {
        /* 这次是反相，判断反相报警是否已经开启 */
        if(!m_alarmPhase.isAlarm)
        {
            /* 开启反相报警 */
            m_alarmPhase.CompareItemID = m_threadInfo.compareItemInfo.nID;
            m_alarmPhase.strCompareItemName = m_threadInfo.compareItemInfo.strName;
            m_alarmPhase.RoadInfo = m_roadInfo; // 设置通道信息

            if(m_alarmPhase.CompareItemID == 1)
            {
                m_alarmPhase.RoadType = ERoadType::RoadType_Main;
            }else {
                m_alarmPhase.RoadType = ERoadType::RoadType_SpaceReceive;
            }
            
            m_alarmPhase.isAlarm = true;
            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;

            /* 开启录音 */
            if(!m_threadCreateAlarmFile->startRecordAlarmFile(m_alarmPhase))
            {
                /* 开启录制报警音频失败 */
                SPDLOG_LOGGER_WARN(m_logger, "{} 开启录制反相报警音频失败", m_logBase);
            }

        }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_alarmLastPhase = m_alarmPhase;
            
            /* 停止录制报警音频 */
            if(!m_threadCreateAlarmFile->stopRecordAlarmFile(m_alarmPhase))
            {
                SPDLOG_LOGGER_WARN(m_logger, "{} 停止录制反相报警音频失败", m_logBase);
            }

            /* 将报警信息发送给写入报警信息的线程 */
            WriteDB.addAlarmInfo(m_alarmPhase);

            /* 打印日志 */
            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 = AlarmInfo_t();
        }
    }

    /* 更新结果，实时更新 */
    // if(m_alarmPhase.AlarmType != EAlarmType::EAT_None)
    // {
    //     /* 有报警类型，进一步判断是否有报警 */
    //     if(m_alarmPhase.isAlarm)
    //     {
    //         /* 有报警，更新报警信息，判断一下上次的报警是否被取走 */
    //         if(m_alarmLastPhase.AlarmType == EAlarmType::EAT_None || m_alarmLastPhase.isAlarm == true)
    //         {
    //             /* 报警结束信息被取走了，或者正在报警中，更新信息 */
    //             m_alarmLastPhase = m_alarmPhase;
    //         }
    //     }else 
    //     {
    //         /* 有报警类型无报警，说明是报警结束了 */
    //         m_alarmLastPhase = m_alarmPhase;
    //         m_alarmPhase = AlarmInfo_t(); // 清空报警信息
    //     }
    // }
}


/* 结束所有的报警 */
void CalculateDBThread::endAllAlarm()
{
    m_roadVolumeInfo.isSilence = false;
    m_roadVolumeInfo.isOverload = false;
    m_roadVolumeInfo.isReversed = false;

    processAlarm();
}