dap_process.c

离散余弦变换对图象信号有近似最优的去相关能力, 但多维的变换公式一直没有给出. 为此深入研究了 三维离散余弦变换, 提出了任意尺寸的三维函数f (x , y , z ) 的正交离散余弦变换公式,

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

#include "dap_demo.h"

static Dap_Functions  m_Dap_Functions = 0 ;

static dap_ctx  m_dap_ctx  = {0} ; 
static avi_context m_write_avi = {0} ; 

static FILE *m_fp_in_a    = 0 ;
static FILE *m_file_out_a = 0 ;

#ifdef __OUT_RAW__
static FILE *m_file_out_raw_a = 0 ;
#endif /* __OUT_RAW__ */


/* WAVE */
#define RIFF_SAMPLE_RATE m_dap_ctx.sample_rate 
#define RIFF_CHANNELS  m_dap_ctx.channels 

int m_iWaveFileHeadSize =0, m_iWaveFileSize =0 ;
#include "..\wave\RIFF.c"


void Get_Dap_Functions0( int function_id )
{
	switch( function_id )
	{

	/* Compression */

	case DAP_FId_H265P_A0_Compression : 
		m_dap_ctx.codec = (FOURCC_ZPA0) ;
		m_Dap_Functions = (Dap_Functions)dap_encode_frame (&m_dap_ctx) ; 
		break ;
	case DAP_FId_H265P_A8_Compression : 
		m_dap_ctx.codec = (FOURCC_ZPA8) ;
		m_Dap_Functions = (Dap_Functions)dap_encode_frame (&m_dap_ctx) ; 
		break ;
	case DAP_FId_H265P_A9_Compression : 
		m_dap_ctx.codec = (FOURCC_ZPA9) ;
		m_Dap_Functions = (Dap_Functions)dap_encode_frame (&m_dap_ctx) ; 
		break ;

	/* Decompression */

	case DAP_FId_H265P_A0_Decompression : 
		m_dap_ctx.codec = (FOURCC_ZPA0) ;
		m_Dap_Functions = (Dap_Functions)dap_decode_frame (&m_dap_ctx) ; 
		break ;
	case DAP_FId_H265P_A8_Decompression :  
		m_dap_ctx.codec = (FOURCC_ZPA8) ;
		m_Dap_Functions = (Dap_Functions)dap_decode_frame (&m_dap_ctx) ; 
		break ;
	case DAP_FId_H265P_A9_Decompression :  
		m_dap_ctx.codec = (FOURCC_ZPA9) ;
		m_Dap_Functions = (Dap_Functions)dap_decode_frame (&m_dap_ctx) ; 
		break ;

	/* Denoise */

	case DAP_FId_Denoise :  
		m_Dap_Functions = (Dap_Functions)dap_denoise  ; 
		break ;

	}

}

static void Get_Dap_Functions( int function_id )
{
	Get_Dap_Functions0( function_id ) ;

	switch( function_id )
	{
	
	/* Compression */

	case DAP_FId_H265P_A0_Compression : 
		printf( "\n digital audio H265+ (ZPA0) compression \n" );
		break ;
	case DAP_FId_H265P_A8_Compression : 
		printf( "\n digital audio H265+ (ZPA8) compression \n" );
		break ;
	case DAP_FId_H265P_A9_Compression : 
		printf( "\n digital audio H265+ (ZPA9) compression \n" );
		break ;
	
	/* Decompression */

	case DAP_FId_H265P_A0_Decompression :
		printf( "\n digital audio H265+ (ZPA0) decopmress \n" );
		break ;
	case DAP_FId_H265P_A8_Decompression :  
		printf( "\n digital audio H265+ (ZPA8) decopmress \n" );
		break ;
	case DAP_FId_H265P_A9_Decompression :  
		printf( "\n digital audio H265+ (ZPA9) decopmress \n" );
		break ;

	/* Denoise */

	case DAP_FId_Denoise :  
		printf( "\n digital audio (sound) denoise \n" );
		break ;

	}

	printf( "\n" );
	printf( "written by [e-mail] \n\n" );

}

static void dap_init( void* dap, int function_id )
{

	dap_ctx *lp_dap_enc = (dap_ctx*)(dap) ;
	dap_ctx *lp_dap_dec = (dap_ctx*)(dap) ;

	switch( function_id )
	{
		
	default : 
		 
	// dap decoder
	lp_dap_dec->frame_number = 0 ;
	lp_dap_dec->m_handle = 0 ; 
	dap_decode_open( lp_dap_dec ) ;

		break ; 
		
	/* audio Compression */

	case DAP_FId_H265P_A0_Compression : 
	case DAP_FId_H265P_A8_Compression :  
	case DAP_FId_H265P_A9_Compression :   

	// dap encoder 
	lp_dap_enc->frame_number = 0 ;
	lp_dap_enc->m_handle = 0 ; 
	dap_encode_open( lp_dap_enc ) ;

		break ;
	}

}


static void dap_exit( void* dap, int function_id )
{

	dap_ctx* lp_dap = (dap_ctx*)( dap ) ;

	switch( function_id )
	{
		
	default : 
		 
	// dap decoder
	dap_decode_close( lp_dap ) ;

		break ; 
		
	/* audio Compression */

	case DAP_FId_H265P_A0_Compression : 
	case DAP_FId_H265P_A8_Compression :  
	case DAP_FId_H265P_A9_Compression :   

	// dap encoder 
	dap_encode_close( lp_dap ) ;

		break ;
	}
}

void write_avi_init() 
{

	avi_context * lp_write_avi = & m_write_avi ;
	dap_ctx * lp_dap_ctx = & m_dap_ctx ;  

	memset( lp_write_avi, 0x00, sizeof(avi_context) ) ;

	lp_write_avi->audio_tag = FOURCC_AUDIO ;
	//lp_write_avi->audio_tag = FOURCC_AUDIO1 ;

	lp_write_avi->audio_Handler = lp_dap_ctx->codec ; 

	lp_write_avi->sample_rate = lp_dap_ctx->sample_rate ;
	lp_write_avi->channels    = lp_dap_ctx->channels ;
	lp_write_avi->bit_rate    = lp_dap_ctx->bit_rate ;

}


static int dap_read_file( void* dap, int function_id, unsigned int frame_length )
{

	int f_flag = 0 ;

	if( Dap_Compression(function_id) ) /* Compression */ 
	{
		f_flag = fread( m_dap_ctx.sample, sizeof(char), frame_length,   m_fp_in_a) == frame_length ; 

	}
	else if( Dap_Decompression(function_id) ) /* Decompression */
	{
		f_flag = fread( & m_dap_ctx.bitstream_length , 1, sizeof(int), m_fp_in_a)  == sizeof(int) ;
		f_flag = fread( m_dap_ctx.bitstream , 1, m_dap_ctx.bitstream_length, m_fp_in_a ) == m_dap_ctx.bitstream_length ;		
	}
	
	return f_flag ;
}

static void dap_write_file( void* dap, int function_id, unsigned int frame_length )
{
	
	if( Dap_Compression(function_id) ) /* Compression */ 
	{

		write_avi_packet( &m_write_avi, m_write_avi.audio_tag, 
			              (char*)(m_dap_ctx.bitstream)-8 , m_dap_ctx.bitstream_length ) ;
		
		m_write_avi.frame_number++ ;
		m_write_avi.total_bytes += m_dap_ctx.bitstream_length ;

#ifdef __OUT_RAW__
		fwrite( & m_dap_ctx.bitstream_length , 1, sizeof(int), m_file_out_raw_a) ;
		fwrite( m_dap_ctx.bitstream , 1, m_dap_ctx.bitstream_length, m_file_out_raw_a ) ;
#endif //__OUT_RAW__

	}
	else if( Dap_Decompression(function_id) ) /* Decompression */
	{
		fwrite( m_dap_ctx.sample, sizeof(char), frame_length, m_file_out_a); 

		m_iWaveFileSize += frame_length ; 
	}

}

static void dap_process( void* dap, int function_id, int fa_flag, unsigned int frame_length )
{

	unsigned int dwTotalCycles = 0 ;
	unsigned int dwStartCycles = 0 ;

	int frames = 0 ; 

	while( fa_flag )
	{
		/* read file */
		
		fa_flag = dap_read_file( dap, function_id, frame_length ) ;

		if( !fa_flag ) break ;

		/* read cycles */ 
		
		dwStartCycles = hmpv_read_fcnt() ;
		
		/* dap function_id */ 
		
		if( m_Dap_Functions( dap ) == davp_success ) m_dap_ctx.frame_number++ ;

		/* write cycles */ 
		
		dwTotalCycles += hmpv_read_fcnt() - dwStartCycles ;
		
		/* write file */
		
		dap_write_file( dap, function_id, frame_length ) ;
		
		printf("dap tansform frames %d \r", ++frames ); 
	}

	/* report */ 
	
	dap_report ( dwTotalCycles,  frames ) ; 

}

static void dap_main(int argc,char **argv)
{	
	char *lpAudioData    = 0 ;
	char* lpAudioOutData = 0 ;

	int function_id  = 0 ;
	int frame_length = 0 ;
	int fa_flag      = 1 ;

	/* parameter */ 
	
	get_parameter( NULL , &m_dap_ctx , argc,  argv ) ; 

	/* dap function_id */

	function_id  = m_function_id ; Get_Dap_Functions( function_id ) ;

	frame_length = DAP_FRAME_SIZE*m_dap_ctx.channels*sizeof(short) ; /*1152*channels*2 __AUDIO_STEREO__ = 1152*4 */
	
	/* file open */ 
	
	m_fp_in_a    = fopen(m_in_file_name,"rb");
	if( ! m_fp_in_a ) { printf("can't open file : %s \n", m_in_file_name ); return ; }

	m_file_out_a = fopen(m_out_file_name,"wb");
	if( ! m_file_out_a ) { printf("can't open file : %s \n", m_out_file_name ); return ; }

#ifdef __OUT_RAW__
	m_file_out_raw_a = fopen(m_out_raw_file_name,"wb"); 
	//if( ! m_file_out_raw_a ) printf("can't open file : %s \n", m_out_raw_file_name );
#endif //__OUT_RAW__
		
	/* dap open */ 
	
	dap_init( &m_dap_ctx, function_id ) ;
	
	/* dap data pointor */ 
		
	lpAudioData    = (char *)M_ALLOC( frame_length*2 + 128 ) ; 
	lpAudioOutData = (char *)M_ALLOC( frame_length*2 + 128 ) ; 
	
	lpAudioData    +=  8 ; /* for write avi head */
	lpAudioOutData +=  8 ; /* for write avi head */
	
	/* dap bitstream pointor */ 

	m_dap_ctx.sample     = lpAudioData ; 
	m_dap_ctx.bitstream  = lpAudioOutData ; 

	/*write avi init */
	write_avi_init()  ;

	/* write avi header */
	
	if( Dap_Compression(function_id) ) 
	{
		write_avi_header( &m_write_avi , m_out_file_name )  ; /* Compression */ 
		/*if( m_fp_in_a )*/ fseek(m_fp_in_a, 44 , SEEK_CUR ); /* wave head size */
	}

	/* write RIFF header */

	if( Dap_Decompression(function_id) ) 
	{
		write_riff_head( m_file_out_a , 0 ) ; /* Decompression */
	}

/**
* dapprocess 
*/
	dap_process( &m_dap_ctx, function_id, fa_flag, frame_length ) ; 

	
	/* write avi trailer */
	
	if( Dap_Compression(function_id) ) 
	{
		/* bit rate */

		if( m_write_avi.frame_number )
		m_write_avi.bit_rate = (m_write_avi.total_bytes<<4)/m_write_avi.frame_number *
			                    m_write_avi.sample_rate / (DAP_FRAME_SIZE<<1) ;

		write_avi_trailer( &m_write_avi , m_out_file_name )  ; /* Compression */
	}

	/* write RIFF trailer */

	if( Dap_Decompression(function_id) ) 
		write_riff_head( m_file_out_a , m_iWaveFileSize ) ; /* Decompression */

	/* dap close */ 
	
	dap_exit( &m_dap_ctx, function_id ) ;
	
	/* dap data pointor */ 

	lpAudioData    -=  8 ; /* for write avi head */
	lpAudioOutData -=  8 ; 

	M_FREE( lpAudioData );  
	M_FREE( lpAudioOutData );  
	
	/* file close */ 
	
	if(m_fp_in_a) fclose(m_fp_in_a);
	if(m_file_out_a) fclose(m_file_out_a);
#ifdef __OUT_RAW__
	if(m_file_out_raw_a) fclose(m_file_out_raw_a);
#endif /* __OUT_RAW__ */

}