Access violation MFC/C++

[lbargers]

hi,

Im working on an .ocx control to integrate a 3rd party video vendor API into our product. Im stuck on an access violation error:
Unhandled exception in iexplorer.exe(PVCODEC.DLL): OxC0000005: Access Violoation. The ocx has been working for the past few days as I've been writting the wrapper. As of this morning Im getting that error. I've been pulling my hair out for the past 3 hours trying to find the cause of this, to no avail. I am attaching my ctrl.cpp code. If anyone has any idea what I am doing wrong can you please advise?

Thanks!

// PelcoDX8100Ctl.cpp : Implementation of the CPelcoDX8100Ctrl ActiveX Control class.

#include "stdafx.h"
#include "PelcoDX8100.h"
#include "PelcoDX8100Ctl.h"
#include "PelcoDX8100Ppg.h"
#include "resource.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

const int NONE_DISPLAY_MODE		= 0;
const int LIVE_DISPLAY_MODE     = 1;
const int PLAYBACK_DISPLAY_MODE = 2;

bool g_bPaused = false;

COverlayWnd* g_pOverlayWnd = NULL;  //global overlay window
CPelcoDX8100Ctrl* g_pMyCtrl = NULL;

LPST_SERVER_BASE_INFO g_pServerInfo;

SYSTEMTIME CPelcoDX8100Ctrl::m_stLastReceivedTime;

#define TID_SERVER_CONNECT	0x1


IMPLEMENT_DYNCREATE(CPelcoDX8100Ctrl, COleControl)

/////////////////////////////////////////////////////////////////////////////
// Message map

BEGIN_MESSAGE_MAP(CPelcoDX8100Ctrl, COleControl)
	//{{AFX_MSG_MAP(CPelcoDX8100Ctrl)
	//}}AFX_MSG_MAP
	ON_OLEVERB(AFX_IDS_VERB_PROPERTIES, OnProperties)
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// Dispatch map

BEGIN_DISPATCH_MAP(CPelcoDX8100Ctrl, COleControl)
	//{{AFX_DISPATCH_MAP(CPelcoDX8100Ctrl)
	DISP_PROPERTY_EX(CPelcoDX8100Ctrl, "PTZSpeed", GetPTZSpeed, SetPTZSpeed, VT_I4)
	DISP_PROPERTY_EX(CPelcoDX8100Ctrl, "PlaybackSpeed", GetPlaybackSpeed, SetPlaybackSpeed, VT_I4)
	DISP_PROPERTY_EX(CPelcoDX8100Ctrl, "StartTime", GetStartTime, SetStartTime, VT_R8)
	DISP_PROPERTY_EX(CPelcoDX8100Ctrl, "PresetId", GetPresetId, SetPresetId, VT_I2)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Connect", Connect, VT_I4, VTS_BSTR VTS_I2 VTS_BSTR VTS_BSTR)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Focusin", Focusin, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Focusout", Focusout, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Irisclose", Irisclose, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Irisopen", Irisopen, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PrptStop", PrptStop, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Ptzdown", Ptzdown, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Ptzleft", Ptzleft, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Ptzright", Ptzright, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Ptzstop", Ptzstop, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Ptzup", Ptzup, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Zoomin", Zoomin, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Zoomout", Zoomout, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Presetgoto", Presetgoto, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Presetset", Presetset, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Disconnect", Disconnect, VT_I4, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PtzDL", PtzDL, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PtzDR", PtzDR, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PtzUL", PtzUL, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PtzUR", PtzUR, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "GetCameraId", GetCameraId, VT_I4, VTS_BSTR)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "BeginLiveStream", BeginLiveStream, VT_EMPTY, VTS_BSTR)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PlaybackPlay", PlaybackPlay, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Pause", Pause, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PlaybackReverse", PlaybackReverse, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PlaybackForward", PlaybackForward, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PlaybackStop", PlaybackStop, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PlaybackFirst", PlaybackFirst, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "PlaybackLast", PlaybackLast, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "Presetreset", Presetreset, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "ChangePlaybackSpeed", ChangePlaybackSpeed, VT_EMPTY, VTS_NONE)
	DISP_FUNCTION(CPelcoDX8100Ctrl, "ViewLive", ViewLive, VT_EMPTY, VTS_NONE)
	//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()


/////////////////////////////////////////////////////////////////////////////
// Event map

BEGIN_EVENT_MAP(CPelcoDX8100Ctrl, COleControl)
	//{{AFX_EVENT_MAP(CPelcoDX8100Ctrl)
	EVENT_CUSTOM("Connected", FireConnected, VTS_I4)
	//}}AFX_EVENT_MAP
END_EVENT_MAP()


/////////////////////////////////////////////////////////////////////////////
// Property pages

BEGIN_PROPPAGEIDS(CPelcoDX8100Ctrl, 1)
	PROPPAGEID(CPelcoDX8100PropPage::guid)
END_PROPPAGEIDS(CPelcoDX8100Ctrl)


/////////////////////////////////////////////////////////////////////////////
// Initialize class factory and guid

IMPLEMENT_OLECREATE_EX(CPelcoDX8100Ctrl, "PELCODX8100.PelcoDX8100Ctrl.1",
	0xd302d9aa, 0x408f, 0x4429, 0x9e, 0x92, 0x5d, 0xe7, 0xde, 0xb4, 0x8, 0xa6)


/////////////////////////////////////////////////////////////////////////////
// Type library ID and version

IMPLEMENT_OLETYPELIB(CPelcoDX8100Ctrl, _tlid, _wVerMajor, _wVerMinor)


/////////////////////////////////////////////////////////////////////////////
// Interface IDs

const IID BASED_CODE IID_DPelcoDX8100 =
		{ 0xc7469f9a, 0x2c8b, 0x4c6b, { 0xbe, 0x4c, 0xe4, 0x96, 0xde, 0x44, 0xd1, 0x84 } };
const IID BASED_CODE IID_DPelcoDX8100Events =
		{ 0x21eb31d7, 0x7100, 0x4763, { 0xb2, 0xdf, 0x41, 0x47, 0x3a, 0xf2, 0x31, 0x4e } };


/////////////////////////////////////////////////////////////////////////////
// Control type information

static const DWORD BASED_CODE _dwPelcoDX8100OleMisc =
	OLEMISC_SETCLIENTSITEFIRST |
	OLEMISC_INSIDEOUT |
	OLEMISC_CANTLINKINSIDE |
	OLEMISC_RECOMPOSEONRESIZE;

IMPLEMENT_OLECTLTYPE(CPelcoDX8100Ctrl, IDS_PELCODX8100, _dwPelcoDX8100OleMisc)


/////////////////////////////////////////////////////////////////////////////
// CPelcoDX8100Ctrl::CPelcoDX8100CtrlFactory::UpdateRegistry -
// Adds or removes system registry entries for CPelcoDX8100Ctrl

BOOL CPelcoDX8100Ctrl::CPelcoDX8100CtrlFactory::UpdateRegistry(BOOL bRegister)
{
	// TODO: Verify that your control follows apartment-model threading rules.
	// Refer to MFC TechNote 64 for more information.
	// If your control does not conform to the apartment-model rules, then
	// you must modify the code below, changing the 6th parameter from
	// afxRegApartmentThreading to 0.

	if (bRegister)
		return AfxOleRegisterControlClass(
			AfxGetInstanceHandle(),
			m_clsid,
			m_lpszProgID,
			IDS_PELCODX8100,
			IDB_PELCODX8100,
			afxRegApartmentThreading,
			_dwPelcoDX8100OleMisc,
			_tlid,
			_wVerMajor,
			_wVerMinor);
	else
		return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
}


/////////////////////////////////////////////////////////////////////////////
// Licensing strings

static const TCHAR BASED_CODE _szLicFileName[] = _T("PelcoDX8100.lic");

static const WCHAR BASED_CODE _szLicString[] =
	L"Copyright (c) 2010 Bold Technologies";


/////////////////////////////////////////////////////////////////////////////
// CPelcoDX8100Ctrl::CPelcoDX8100CtrlFactory::VerifyUserLicense -
// Checks for existence of a user license

BOOL CPelcoDX8100Ctrl::CPelcoDX8100CtrlFactory::VerifyUserLicense()
{
	return AfxVerifyLicFile(AfxGetInstanceHandle(), _szLicFileName,
		_szLicString);
}

/////////////////////////////////////////////////////////////////////////////
// CPelcoDX8100Ctrl::CPelcoDX8100CtrlFactory::GetLicenseKey -
// Returns a runtime licensing key

BOOL CPelcoDX8100Ctrl::CPelcoDX8100CtrlFactory::GetLicenseKey(DWORD dwReserved,
	BSTR FAR* pbstrKey)
{
	if (pbstrKey == NULL)
		return FALSE;

	*pbstrKey = SysAllocString(_szLicString);
	return (*pbstrKey != NULL);
}

const DWORD dwSupportedBits = 
      INTERFACESAFE_FOR_UNTRUSTED_CALLER |
      INTERFACESAFE_FOR_UNTRUSTED_DATA;
const DWORD dwNotSupportedBits = ~ dwSupportedBits;

HRESULT STDMETHODCALLTYPE CPelcoDX8100Ctrl::XObjSafe::GetInterfaceSafetyOptions( REFIID riid, DWORD __RPC_FAR *pdwSupportedOptions, DWORD __RPC_FAR *pdwEnabledOptions)
{
   METHOD_PROLOGUE(CPelcoDX8100Ctrl, ObjSafe)

   HRESULT retval = ResultFromScode(S_OK);

   IUnknown FAR* punkInterface;
   retval = pThis->ExternalQueryInterface(&riid, (void * *)&punkInterface);
   if (retval != E_NOINTERFACE) 
   {
      punkInterface->Release();
   }
   
   // We support both kinds of safety and always have both set regardless of the interface
   *pdwSupportedOptions = *pdwEnabledOptions = dwSupportedBits;
   return retval;
}

HRESULT STDMETHODCALLTYPE CPelcoDX8100Ctrl::XObjSafe::SetInterfaceSafetyOptions( REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions)
{
   METHOD_PROLOGUE(CPelcoDX8100Ctrl, ObjSafe)
   
   IUnknown FAR* punkInterface;
   pThis->ExternalQueryInterface(&riid, (void * *)&punkInterface);
   
   if (punkInterface) 
   {
      punkInterface->Release();
   }
   else 
   {
      return ResultFromScode(E_NOINTERFACE);
   }
   // Can't set bits we don't support.
   if (dwOptionSetMask & dwNotSupportedBits) 
   { 
      return ResultFromScode(E_FAIL);
   }

   dwEnabledOptions &= dwSupportedBits;
   if ((dwOptionSetMask & dwEnabledOptions) != dwOptionSetMask) 
   {
      return ResultFromScode(E_FAIL);
   }                                    
   
   // Don't need to change anything since we're always safe.
   return ResultFromScode(S_OK);
}

ULONG FAR EXPORT CPelcoDX8100Ctrl::XObjSafe::AddRef()
{
    METHOD_PROLOGUE(CPelcoDX8100Ctrl, ObjSafe)
    return pThis->ExternalAddRef();
}

ULONG FAR EXPORT CPelcoDX8100Ctrl::XObjSafe::Release()
{
    METHOD_PROLOGUE(CPelcoDX8100Ctrl, ObjSafe)
    return pThis->ExternalRelease();
}

HRESULT FAR EXPORT CPelcoDX8100Ctrl::XObjSafe::QueryInterface(REFIID iid, void FAR* FAR* ppvObj)
{
    METHOD_PROLOGUE(CPelcoDX8100Ctrl, ObjSafe)
    return (HRESULT)pThis->ExternalQueryInterface(&iid, ppvObj);
}

/////////////////////////////////////////////////////////////////////////////
// CPelcoDX8100Ctrl::CPelcoDX8100Ctrl - Constructor

CPelcoDX8100Ctrl::CPelcoDX8100Ctrl()
{
	InitializeIIDs(&IID_DPelcoDX8100, &IID_DPelcoDX8100Events);
	SetInitialSize(533,400);
	Initialize();
}

void CPelcoDX8100Ctrl::Initialize()
{
	g_pMyCtrl = this;
	m_hServer = NULL;
	m_iLastError = 0;
	m_ConnectTimeout = 15;
	m_iPTZSpeed = 0;
	m_dStartTime = 0.0;
	m_nDisplayMode = NONE_DISPLAY_MODE;
	m_nCameraId = -1;
	m_playbackSpeed = -1;
	m_sPresetId = -1;
	m_bPTZEnabled = false;
	m_nDivision = -1;
	g_bPaused = false;
	
}

/////////////////////////////////////////////////////////////////////////////
// CPelcoDX8100Ctrl::~CPelcoDX8100Ctrl - Destructor

CPelcoDX8100Ctrl::~CPelcoDX8100Ctrl()
{

	if (m_hServer)
	{	
		g_bPaused = true; 
		if(g_pOverlayWnd)
		{
			g_pOverlayWnd = NULL;
			delete g_pOverlayWnd;
			

			if(m_nDisplayMode == LIVE_DISPLAY_MODE)
			{
				DxStopLiveStream( m_hServer );
			}

			if(m_nDisplayMode == PLAYBACK_DISPLAY_MODE)
			{
				DxSearchStop( m_hServer );
			}
		}

		DxClose(m_hServer);
		m_hServer = NULL;
	}
}


/////////////////////////////////////////////////////////////////////////////
// CPelcoDX8100Ctrl::OnDraw - Drawing function

void CPelcoDX8100Ctrl::OnDraw(
			CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
{

	if(m_hWnd){

		if (!pdc)
			return;

		if(m_nDisplayMode != LIVE_DISPLAY_MODE && m_nDisplayMode != PLAYBACK_DISPLAY_MODE)
		{
			CString strTemp;
			strTemp = "NOT CONNECTED";

			pdc->FillRect(rcBounds, CBrush::FromHandle(GetSysColorBrush(COLOR_BTNFACE)));

			CRect oFrameRect;
			GetClientRect(&oFrameRect);

			pdc->DrawEdge(&oFrameRect, EDGE_BUMP, BF_RECT);
			pdc->SetTextColor(RGB(255,255,255));
			pdc->SetBkColor(RGB(054,154,37));
			pdc->DrawText(strTemp, strlen(strTemp),&oFrameRect,DT_CENTER|DT_VCENTER|DT_SINGLELINE);
		}
	}

}


/////////////////////////////////////////////////////////////////////////////
// CPelcoDX8100Ctrl::DoPropExchange - Persistence support

void CPelcoDX8100Ctrl::DoPropExchange(CPropExchange* pPX)
{
	ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
	COleControl::DoPropExchange(pPX);

}

/////////////////////////////////////////////////////////////////////////////
// CPelcoDX8100Ctrl::OnResetState - Reset control to default state

void CPelcoDX8100Ctrl::OnResetState()
{
	COleControl::OnResetState();  // Resets defaults found in DoPropExchange
}

/////////////////////////////////////////////////////////////////////////////
// CPelcoDX8100Ctrl message handlers


BOOL CPelcoDX8100Ctrl::OnSetExtent(LPSIZEL lpSizeL)
{
	// TODO: Add your specialized code here and/or call the base class
	if (g_pOverlayWnd && m_hWnd)
	{
		RECT rect;
		GetClientRect(&rect);
		
		g_pOverlayWnd->SetWindowPos(this, rect.top, rect.left, rect.right - rect.left, rect.top - rect.bottom, NULL);
		
	}

	return COleControl::OnSetExtent(lpSizeL);
	
}

void CPelcoDX8100Ctrl::InternalResize()
{
	int iWidth, iHeight;

	this->GetControlSize(&iWidth, &iHeight);
	InternalResize(iWidth,iHeight);
}

void CPelcoDX8100Ctrl::InternalResize(LONG width, LONG height)
{
	if(m_hWnd && g_pOverlayWnd)
	{
		CWnd * pWnd = CWnd::FromHandle(m_hWnd);
		pWnd->SetWindowPos(&wndTop,0,0,width,height,SWP_SHOWWINDOW);
		g_pOverlayWnd->SetWindowPos(&wndTop,0,0,width,height,SWP_SHOWWINDOW);
	}
}

long CPelcoDX8100Ctrl::Disconnect() 
{
	m_nDisplayMode = NONE_DISPLAY_MODE;
	g_bPaused = true; 

	if (m_hServer)
	{		
		if(g_pOverlayWnd)
		{
			delete g_pOverlayWnd;
			g_pOverlayWnd = NULL;

			if(m_nDisplayMode == LIVE_DISPLAY_MODE)
			{
				DxStopLiveStream( m_hServer );
			}

			if(m_nDisplayMode == PLAYBACK_DISPLAY_MODE)
			{
				DxPlaybackCtrl(m_hServer, _DXSDK_PLAYBACK_STOP);
				DxSearchStop( m_hServer );
			}
		}

		DxClose(m_hServer);
		m_hServer = NULL;
	}

	return 0;
}

[lbargers]

long CPelcoDX8100Ctrl::GetPTZSpeed() 
{
	return m_iPTZSpeed;
}

void CPelcoDX8100Ctrl::SetPTZSpeed(long nNewValue) 
{
	m_iPTZSpeed = nNewValue;
	SetModifiedFlag();
}

long CPelcoDX8100Ctrl::GetCameraId(LPCTSTR cameraName) 
{
	ST_CHANNEL_INFO stChInfo;

	int ret = 0;

	CString name = cameraName;

	name.TrimRight();

	for( int nCamNum=0;nCamNum< MAX_SUPPORT_CH ;nCamNum++) 
	{
		ret = DxGetCameraInformation(m_hServer, nCamNum, &stChInfo);
		if (name == stChInfo.szCameraName)
		{
			m_nCameraId = nCamNum;
			m_bPTZEnabled = stChInfo.bPTZEnable;
			break;	
		}
	}

	m_CameraName = name;

	return m_bPTZEnabled; //return PTZenabled setting back to display
}

void CPelcoDX8100Ctrl::SetHServer(HSERVER hServer, int nDivision,LPLIVE_VID_CONF lpliveVidConf)
{
	m_hServer = hServer;
	m_nDivision = nDivision;

	memcpy(&m_LiveVidConf,lpliveVidConf,sizeof(LIVE_VID_CONF));
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Live Stream
//

long CPelcoDX8100Ctrl::Connect(LPCTSTR address, short port, LPCTSTR userId, LPCTSTR password) 
{
	g_bPaused = false;

    g_pServerInfo = new ST_SERVER_BASE_INFO();
	if (!g_pServerInfo)
		return 1;

	memset(g_pServerInfo,0,sizeof(g_pServerInfo));

	StringCbCopy(g_pServerInfo->szServerAddr, sizeof(g_pServerInfo->szServerAddr), address);
	StringCbCopy(g_pServerInfo->szUserID, sizeof(g_pServerInfo->szUserID), userId);
	StringCbCopy(g_pServerInfo->szUserPasswd, sizeof(g_pServerInfo->szUserPasswd), password);
	
	g_pServerInfo->usServerPort = port;

	g_pServerInfo->lpfnConectCallback = CPelcoDX8100Ctrl::OnConnectedCallback;
	g_pServerInfo->lpfnDisconnectCallback = CPelcoDX8100Ctrl::OnDisconnectCallback;

	DxSetSocketTimeOut(m_ConnectTimeout);

	m_hServer = DxConnect(g_pServerInfo);

	if (!m_hServer)
	{
		m_iLastError = DxGetLastError();
		return m_iLastError;
	}


	return 0;
}

void CPelcoDX8100Ctrl::BeginLiveStream(LPCTSTR cameraName) 
{	

	g_bPaused = true;

	if(g_pOverlayWnd)
	{
		g_pOverlayWnd = NULL;
		delete g_pOverlayWnd;

		if(m_nDisplayMode == PLAYBACK_DISPLAY_MODE)
		{
			DxSearchStop( m_hServer );
			DxPlaybackCtrl(m_hServer, _DXSDK_PLAYBACK_STOP);
		}else
		{
			DxStopLiveStream( m_hServer );
		}
	}

	g_pOverlayWnd = NULL;
	g_pOverlayWnd = new COverlayWnd;

	g_pOverlayWnd->CreateEx(WS_EX_ACCEPTFILES,NULL,"",WS_CHILD|WS_VISIBLE|WS_BORDER,CRect(0,0,533,400),this,NULL);
	g_pOverlayWnd->InitDirectDraw();
	g_pOverlayWnd->SetDivision(1);

	LIVE_VID_CONF vidConf;
	memset(&vidConf,0,sizeof(vidConf));

	vidConf.btChEnable[m_nCameraId] = true;
	vidConf.uiMinimumStreamIntervalMS = 5;
	vidConf.VidForat = FORMAT_YUV16;
	vidConf.lpfnVidStreamCallback = CPelcoDX8100Ctrl::OnImageDisplayCallback;

	int ret = DxBeginLiveStream(m_hServer, &vidConf);

	int nDivision[6] = {1,4,9,16,25,32};
	SetDisplayMode(LIVE_DISPLAY_MODE);
	SetHServer(m_hServer, nDivision[1] , &vidConf); 
	
	g_bPaused = false;

}

VOID CPelcoDX8100Ctrl::OnConnectedCallback(HSERVER hServer, LPST_CONNECT_INFO lpstConnectInfo)
{
}

VOID CPelcoDX8100Ctrl::OnDisconnectCallback(HSERVER hServer)
{
}

VOID CPelcoDX8100Ctrl::OnImageDisplayCallback(HSERVER hServer, LPST_LIVE_VID_ITEM lpstVidStream)
{

	if(g_bPaused == false)
	{
		if( g_pOverlayWnd && g_pMyCtrl && g_pOverlayWnd->m_hWnd && g_pOverlayWnd->IsWindowVisible() )
		{	
			g_pOverlayWnd->WriteOverlayScrn( lpstVidStream , (BYTE*)lpstVidStream->stFrameItem.lpVidBuffer );
			g_pOverlayWnd->UpdateOverlay();
			g_pMyCtrl->InternalResize();
		}
	}
}


VOID CPelcoDX8100Ctrl::OnLiveVideoStreamAborted(HSERVER hServer,INT nErrCode)
{
	AfxMessageBox("Video Stream Aborted.\n");
}


void CPelcoDX8100Ctrl::SetDisplayMode(int DisplayMode) // 1 - live, 2 - playback
{
	ASSERT(DisplayMode == LIVE_DISPLAY_MODE || DisplayMode == PLAYBACK_DISPLAY_MODE);
	m_nDisplayMode = DisplayMode;
}



LRESULT CPelcoDX8100Ctrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
	try
	{
		CString tmp;

		switch(message)
		{
			case WM_KEYDOWN:
			{
				Connect("172.16.141.48", 9002, "admin", "admin");
				GetCameraId("Front Door");
				BeginLiveStream("Front Door");
				//PTZSpeed = 45;
			}
		}

		return COleControl::WindowProc(message, wParam, lParam);
	}
	catch(...)
	{
		return -1;
	}

}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Playback Funtionality
//

void CPelcoDX8100Ctrl::_PlaybackCtrl()
{

	ASSERT( m_nDisplayMode != NONE_DISPLAY_MODE);

	if(g_pOverlayWnd)
	{
		g_pOverlayWnd = NULL;
		delete g_pOverlayWnd;

		if(m_nDisplayMode == PLAYBACK_DISPLAY_MODE)
		{
			DxSearchStop( m_hServer );
			DxPlaybackCtrl(m_hServer, _DXSDK_PLAYBACK_STOP);
		}else
		{
			DxStopLiveStream( m_hServer );
		}
	}

	g_pOverlayWnd = new COverlayWnd;

	g_pOverlayWnd->CreateEx(WS_EX_ACCEPTFILES,NULL,"",WS_CHILD|WS_VISIBLE|WS_BORDER,CRect(0,0,533,400),this,NULL);
	g_pOverlayWnd->InitDirectDraw();
	g_pOverlayWnd->SetDivision(1);
	
	
	ST_PLAYBACK_OPT stPlayOption;

	memset( &stPlayOption,0,sizeof(ST_PLAYBACK_OPT) );

	m_nCameraSelectedMask = 0;
	// Get select video channel.
	stPlayOption.btChannel[m_nCameraId] = TRUE;
	m_nCameraSelectedMask = m_nCameraId;

	//set of video Output format.
	// FORMAT_YUV16 or FORMAT_RGB24 supported now
	stPlayOption.VidForat = FORMAT_YUV16;

	m_dStartTime += 2;

	SYSTEMTIME st;
	VariantTimeToSystemTime(m_dStartTime, &st);

	stPlayOption.stStartTime.wYear = st.wYear;
	stPlayOption.stStartTime.wMonth = st.wMonth;
	stPlayOption.stStartTime.wDay = st.wDay;
	stPlayOption.stStartTime.wHour = st.wHour; //AM
	stPlayOption.stStartTime.wMinute = st.wMinute;
	stPlayOption.stStartTime.wSecond = st.wSecond;
	stPlayOption.stStartTime.wMilliseconds = st.wMilliseconds;
	stPlayOption.stStartTime.wDayOfWeek = st.wDayOfWeek;	//Monday. start is sunday = 0;
	// Play Enable Audio channel.
	stPlayOption.nPlayAudioCh = -1;
	m_stLastReceivedTime = stPlayOption.stStartTime;// store last received time

	// Callback Function address.
	stPlayOption.lpfnPlaybackEventCallback = CPelcoDX8100Ctrl::OnSearchCallback;

	// Set playback speed
	switch(m_playbackSpeed) {
	case 0:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_1;	// 1X
		break;
	case 1:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_2;	// 1X
		break;
	case 2:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_4;	// 1X
		break;
	case 3:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_6;	// 1X
		break;
	default:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_1;	// 1X
	}
	DxSearchPlaybackSetOption(m_hServer, &stPlayOption);

	// Set Playback Timeout
	int nPlaybackTimeoutSeconds;
	nPlaybackTimeoutSeconds = GetDlgItemInt(IDC_SEARCH_MAXINTERVAL, NULL, TRUE);
	if(nPlaybackTimeoutSeconds < 0)
	{
		nPlaybackTimeoutSeconds = 0;
	}
	// Playback timeout
	DxSetPlaybackTimeoutSeconds(m_hServer, nPlaybackTimeoutSeconds);
	SetDisplayMode(PLAYBACK_DISPLAY_MODE);
}

void CPelcoDX8100Ctrl::_GetPlaybackOption() 
{
	g_bPaused = false;
	ST_PLAYBACK_OPT stPlayOption;
	memset( &stPlayOption,0,sizeof(ST_PLAYBACK_OPT) );


	stPlayOption.btChannel[m_nCameraId] = TRUE;
	
	// playback option apply only if camera selected
	if(m_nCameraSelectedMask == 0)
	{
		stPlayOption.btChannel[0] = TRUE;
	}
	//set of video Output format.
	// FORMAT_YUV16 or FORMAT_RGB24 supported now
	stPlayOption.VidForat = FORMAT_YUV16;

	stPlayOption.stStartTime = m_stLastReceivedTime;


	// Callback Function address.
	stPlayOption.lpfnPlaybackEventCallback = CPelcoDX8100Ctrl::OnSearchCallback;

	// Set playback speed
	switch(m_playbackSpeed)
	{
	case 0:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_1;	// 1X
		break;
	case 1:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_2;	// 1X
		break;
	case 2:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_4;	// 1X
		break;
	case 3:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_6;	// 1X
		break;
	default:
		stPlayOption.fPlaybackSpeed = _DXSDK_PLAYBACK_SPD_1;	// 1X
	}

	DxSearchPlaybackSetOption(m_hServer, &stPlayOption);
}


VOID CPelcoDX8100Ctrl::OnSearchCallback(HSERVER hServer, LPSEARCH_ITEM lpSearchItem)
{
	
	if( !lpSearchItem )	//End of search
	{
		TRACE("End of Search.\n");

		return;
	}
	else
	{
		LPSEARCH_ITEM lpstVidStream = lpSearchItem;
		CTime TimeStamp(lpstVidStream->stFrameItem.stVidTimeStamp);// Video Time Stamp
		m_stLastReceivedTime = lpstVidStream->stFrameItem.stVidTimeStamp;
	
		CString strTmp;
		strTmp.Format("%s-%d",TimeStamp.Format("%Y/%m/%d-%H:%M:%S"),lpstVidStream->stFrameItem.stVidTimeStamp.wMilliseconds);
        VideoPartInfo(IDC_STATIC_V_TIMESTAMP,strTmp);

		strTmp.Format("%d",lpstVidStream->nChannel+1);
		TRACE("%s,",strTmp);
        
		TRACE("%d\n",lpstVidStream->stFrameItem.uiVidBufSize );

		CPelcoDX8100Ctrl::OnImageDisplayCallback(hServer, (LPST_LIVE_VID_ITEM)lpSearchItem);
	}	


}

double CPelcoDX8100Ctrl::GetStartTime() 
{
	return m_dStartTime;
}

void CPelcoDX8100Ctrl::SetStartTime(double newValue) 
{
	m_dStartTime = newValue;
	SetModifiedFlag();
}

long CPelcoDX8100Ctrl::GetPlaybackSpeed() 
{
	return m_playbackSpeed;
}

void CPelcoDX8100Ctrl::SetPlaybackSpeed(long nNewValue) 
{
	m_playbackSpeed = nNewValue;
	SetModifiedFlag();
}

void CPelcoDX8100Ctrl::Pause() 
{
	  g_bPaused = true;
	
	::DxPlaybackCtrl(m_hServer,_DXSDK_PLAYBACK_PAUSE);
}

void CPelcoDX8100Ctrl::PlaybackPlay() 
{ 
	g_bPaused = true;

	if(g_pOverlayWnd)
		delete g_pOverlayWnd;

	_PlaybackCtrl();
	_GetPlaybackOption();

    ::DxPlaybackCtrl(m_hServer, _DXSDK_PLAYBACK_FPLAY);

	g_bPaused = false;
}

void CPelcoDX8100Ctrl::PlaybackReverse() 
{
	::DxPlaybackCtrl(m_hServer, _DXSDK_PLAYBACK_RPLAY);
	_GetPlaybackOption();
}

void CPelcoDX8100Ctrl::PlaybackForward() 
{
	::DxPlaybackCtrl(m_hServer, _DXSDK_PLAYBACK_FPLAY);
	_GetPlaybackOption();
}

void CPelcoDX8100Ctrl::PlaybackStop() 
{
	::DxPlaybackCtrl(m_hServer, _DXSDK_PLAYBACK_STOP);
	_GetPlaybackOption();
}

void CPelcoDX8100Ctrl::PlaybackFirst() 
{
	::DxPlaybackCtrl(m_hServer, _DXSDK_PLAYBACK_FIRST);
	_GetPlaybackOption();
}

void CPelcoDX8100Ctrl::PlaybackLast() 
{
	::DxPlaybackCtrl(m_hServer, _DXSDK_PLAYBACK_LAST);
	_GetPlaybackOption();
}

void CPelcoDX8100Ctrl::ViewLive() 
{

	if(g_pOverlayWnd)
		delete g_pOverlayWnd;

	g_bPaused = false;

	BeginLiveStream(m_CameraName );

}

void CPelcoDX8100Ctrl::VideoPartInfo(int id, CString strTemp)
{
    if(g_pOverlayWnd == NULL)
		return ;

    CDC* pDC = g_pOverlayWnd->GetDC();
    pDC->SetBkMode(TRANSPARENT);
    pDC->SetTextColor(RGB(0,255,127));
    g_pOverlayWnd->InvalidateRect(CRect(25, 15, 300, 30),TRUE );
    pDC->DrawText(strTemp, strlen(strTemp), CRect(25, 15, 300, 30), DT_CENTER);
	pDC = NULL;
	delete pDC;   
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// PTZ Funtionality
//

void CPelcoDX8100Ctrl::Focusin() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_FOCUS_IN | _DX_PTZ_ACT_START , 0 );
}

void CPelcoDX8100Ctrl::Focusout() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_FOCUS_OUT | _DX_PTZ_ACT_START , 0 );
}

void CPelcoDX8100Ctrl::Irisclose() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_IRIS_CLOSE | _DX_PTZ_ACT_START , 0 );
}

void CPelcoDX8100Ctrl::Irisopen() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_IRIS_OPEN | _DX_PTZ_ACT_START , 0 );
}

void CPelcoDX8100Ctrl::PrptStop() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId, _DX_PTZ_ACT_STOP , 0 );
}

void CPelcoDX8100Ctrl::Ptzdown() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_MOVE_BOTTOM | _DX_PTZ_ACT_START , GetPTZSpeed());
}

void CPelcoDX8100Ctrl::Ptzleft() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_MOVE_LEFT | _DX_PTZ_ACT_START , GetPTZSpeed());
}

void CPelcoDX8100Ctrl::Ptzright() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_MOVE_RIGHT | _DX_PTZ_ACT_START, GetPTZSpeed());
}

void CPelcoDX8100Ctrl::Ptzup() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_MOVE_TOP | _DX_PTZ_ACT_START , GetPTZSpeed());
}

void CPelcoDX8100Ctrl::PtzDL() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_MOVE_DL | _DX_PTZ_ACT_START , GetPTZSpeed());
}

void CPelcoDX8100Ctrl::PtzDR() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_MOVE_DR | _DX_PTZ_ACT_START , GetPTZSpeed());
}

void CPelcoDX8100Ctrl::PtzUL() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_MOVE_UL | _DX_PTZ_ACT_START , GetPTZSpeed());
}

void CPelcoDX8100Ctrl::PtzUR() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_MOVE_UR | _DX_PTZ_ACT_START , GetPTZSpeed());
}

void CPelcoDX8100Ctrl::Ptzstop() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_MOVE_LEFT | _DX_PTZ_ACT_STOP , GetPTZSpeed());
}


void CPelcoDX8100Ctrl::Zoomin() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_ZOOM_IN | _DX_PTZ_ACT_START , 0 );
}

void CPelcoDX8100Ctrl::Zoomout() 
{
	DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_ZOOM_OUT | _DX_PTZ_ACT_START , 0 );
}


void CPelcoDX8100Ctrl::Presetgoto() 
{
    if(m_nCameraId == -1 ) return;
	::DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_GOTO_PRESET, m_sPresetId );	
}

void CPelcoDX8100Ctrl::Presetset() 
{
    if(m_nCameraId == -1 ) return;
	::DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_SET_PRESET, m_sPresetId );
}

void CPelcoDX8100Ctrl::Presetreset() 
{
	if(m_nCameraId == -1 ) return;
	::DxPTZActCtrl(m_hServer,m_nCameraId,_DXPTZ_REMOVE_PRESET, m_sPresetId );
}

short CPelcoDX8100Ctrl::GetPresetId() 
{
	return m_sPresetId;
}

void CPelcoDX8100Ctrl::SetPresetId(short nNewValue) 
{
	m_sPresetId = nNewValue;
	SetModifiedFlag();
}

void CPelcoDX8100Ctrl::ChangePlaybackSpeed() 
{
	_GetPlaybackOption();

}

[MrViggy]

Have you run it in the debugger to see where in the code it's getting this access violation?

Viggy

[Lindley]

Well, I'm not going to try to understand all that. A few comments though....

This seems suspicious:

g_pOverlayWnd = NULL;
delete g_pOverlayWnd;

But even if you fix that, you're still dealing with raw pointers, which are error-prone. You'd be better off using smart pointers. Which compiler you have determines how easy that is, of course; anything very old and you'll have to rely on Boost for the good ones (std::auto_ptr is not recommended).

You are using memset() and memcpy() a lot. These are C functions, not designed to work with C++ objects. They'll be fine so long as your objects are plain-old-data, but if they have nontrivial constructors/destructors, virtual functions, or contain any objects with such, then you'll need to stop using them. Prefer std::fill() to memset() and std::copy() to memcpy().

You are using global variables. Occasionally useful, but always suspect, particularly in a multithreaded environment.

[lbargers]

Thanks both for the quick replies. Unfortunantley Im having to write this .ocx in VC++ 6.0 because the vendor code api is not supported on anything other than Windows XP, Server 2003. We originally tried writting it in C++ 2010 but direct draw wasn't playing nice. So we put togather an XP machine with VC++ 6.0.

How can I better handle the following?

g_pOverlayWnd = NULL;
delete g_pOverlayWnd;

I've tried numerous ways and this was the only way to get it to properly destroy the global overlay.

We have to use the globals because the API uses static callbacks to display the overlay window on top of the control.

I have used the debugger but the call stack it returns is useless, seems like the access violation is bubbling up all the way into iexplore.exe before the violation gets caught.

This entire project has been a mess since the beginning.

[Lindley]

How can I better handle the following?

g_pOverlayWnd = NULL;
delete g_pOverlayWnd;

I've tried numerous ways and this was the only way to get it to properly destroy the global overlay.

Well....you aren't destroying the overlay there. If that's the only way you could get it to not crash, then perhaps part of the overlay is corrupt?

[jnmacd]

You are calling delete on a pointer that points to NOTHING. Lindley is right, you aren't deleting anything.
Generally you call delete first, then set the pointer to NULL.


For example.. you have,

	if(g_pOverlayWnd)
		delete g_pOverlayWnd;

... you need to set the pointer to NULL after deleting.
Otherwise.. when you later on run..

if(g_pOverlayWnd && g_pOverlayWnd->yadda....)

Guess what, g_pOverlayWnd isn't null so its going to try to access its function, which will crash since you previously deleted it.

[Paul McKenzie]

We have to use the globals because the API uses static callbacks to display the overlay window on top of the control.

Actually that is not a reason to use global variables. The Windows API uses callbacks, and MFC and other wrappers have been created for Windows programmers.

A properly written OO wrapper removes the need for globals.

Regards,

Paul McKenzie

[ovidiucucu]

Just a little aside note.

   delete NULL;

simply does NOTHING.

So...

	if(g_pOverlayWnd)
		delete g_pOverlayWnd;

...is like massaging a wooden leg.