www.pudn.com > Gesture[20040824].rar > CamAvi.cpp

// CamAvi.cpp: implementation of the CCamAvi class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "stdafx.h" 
#include "Gesture.h" 
#include "CamAvi.h" 
 
#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
bool CCamAvi::Initialize (const char* filename) 
{ 
	long hr; 
	AVISTREAMINFO info; 
	//ICINFO icinfo; 
	 
	m_init = false; 
	m_pos = 0; 
	 
	AVIFileInit (); 
	 
	hr = AVIFileOpen (&m_paf, filename, OF_READ, NULL); 
	if (hr!=0) return false; 
 
	hr = AVIFileGetStream (m_paf, &m_pas, streamtypeVIDEO, 0); 
	if (hr!=0) return false; 
 
	hr = AVIStreamInfo (m_pas, &info, sizeof (info));	 
	if (hr!=0) return false; 
 
	hr = sizeof (m_bi); 
	hr = AVIStreamReadFormat (m_pas, 0, &m_bi, &hr); 
	if (hr!=0) return false;	 
	 
	if (m_bi.bmiHeader.biCompression!=0) 
	{ 
		// find decompressor 
		m_hic = ICOpen (ICTYPE_VIDEO, info.fccHandler ,ICMODE_DECOMPRESS); 
		if (m_hic==0) return false; 
	} 
	AVISTREAMINFO a; 
	AVIStreamInfo (m_pas, &a, sizeof (a)); 
	m_length = a.dwLength; 
	hr = AVIStreamBeginStreaming (m_pas, 0, 100, 1000);	 
	m_init = true; 
	 
	m_pos = AVIStreamStart (m_pas); 
	if (m_bi.bmiHeader.biCompression!=0)  
	{ 
		hr = ICDecompressGetFormat (m_hic, &m_bi, &m_bi_out); 
	} 
	else m_bi_out = m_bi; 
	m_data = new BYTE[m_bi.bmiHeader.biSizeImage]; 
 
	m_frame->Create(m_bi_out.bmiHeader.biWidth, m_bi_out.bmiHeader.biHeight, m_bi_out.bmiHeader.biBitCount); 
	return true; 
} 
 
void CCamAvi::Uninitialize () 
{ 
	m_init = false; 
 
	AVIFileRelease (m_paf); 
	delete m_data; 
	return; 
} 
 
CCamAvi::CCamAvi() 
{ 
	m_hDIB = NULL; 
	m_palDIB = NULL; 
	m_pos = 0; 
 
	m_init = false; 
	m_frame = new CImage; 
} 
 
CCamAvi::~CCamAvi () 
{ 
	if (m_data) delete m_data; 
	delete m_frame; 
} 
 
void CCamAvi::GetFrameFromAvi() 
{ 
	IplImage* img = m_frame->GetImage(); 
	BITMAPINFOHEADER *b; 
	long written, s_written; 
 
	long err = AVIStreamRead (m_pas, m_pos, 1, m_data, m_bi.bmiHeader.biSizeImage, &written, &s_written); 
	if (err!=0) return; 
 
	if (m_bi.bmiHeader.biCompression!=0)  
	{ 
		// decompress data  
		if ( m_hDIB!=NULL ) ::GlobalFree( m_hDIB ); 
		m_hDIB = (HDIB) ICImageDecompress(m_hic, 0, &m_bi, m_data, &m_bi_out); 
		b = (BITMAPINFOHEADER*)GlobalLock(m_hDIB); 
		iplConvertFromDIB(b, img);	 
		GlobalUnlock(m_hDIB); 
	} else { 
		iplConvertFromDIBSep(&m_bi.bmiHeader, (const char*) m_data, img); 
		/*m_hDIB = (HDIB)::GlobalAlloc(GMEM_FIXED,sizeof(m_bi)+m_bi.bmiHeader.biSizeImage); 
		b = (BITMAPINFOHEADER*)GlobalLock(m_hDIB); 
		b = m_bi;*/ 
	} 
	InitDIBData(); 
	//m_pos = (m_pos+1)%m_length; 
} 
 
void CCamAvi::SetReaderPosition(int pos) 
{ 
	m_pos = pos%m_length; 
} 
 
void CCamAvi::NextFrame() 
{ 
	m_pos = (m_pos+1)%m_length; 
} 
 
void CCamAvi::PrevFrame() 
{ 
	m_pos = (m_pos-1)%m_length; 
} 
 
void CCamAvi::FirstFrame() 
{ 
	m_pos = 0; 
} 
	 
void CCamAvi::LastFrame() 
{ 
	m_pos = m_length-1; 
} 
 
bool CCamAvi::IsLastFrame() 
{ 
	if ( m_pos==m_length-1 ) return true; 
	return false; 
} 
 
bool CCamAvi::IsFirstFrame() 
{ 
	if ( m_pos==0 ) return true; 
	return false; 
} 
 
void CCamAvi::InitDIBData() 
{ 
	if (m_palDIB != NULL) { 
		delete m_palDIB; 
		m_palDIB = NULL; 
	} 
 
	if (m_hDIB == NULL) 
		return; 
	// Set up document size 
	LPSTR lpDIB = (LPSTR) ::GlobalLock((HGLOBAL) m_hDIB); 
	if (::DIBWidth(lpDIB) > INT_MAX ||::DIBHeight(lpDIB) > INT_MAX) 
	{ 
		::GlobalUnlock((HGLOBAL) m_hDIB); 
		::GlobalFree((HGLOBAL) m_hDIB); 
		m_hDIB = NULL; 
		CString strMsg; 
		strMsg.LoadString(IDS_DIB_TOO_BIG); 
		MessageBox(NULL, strMsg, NULL, MB_ICONINFORMATION | MB_OK); 
		return; 
	} 
	::GlobalUnlock((HGLOBAL) m_hDIB); 
	// Create copy of palette 
	m_palDIB = new CPalette; 
	if (m_palDIB == NULL) 
	{ 
		// we must be really low on memory 
		::GlobalFree((HGLOBAL) m_hDIB); 
		m_hDIB = NULL; 
		return; 
	} 
	if (::CreateDIBPalette(m_hDIB, m_palDIB) == NULL) 
	{ 
		// DIB may not have a palette 
		delete m_palDIB; 
		m_palDIB = NULL; 
		return; 
	} 
}