common.h

经典的MP4编解码核心库

#ifndef _COMMON_H_
#define _COMMON_H_

#include "../global.h"

/* --- macroblock coding modes --- */

#define MODE_INTER		0
#define MODE_INTER_Q	1
#define MODE_INTER4V	2
#define	MODE_INTRA		3
#define MODE_INTRA_Q	4
#define MODE_SKIP		5		/* Skipped Microblock, set after coding */
#define MODE_STUFFING	7
#define MODE_NOT_CODED	15

// MB mode for BVOP encoding		
#define MBM_B_MODE      0x07    /* Mode mask */
#define MBM_B_FWDFRM    0       /* Forward frame prediction */
#define MBM_B_BAKFRM    1       /* Backward frame prediction */
#define MBM_B_AVEFRM    2       /* Average (bidirectional) frame prediction */
#define MBM_B_DIRECT    3       /* Direct mode */
#define MBM_SKIP		4		/* MB Skipped  */
/* nothing defined */           /* Transparent */
#define MBM_B_FWDFLD    5       /* Forward field prediction */
#define MBM_B_BAKFLD    6       /* Backward field prediction */
#define MBM_B_AVEFLD    7       /* Average (bidirectional) field prediction */
#define MBM_B_REFFLDS   0xF0    /* Mask of reference file selectors */
#define MBM_B_FWDTOP    0x10    /* Fwd Top fld reference is bot if set */
#define MBM_B_FWDBOT    0x20    /* Fwd Bot fld reference is bot if set */
#define MBM_B_BAKTOP    0x40    /* Bak Top fld reference is bot if set */
#define MBM_B_BAKBOT    0x80    /* Bak Bot fld reference is bot if set */

// Macro used to indicate the functions are used
// by encoder or decoder
#define DECODE			0
#define ENCODE			1

void init_rmp4_codec(uint32_t cpu_flags);

void select_optcode_common(uint32_t cpu_flags);

void get_pmv(const MACROBLOCK * const pMBs,
			 const uint32_t x, const uint32_t y,
			 const uint32_t x_dim,
			 const uint32_t block,
			 int32_t * const pred_x, int32_t * const pred_y);

void get_pmv_dec(const Macroblock * const pMBs,
			 	 const uint32_t x, const uint32_t y,
				 const uint32_t x_dim,
				 const uint32_t block,
				 int32_t * const pred_x, int32_t * const pred_y);

void predict_acdc(MACROBLOCK *pMBs,
				uint32_t x, uint32_t y,	uint32_t mb_width, 
				uint32_t block, 
				int16_t qcoeff[64],
				uint32_t current_quant,
				int32_t iDcScaler,
				int16_t predictors[8]);

void predict_acdc_dec(Macroblock *pMBs,
				uint32_t x, uint32_t y,	uint32_t mb_width, 
				uint32_t block, 
				int16_t qcoeff[64],
				uint32_t current_quant,
				int32_t iDcScaler,
				int16_t predictors[8]);

static __inline int32_t get_dc_scaler(uint32_t quant, int32_t lum)
{
    int32_t dc_scaler;

	if(quant < 5) {
        dc_scaler = 8;
		return dc_scaler;
	}

	if(quant < 25 && !lum) {
        dc_scaler = (quant + 13) >> 1;
		return dc_scaler;
	}

	if(quant < 9) {
        dc_scaler = quant << 1;
		return dc_scaler;
	}

    if(quant < 25) {
        dc_scaler = quant + 8;
		return dc_scaler;
	}

	if(lum)
		dc_scaler = (quant << 1) - 16;
	else
        dc_scaler = quant - 6;

    return dc_scaler;
}


int get_cpu_cap(char * cpu_brand);


/* --- emms --- */

typedef void (emmsFunc)();
typedef emmsFunc* emmsFuncPtr;	

extern emmsFuncPtr emms;

emmsFunc emms_c;
emmsFunc emms_mmx;

/* --- block_zero () --- */

typedef uint32_t (block_zeroFunc)(const int16_t * const block, const uint32_t mask_sav, const uint32_t mask_var);
typedef block_zeroFunc* block_zeroFuncPtr;	

extern block_zeroFuncPtr block_zero;

block_zeroFunc block_zero_c;
block_zeroFunc block_zero_mmx;
							
/* --- fdct --- */

typedef void (fdctFunc)(short * const block);
typedef fdctFunc* fdctFuncPtr;	

extern fdctFuncPtr fdct8x8;

fdctFunc fdct8x8_int32;
fdctFunc fdct8x8_mmx;


/* --- idct --- */

void idct8x8_int32_init();

typedef void (idctFunc)(short * const block);
typedef idctFunc* idctFuncPtr;	

extern idctFuncPtr idct8x8;

idctFunc idct8x8_int32;
idctFunc idct8x8_mmx;
idctFunc idct8x8_sse;


/* --- H263/MPEG quantization --- */

// initialize fast quantization table
void quant_mpeg_intra_init(int16_t *intra_m,  int use_default);
void quant_mpeg_inter_init(int16_t *inter_m, int use_default);

//----------------------------------
// h263 quant intra 
typedef void (quant_h263_intraFunc)(int16_t * const coeff,
				const int16_t * data,
				const uint32_t quant,
				const int32_t dcscalar);
typedef quant_h263_intraFunc* quant_h263_intraFuncPtr;	

quant_h263_intraFunc quant_h263_intra_c;
quant_h263_intraFunc quant_h263_intra_mmx;

extern quant_h263_intraFuncPtr quant_h263_intra;

typedef void (dequant_h263_intraFunc)(int16_t * const data,
				const int16_t * coeff,
				const uint32_t quant,
				const int32_t dcscalar);
typedef dequant_h263_intraFunc* quant_h263_intraFuncPtr;	

dequant_h263_intraFunc dequant_h263_intra_c;
dequant_h263_intraFunc dequant_h263_intra_mmx;

extern quant_h263_intraFuncPtr dequant_h263_intra;

// quant inter
typedef uint32_t (quant_h263_interFunc)(int16_t *coeff,
				const int16_t *data,
				const uint32_t quant);
typedef quant_h263_interFunc* quant_h263_interFuncPtr;	

extern quant_h263_interFuncPtr quant_h263_inter;
quant_h263_interFunc quant_h263_inter_c;
quant_h263_interFunc quant_h263_inter_mmx;

// dequant inter
typedef void (dequant_h263_interFunc)(int16_t *const coeff,
				const int16_t *data,
				const uint32_t quant);
typedef dequant_h263_interFunc* dequant_h263_interFuncPtr;	

extern dequant_h263_interFuncPtr dequant_h263_inter;
dequant_h263_interFunc dequant_h263_inter_c;
dequant_h263_interFunc dequant_h263_inter_mmx;


// quant_mpeg/dequant_mpeg intra functions

typedef void (quant_mpeg_intraFunc)(int16_t * coeff,
				const int16_t * data,
				const uint32_t quant,
				const int32_t dcscalar);
typedef quant_mpeg_intraFunc* quant_mpeg_intraFuncPtr;	

extern quant_mpeg_intraFuncPtr quant_mpeg_intra;
quant_mpeg_intraFunc quant_mpeg_intra_c;
quant_mpeg_intraFunc quant_mpeg_intra_mmx;

extern quant_mpeg_intraFuncPtr dequant_mpeg_intra;
quant_mpeg_intraFunc dequant_mpeg_intra_c;
quant_mpeg_intraFunc dequant_mpeg_intra_mmx;

// quant_mpeg inter functions

typedef uint32_t (quant_mpeg_interFunc)(int16_t *coeff,
				const int16_t *data,
				const uint32_t quant);
typedef quant_mpeg_interFunc* quant_mpeg_interFuncPtr;

extern quant_mpeg_interFuncPtr quant_mpeg_inter;
quant_mpeg_interFunc quant_mpeg_inter_c;
quant_mpeg_interFunc quant_mpeg_inter_mmx;


// dequant_mpeg inter functions
typedef void (dequant_mpeg_interFunc)(int16_t *coeff,
				const int16_t *data,
				const uint32_t quant);
typedef dequant_mpeg_interFunc* dequant_mpeg_interFuncPtr;

extern dequant_mpeg_interFuncPtr dequant_mpeg_inter;
dequant_mpeg_interFunc dequant_mpeg_inter_c;
dequant_mpeg_interFunc dequant_mpeg_inter_mmx;

/* --- transfers --- */

// mc, copy 8bit to 16bit
typedef void (MC_COPY_8TO16)(int16_t * const dst,
					const uint8_t * const src,
					uint32_t stride);
typedef MC_COPY_8TO16* MC_COPY_8TO16_PTR;	
extern MC_COPY_8TO16_PTR mc_copy_8to16;
MC_COPY_8TO16 mc_copy_8to16_c;
MC_COPY_8TO16 mc_copy_8to16_mmx;

// transfer16to8
typedef void (MC_COPY_16TO8)(uint8_t * const dst,
					const int16_t * const src,
					uint32_t stride);
typedef MC_COPY_16TO8* MC_COPY_16TO8_PTR;	
extern MC_COPY_16TO8_PTR mc_copy_16to8;
MC_COPY_16TO8 mc_copy_16to8_c;
MC_COPY_16TO8 mc_copy_16to8_mmx;

// transfer8to16sub
typedef void (MC_SUB_8TO16)(int16_t * const dct,
				uint8_t * const cur,
				const uint8_t * ref,
				const uint32_t stride);
typedef MC_SUB_8TO16* MC_SUB_8TO16_PTR;

extern MC_SUB_8TO16_PTR mc_sub_8to16;
MC_SUB_8TO16 mc_sub_8to16_c;
MC_SUB_8TO16 mc_sub_8to16_mmx;

// mc_add_16to8
typedef void (MC_ADD_16TO8)(uint8_t * const dst,
					const int16_t * const src,
					uint32_t stride);
typedef MC_ADD_16TO8* MC_ADD_16TO8_PTR;	
extern MC_ADD_16TO8_PTR mc_add_16to8;
MC_ADD_16TO8 mc_add_16to8_c;
MC_ADD_16TO8 mc_add_16to8_mmx;

// mc_copy_8x8
typedef void (MC_COPY_8x8)(uint8_t * const dst,
					const uint8_t * const src,
					const uint32_t stride);
typedef MC_COPY_8x8* MC_COPY_8x8_PTR;	
extern MC_COPY_8x8_PTR mc_copy_8x8;
MC_COPY_8x8 mc_copy_8x8_c;
MC_COPY_8x8 mc_copy_8x8_mmx;


// Added by David, 2002
typedef void (COPY_IMAGE2BLOCK)(uint8_t * const dst,
					const uint8_t * const src,
					const uint32_t stride);
typedef COPY_IMAGE2BLOCK* COPY_IMAGE2BLOCK_PTR;	
extern COPY_IMAGE2BLOCK_PTR copy_image2block;
COPY_IMAGE2BLOCK copy_image2block_c;
COPY_IMAGE2BLOCK copy_image2block_mmx;

typedef void (COPY_BLOCK2IMAGE)(const uint8_t * const src,
					 uint8_t * const dst,
					const uint32_t stride);
typedef COPY_BLOCK2IMAGE* COPY_BLOCK2IMAGE_PTR;	
extern COPY_BLOCK2IMAGE_PTR copy_block2image;
COPY_BLOCK2IMAGE copy_block2image_c;
COPY_BLOCK2IMAGE copy_block2image_mmx;

typedef void (AVERAGE_BLOCK2IMAGE)(const uint8_t * const src,
					 uint8_t * const dst,
					const uint32_t stride);
typedef AVERAGE_BLOCK2IMAGE* AVERAGE_BLOCK2IMAGE_PTR;	
extern AVERAGE_BLOCK2IMAGE_PTR average_block2image;
AVERAGE_BLOCK2IMAGE average_block2image_c;
AVERAGE_BLOCK2IMAGE average_block2image_mmx;

typedef int (AVERAGE_SAD)(uint8_t *curr_blk, uint8_t *result, uint8_t *source1, uint8_t *source2);
typedef AVERAGE_SAD* AVERAGE_SAD_PTR;
extern AVERAGE_SAD_PTR average_sad;
AVERAGE_SAD average_sad_c;
AVERAGE_SAD average_sad_mmx;
AVERAGE_SAD average_sad_xmm;

typedef void (AVERAGE_BLOCK)(uint8_t *result, uint8_t *src1, uint8_t *src2);
typedef AVERAGE_BLOCK* AVERAGE_BLOCK_PTR;
extern AVERAGE_BLOCK_PTR average_block;
AVERAGE_BLOCK average_block_c;
AVERAGE_BLOCK average_block_mmx;

int average_sad_MB(uint8_t curr_blk[][64], uint8_t result[][64],uint8_t source1[][64], uint8_t source2[][64]);
void loadCurrMB(int i, int j, uint8_t curr_MB[][64], uint8_t *pCurrent, int stride);
//~added

#endif /* _COMMON_H_ */