cplayer/CPlayer/hkc/hkcamera.cpp

#include "hkcamera.h"
#include "./ui_hkcamera.h"

#include <QDebug>
#include <QDateTime>
#include <QFile>
#include <QFileInfo>
// #include <QMediaPlayer>
// #include <QVideoWidget>
// #include <QMediaPlaylist>
#include <QVBoxLayout>

// #include "VideoPlayer.h"

LONG m_playPort;                             /* 全局的播放库port号 */

HKCamera::HKCamera(QObject *parent)
    : QObject(parent)
    // , ui(new Ui::HKCamera)
{
    // ui->setupUi(this);


    m_logger = spdlog::get("HK_Camera");
    if(m_logger == nullptr)
    {
        qDebug() << "获取HK_Camera logger失败!";
        return;
    }

    /* 初始化变量 */
    m_playPort = -1;

    // m_vLayout = new QVBoxLayout(this);


    SPDLOG_LOGGER_INFO(m_logger,"============   Hello HK_Camera    ============");
}

HKCamera::~HKCamera()
{
    // delete ui;
    /* 退出登录 */
    NET_DVR_Logout(m_loginID);
    /* 释放SDK资源，重复清除资源会怎么样 */
    NET_DVR_Cleanup();
}

/* 初始化海康摄像头SDK */
bool HKCamera::initHKCamera(const HKLoginInfo& info)
{
    /* 初始化海康摄像头SDK */
    if(!NET_DVR_Init())
    {
        SPDLOG_LOGGER_ERROR(m_logger,"NET_DVR_Init 失败！");
        return false;
    }
    /* 设置超时时间 */
    NET_DVR_SetConnectTime(3000,3);
    NET_DVR_SetReconnect();
    /* 设置异常消息回调函数 */
    #ifdef Q_OS_LINUX
    NET_DVR_SetExceptionCallBack_V30(0, nullptr, exceptionCallBack, nullptr);
    #endif
    /* 用户登录，同步登陆 */
    NET_DVR_USER_LOGIN_INFO loginInfo = {0};
    /* 返回的设备信息，包括序列号、设备类型、通道号等 */
    NET_DVR_DEVICEINFO_V40 deviceInfo = {0};

    strncpy(loginInfo.sDeviceAddress, info.HostName.toStdString().c_str(), info.HostName.count());
    strncpy(loginInfo.sUserName, info.UserName.toStdString().c_str(), info.UserName.count());
    strncpy(loginInfo.sPassword, info.Password.toStdString().c_str(), info.Password.count());
    loginInfo.wPort = info.Port;        /* 端口 */
    loginInfo.bUseAsynLogin = 0;        /* 同步登陆，= 1 是异步登录 */
    SPDLOG_DEBUG("登录信息：{}:{}:{}:{}",loginInfo.sDeviceAddress,loginInfo.wPort, loginInfo.sUserName, loginInfo.sPassword);

    /* 这里是同步登陆，返回值就是设备操作ID，异步登录需要在回调函数中取出返回的ID */
    m_loginID = NET_DVR_Login_V40(&loginInfo, &deviceInfo);
    if(m_loginID < 0)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"登录摄像机 {} 失败，错误代码:{}",info.HostName.toStdString(),NET_DVR_GetLastError());
        NET_DVR_Cleanup();      /* 需不需要在这里清除资源？ */
        return false;
    }
    /* 取出通道号 */
    m_devInfo.AChannelNum = 0;
    m_devInfo.AChannelStart = 0;
    m_devInfo.DChannelNum = 0;
    m_devInfo.DChannelStart = 0;

    m_devInfo.AChannelNum = deviceInfo.struDeviceV30.byChanNum;     /* 模拟通道个数 */
    m_devInfo.AChannelStart = deviceInfo.struDeviceV30.byStartChan; /* 模拟通道的起始通道号 */
    unsigned char h8 = deviceInfo.struDeviceV30.byIPChanNum;        /* 数字通道的最大个数需要组合起来 */
    unsigned char l8 = deviceInfo.struDeviceV30.byHighDChanNum;
    m_devInfo.DChannelNum = h8 * 256 + l8;
    m_devInfo.DChannelStart = deviceInfo.struDeviceV30.byStartDChan;/* 数字通道起始号 */

    SPDLOG_LOGGER_TRACE(m_logger,"最大模拟通道号数:{}，起始号:{}",m_devInfo.AChannelNum,m_devInfo.AChannelStart);
    SPDLOG_LOGGER_TRACE(m_logger,"最大数字通道号数:{}，起始号:{}",m_devInfo.DChannelNum,m_devInfo.DChannelStart);

    SPDLOG_LOGGER_INFO(m_logger,"****** HK SDK初始化完成! ******");
    return true;
}


/* 获取模拟通道数 */
quint32 HKCamera::getAnalogChannelNum()
{
    return m_devInfo.AChannelNum;
}

/* 获取模拟通道起始号 */
quint32 HKCamera::getAnalogChannelStart()
{
    return m_devInfo.AChannelStart;
}

/* 获取数字通道数 */
quint32 HKCamera::getDigitalChannelNum()
{
    return m_devInfo.DChannelNum;
}

/* 获取数字通道起始号 */
quint32 HKCamera::getDigitalChannelSatrt()
{
    return m_devInfo.DChannelStart;
}

/**
 * @brief 实时播放监控，视频流在回调函数中
 * 
 * @param Channel 
 * @return true 
 * @return false 
 */
bool HKCamera::getRealDataFromCamera(int Channel)
{
    /* 启动预览并设置回调数据流 */
    LONG realPlayHandle;

    NET_DVR_PREVIEWINFO playInfo = {0};
    playInfo.hPlayWnd     = 0;          //需要SDK解码时句柄设为有效值，仅取流不解码时可设为空
    playInfo.lChannel     = Channel;    //预览通道号
    playInfo.dwStreamType = 0;          //0-主码流，1-子码流，2-码流3，3-码流4，以此类推
    playInfo.dwLinkMode   = 0;          //0- TCP方式，1- UDP方式，2- 多播方式，3- RTP方式，4-RTP/RTSP，5-RSTP/HTTP
    playInfo.bBlocked     = 1;          //0- 非阻塞取流，1- 阻塞取流
    /* 设置回调函数 */
    realPlayHandle = NET_DVR_RealPlay_V40(m_loginID, &playInfo, realDataCallBack, nullptr);
    if (realPlayHandle < 0)
    {
        SPDLOG_ERROR("NET_DVR_RealPlay_V40()调用错误，错误代码:{}",NET_DVR_GetLastError());
        return false;
    }

    /* 延时一定时间，这里延时也可以使用一个条件变量，在另一个线程控制通断 */
    std::this_thread::sleep_for(std::chrono::seconds(10));
    //关闭预览
    NET_DVR_StopRealPlay(realPlayHandle);

    SPDLOG_LOGGER_DEBUG(m_logger,"实时获取数据结束");

    return true;
}

/**
 * @brief 实时显示视频，使用SDK解码
 * 
 * @param Chnannel 
 * @param playWindow 
 */
void HKCamera::realPlayBack(int channel, QWidget* playWindow)
{
    // if(playWindow == nullptr)
    // {
    //     SPDLOG_LOGGER_ERROR(m_logger,"播放窗口错误!");
    //     return;
    // }

    /* 启动预览并设置回调数据流 */
    LONG realPlayHandle;

    NET_DVR_PREVIEWINFO playInfo = {0};
    playInfo.hPlayWnd     = 0;          //需要SDK解码时句柄设为有效值，仅取流不解码时可设为空
    playInfo.lChannel     = channel;    //预览通道号
    playInfo.dwStreamType = 0;          //0-主码流，1-子码流，2-码流3，3-码流4，以此类推
    playInfo.dwLinkMode   = 0;          //0- TCP方式，1- UDP方式，2- 多播方式，3- RTP方式，4-RTP/RTSP，5-RSTP/HTTP
    playInfo.bBlocked     = 1;          //0- 非阻塞取流，1- 阻塞取流
    /* 设置回调函数 */
    realPlayHandle = NET_DVR_RealPlay_V40(m_loginID, &playInfo, realDataCallBack, nullptr);
    if (realPlayHandle < 0)
    {
        SPDLOG_ERROR("NET_DVR_RealPlay_V40()调用错误，错误代码:{}",NET_DVR_GetLastError());
        return;
    }

    /* 延时一定时间，这里延时也可以使用一个条件变量，在另一个线程控制通断 */
    std::this_thread::sleep_for(std::chrono::seconds(10));
    //关闭预览
    NET_DVR_StopRealPlay(realPlayHandle);

    SPDLOG_DEBUG("实时获取数据结束");
}

/* 智能检索 */
bool HKCamera::smartSearch(int channel, const QDateTime& start, const QDateTime& end)
{
    SPDLOG_LOGGER_INFO(m_logger,"智能检索，通道号:{}，时间段：{} - {}",channel,start.toString("yyyy-MM-dd hh:mm:ss").toStdString(),end.toString("yyyy-MM-dd hh:mm:ss").toStdString());
    
    LPNET_DVR_SMART_SEARCH_PARAM_V40 lpSmartSearchParam = new NET_DVR_SMART_SEARCH_PARAM_V40;
    NET_DVR_SmartSearch_V40(m_loginID, lpSmartSearchParam);




    return true;
}


/* 按照时间查找文件，主要是查找该时间段的文件是否存在 */
bool HKCamera::findFileWithTime(int channel,const QDateTime& start,const QDateTime& end)
{
    int findHandle = 0;
    /* 根据版本选择查询的API，这个版本是自己定的，不一定对 */
    if(m_sdkVersion == 5)
    {
        /* 设置查询条件 */
        NET_DVR_FILECOND_V50 findCond;
        findCond.dwFileType = 0xFF;     /* 文件类型 */
        findCond.struStreamID.dwSize = sizeof(NET_DVR_STREAM_INFO);
        findCond.struStreamID.dwChannel = channel;          /* 通道号 */
        findCond.byIsLocked = 0xff;     /* 是否锁定文件 */
        findCond.byNeedCard = 0;        /* 是否需要查询卡，0不需要 */
        /* 设置开始时间 */
        findCond.struStartTime.wYear = start.date().year();
        findCond.struStartTime.byMonth = start.date().month();
        findCond.struStartTime.byDay = start.date().day();
        findCond.struStartTime.byHour = start.time().hour();
        findCond.struStartTime.byMinute = start.time().minute();
        findCond.struStartTime.bySecond = start.time().second();
        /* 设置结束时间 */
        findCond.struStopTime.wYear = end.date().year();
        findCond.struStopTime.byMonth = end.date().month();
        findCond.struStopTime.byDay = end.date().day();
        findCond.struStopTime.byHour = end.time().hour();
        findCond.struStopTime.byMinute = end.time().minute();
        findCond.struStopTime.bySecond = end.time().second();
        /* 查找录像文件 */
        findHandle = NET_DVR_FindFile_V50(m_loginID, &findCond);
    }
    else if(m_sdkVersion == 3)
    {
        NET_DVR_FILECOND findCond;
        findCond.dwFileType = 0xff;        /* 文件类型 */
        findCond.lChannel = channel;       /* 通道号 */
        findCond.dwIsLocked = 0xff;        /* 所有文件 */
        findCond.dwUseCardNo = 0;          /* 不查询卡 */

        findCond.struStartTime.dwYear = start.date().year();
        findCond.struStartTime.dwMonth = start.date().month();
        findCond.struStartTime.dwDay = start.date().day();
        findCond.struStartTime.dwHour = start.time().hour();
        findCond.struStartTime.dwMinute = start.time().minute();
        findCond.struStartTime.dwSecond = start.time().second();

        findCond.struStopTime.dwYear = end.date().year();
        findCond.struStopTime.dwMonth = end.date().month();
        findCond.struStopTime.dwDay = end.date().day();
        findCond.struStopTime.dwHour = end.time().hour();
        findCond.struStopTime.dwMinute = end.time().minute();
        findCond.struStopTime.dwSecond = end.time().second();
        /* 查找录像文件 */
        findHandle = NET_DVR_FindFile_V30(m_loginID, &findCond);
    }
    
    if(findHandle < 0)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"查找文件失败，错误代码:{}",NET_DVR_GetLastError());
        NET_DVR_FindClose_V30(findHandle);
        return false;
    }
    SPDLOG_LOGGER_DEBUG(m_logger,"查找文件成功! findHandle:{}",findHandle);

    /* 逐个获取查询结果 */
    NET_DVR_FINDDATA_V50 fileData;
    // char fileName[100] = { 0 }; //需要下载的文件
    QString fileName;
    int fileNum = 0;
    bool isFind = false;
    while (true)
    {
        int result = NET_DVR_FindNextFile_V50(findHandle, &fileData);
        /* 正在查找中 */
        if (result == NET_DVR_ISFINDING)
        {
            SPDLOG_LOGGER_DEBUG(m_logger,"正在查找中...");
            continue;
        }
        /* 查找到文件 */
        else if (result == NET_DVR_FILE_SUCCESS)
        {
            fileNum++;
            // printf("find file no: %d, file name:%s\n", fileNum, fileData.sFileName);
            if (fileNum == 1)
            {
                // strcpy(fileName, fileData.sFileName);
                fileName.clear();
                fileName = QString::asprintf("%s", fileData.sFileName);
                SPDLOG_LOGGER_INFO(m_logger,"查找到了文件名：{}", fileName.toStdString());
            }
            isFind = true;
            continue;
        }
        /* 没有文件，没有更多的文件 */
        else if (result == NET_DVR_FILE_NOFIND || result == NET_DVR_NOMOREFILE)
        {
            SPDLOG_LOGGER_INFO(m_logger,"没有其他文件，退出");
            break;
        }
        else
        {
            SPDLOG_LOGGER_WARN(m_logger,"查找失败，退出");
            // printf("find file fail for illegal get file state");
            break;
        }
    }

    //停止查找，释放资源
    if (findHandle >= 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"停止查找，释放资源...");
        NET_DVR_FindClose_V30(findHandle);
    }
    SPDLOG_LOGGER_INFO(m_logger, "查找文件结束");

    return isFind;
}

/* 查找一段时间的视频是否完整 */
bool HKCamera::findFileIsComplete(int channel,const QDateTime& start,const QDateTime& end)
{
    
    /* 刷新摄像机索引 */
    if(!NET_DVR_UpdateRecordIndex(m_loginID, channel))
    {
        auto err = NET_DVR_GetLastError();
        if(23 == err)
        {
            SPDLOG_LOGGER_DEBUG(m_logger,"刷新摄像机索引失败，设备不支持");
        }else {
            SPDLOG_LOGGER_DEBUG(m_logger,"刷新摄像机索引失败，错误代码:{}",err);
        }
    }

    int findHandle = 0;
    /* 根据版本选择查询的API，这个版本是自己定的，不一定对 */
    if(m_sdkVersion == 5)
    {
        /* 设置查询条件 */
        NET_DVR_FILECOND_V50 findCond;
        findCond.dwFileType = 0xFF;     /* 文件类型 */
        findCond.struStreamID.dwSize = sizeof(NET_DVR_STREAM_INFO);
        findCond.struStreamID.dwChannel = channel;          /* 通道号 */
        findCond.byIsLocked = 0xff;     /* 是否锁定文件 */
        findCond.byNeedCard = 0;        /* 是否需要查询卡，0不需要 */
        /* 设置开始时间 */
        findCond.struStartTime.wYear = start.date().year();
        findCond.struStartTime.byMonth = start.date().month();
        findCond.struStartTime.byDay = start.date().day();
        findCond.struStartTime.byHour = start.time().hour();
        findCond.struStartTime.byMinute = start.time().minute();
        findCond.struStartTime.bySecond = start.time().second();
        /* 设置结束时间 */
        findCond.struStopTime.wYear = end.date().year();
        findCond.struStopTime.byMonth = end.date().month();
        findCond.struStopTime.byDay = end.date().day();
        findCond.struStopTime.byHour = end.time().hour();
        findCond.struStopTime.byMinute = end.time().minute();
        findCond.struStopTime.bySecond = end.time().second();
        /* 查找录像文件 */
        findHandle = NET_DVR_FindFile_V50(m_loginID, &findCond);
    }
    else if(m_sdkVersion == 3)
    {
        NET_DVR_FILECOND findCond;
        findCond.dwFileType = 0xff;        /* 文件类型 */
        findCond.lChannel = channel;       /* 通道号 */
        findCond.dwIsLocked = 0xff;        /* 所有文件 */
        findCond.dwUseCardNo = 0;          /* 不查询卡 */

        findCond.struStartTime.dwYear = start.date().year();
        findCond.struStartTime.dwMonth = start.date().month();
        findCond.struStartTime.dwDay = start.date().day();
        findCond.struStartTime.dwHour = start.time().hour();
        findCond.struStartTime.dwMinute = start.time().minute();
        findCond.struStartTime.dwSecond = start.time().second();

        findCond.struStopTime.dwYear = end.date().year();
        findCond.struStopTime.dwMonth = end.date().month();
        findCond.struStopTime.dwDay = end.date().day();
        findCond.struStopTime.dwHour = end.time().hour();
        findCond.struStopTime.dwMinute = end.time().minute();
        findCond.struStopTime.dwSecond = end.time().second();
        /* 查找录像文件 */
        findHandle = NET_DVR_FindFile_V30(m_loginID, &findCond);
    }
    
    if(findHandle < 0)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"查找文件失败，错误代码:{}",NET_DVR_GetLastError());
        NET_DVR_FindClose_V30(findHandle);
        return false;
    }
    SPDLOG_LOGGER_DEBUG(m_logger,"查找文件成功! findHandle:{}",findHandle);

    /* 逐个获取查询结果 */
    NET_DVR_FINDDATA_V50 fileData;
    RetFileInfo fileInfo;
    // char fileName[100] = { 0 }; //需要下载的文件
    QString fileName;
    int fileNum = 0;
    bool isComplete = false;
    while (true)
    {
        int result = NET_DVR_FindNextFile_V50(findHandle, &fileData);
        /* 正在查找中 */
        if (result == NET_DVR_ISFINDING)
        {
            SPDLOG_LOGGER_DEBUG(m_logger,"正在查找中...");
            continue;
        }
        /* 查找到文件 */
        else if (result == NET_DVR_FILE_SUCCESS)
        {
            fileNum++;
            // printf("find file no: %d, file name:%s\n", fileNum, fileData.sFileName);
            // if (fileNum == 1)
            // {
                // strcpy(fileName, fileData.sFileName);
                fileName.clear();
                fileName = QString::asprintf("%s", fileData.sFileName);
                /* 将数据转换成QDateTime */
                fileInfo.fileName = fileName;
                fileInfo.setStartTime(fileData.struStartTime);
                fileInfo.setEndTime(fileData.struStopTime);
                fileInfo.fileSize = fileData.dwFileSize;

                // SPDLOG_LOGGER_INFO(m_logger,"查找到了文件名：{}", fileName.toStdString());
                // SPDLOG_LOGGER_INFO(m_logger,"开始时间：{}",fileInfo.startTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
                // SPDLOG_LOGGER_INFO(m_logger,"结束时间：{}",fileInfo.endTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
                // SPDLOG_LOGGER_INFO(m_logger,"文件大小：{}",fileInfo.fileSize);
                SPDLOG_LOGGER_INFO(m_logger, "--------------------------------------------------------------");
                /* 判断时间是否覆盖了传入的时间 */
                if(fileInfo.endTime >= end)
                {
                    isComplete = true;
                    SPDLOG_LOGGER_INFO(m_logger,"摄像机视频已达到结束时间，开始时间：{}，结束时间：{}", 
                                        fileInfo.startTime.toString("yyyy-MM-dd hh:mm:ss").toStdString(), 
                                        fileInfo.endTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
                } else
                {
                    SPDLOG_LOGGER_INFO(m_logger,"视频文件未覆盖结束时间，摄像机已存储的视频最新时间: {}", fileInfo.endTime.toString("yyyy-MM-dd hh:mm:ss").toStdString());
                    SPDLOG_LOGGER_INFO(m_logger,"需要时间段：{} - {}",start.toString("yyyy-MM-dd hh:mm:ss").toStdString(),end.toString("yyyy-MM-dd hh:mm:ss").toStdString());
                }

            // }
            continue;
        }
        /* 没有文件，没有更多的文件 */
        else if (result == NET_DVR_FILE_NOFIND || result == NET_DVR_NOMOREFILE)
        {
            SPDLOG_LOGGER_INFO(m_logger,"没有其他文件，退出查找");
            break;
        }
        else
        {
            SPDLOG_LOGGER_WARN(m_logger,"视频文件查找失败，退出");
            // printf("find file fail for illegal get file state");
            break;
        }
    }

    //停止查找，释放资源
    if (findHandle >= 0)
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"停止查找视频，释放资源...");
        NET_DVR_FindClose_V30(findHandle);
    }
    SPDLOG_LOGGER_INFO(m_logger, "查找视频文件结束");

    return isComplete;
}


/* 按照时间段下载记录的文件 */
bool HKCamera::downloadRecordFile(int channel,const QString& savePath,const QDateTime& start,const QDateTime& end)
{
    SPDLOG_LOGGER_INFO(m_logger,"下载文件，保存路径:{}",savePath.toStdString());
    SPDLOG_LOGGER_INFO(m_logger,"下载时间段：{} - {}",start.toString("yyyy-MM-dd hh:mm:ss").toStdString(),end.toString("yyyy-MM-dd hh:mm:ss").toStdString());
    SPDLOG_LOGGER_INFO(m_logger,"下载通道号:{}",channel);
    NET_DVR_PLAYCOND downloadCond = {0};
    /* 这里好像也没有区分模拟通道和数字通道 */
    downloadCond.dwChannel = channel;
    /* 设置开始时间和结束时间 */
    downloadCond.struStartTime.dwYear = start.date().year();
    downloadCond.struStartTime.dwMonth = start.date().month();
    downloadCond.struStartTime.dwDay = start.date().day();
    downloadCond.struStartTime.dwHour = start.time().hour();
    downloadCond.struStartTime.dwMinute = start.time().minute();
    downloadCond.struStartTime.dwSecond = start.time().second();

    downloadCond.struStopTime.dwYear = end.date().year();
    downloadCond.struStopTime.dwMonth = end.date().month();
    downloadCond.struStopTime.dwDay = end.date().day();
    downloadCond.struStopTime.dwHour = end.time().hour();
    downloadCond.struStopTime.dwMinute = end.time().minute();
    downloadCond.struStopTime.dwSecond = end.time().second();

    /* 按时间下载 */
    int playBack;
    /* 第二个参数是保存的文件名称 */
    std::string tmpStr = savePath.toStdString();
    playBack = NET_DVR_GetFileByTime_V40(m_loginID, &tmpStr[0], &downloadCond);
    // playBack = NET_DVR_GetFileByTime_V40(m_loginID, savePath.toStdString().data(), &downloadCond);
    if(playBack < 0)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"NET_DVR_GetFileByTime_V40 错误，错误代码:{}", NET_DVR_GetLastError());
        return false;
    }
    /* 开始下载 */
    if(!NET_DVR_PlayBackControl_V40(playBack, NET_DVR_PLAYSTART, NULL, 0, NULL,NULL))
    {
        SPDLOG_LOGGER_ERROR(m_logger,"NET_DVR_PlayBackControl_V40 错误，错误代码:{}",NET_DVR_GetLastError());
        return false;
    }

    int nPos = 0;
    /* 等待下载完成的过程，1秒刷新一次，按照时间下载不支持进度，返回的都是0 */
    for(nPos = 0; nPos < 100 && nPos>=0; nPos = NET_DVR_GetDownloadPos(playBack))
    {
        SPDLOG_LOGGER_INFO(m_logger,"下载中... {}",nPos);
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
    if(!NET_DVR_StopGetFile(playBack))
    {
        SPDLOG_LOGGER_DEBUG(m_logger,"停止下载文件失败，错误代码 {}",NET_DVR_GetLastError());
        return false;
    }
    if(nPos<0||nPos>100)
    {
        SPDLOG_LOGGER_ERROR(m_logger,"下载错误，错误代码 {}", NET_DVR_GetLastError());
        /* 判断文件大小，等于0，则删除 */
        QFile file(savePath);
        if(file.exists() && file.size() == 0)
        {
            file.remove();
        }
        return false;
    }
    SPDLOG_LOGGER_INFO(m_logger,"下载成功!");

    return true;
}

/* 打开视频文件，顺便初始化播放类 */
CVideoPlayer* HKCamera::openVideoFile(const QString& fileName)
{
    /* 初始化播放实例 */
    SPDLOG_DEBUG("...新建一个播放窗口...");
    auto videoPlayer = new CVideoPlayer;
    // videoPlayer->setPlayVedio(fileName);
    videoPlayer->openPlayVedio(fileName);
    m_listPlayer.append(videoPlayer);

    return videoPlayer;
}


/* 播放视频 */
void HKCamera::playVideo(CVideoPlayer* videoPlayer)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return;
    }

    videoPlayer->play();
}

/* 关闭播放，清空播放类 */
void HKCamera::closePlay(CVideoPlayer* videoPlayer)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return;
    }

    SPDLOG_DEBUG("...关闭播放...");
    if(videoPlayer != nullptr)
    {
        /* 获取视频文件名称路径 */
        QString fileName = videoPlayer->getFileName();
        stop(videoPlayer);
        SPDLOG_DEBUG("...删除播放类...");
        SPDLOG_INFO("删除本地视频: {}", fileName.toStdString());
        QFile file(fileName);
        if(file.exists())
        {
            file.remove();
        }
        m_listPlayer.removeOne(videoPlayer);
        delete videoPlayer;
        videoPlayer = nullptr;
    }
}

/* 暂停播放 */
void HKCamera::pause(CVideoPlayer* videoPlayer)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return;
    }

    videoPlayer->pause();
}

/* 停止播放 */
void HKCamera::stop(CVideoPlayer* videoPlayer)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return;
    }

    videoPlayer->stop();
}

/* 继续播放 */
void HKCamera::continuePlay(CVideoPlayer* videoPlayer)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return;
    }
    
    videoPlayer->play();
}

/* 获取播放时长 */
unsigned long long HKCamera::getPlayDuration(CVideoPlayer* videoPlayer)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return -1;
    }

    SPDLOG_TRACE("获取播放时长:{}",videoPlayer->getDuration());
    return videoPlayer->getDuration();
}

/* 设置当前播放位置 */
void HKCamera::setCurrentPlayPos(CVideoPlayer* videoPlayer, unsigned long long pos)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return;
    }

    videoPlayer->setCurrentPos(pos);
}

/* 获取当前播放位置 */
unsigned long long HKCamera::getCurrentPlayPos(CVideoPlayer* videoPlayer)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return -1;
    }

    SPDLOG_TRACE("获取当前播放位置:{}",videoPlayer->getCurrentPos());
    return videoPlayer->getCurrentPos();
}

/* 获取播放状态 */
bool HKCamera::getPlayState(CVideoPlayer* videoPlayer)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return false;
    }

    return videoPlayer->getPlayStatus();
}


/* 设置播放窗口的父窗口 */
void HKCamera::setVideoParent(CVideoPlayer* videoPlayer, QWidget* parent)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return;
    }

    videoPlayer->setParent(parent);
    SPDLOG_LOGGER_TRACE(m_logger,"设置播放窗口的父窗口");
}

/* 设置音量 */
void HKCamera::setVolume(CVideoPlayer* videoPlayer, int volume)
{
    if(volume <0 || volume > 100)
    {
        SPDLOG_LOGGER_WARN(m_logger,"音量设置错误，范围是0-100");
        return;
    }
    
}

/* 获取音量 */
int HKCamera::getVolume(CVideoPlayer* videoPlayer)
{
    return 0;
}

/* 检查指针是否在列表容器中 */
bool HKCamera::checkVideoPlayerInList(CVideoPlayer* videoPlayer)
{
    if(!m_listPlayer.contains(videoPlayer))
    {
        SPDLOG_LOGGER_WARN(m_logger, "窗口 {} 不在列表中",(void *)videoPlayer);
        return false;
    }
    return true;
}


/* 设置回调函数 */
void HKCamera::setCallBack(CallBackType type, std::function<Play_CallBack> playCallback,void* pContext)
{
    for(auto& it : m_listPlayer)
    {
        if(type == CallBackType::PlayCallBack)
        {
            it->setPlayCallBack(playCallback, pContext);
        }
        else if(type == CallBackType::DownloadCallBack)
        {
            
        }
    }
    
}



/**
 * @brief 异常回调函数
 * 
 * @param type 异常类型，目前就知道以下几个
 * @param userID 
 * @param handle 
 * @param user 
 */
void HKCamera::exceptionCallBack(unsigned int type, int userID,int handle,void* user)
{
    /* 异常代码是16进制的 */
    SPDLOG_WARN("调用了异常回调函数，异常代码:{:#X}",type);
    switch(type)
    {
        /* 报警上传时网络异常 */
        case EXCEPTION_ALARM:
            SPDLOG_WARN("报警上传时网络异常!!!");
            //TODO: 关闭报警上传
            break;
        /* 网络预览时异常 */
        case EXCEPTION_PREVIEW:
            SPDLOG_WARN("网络预览时网络异常!!!");
            //TODO: 关闭网络预览
            break;
        /* 预览时重连 */
        case EXCEPTION_RECONNECT:
            break;
        case EXCEPTION_PLAYBACK:
            SPDLOG_WARN("回放异常!");
            break;
        default:
            break;
    }
}


/**
 * @brief 实时预览回调函数，没有解码的数据流
 * 
 * @param realHandle 操作句柄
 * @param dataType 数据类型
 * @param pBuffer 数据指针
 * @param bufSize 数据大小
 * @param user 
 */
void HKCamera::realDataCallBack(LONG realHandle, DWORD dataType, BYTE *pBuffer,DWORD bufSize,void* user)
{
    // SPDLOG_DEBUG("realDataCallBack接收到了数据，数据大小为:{}",bufSize);

    /* 获取播放的窗口指针 */

    unsigned int hWnd = 0;

    switch (dataType)
    {
        /* 系统头数据 */
        case NET_DVR_SYSHEAD:
            if (m_playPort >= 0)
            {
                break;  //该通道取流之前已经获取到句柄，后续接口不需要再调用
            }
            SPDLOG_DEBUG("系统头数据");
            // if (!PlayM4_GetPort(&m_playPort))  //获取播放库未使用的通道号
            // {
            //     break;
            // }
            //m_iPort = lPort; //第一次回调的是系统头，将获取的播放库port号赋值给全局port，下次回调数据时即使用此port号播放
            if (bufSize > 0)
            {
                // if (!PlayM4_SetStreamOpenMode(m_playPort, STREAME_REALTIME))  //设置实时流播放模式
                // {
                //     break;
                // }

                // if (!PlayM4_OpenStream(m_playPort, pBuffer, bufSize, 1024*1024)) //打开流接口
                // {
                //     break;
                // }

                // if (!PlayM4_Play(m_playPort, hWnd)) //播放开始
                // {
                //     break;
                // }
            }
            break; 
        /* 视频流数据（包括复合流和音视频分开的视频流数据） */
        case NET_DVR_STREAMDATA:
            if (bufSize > 0 && m_playPort != -1)
            {
                // if (!PlayM4_InputData(m_playPort, pBuffer, bufSize))
                // {
                //     break;
                // } 
            }
            SPDLOG_DEBUG("视频流数据,bufSize = {}",bufSize);
            break; 
        /* 其他数据 */
        default:
            if (bufSize > 0 && m_playPort != -1)
            {
                // if (!PlayM4_InputData(m_playPort, pBuffer, bufSize))
                // {
                //     break;
                // } 
            }
            SPDLOG_DEBUG("其他数据");
            break;
    }

}