海康私有流分析接口源码（含使用说明文档）

【实例简介】实现海康私有流分析为标准流

【实例截图】

【文件目录】

AnalyzeData

├── AnalyzeData(3.0.0.01)使用说明.doc
├── AnalyzeData.dll
├── AnalyzeData.lib
├── AnalyzeData.pdb
├── AnalyzeDataInterface.h
├── AnalyzeDataNewInterface.h
└── Demo_Stream
    ├── AnalyzeDataInterface.h
    ├── Debug
    ├── Demo.cpp
    ├── Demo.dsp
    ├── Demo.dsw
    ├── Demo.ncb
    ├── Demo.opt
    ├── HCNetSDK.dll
    ├── HCNetSDK.h
    ├── HCNetSDK.lib
    ├── StdAfx.cpp
    └── StdAfx.h

2 directories, 17 files

【核心代码】// Demo.cpp : Defines the entry point for the console application.
//
#include "afx.h"
#include "stdafx.h"
#include "windows.h"
#include "stdio.h"
#include "HCNetSDK.h"
#include "AnalyzeDataInterface.h"

#pragma comment (lib, "AnalyzeData.lib")
#pragma comment (lib, "HCNetSDK.lib")

#define BUFFER_SIZE  32 * 1024
#define HEADER_SIZE  40

class CSource
{
public:
CSource();
virtual ~CSource();

BOOL OpenFile(char* strFileName);
BOOL OpenFileStream(char* strFileName);
BOOL OpenRealStream(char* strIP);
void Close();
BOOL AnalyzeFileStream();
BOOL AnalyzeRealStream(BYTE* pData, DWORD dwDataLen, DWORD dwType);
BOOL AnalyzeFile(char* strFileName);

private:
HANDLE m_hFile;
HANDLE m_hThread;
BOOL   m_bStop;
BYTE*  m_pBuffer;
LONG   m_lPort;
LONG   m_lUser;
LONG   m_lPlay;
};

CSource::CSource()
{
m_hFile   = INVALID_HANDLE_VALUE;
m_hThread = NULL;
m_bStop   = FALSE;
m_pBuffer = NULL;
m_lPort   = -1;
m_lUser   = -1;
m_lPlay   = -1;
}

CSource::~CSource()
{
Close();
}

void CSource::Close()
{
if (m_hThread)
{
m_bStop = TRUE;
WaitForSingleObject(m_hThread, INFINITE);

CloseHandle(m_hThread);
m_hThread = NULL;
}

if (m_pBuffer)
{
delete[] m_pBuffer;
m_pBuffer = NULL;
}

if (m_hFile != INVALID_HANDLE_VALUE)
{
CloseHandle(m_hFile);
m_hFile = INVALID_HANDLE_VALUE;
}

if (m_lPlay != -1)
{
NET_DVR_StopRealPlay(m_lPlay);
m_lPlay = -1;
}

if (m_lUser != -1)
{
NET_DVR_Logout(m_lUser);
m_lUser = -1;
}

NET_DVR_Cleanup();

if (m_lPort != -1)
{
AnalyzeDataClose(m_lPort);
m_lPort = -1;
}
}

DWORD WINAPI ReadFileThread(LPVOID lpParam)
{
CSource* pcSource = (CSource*)lpParam;

pcSource->AnalyzeFileStream();

return 1;
}

BOOL CSource::AnalyzeFileStream()
{
DWORD dwBytes = 0;

ReadFile(m_hFile, m_pBuffer, HEADER_SIZE, &dwBytes, NULL);

if ( !AnalyzeDataOpenStreamEx(m_lPort, m_pBuffer) )
{
printf("Demo: open stream failed!\n");
return FALSE;
}

while (TRUE)
{
if (m_bStop)
{
break;
}

    ReadFile(m_hFile, m_pBuffer, BUFFER_SIZE, &dwBytes, NULL);

    if (dwBytes == 0)
{
Sleep(10);
continue;
}

    if ( !AnalyzeDataInputData(m_lPort, m_pBuffer, dwBytes) )
{
printf("Demo: buffer overflow, lost stream data!\n");
}

PACKET_INFO_EX stPacket;




while (AnalyzeDataGetPacketEx(m_lPort, &stPacket) == 0)
{
if (stPacket.nPacketType == VIDEO_I_FRAME)
{
printf("Video I frame, framenum = %u, timestamp = %u, size = %dx%d,globaltime=%d-%d-%d-%d-%d-%d!\n", 
stPacket.dwFrameNum, stPacket.dwTimeStamp, stPacket.uWidth, stPacket.uHeight,stPacket.nYear,
stPacket.nMonth,stPacket.nDay,stPacket.nHour,stPacket.nMinute,stPacket.nSecond);


}
else if (stPacket.nPacketType == VIDEO_P_FRAME)
{
printf("Video P frame, framenum = %u, timestamp = %u, size = %dx%d,globaltime=%d-%d-%d-%d-%d-%d!\n", 
stPacket.dwFrameNum, stPacket.dwTimeStamp, stPacket.uWidth, stPacket.uHeight,stPacket.nYear,
stPacket.nMonth,stPacket.nDay,stPacket.nHour,stPacket.nMinute,stPacket.nSecond);
}
else if (stPacket.nPacketType == VIDEO_B_FRAME)
{
printf("Video B frame, framenum = %u, timestamp = %u, size = %dx%d,globaltime=%d-%d-%d-%d-%d-%d!\n", 
stPacket.dwFrameNum, stPacket.dwTimeStamp, stPacket.uWidth, stPacket.uHeight,stPacket.nYear,
stPacket.nMonth,stPacket.nDay,stPacket.nHour,stPacket.nMinute,stPacket.nSecond);
}
else if (stPacket.nPacketType == AUDIO_PACKET)
{

printf("Audio frame, timestamp = %u!\n", stPacket.dwTimeStamp);
}
else              
{
//
}
}

}


return TRUE;
}

BOOL CSource::OpenFileStream(char* strFileName)
{
Close();

try
{
m_hFile = CreateFile(strFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (m_hFile == INVALID_HANDLE_VALUE)
{
printf("Demo: create file failed!\n");
throw 0;
}

m_pBuffer = new BYTE[BUFFER_SIZE];
if (m_pBuffer == NULL)
{
throw 0;
}

m_hThread = CreateThread(NULL, 0, ReadFileThread, this, 0, NULL);
if (m_hThread == NULL)
{
throw 0;
}

m_lPort = AnalyzeDataGetSafeHandle();
if (m_lPort == -1)
{
throw 0;
}
}
catch (...)
{
Close();
return FALSE;
}

return TRUE;
}

void CALLBACK RealDataCallBack(LONG lHandle, DWORD dwDataType, BYTE* pBuffer, DWORD dwBufSize, DWORD dwUser)
{
UNREFERENCED_PARAMETER(lHandle);

CSource* pcSource = (CSource*)dwUser;

pcSource->AnalyzeRealStream(pBuffer, dwBufSize, dwDataType);
}

BOOL CSource::AnalyzeRealStream(BYTE* pData, DWORD dwDataLen, DWORD dwType)
{
switch (dwType)
{
case NET_DVR_SYSHEAD:
{
if ( !AnalyzeDataOpenStreamEx(m_lPort, pData) )
{
printf("Demo: open stream failed!\n");
return FALSE;
}

break;
}
case NET_DVR_STREAMDATA:
{
if ( !AnalyzeDataInputData(m_lPort, pData, dwDataLen) )
{
printf("Demo: buffer overflow, lost stream data!\n");
}

PACKET_INFO_EX stPacket;

while (AnalyzeDataGetPacketEx(m_lPort, &stPacket) == 0)
{
if (stPacket.nPacketType == VIDEO_I_FRAME)
{
printf("Video I frame, framenum = %u, timestamp = %u, size = %dx%d,globaltime=%d:%d:%d:%d:%d:%d,dwFrameRate = %d!\n", 
stPacket.dwFrameNum, stPacket.dwTimeStamp, stPacket.uWidth, stPacket.uHeight,stPacket.nYear,
stPacket.nMonth,stPacket.nDay,stPacket.nHour,stPacket.nMinute,stPacket.nSecond,stPacket.dwFrameRate);
}
else if (stPacket.nPacketType == VIDEO_P_FRAME)
{
printf("Video P frame, framenum = %u, timestamp = %u, size = %dx%d,globaltime=%d:%d:%d:%d:%d:%d,dwFrameRate = %d!\n", 
stPacket.dwFrameNum, stPacket.dwTimeStamp, stPacket.uWidth, stPacket.uHeight,stPacket.nYear,
stPacket.nMonth,stPacket.nDay,stPacket.nHour,stPacket.nMinute,stPacket.nSecond,stPacket.dwFrameRate);
}
else if (stPacket.nPacketType == VIDEO_B_FRAME)
{
printf("Video B frame, framenum = %u, timestamp = %u, size = %dx%d,globaltime=%d:%d:%d:%d:%d:%d,dwFrameRate =%d!\n", 
stPacket.dwFrameNum, stPacket.dwTimeStamp, stPacket.uWidth, stPacket.uHeight,stPacket.nYear,
stPacket.nMonth,stPacket.nDay,stPacket.nHour,stPacket.nMinute,stPacket.nSecond,stPacket.dwFrameRate);
}
else if (stPacket.nPacketType == AUDIO_PACKET)
  {
  // printf("Audio frame, timestamp = %u!\n", stPacket.dwTimeStamp);
  }
  // else
// {
// //
// }
}

break;
}
default:
{
break;
}
}

return TRUE;
}

BOOL CSource::OpenRealStream(char* strIP)
{
Close();

try
{
if ( !NET_DVR_Init() )
{
printf("Demo: Demo: init NETDVR failed!\n");
throw 0;
}

    NET_DVR_DEVICEINFO DeviceInfo;

    m_lUser = NET_DVR_Login(strIP, 8000, "admin", "12345", &DeviceInfo);
    if (m_lUser == -1)
{
printf("Demo: login NETDVR failed!\n");
throw 0;
}

NET_DVR_CLIENTINFO playstru = {1, 0, NULL, ""};

    m_lPlay = NET_DVR_RealPlay(m_lUser, &playstru);
    if (m_lPlay == -1)
{
printf("Demo: start realplay failed!\n");
throw 0;
}

    if ( !NET_DVR_SetRealDataCallBack(m_lPlay, RealDataCallBack, (DWORD)this) )
{
throw 0;
}

m_lPort = AnalyzeDataGetSafeHandle();
if (m_lPort == -1)
{
throw 0;
}
}
catch (...)
{
Close();
return FALSE;
}

return TRUE;
}

BOOL CSource::AnalyzeFile(char* strFileName)
{
if ( !AnalyzeDataOpenFile(m_lPort, strFileName) )
{
printf("Demo: open file failed!\n");
return FALSE;
}

PACKET_INFO_EX stPacket;

int nRet = -1;
do
{
nRet = AnalyzeDataGetPacketEx(m_lPort, &stPacket);
if (nRet == 2)
{
printf("Demo: file data is over!\n");
break;
}

if (stPacket.nPacketType == VIDEO_I_FRAME)
{
printf("Video I frame, framenum = %u, timestamp = %u, size = %dx%d!\n", 
stPacket.dwFrameNum, stPacket.dwTimeStamp, stPacket.uWidth, stPacket.uHeight);
}
else if (stPacket.nPacketType == VIDEO_P_FRAME)
{
printf("Video P frame, framenum = %u, timestamp = %u, size = %dx%d!\n", 
stPacket.dwFrameNum, stPacket.dwTimeStamp, stPacket.uWidth, stPacket.uHeight);
}
else if (stPacket.nPacketType == VIDEO_B_FRAME)
{
printf("Video B frame, framenum = %u, timestamp = %u, size = %dx%d!\n", 
stPacket.dwFrameNum, stPacket.dwTimeStamp, stPacket.uWidth, stPacket.uHeight);
}
else if (stPacket.nPacketType == AUDIO_PACKET)
{
// printf("Audio frame, timestamp = %u!\n", stPacket.dwTimeStamp);
}
else
{
//
}
}
while (nRet == 0);

return TRUE;
}

BOOL CSource::OpenFile(char* strFileName)
{
Close();

try
{
m_lPort = AnalyzeDataGetSafeHandle();
if (m_lPort == -1)
{
throw 0;
}

if ( !AnalyzeFile(strFileName) )
{
throw 0;
}
}
catch (...)
{
Close();
return FALSE;
}

return TRUE;
}

int main()
{
CSource cSource;

cSource.OpenFileStream("E:\\测试视频\\large.mp4");

// cSource.OpenFileStream("D:\\测试文件\\分析库只有一帧\\10.0_main_XVGA_0.5_3072.0_1.mp4");

// cSource.OpenRealStream("172.10.177.80");

getchar();

cSource.Close();

return 0;
}