h265vview_local.h

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

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

#ifndef __H265V_VIEW_LOCAL_H__
#define __H265V_VIEW_LOCAL_H__

#pragma pack(push, 1)

/* device item context */

typedef union __device_item_context__ {
	unsigned  m_data : 8 ;
		struct {
			unsigned m_Video   : 1 ;  
			unsigned m_Audio   : 1 ;  
			unsigned m_Bt878   : 1 ;
            unsigned m_Saa7130 : 1 ; 
			unsigned m_Network : 1 ;  
		} bits ;
}device_items;

#define m_device         m_device_items.m_data
#define m_device_Video   m_device_items.bits.m_Video
#define m_device_Audio   m_device_items.bits.m_Audio
#define m_device_Bt878   m_device_items.bits.m_Bt878
#define m_device_Saa7130 m_device_items.bits.m_Saa7130
#define m_device_Network m_device_items.bits.m_Network 

#define SetdeviceItemBits(aa) { const device_items tmp = m_device_items ; m_device =0 ; \
                                 m_device_ ##aa = ((device_items*)&tmp)->bits.m_ ##aa ; }

#define SetdeviceItem(aa) m_device_ ##aa = (m_device_ ##aa == 0) ; \
                           SetdeviceItemBits(aa)



/* dvp item context */

typedef union __dvp_items__ 
{
	__int64  m_data  ;
		struct 
		{
			unsigned m_Wavelets_Analysis_2D   : 1 ;  
			unsigned m_Wavelets_Synthesis_2D  : 1 ;
			unsigned m_Wavelets_Analysis_3D   : 1 ;  
			unsigned m_Wavelets_Synthesis_3D  : 1 ;
			unsigned m_Wavelets_Analysis_4D   : 1 ;  
			unsigned m_Wavelets_Synthesis_4D  : 1 ; 

			unsigned m_Denoise   : 1 ;  
            unsigned m_Recognise : 1 ;

			unsigned m_H265P_V8_Compression : 1 ;  
			
		} bits ;
}dvp_items;

#define m_dvp                       m_dvp_items.m_data
#define m_dvp_Wavelets_Analysis_2D  m_dvp_items.bits.m_Wavelets_Analysis_2D
#define m_dvp_Wavelets_Synthesis_2D m_dvp_items.bits.m_Wavelets_Synthesis_2D
#define m_dvp_Wavelets_Analysis_3D  m_dvp_items.bits.m_Wavelets_Analysis_3D
#define m_dvp_Wavelets_Synthesis_3D m_dvp_items.bits.m_Wavelets_Synthesis_3D
#define m_dvp_Wavelets_Analysis_4D  m_dvp_items.bits.m_Wavelets_Analysis_4D
#define m_dvp_Wavelets_Synthesis_4D m_dvp_items.bits.m_Wavelets_Synthesis_4D

#define m_dvp_Denoise        m_dvp_items.bits.m_Denoise 
#define m_dvp_Recognise      m_dvp_items.bits.m_Recognise

#define m_dvp_H265P_V8_Compression m_dvp_items.bits.m_H265P_V8_Compression 

#define SetDvpItemsBits(aa) { const dvp_items tmp = m_dvp_items ; m_dvp =0 ;   \
                              m_dvp_ ##aa = ((dvp_items*)&tmp)->bits.m_ ##aa ; }

#define SetDvpItem0(aa) if( m_dvp_ ##aa ) { Get_Dvp_Functions(DVP_FID_ ##aa) ; }             \
	                    if( m_dvp_Compression )                                              \
						m_pSystemManage.m_pVideoCodecManage_Dlg->SetVideoCodec( &m_dvp_ctx ) ;

#define SetDvpItem(aa,b) m_pProcessShareData->m_iWndCount = 1 ;            \
	                     m_pProcessShareData->m_bDrawMatrix = FALSE ;      \
	                     m_bHistogram_bak = m_bHistogram ;                 \
						 m_bHistogram  = FALSE ;                           \
	                     m_dvp_ ##aa = (m_dvp_ ##aa == 0) ;                \
	                     SetDvpItemsBits(aa) ;                             \
	                     m_pText0 = ( m_dvp_ ##aa ) ? TEXT(b) : TEXT("") ; \
                         SetDvpItem0(aa)                                   \
						 m_iTotalCycles = 0 ;                              \


#define m_dvp_Trace ( m_dvp_Trace_Edge  | m_dvp_Trace_Object | m_dvp_Trace_Background )

#define m_dvp_Wavelets_34D ( m_dvp_Wavelets_Analysis_3D  | m_dvp_Wavelets_Analysis_4D | \
	                         m_dvp_Wavelets_Synthesis_3D | m_dvp_Wavelets_Synthesis_4D )

#define m_dvp_Wavelets_Analysis ( m_dvp_Wavelets_Analysis_2D | \
	                              m_dvp_Wavelets_Analysis_3D | \
	                              m_dvp_Wavelets_Analysis_4D  )

#define m_dvp_Wavelets_Synthesis ( m_dvp_Wavelets_Synthesis_2D | \
	                               m_dvp_Wavelets_Synthesis_3D | \
	                               m_dvp_Wavelets_Synthesis_4D  )

#define m_dvp_Analysis ( m_dvp_Wavelets_Analysis )

#define m_dvp_Synthesis ( m_dvp_Wavelets_Synthesis )

#define m_dvp_Analysis_Synthesis ( m_dvp_Analysis | m_dvp_Synthesis )

#define SetDvpItemsBits0(aa) m_dvp_ ##aa = ((dvp_items*)&tmp)->bits.m_ ##aa ; 

#define OnlyDvp_Analysis_Synthesis() { const dvp_items tmp = m_dvp_items ; m_dvp =0 ;                              \
                                       SetDvpItemsBits0(Wavelets_Analysis_2D); SetDvpItemsBits0(Wavelets_Synthesis_2D);  \
                                       SetDvpItemsBits0(Wavelets_Analysis_3D); SetDvpItemsBits0(Wavelets_Synthesis_3D);  \
									   SetDvpItemsBits0(Wavelets_Analysis_4D); SetDvpItemsBits0(Wavelets_Synthesis_4D); }

#define m_dvp_Compression ( m_dvp_H265P_V8_Compression )

#define ClearDvp_Compression() ( m_dvp_H265P_V8_Compression = FALSE )


/* dap item context */

typedef union __dap_items__ 
{
	__int8  m_data  ;
		struct 
		{
			
			unsigned m_H265P_A8_Compression : 1 ;  

			unsigned m_Denoise   : 1 ;

		} bits ;
}dap_items;

#define m_dap                      m_dap_items.m_data
#define m_dap_H265P_A8_Compression m_dap_items.bits.m_H265P_A8_Compression

#define m_dap_Denoise   m_dap_items.bits.m_Denoise

#define SetDapItemsBits(aa) { const dap_items tmp = m_dap_items ; m_dap = 0 ;   \
                              m_dap_ ##aa = ((dap_items*)&tmp)->bits.m_ ##aa ; }

#define SetDapItem0(aa) if( m_dap_ ##aa ) { Get_Dap_Functions(DAP_FID_ ##aa) ; }              \
	                    if( m_dap_Compression )                                               \
						m_pSystemManage.m_pAudioCodecManage_Dlg->SetAudioCodec( &m_dap_ctx ) ;

#define SetDapItem(aa,b) m_dap_ ##aa = (m_dap_ ##aa == 0) ;                \
	                     SetDapItemsBits(aa) ;                             \
	                     m_pText0 = ( m_dap_ ##aa ) ? TEXT(b) : TEXT("") ; \
                         SetDapItem0(aa)                                   \
						 m_iTotalCycles = 0 ;                              \

#define m_dap_Compression ( m_dap_H265P_A8_Compression  )

#define ClearDap_Compression() ( m_dap_H265P_A8_Compression = FALSE )


/* operate item context */

typedef union __operate_item_context__ {
	unsigned  m_data : 8 ;
		struct {
			unsigned m_Start    : 1 ;  
			unsigned m_Stop     : 1 ;
            unsigned m_Previous : 1 ; 
			unsigned m_Next     : 1 ; 
			unsigned m_Go       : 1 ; 
		} bits ;
}operate_items;

#define m_operate          m_operate_items.m_data
#define m_operate_Start    m_operate_items.bits.m_Start
#define m_operate_Stop     m_operate_items.bits.m_Stop
#define m_operate_Previous m_operate_items.bits.m_Previous
#define m_operate_Next     m_operate_items.bits.m_Next
#define m_operate_Go       m_operate_items.bits.m_Go

#define SetOperateItemBits(aa) { const operate_items tmp = m_operate_items ; m_operate =0 ; \
                                 m_operate_ ##aa = ((operate_items*)&tmp)->bits.m_ ##aa ; }

#define SetOperateItem(aa) m_operate_ ##aa = (m_operate_ ##aa == 0) ; \
                           SetOperateItemBits(aa)  



/* view item context */

typedef union __view_items__ 
{
	unsigned  m_data : 8 ;
		struct 
		{
			unsigned m_Y    : 1 ;  
			unsigned m_U    : 1 ;
            unsigned m_V    : 1 ; 
		} bits ;
}view_items ;

#define m_view   m_view_items.m_data
#define m_view_Y m_view_items.bits.m_Y
#define m_view_U m_view_items.bits.m_U
#define m_view_V m_view_items.bits.m_V

#define SetViewItemBits(aa) { const view_items tmp = m_view_items ; m_view =0 ; \
                              m_view_ ##aa = ((view_items*)&tmp)->bits.m_ ##aa ; }

#define SetViewItem(aa) m_view_ ##aa = (m_view_ ##aa == 0) &       \
                        (m_device_Video) & (m_dvp  == 0) ; \
                        SetViewItemBits(aa) ;  


#pragma pack(pop, 1)


#endif //__H265V_VIEW_LOCAL_H__