server1/Server/ThreadCalculate/ConsistencyCompareThread.cpp

#include "ConsistencyCompareThread.h"

#include "GlobalVariable.h"
#include "SystemConfig.h"
#include "ThreadManager.h"
#include "CreateRecordFileThread.h"
#include "ThreadWriteDBManager.h"

#include "CreateWAVThread.h"
#include "LHCompareAPI.h"
#include "SystemConfig.h"



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

}

ConsistencyCompareThread::~ConsistencyCompareThread()
{

}


/* 判断录音通道是否相等 */
// bool ConsistencyCompareThread::isRoadEqual(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2)
// {
//     /* r1对比m_r1，r2对比M_r2 */
//     if( roadInfo1.nSoundCardNum == m_roadInfo1.nSoundCardNum && roadInfo1.roadInfo.nRoadNum == m_roadInfo1.roadInfo.nRoadNum &&
//         roadInfo2.nSoundCardNum == m_roadInfo2.nSoundCardNum && roadInfo2.roadInfo.nRoadNum == m_roadInfo2.roadInfo.nRoadNum )
//     {
//         return true;
//     }
    
//     /* 反过来对比一下 */
//     if( roadInfo1.nSoundCardNum == m_roadInfo2.nSoundCardNum && roadInfo1.roadInfo.nRoadNum == m_roadInfo2.roadInfo.nRoadNum &&
//         roadInfo2.nSoundCardNum == m_roadInfo1.nSoundCardNum && roadInfo2.roadInfo.nRoadNum == m_roadInfo1.roadInfo.nRoadNum )
//     {
//         return true;
//     }

//     return false;
// }

/* 初始化 */
bool ConsistencyCompareThread::initConsistencyCompare()
{
    /* 初始化数据 */
    if(!initData())
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
        return false;
    }

    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 一致性对比功能(调用动态库)初始化完成  ", m_logBase);

    return true;
}

/* 比对函数 */
bool ConsistencyCompareThread::compareConsistencyData()
{
    /*--------------------------------------------------------------
     * 更新最新数据
     *--------------------------------------------------------------*/
    m_pCreateWAVThread1->getLatestFileName(m_wavFilePath1);
    m_pCreateWAVThread2->getLatestFileName(m_wavFilePath2);
    /* 检查是否有新的数据 */
    if(m_wavFilePath1 == m_prevWavFilePath1 || m_wavFilePath2 == m_prevWavFilePath2)
    {
        // SPDLOG_LOGGER_INFO(m_logger, "{} 检测到文件路径未变化", m_logBase);
        return false;
    }
    /*--------------------------------------------------------------
     * 开始比对计算，并保存计算结果
     *--------------------------------------------------------------*/
    if(!compareConsistency())
    {
        return false;
    }
    /* 计算一致性结果 */
    computeResult();
    m_prevWavFilePath1 = m_wavFilePath1; // 更新上一个wav文件路径
    m_prevWavFilePath2 = m_wavFilePath2; // 更新上一个wav文件路径

    return true;
}

/* 清理数据 */
void ConsistencyCompareThread::clearConsistencyCompareData()
{
    clearData();
    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 一致性对比功能(调用动态库)清理完成  ", m_logBase);
}


/* 线程功能函数 */
void ConsistencyCompareThread::task()
{
    m_isRunning = true;
    /* 初始化 */
    if(!initData())
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
        return;
    }

    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 一致性对比线程(调用动态库)开始运行  ", m_logBase);
    
    // std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now();
#if(CONSISTENCY_DEBUG)
    int nCompareCount = 0; // 计算次数
    bool isConsistency = true;
#endif 

    while(true)
    {
        /* 判断是否需要退出线程 */
        if(m_isRunning == false)
        {
            /* 如果此时还在非一致性报警中，结束报警 */
            if(m_alarmConsistencyMain.isAlarm || m_alarmConsistencySub.isAlarm)
            {
                endAlarm();
            }
            /* 退出线程 */
            break;
        }

        std::this_thread::sleep_for(std::chrono::milliseconds(100));

        /* 判断是否开启不一致检测 */
        if(m_isEnableNotConsistencyDetect.load() == false)
        {
            /* 不开启不一致检测，直接返回一致性结果 */
            m_isConsistency = true;
            m_isConsistencyWarning = false;
            continue; // 跳过后续的计算
        }

        /* 判断是否在检测时间段内 */
        if(m_isInDetectPeriod.load() == false)
        {
            /* 不在检测时间段内，不需要比对，结果一直为一致性 */
            m_isConsistency = true;
            m_isConsistencyWarning = false;
            /* 如果此时还在非一致性报警中，结束报警 */
            if(m_alarmConsistencyMain.isAlarm || m_alarmConsistencySub.isAlarm)
            {
                endAlarm();
            }
            continue;
        }
        /* 计算一致性 */
        if(!compareConsistencyData())
        {
            /* 没有新数据或者计算失败，继续等待 */
            continue;
        }

    #if(CONSISTENCY_DEBUG)
        /* 模拟不一致报警，启动检测五次开始报警，报警5次取消报警，间隔5次继续报警 */
        if(isConsistency)
        {
            if(nCompareCount > 3)
            {
                isConsistency = false;
                m_isConsistency = false;
                m_isConsistencyWarning = true;
                nCompareCount = 0;
      }
        }else {
            if(nCompareCount > 3)
            {
                isConsistency = true;
                m_isConsistency = true;
                m_isConsistencyWarning = false;
                nCompareCount = 0;
            }
        }
        nCompareCount++;
    #endif

        /* 保存结果 */
        saveAlarmInfo();
    }
    clearData();
    SPDLOG_LOGGER_WARN(m_logger, " ★ {} 一致性对比线程(调用动态库)已结束运行  ", m_logBase);
    
}

/* 初始化数据 */
bool ConsistencyCompareThread::initData()
{
    if(m_threadInfo.compareItemInfo.mapRoad.size() < 2)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 录音通道信息不足，至少需要两个通道", m_logBase);
        return false;
    }
    /* 获取一致性检测的参数 */
    const auto& compareConfig = SysConfig.getAICompareConfig();
    m_numCompareContinue = compareConfig.nAiCompareCount;
    m_numFileDuration = compareConfig.nAiComputeDuration;
    m_fNotConsistencyThreshold = compareConfig.fNotSimilarThrehold;
    m_fConsistencyThreshold = compareConfig.fSimilarThrehold;

    /* 获取两个录音通道的信息 */
    auto it = m_threadInfo.compareItemInfo.mapRoad.begin();
    m_itemRoadInfo1 = it.value(); // 第一个通道
    it++;
    m_itemRoadInfo2 = it.value(); // 第二个通道

    m_logBase = fmt::format("对比通道 {}:{} - {}:{}", 
                    m_itemRoadInfo1.scRoadInfo.strSoundCardName, m_itemRoadInfo1.scRoadInfo.pcmInfo.strPCMName, 
                    m_itemRoadInfo2.scRoadInfo.strSoundCardName, m_itemRoadInfo2.scRoadInfo.pcmInfo.strPCMName);
    
    /* 获取创建wav文件的指针 */
    auto startTime = std::chrono::steady_clock::now(); // 记录开始时间
    while(true)
    {
        if(m_pCreateWAVThread1 == nullptr)
        {
            m_pCreateWAVThread1 = ThreadMan.getCreateWAVThread(m_itemRoadInfo1.scRoadInfo.pcmInfo.strPCMName);
        }
        if(m_pCreateWAVThread2 == nullptr)
        {
            m_pCreateWAVThread2 = ThreadMan.getCreateWAVThread(m_itemRoadInfo2.scRoadInfo.pcmInfo.strPCMName);
        }
        
        /* 获取生成报警音频文件的线程 */
        if(m_threadCreateAlarmFile1 == nullptr)
        {
            m_threadCreateAlarmFile1 = ThreadMan.getCreateRecordFileThread(m_itemRoadInfo1.scRoadInfo.pcmInfo.strPCMName);
        }
        if(m_threadCreateAlarmFile2 == nullptr)
        {
            m_threadCreateAlarmFile2 = ThreadMan.getCreateRecordFileThread(m_itemRoadInfo2.scRoadInfo.pcmInfo.strPCMName);
        }

        if( m_pCreateWAVThread1 != nullptr && m_pCreateWAVThread2 != nullptr && 
            m_threadCreateAlarmFile1 != nullptr && m_threadCreateAlarmFile2 != nullptr )
        {
            break; // 获取到两个线程，跳出循环
        }
        /* 超过10秒还没有获取到线程，返回失败 */
        if(std::chrono::steady_clock::now() - startTime > std::chrono::seconds(10))
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 获取生成音量的线程超时",  m_logBase);
            return false;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    if(m_pCreateWAVThread1 == nullptr || m_pCreateWAVThread2 == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 获取录音线程失败", m_logBase);
        return false;
    }
    
    if(m_threadCreateAlarmFile1 == nullptr || m_threadCreateAlarmFile2 == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 获取生成报警音频文件的线程失败", m_logBase);
        return false;
    }

    return true;
}

/* 清理数据 */
void ConsistencyCompareThread::clearData()
{
    m_isRunning = false;
    m_pCreateWAVThread1 = nullptr;
    m_pCreateWAVThread2 = nullptr;

}

/* 比对两个wav文件的一致性 */
bool ConsistencyCompareThread::compareConsistency()
{
    /* 计算比对需要的时间 */
    std::chrono::steady_clock::time_point startTime = std::chrono::steady_clock::now();
    CompareResult* result = LHCompare(m_wavFilePath1.fileName.c_str(), m_wavFilePath2.fileName.c_str(), m_sensitivity);
    if(result == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "{} 一致性比对失败，可能是文件格式不支持或动态库加载失败", m_logBase);
        return false;
    }
    
    /* 如果高相似度小于1，将两个通道反过来对比一下 */
    if(result->highest_similarity < 1)
    {
        delete result;
        result = nullptr;
        SPDLOG_LOGGER_WARN(m_logger, "{} 高相似度小于1，尝试反向对比", m_logBase);
        result = LHCompare(m_wavFilePath2.fileName.c_str(), m_wavFilePath1.fileName.c_str(), m_sensitivity);
        if(result == nullptr)
        {
            SPDLOG_LOGGER_ERROR(m_logger, "{} 一致性比对失败，可能是文件格式不支持或动态库加载失败", m_logBase);
            return false;
        }
    }
    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 一致性比对结果: 源文件: {}, 目标文件: {}, 最高相似度: {:.3f}, 平均相似度: {:.3f}",
    //     m_logBase, m_wavFilePath1.fileName, m_wavFilePath2.fileName, result->highest_similarity, result->average_similarity);

    /* 保存结果 */
    double highestSimilarity = result->highest_similarity / 100.0; // 将相似度转换为0-1范围
    double averageSimilarity = result->average_similarity / 100.0; // 将相似度转换为0-1范围
    m_consistencyResult.AddResult(highestSimilarity);
    m_similarity = highestSimilarity;

    delete result;
    result = nullptr;

    /* 计算比对耗时 */
    std::chrono::steady_clock::time_point endTime = std::chrono::steady_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

    SPDLOG_LOGGER_DEBUG(m_logger, "{} 一致性比对结果: 最高相似度: {:.3f}, 平均相似度: {:.3f}, 耗时: {}ms",
        m_logBase, highestSimilarity, averageSimilarity, duration.count());

    return true;
}



/* 根据动态库返回的结果计算一致性 */
bool ConsistencyCompareThread::computeResult()
{
    std::string strConInfo, strNotConInfo;
    auto consistencyState = m_consistencyResult.computeConsistency(m_numCompareContinue, m_fConsistencyThreshold, strConInfo);
    auto notConsisencyState = m_consistencyResult.computeNotConsistency(m_numCompareContinue, m_fNotConsistencyThreshold, strNotConInfo);

    SPDLOG_LOGGER_DEBUG(m_logger, "{} 此次一致性计算结果: {}, 不一致性计算结果: {}, 一致性说明: {}, 不一致说明: {}",
        m_logBase, static_cast<int>(consistencyState), static_cast<int>(notConsisencyState), strConInfo, strNotConInfo);

    if (eConsistencyState::eCS_Consistency == consistencyState)
    {
        /* 计算出的一致性是确定的 */
        m_isConsistency.store(true);
        m_isConsistencyWarning.store(false);
    }
    else if(eConsistencyState::eCS_NotConsistency == notConsisencyState)
    {
        /* 计算出的不一致性是确定的 */
        m_isConsistency.store(false);
        m_isConsistencyWarning.store(true);
    }else 
    {
        /* 都不是确定的一致性和不一致性，使用上次的结果 */
        m_isConsistency.store(m_isConsistencyLatest.load());
        m_isConsistencyWarning.store(true);
    }

    return true;
}


/* 保存报警信息 */
void ConsistencyCompareThread::saveAlarmInfo()
{
    if(m_isConsistency)
    {
        /* 这次是一致的，判断之前是否在一致性报警中 */
        if(m_alarmConsistencyMain.isAlarm || m_alarmConsistencySub.isAlarm)
        {
            /* 之前在一致性报警中，这次一致，结束不一致性报警 */
            m_alarmConsistencyMain.isAlarm = false;
            m_alarmConsistencySub.isAlarm = false;
            /* 结束时间向后推1秒 */
            m_alarmConsistencyMain.EndTime = m_wavFilePath1.endDateTime.addSecs(1);
            m_alarmConsistencySub.EndTime = m_wavFilePath2.endDateTime.addSecs(1);
            /* 结束录制报警音频 */
            m_threadCreateAlarmFile1->stopRecordAlarmFile(m_alarmConsistencyMain);
            m_threadCreateAlarmFile2->stopRecordAlarmFile(m_alarmConsistencySub);

            /* 设置录音状态 */
            m_alarmConsistencyMain.fileState = eRecordState::eRS_RecordCompleted;
            m_alarmConsistencySub.fileState = eRecordState::eRS_RecordCompleted;

            /* 将报警信息写入数据库 */
            WriteDB.addAlarmInfo(m_alarmConsistencyMain, m_alarmConsistencySub);

            
            SPDLOG_LOGGER_INFO(m_logger, "{}: 一致性报警结束，结束时间: {}", m_logBase, 
                m_wavFilePath1.endDateTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
            /* 清除报警信息 */
            m_alarmConsistencyMain = AlarmInfo_t();
            m_alarmConsistencySub = AlarmInfo_t();
        }
    }else 
    {
        /* 不一致，判断之前的一致性，判断一个就可以了 */
        if(!m_alarmConsistencySub.isAlarm)
        {
            /* 开是不一致报警 */
            m_alarmConsistencyMain.isAlarm = true;
            m_alarmConsistencySub.isAlarm = true;
            m_alarmConsistencyMain.CompareItemID = m_threadInfo.compareItemInfo.nID;
            m_alarmConsistencySub.CompareItemID = m_threadInfo.compareItemInfo.nID;
            m_alarmConsistencyMain.strCompareItemName = m_threadInfo.compareItemInfo.strName;
            m_alarmConsistencySub.strCompareItemName = m_threadInfo.compareItemInfo.strName;
            m_alarmConsistencyMain.RoadInfo = m_itemRoadInfo1;
            m_alarmConsistencySub.RoadInfo = m_itemRoadInfo2;
            
            m_alarmConsistencyMain.RoadType = ERoadType::RoadType_Main;
            m_alarmConsistencySub.RoadType = ERoadType::RoadType_SpaceReceive;

            m_alarmConsistencyMain.AlarmType = EAlarmType::EAR_Consistency;
            m_alarmConsistencySub.AlarmType = EAlarmType::EAR_Consistency;
            
            /* 计算开始时间，开始时间计算方法:
               单次计算的时间长度是 numFileDuration, 计算 m_numCompareContinue 次才会不一致性报警，因此向前推
                m_numFileDuration * m_numCompareContinue 秒
            */
            int seconds = m_numFileDuration * m_numCompareContinue;
            /* 因为 m_numCompareContinue 次计算也包括这次的文件，所以从结束时间开始向前推 */
            m_alarmConsistencyMain.StartTime = m_wavFilePath1.endDateTime.addSecs(-seconds);
            m_alarmConsistencySub.StartTime = m_wavFilePath2.endDateTime.addSecs(-seconds);

            SPDLOG_LOGGER_WARN(m_logger, "{}: 不一致报警开始", m_logBase);
            m_threadCreateAlarmFile1->startRecordAlarmFile(m_alarmConsistencyMain);
            m_threadCreateAlarmFile2->startRecordAlarmFile(m_alarmConsistencySub);
        }
    }
}

/* 结束报警 */
void ConsistencyCompareThread::endAlarm()
{
    m_isConsistency = true;

    /* 这次是一致的，判断之前是否在一致性报警中 */
    if(m_alarmConsistencyMain.isAlarm || m_alarmConsistencySub.isAlarm)
    {
        /* 之前在一致性报警中，这次一致，结束不一致性报警 */
        m_alarmConsistencyMain.isAlarm = false;
        m_alarmConsistencySub.isAlarm = false;
        /* 结束时间向后推1秒 */
        m_alarmConsistencyMain.EndTime = m_wavFilePath1.endDateTime.addSecs(1);
        m_alarmConsistencySub.EndTime = m_wavFilePath2.endDateTime.addSecs(1);
        /* 结束录制报警音频 */
        m_threadCreateAlarmFile1->stopRecordAlarmFile(m_alarmConsistencyMain);
        m_threadCreateAlarmFile2->stopRecordAlarmFile(m_alarmConsistencySub);
        /* 设置录音状态 */
        m_alarmConsistencyMain.fileState = eRecordState::eRS_RecordCompleted;
        m_alarmConsistencySub.fileState = eRecordState::eRS_RecordCompleted;
        /* 将报警信息写入数据库 */
        WriteDB.addAlarmInfo(m_alarmConsistencyMain, m_alarmConsistencySub);
        
        SPDLOG_LOGGER_INFO(m_logger, "{}: 一致性报警结束，结束时间: {}", m_logBase, 
            m_wavFilePath1.endDateTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
        /* 清除报警信息 */
        m_alarmConsistencyMain = AlarmInfo_t();
        m_alarmConsistencySub = AlarmInfo_t();
    }
}