h265vviewoperate.cpp

ZPAV (H265) PC(X86) demo ZPAV (H265) 是 音视频 压缩解压 协议

/*
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//   Copyright (C) 2006-2008  Beijing,  pengzhen ([e-mail])   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////
*/

#ifdef __USE_THREAD__

// start the thread
void CH265VView::ViewThreadOpen(void)
{
	
    DWORD dwThreadID;
	m_ViewMilliSecond = 0; 
    m_hViewThread = ::CreateThread( NULL, 0,
		                            (LPTHREAD_START_ROUTINE)ViewThreadInitialProc, this,
		                            CREATE_SUSPENDED, &dwThreadID );
	
	if( m_hViewThread )
	{
		//::SetThreadPriority(m_hViewThread , THREAD_PRIORITY_TIME_CRITICAL);
		//::SetThreadPriority(m_hViewThread , THREAD_PRIORITY_HIGHEST);
		
		::InitializeCriticalSection( m_csViewLock ); 
	}
	
}

// stop the thread and close the handle
void CH265VView::ViewThreadClose(void)
{
	
    if (m_hViewThread) 
	{
		::SuspendThread( m_hViewThread ); 
		
		::TerminateThread( m_hViewThread,  0xffff0000+0x1f );
		
        ::CloseHandle(m_hViewThread); m_hViewThread = NULL;

		 ::DeleteCriticalSection( m_csViewLock ); 
    }
}

void CH265VView::ViewThreadInitialProc(void* pv)
{
	CH265VView * pThis = (CH265VView*)( pv ) ; 
	if( pThis ) pThis->ViewThreadProc();
}

void CH265VView::ViewThreadProc(void)
{
	
	for (;;)  
	{
		
		::WaitForSingleObject(m_hViewThread, m_ViewMilliSecond); 

		acquire_exclusive(); 
		
		ProcessSystem() ; DisplayVideo() ;
		
		release_exclusive();
		
    }
	
}

#endif //__USE_THREAD__

void CH265VView::OperateStart( BOOL bStartRecieveWnd )
{
	SetOperateItem(Start) ;
	if( bStartRecieveWnd ) SystemSendMessage( WM_USER_VIEW_START ) ;  
	StartView() 
}

void CH265VView::OperateStop( BOOL iGetShareFrames )
{
	StopView() ; 
	SetOperateItem(Stop) ;

	if( m_bSendWnd ) { m_pProcessShareData->m_iVideoFrames = m_iVideoFrames ? m_iVideoFrames-1 : 0 ; }
	SystemSendMessage( WM_USER_VIEW_STOP ) ; 
	if( m_bRecieveWnd && iGetShareFrames ) { m_iVideoFrames = m_pProcessShareData->m_iVideoFrames ; GoVideo() ; }
}

void CH265VView::OperatePrevious( BOOL iGetShareFrames )
{

	if( m_bSendWnd && ( m_dvp_Wavelets_34D ) ) return ;

	OperateStop( iGetShareFrames ) ; 
	SetOperateItem(Previous) ;
	SystemSendMessage( WM_USER_VIEW_PREVIOUS ) ;

	/* Previous */

	acquire_exclusive();
	
	m_iVideoFrames -=2 ;  
	
	if( m_iVideoFrames < 0 ) // 0 1 
	{
		if(m_device_Video) m_pVideoFile.SeekToBegin();
		m_iVideoFrames = 0 ; m_pVideo_Resource_Work  = m_pVideo_Resource ;
	}
	else 
	{
		if(m_device_Video) { m_pVideoFile.Seek( -(m_iVideo_Size<<1), CFile::current ) ; }
	    else               { m_pVideo_Resource_Work -= (m_iVideo_Resource_Size<<1) ; } 
	}
	
	ProcessSystem() ; DisplayVideo() ;

	release_exclusive();

}

void CH265VView::OperateNext( BOOL iGetShareFrames )
{

	OperateStop( iGetShareFrames ) ; 
	SetOperateItem(Next) ;
	SystemSendMessage( WM_USER_VIEW_NEXT ) ;

	/* Next */

	acquire_exclusive();
	
	ProcessSystem() ; DisplayVideo() ;

	release_exclusive();	
}

void CH265VView::OperateGo() 
{	
	
	int  thread_ctrl_flag = thread_ctrl() ; 
	
	OperateStop() ; 

	CGoDlg lpGoDlg ;
	
	lpGoDlg.m_iEditFrames      = m_iVideoFrames ;
	lpGoDlg.m_iEditTotalFrames = m_device_Video ? m_iVideoTotalFrames:m_iVideoTotalFramesResource ;
	
	if( lpGoDlg.DoModal() == IDOK )
	{
		
		/* Go */

		m_iVideoFrames = lpGoDlg.m_iEditFrames - 1 ; 
		
		SetOperateItem(Go) ;
		SystemSendMessage( WM_USER_VIEW_GO ) ;
		
		GoVideo() ;
		
	}
	else
	{
		if( thread_ctrl_flag ) OperateStart() ;
	}
}

void CH265VView::SystemExecute()
{

	if( m_bRecieveWnd ) return ;

	CString lpExeName = m_pApp->m_pExeFullName ;

	m_pProcessShareData->m_bWndStart = FALSE ;

	HINSTANCE hInst = ShellExecute(NULL, TEXT("open"),lpExeName, NULL, NULL, SW_SHOWNORMAL  ); 

	//if ((long)hInst <= 32) PRINTF(CString( TEXT("打不开 : ") )+status.m_szFullName);

	/* Waiting Recieve Windows Start */ 

	if ((long)hInst > 32)
	{
		int i = (10*1000)/40 ; 
		while( i -- ) 
		{ 
			//Sleep(40); 

			if( m_pProcessShareData->m_bWndStart ) break ;

			Sleep(40); 
		}
	}

}

void CH265VView::SystemSendMessage(WPARAM wParam, LPARAM lParam , int iStartWindowsId )
{

	if( m_bRecieveWnd ) return ;

	for( int i = m_iRecieveWindows/*m_pProcessShareData->m_iWndCount*/ ; 
	         i > iStartWindowsId/*m_iSendWindowId*/ ; i--)
	{
		HWND hWnd = m_pProcessShareData->m_hWnd[i] ;
		//HWND hWnd=::FindWindow(NULL, TEXT("H265V") ); 
		if(hWnd) ::SendMessage( hWnd,WM_USER_CTRL,wParam,lParam );
		if( wParam == WM_USER_APP_EXIT ) m_pProcessShareData->m_hWnd[i] = NULL ; 
	}

}

void CH265VView::SystemSendMessage1(WPARAM wParam, LPARAM lParam )
{
/*
	//if( m_bRecieveWnd ) return ;

	//HWND hWnd=::FindWindow(NULL, "ViewPic" );
	HWND hWnd = (m_bSendWnd) ? m_pProcessShareData->m_hReceiveWnd : 
	                           m_pProcessShareData->m_hSendWnd  ;
	if(hWnd) ::SendMessage( hWnd,WM_USER_CTRL,wParam,lParam );
*/
}

void CH265VView::SystemExecuteSendMessage( BOOL bExecute , WPARAM wParam , LPARAM lParam )
{
	if(bExecute) SystemExecute() ; 
	else SystemSendMessage( wParam , lParam ) ; 
}

void CH265VView::SystemKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{

	//if(m_bSendWnd )
	{
		switch( nChar )
		{
		case VK_LEFT : OperatePrevious() ; break ;
		case VK_UP   : OperatePrevious() ; break ;

		case VK_RIGHT : OperateNext() ; break ;
		case VK_DOWN  : OperateNext() ; break ;
		}
	}

	if( CursorIF() ) 

	{
	
		LONG *xy , *xy_c ;
		CPoint pos_c; 
		
		if( nChar == VK_LEFT || nChar == VK_RIGHT ) //left //right
		{
			xy   = &m_pMousePos.x ;
			xy_c = &pos_c.x ;
		}
		else
		{
			xy   = &m_pMousePos.y ;
			xy_c = &pos_c.y ;
		}
		
		if( *xy )
		{
			const int step =  ( nChar == VK_LEFT || nChar == VK_UP ) ? -1 : 1 ; //left //up 

			GetCursorPos(&pos_c);

			*xy   += step ;
			*xy_c += step ;
			
			SetCursorPos(pos_c.x,pos_c.y) ;
		}
		
	}
	

	if(m_bSendWnd)
	{
		if( nChar == 'p' || nChar == 'P' )
		{
			if(m_bHistogram) 
			{
				m_pProcessShareData->pixel = (BYTE)m_pImagePos.x ; 
			}
			else 
			{
				int size = m_pImagePos.x + m_pImagePos.y*m_iVideo_Width;
				m_pProcessShareData->pixel = ((BYTE*)(m_pVideo_Y))[size] ; 
			}
			SystemSendMessage( WM_USER_DRAW_PIX ) ;
		}
	}

}

LRESULT CH265VView::SystemWmUserCtrl(WPARAM wParam, LPARAM lParam )
{

	int  thread_ctrl_flag = 0 ;

	switch(wParam)
	{
		case WM_USER_APP_EXIT  : m_pApp->AppExit(); break ;
		case WM_USER_DRAW_RECT : SetDrawRect(); break ;
		case WM_USER_FILE_OPEN : OpenVideoFile(); break ; 

		case WM_USER_VIEW_START    : OperateStart(); break ; 
		case WM_USER_VIEW_STOP     : OperateStop( TRUE ); break ; 
		case WM_USER_VIEW_PREVIOUS : OperatePrevious( TRUE ) ; break ; 
		case WM_USER_VIEW_NEXT     : OperateNext( TRUE ); break ; 
		//case WM_USER_VIEW_GO       : OperateGo(); break ; 
		case WM_USER_VIEW_HISTOGRAM : m_bHistogram = (BOOL)(lParam) ; break ; 

		case WM_USER_DRAW_MV   : if( m_pProcessShareData->m_bDrawMatrix ) DrawMV() ; break ;
		case WM_USER_DRAW_PIX  : ManualSegmentationImage() ; break ;

		/* Video Manage */
		case WM_USER_VIDEO_SIZE       : SetImageSize( (CSize*)lParam ) ; break ;
		case WM_USER_VIDEO_STANDARD   : break ;
		case WM_USER_VIDEO_PORT       : break ;
		case WM_USER_VIDEO_LUMA       : break ;
		case WM_USER_VIDEO_CHROMA     : break ;
		case WM_USER_VIDEO_HUE        : break ;
		case WM_USER_VIDEO_SATURATION : break ;
		case WM_USER_VIDEO_CONTRAST   : break ;

		/* Wavelets Manage */

		case WM_USER_WAVELETS_TYPES : 
			if( m_dvp_ctx.wavelets == (unsigned int)(lParam) ) break ; 
			acquire_exclusive();  
			m_dvp_ctx.wavelets = (unsigned int)(lParam) ; 
			release_exclusive();
			break ;

		case WM_USER_WAVELETS_BANDS : 
			if( m_dvp_ctx.bands == (unsigned int)(lParam) ) break ;  
			acquire_exclusive();   
			m_dvp_ctx.bands   = (unsigned int)(lParam) ; 
			release_exclusive();
			break ;

	}

	return 0 ;
}