cplayer/CPlayer/HKSDKAPI/hksdkapi.cpp

#include "hksdkapi.h"

#include "LHQLogAPI.h"

#include <QLibrary>



/* ========================================================================
 * ************************* 定义海康的SDK接口 *****************************
 * ======================================================================== */

/* 网络登陆相关的函数指针 */
using pNet_DEV_Init = bool(*)();
using pNET_DVR_Cleanup = bool(*)();
using pNET_DVR_SetConnectTime = bool(*)(DWORD dwWaitTime, DWORD dwTryTimes);
using pNET_DVR_SetReconnect = bool(*)(DWORD dwInterval, BOOL bEnableRecon);
using pNET_DVR_Login_V40 = LONG(*)(LPNET_DVR_USER_LOGIN_INFO pLoginInfo,LPNET_DVR_DEVICEINFO_V40 lpDeviceInfo);
using pNET_DVR_Logout = BOOL(*)(LONG lUserID);
using pNET_DVR_GetLastError = DWORD(*)();

using pNET_DVR_RealPlay_V40 = LONG(*)(LONG lUserID, LPNET_DVR_PREVIEWINFO lpPreviewInfo, REALDATACALLBACK fRealDataCallBack_V30, void* pUser);
using pNET_DVR_StopRealPlay = bool(*)(LONG lRealHandle);

using pNET_DVR_SetExceptionCallBack_V30 =  BOOL(*)(UINT reserved1, void* reserved2, void (CALLBACK* fExceptionCallBack)(DWORD dwType, LONG lUserID, LONG lHandle, void *pUser), void *pUser);


/* 播放相关的函数指针 */
using pPlayM4_GetPort = BOOL(*)(LONG* nPort);
using pPlayM4_FreePort = BOOL(*)(LONG nPort);
using pPlayM4_Stop = BOOL(*)(LONG nPort);

using pPlayM4_CloseStream = BOOL(*)(LONG nPort);
using pPlayM4_PlaySound = BOOL(*)(LONG nPort);
using pPlayM4_InputData = BOOL(*)(LONG nPort,PBYTE pBuf,DWORD nSize);
using pPlayM4_GetLastError = DWORD(*)(LONG nPort);

#if defined (Q_OS_WIN)
using pPlayM4_Play = BOOL(*)(LONG nPort, HWND hWnd);
using pPlayM4_OpenStream = BOOL(*)(LONG nPort,PBYTE pFileHeadBuf,DWORD nSize,DWORD nBufPoolSize);
using pPlayM4_SetDecCallBackMend = BOOL(*)(LONG nPort, void (CALLBACK* DecCBFun)(long nPort, char * pBuf, long nSize, FRAME_INFO * pFrameInfo, void* nUser,void* nReserved2), void* nUser);
#elif defined (Q_OS_LINUX)
using pPlayM4_Play = int(*)(int nPort, PLAYM4_HWND hWnd);
using pPlayM4_OpenStream = int(*)(int nPort,unsigned char * pFileHeadBuf,unsigned int nSize,unsigned int nBufPoolSize);
using pPlayM4_SetDecCallBackMend = int(*)(int nPort,void (CALLBACK* DecCBFun)(int nPort,char * pBuf,int nSize,FRAME_INFO * pFrameInfo, void* nUser,int nReserved2), void* nUser);
#endif

/* 网络登录相关的函数指针 */
pNet_DEV_Init g_NET_DVR_Init = nullptr;
pNET_DVR_Cleanup g_NET_DVR_Cleanup = nullptr;
pNET_DVR_SetConnectTime g_NET_DVR_SetConnectTime = nullptr;
pNET_DVR_SetReconnect g_NET_DVR_SetReconnect = nullptr;
pNET_DVR_Login_V40 g_NET_DVR_Login_V40 = nullptr;
pNET_DVR_Logout g_NET_DVR_Logout = nullptr;
pNET_DVR_GetLastError g_NET_DVR_GetLastError = nullptr;

pNET_DVR_RealPlay_V40 g_NET_DVR_RealPlay_V40 = nullptr;
pNET_DVR_StopRealPlay g_NET_DVR_StopRealPlay = nullptr;

pNET_DVR_SetExceptionCallBack_V30 g_NET_DVR_SetExceptionCallBack_V30 = nullptr;

/* 播放相关的函数指针 */
pPlayM4_GetPort g_PlayM4_GetPort = nullptr;
pPlayM4_FreePort g_PlayM4_FreePort = nullptr;
pPlayM4_Stop g_PlayM4_Stop = nullptr;
pPlayM4_OpenStream g_PlayM4_OpenStream = nullptr;
pPlayM4_CloseStream g_PlayM4_CloseStream = nullptr;
pPlayM4_SetDecCallBackMend g_PlayM4_SetDecCallBackMend = nullptr;
pPlayM4_Play g_PlayM4_Play = nullptr;
pPlayM4_PlaySound g_PlayM4_PlaySound = nullptr;
pPlayM4_InputData g_PlayM4_InputData = nullptr;
pPlayM4_GetLastError g_PlayM4_GetLastError = nullptr;


/* ========================================================================
 * ****************************** API函数 **********************************
 * ======================================================================== */
/* 加载动态库 */
bool load_HKSDK_Library(QString libPath)
{
    if(libPath.isEmpty())
    {
        return false;
    }
    /* 加载网络动态库 */
#if defined(Q_OS_WIN)
    QString libNetPath = libPath + "/HCNetSDK.dll";
    QString libPlayPath = libPath + "/PlayCtrl.dll";
#elif defined(Q_OS_LINUX)
    QString libNetPath = libPath + "/libhcnetsdk.so";
    QString libPlayPath = libPath + "/libPlayCtrl.so";
#endif

    QLibrary libNet(libNetPath);
    if(!libNet.load())
    {
        LH_WRITE_ERROR(QString("load 《HCNetSDK》 library failed, path: %1").arg(libPath));
        return false;
    }
    g_NET_DVR_Init = (pNet_DEV_Init)libNet.resolve("NET_DVR_Init");
    g_NET_DVR_Cleanup = (pNET_DVR_Cleanup)libNet.resolve("NET_DVR_Cleanup");
    g_NET_DVR_SetConnectTime = (pNET_DVR_SetConnectTime)libNet.resolve("NET_DVR_SetConnectTime");
    g_NET_DVR_SetReconnect = (pNET_DVR_SetReconnect)libNet.resolve("NET_DVR_SetReconnect");
    g_NET_DVR_Login_V40 = (pNET_DVR_Login_V40)libNet.resolve("NET_DVR_Login_V40");
    g_NET_DVR_Logout = (pNET_DVR_Logout)libNet.resolve("NET_DVR_Logout");
    g_NET_DVR_GetLastError = (pNET_DVR_GetLastError)libNet.resolve("NET_DVR_GetLastError");
    g_NET_DVR_RealPlay_V40 = (pNET_DVR_RealPlay_V40)libNet.resolve("NET_DVR_RealPlay_V40");
    g_NET_DVR_StopRealPlay = (pNET_DVR_StopRealPlay)libNet.resolve("NET_DVR_StopRealPlay");
    g_NET_DVR_SetExceptionCallBack_V30 = (pNET_DVR_SetExceptionCallBack_V30)libNet.resolve("NET_DVR_SetExceptionCallBack_V30");

    if(g_NET_DVR_Init == nullptr || g_NET_DVR_Cleanup == nullptr || g_NET_DVR_SetConnectTime == nullptr || 
        g_NET_DVR_SetReconnect == nullptr || g_NET_DVR_Login_V40 == nullptr || g_NET_DVR_Logout == nullptr ||
        g_NET_DVR_GetLastError == nullptr || g_NET_DVR_RealPlay_V40 == nullptr || g_NET_DVR_StopRealPlay == nullptr ||
        g_NET_DVR_SetExceptionCallBack_V30 == nullptr)
    {
        LH_WRITE_ERROR("load HCNetSDK library failed, resolve function failed!");
        return false;
    }

    /* 加载播放动态库 */
    QLibrary libPlayM4(libPlayPath);
    if(!libPlayM4.load())
    {
        LH_WRITE_ERROR(QString("load 《PlayCtrl》 library failed, path: %1").arg(libPath));
        return false;
    }

    g_PlayM4_GetPort = (pPlayM4_GetPort)libPlayM4.resolve("PlayM4_GetPort");
    g_PlayM4_FreePort = (pPlayM4_FreePort)libPlayM4.resolve("PlayM4_FreePort");
    g_PlayM4_Stop = (pPlayM4_Stop)libPlayM4.resolve("PlayM4_Stop");
    g_PlayM4_OpenStream = (pPlayM4_OpenStream)libPlayM4.resolve("PlayM4_OpenStream");
    g_PlayM4_CloseStream = (pPlayM4_CloseStream)libPlayM4.resolve("PlayM4_CloseStream");
    g_PlayM4_SetDecCallBackMend = (pPlayM4_SetDecCallBackMend)libPlayM4.resolve("PlayM4_SetDecCallBackMend");
    g_PlayM4_Play = (pPlayM4_Play)libPlayM4.resolve("PlayM4_Play");
    g_PlayM4_PlaySound = (pPlayM4_PlaySound)libPlayM4.resolve("PlayM4_PlaySound");
    g_PlayM4_InputData = (pPlayM4_InputData)libPlayM4.resolve("PlayM4_InputData");
    g_PlayM4_GetLastError = (pPlayM4_GetLastError)libPlayM4.resolve("PlayM4_GetLastError");

    if(g_PlayM4_GetPort == nullptr || g_PlayM4_FreePort == nullptr || g_PlayM4_Stop == nullptr || 
        g_PlayM4_OpenStream == nullptr || g_PlayM4_CloseStream == nullptr || g_PlayM4_SetDecCallBackMend == nullptr ||
        g_PlayM4_Play == nullptr || g_PlayM4_PlaySound == nullptr || g_PlayM4_InputData == nullptr || g_PlayM4_GetLastError == nullptr)
    {
        LH_WRITE_ERROR("load PlayCtrl library failed, resolve function failed!");
        return false;
    }

    return true;
}


bool NET_DVR_Init()
{
    if(g_NET_DVR_Init == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_Init is nullptr");
        return false;
    }
    return g_NET_DVR_Init();
}

bool NET_DVR_Cleanup()
{
    if(g_NET_DVR_Cleanup == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_Cleanup is nullptr");
        return false;
    }
    return g_NET_DVR_Cleanup();
}

bool NET_DVR_SetConnectTime(DWORD dwWaitTime, DWORD dwTryTimes)
{
    if(g_NET_DVR_SetConnectTime == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_SetConnectTime is nullptr");
        return false;
    }
    return g_NET_DVR_SetConnectTime(dwWaitTime, dwTryTimes);
}

bool NET_DVR_SetReconnect(DWORD dwInterval, BOOL bEnableRecon)
{
    if(g_NET_DVR_SetReconnect == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_SetReconnect is nullptr");
        return false;
    }
    return g_NET_DVR_SetReconnect(dwInterval, bEnableRecon);
}

LONG NET_DVR_Login_V40(LPNET_DVR_USER_LOGIN_INFO pLoginInfo,LPNET_DVR_DEVICEINFO_V40 lpDeviceInfo)
{
    if(g_NET_DVR_Login_V40 == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_Login_V40 is nullptr");
        return -1;
    }
    return g_NET_DVR_Login_V40(pLoginInfo, lpDeviceInfo);
}

bool NET_DVR_Logout(LONG lUserID)
{
    if(g_NET_DVR_Logout == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_Logout is nullptr");
        return false;
    }
    return g_NET_DVR_Logout(lUserID);
}

DWORD NET_DVR_GetLastError()
{
    if(g_NET_DVR_GetLastError == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_GetLastError is nullptr");
        return -1;
    }
    return g_NET_DVR_GetLastError();
}

LONG NET_DVR_RealPlay_V40(LONG lUserID, LPNET_DVR_PREVIEWINFO lpPreviewInfo, REALDATACALLBACK fRealDataCallBack_V30, void* pUser)
{
    if(g_NET_DVR_RealPlay_V40 == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_RealPlay_V40 is nullptr");
        return -1;
    }
    return g_NET_DVR_RealPlay_V40(lUserID, lpPreviewInfo, fRealDataCallBack_V30, pUser);
}

bool NET_DVR_StopRealPlay(LONG lRealHandle)
{
    if(g_NET_DVR_StopRealPlay == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_StopRealPlay is nullptr");
        return false;
    }
    return g_NET_DVR_StopRealPlay(lRealHandle);
}

bool NET_DVR_SetExceptionCallBack_V30(UINT reserved1, void* reserved2, void (CALLBACK* fExceptionCallBack)(DWORD dwType, LONG lUserID, LONG lHandle, void* pUser), void* pUser)
{
    if(g_NET_DVR_SetExceptionCallBack_V30 == nullptr)
    {
        LH_WRITE_ERROR("NET_DVR_SetExceptionCallBack_V30 is nullptr");
        return false;
    }
    return g_NET_DVR_SetExceptionCallBack_V30(reserved1, reserved2, fExceptionCallBack, pUser);
}

bool PlayM4_GetPort(LONG* nPort)
{
    if(g_PlayM4_GetPort == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_GetPort is nullptr");
        return false;
    }
    return g_PlayM4_GetPort(nPort);
}

bool PlayM4_FreePort(LONG nPort)
{
    if(g_PlayM4_FreePort == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_FreePort is nullptr");
        return false;
    }
    return g_PlayM4_FreePort(nPort);
}

bool PlayM4_Stop(LONG nPort)
{
    if(g_PlayM4_Stop == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_Stop is nullptr");
        return false;
    }
    return g_PlayM4_Stop(nPort);
}

bool PlayM4_CloseStream(LONG nPort)
{
    if(g_PlayM4_CloseStream == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_CloseStream is nullptr");
        return false;
    }
    return g_PlayM4_CloseStream(nPort);
}


bool PlayM4_PlaySound(LONG nPort)
{
    if(g_PlayM4_PlaySound == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_PlaySound is nullptr");
        return false;
    }
    return g_PlayM4_PlaySound(nPort);
}

bool PlayM4_InputData(LONG nPort,PBYTE pBuf,DWORD nSize)
{
    if(g_PlayM4_InputData == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_InputData is nullptr");
        return false;
    }
    return g_PlayM4_InputData(nPort, pBuf, nSize);
}

DWORD PlayM4_GetLastError(LONG nPort)
{
    if(g_PlayM4_GetLastError == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_GetLastError is nullptr");
        return -1;
    }
    return g_PlayM4_GetLastError(nPort);
}

#if defined (Q_OS_WIN)
bool PlayM4_Play(LONG nPort, HWND hWnd)
#elif defined (Q_OS_LINUX)
int PlayM4_Play(int nPort, PLAYM4_HWND hWnd)
#endif
{
    if(g_PlayM4_Play == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_Play is nullptr");
        return false;
    }
    return g_PlayM4_Play(nPort, hWnd);
}

#if defined (Q_OS_WIN)
bool PlayM4_OpenStream(LONG nPort,PBYTE pFileHeadBuf,DWORD nSize,DWORD nBufPoolSize)
#elif defined (Q_OS_LINUX)
int PlayM4_OpenStream(int nPort,unsigned char * pFileHeadBuf,unsigned int nSize,unsigned int nBufPoolSize)
#endif
{
    if(g_PlayM4_OpenStream == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_OpenStream is nullptr");
        return false;
    }
    return g_PlayM4_OpenStream(nPort, pFileHeadBuf, nSize, nBufPoolSize);
}

#if defined (Q_OS_WIN)
bool PlayM4_SetDecCallBackMend(LONG nPort, void (CALLBACK* DecCBFun)(long nPort, char * pBuf, long nSize, FRAME_INFO * pFrameInfo, void* nUser,void* nReserved2), void* nUser)
#elif defined (Q_OS_LINUX)
int PlayM4_SetDecCallBackMend(int nPort, void (CALLBACK* DecCBFun)(int nPort, char * pBuf, int nSize, FRAME_INFO * pFrameInfo, void* nUser, int nReserved2), void* nUser)
#endif
{
    if(g_PlayM4_SetDecCallBackMend == nullptr)
    {
        LH_WRITE_ERROR("PlayM4_SetDecCallBackMend is nullptr");
        return false;
    }
    return g_PlayM4_SetDecCallBackMend(nPort, DecCBFun, nUser);
}