mbtransquant.c

用MPEG-4对YUV视频文件编码压缩成divx视频文件

		for (i = 1; i < 8; i++) {
		

			level = qcoeff[i * 8];
			S2 += abs(level);
			level -= predictors[i];
			S1 += abs(level);
			predictors[i] = level;
		}

	}

	return S2 - S1;
}



/*!
 ****************************************************************************
 * \brief
 *
 *  apply predictors[] to qcoeff 
 *
 ***************************************************************************
*/
void
apply_acdc(MACROBLOCK * pMB,		/*<-- macroblock struct */	
		   uint32_t block,			/*<-- block number in a macroblock */
		   int16_t qcoeff[64],		/*<--> in:dc diff,ac not diff
										  /out:first row or column ac diff */
		   int16_t predictors[8]	/*<--> dc not change,but ac is the diff*/
		   )
{
	uint32_t i;

	if (pMB->acpred_directions[block] == 1) {
		for (i = 1; i < 8; i++) {
			qcoeff[i] = predictors[i];
		}
	} else {
		for (i = 1; i < 8; i++) {
			qcoeff[i * 8] = predictors[i];
		}
	}
}

/*!
 ****************************************************************************
 * \brief
 *
 *	intra block dct,quant,idct,dequant,predict
 * 
 ***************************************************************************
*/
void dec(short *const data)
{
	int i;
	for (i=0; i<64; i++)
	     data[i]=data[i]-128;
}

void inc(short *const data)
{
	int i;
	for (i=0; i<64; i++)
		data[i]=data[i]+128;
}


void
MBTransQuantIntra(const MBParam * pParam,		/*<-- macroblcok param struct */
				  FRAMEINFO * frame,			/*<-- frame param struct */
				  MACROBLOCK * pMB,				/*<-- macroblock struct */
				  const uint32_t x_pos,			/*<-- macroblock row pos */
				  const uint32_t y_pos,			/*<-- macroblock column pos*/
				  int16_t data[6 * 64],			/*<-->in:orig value/out:dequant orig value */
				  int16_t qcoeff[6 * 64])		/*<--> quant predict orig value*/
{

	uint32_t stride = pParam->edged_width;
	uint32_t stride2 = stride / 2;
	uint32_t next_block = stride * 8;
	uint32_t i;
	uint32_t iQuant = frame->quant;
	uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
	IMAGE *pCurrent = &frame->image;
	uint32_t iDcScaler;
	uint32_t chrom_lumflag;
	/* whq,2002.12.19 */
	int32_t S = 0;
	/*save the predict value for a macroblock*/
	int16_t predictors[6][8];
	uint32_t mb_width = pParam->mb_width;
	/* whq */

	pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
	pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
	pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);

	start_timer();
	transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
	transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
	transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
	transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
	transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
	transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
	stop_transfer_timer();

	for (i = 0; i < 6; i++) {
		/*
		whq,2002.12.17,move iDcScaler out of the function 
		i<4 do only once,quant4_intra parameter i<4 can use the result
		*/
		/*whq,2002.12.18*/
	/*	uint32_t iDcScalerold = get_dc_scaler(iQuant, i < 4);*/
		chrom_lumflag = (i<4) ? 1:0;
		iDcScaler =chrom_lumflag?(frame->lum_dcscaler):(frame->chrom_dcscaler);
	/*	if(iDcScalerold!=iDcScaler)
			printf("old=%d,new=%d\n",iDcScalerold,iDcScaler);*/
		start_timer();
		fdct(&data[i * 64]);

		stop_dct_timer();

		start_timer();

		quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, chrom_lumflag);

		stop_quant_timer();
		
            /* whq */
		start_timer();
		dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
		stop_iquant_timer();
			
		start_timer();
		idct(&data[i * 64]);

		stop_idct_timer();

			/* whq,2002.12.19,add prediction here */
			/* add prediction after quant */	
			/*得到一行或一列的ac，dc预测值*/
		start_timer();
		predict_acdc(frame->mbs, x_pos, y_pos, mb_width, i, &qcoeff[i * 64],
						 iQuant, chrom_lumflag, predictors[i]);
		/*whq,2002.12.23,can  combine calc_acdc and apply_acdc*/
		S += calc_acdc(pMB, i, &qcoeff[i * 64], iDcScaler, predictors[i]);
		stop_prediction_timer();
		}
	/* whq,2002.12.19,prediction */
	start_timer();
	if (S < 0)				/* dont predict*/
		{
		for (i = 0; i < 6; i++) {
				pMB->acpred_directions[i] = 0;
			}
			
		}
	/*whq,2002.12.23,can be combine in the calc_acdc*/
	else {
			for (i = 0; i < 6; i++) {
				apply_acdc(pMB, i, &qcoeff[i * 64], predictors[i]);
			}
		}
	pMB->cbp = calc_cbp(qcoeff);
	stop_prediction_timer();
	/* whq */

	start_timer();
	transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
	transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
	transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
	transfer_16to8copy(pY_Cur + next_block + 8, &data[3 * 64], stride);
	transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
	transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
	stop_transfer_timer();

}

/*!
 ****************************************************************************
 * \brief
 *
 *  inter block dct,quant,idct,dequant
 *
 ***************************************************************************
*/
#ifdef  _TRIMEDIA
uint8_t											/*==> return cbp */
MBTransQuantInter(const MBParam * pParam,		/*<-- macroblcok param struct */
				  FRAMEINFO * frame,			/*<-- frame param struct */
				  MACROBLOCK * pMB,				/*<-- macroblock struct */
				  const uint32_t x_pos,			/*<-- macroblock row pos */
				  const uint32_t y_pos,			/*<-- macroblock column pos*/
				  int16_t data[384],			/*<-->in:diff value/out:dequant diff value */
				  int16_t qcoeff[384]		/*<--> quant diff value*/
				  )
{

	uint32_t stride = pParam->edged_width;
	uint32_t stride2 = stride>>1;
	uint32_t next_block = stride<<3;
	uint32_t i;
	uint32_t iQuant = frame->quant;
	uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
	uint8_t cbp = 0;
	uint32_t sum;
	IMAGE *pCurrent = &frame->image;
	uint32_t temp;
/*	
	uint32_t stride_y;
	uint32_t stride_uv;
	stride_uv = (y_pos<<3)*stride2;
	stride_y  = (stride_uv<<2) + (x_pos<<4);
	stride_uv = stride_uv + (x_pos<<3);
	pY_Cur = pCurrent->y + stride_y;
        pU_Cur = pCurrent->u + stride_uv;
        pV_Cur = pCurrent->v + stride_uv;
*/
	

	pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
	pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
	pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);



       
	for (i = 0; i < 6; i++) {
		temp = i<<6;
		
		/* 
		 *  no need to transfer 8->16-bit
		 * (this is performed already in motion compensation) 
		 */
		start_timer();
		fdct(&data[temp]);
		stop_dct_timer();

		start_timer();
		sum = quant4_inter(&qcoeff[temp], &data[temp], iQuant);
		stop_quant_timer();


		if (sum >= TOOSMALL_LIMIT) {	/*not skip block */


				start_timer();
				dequant4_inter(&data[temp], &qcoeff[temp], iQuant);
				stop_iquant_timer();

			        cbp |= 1 << (5 - i);
			        
                                
			        start_timer();
			        idct(&data[temp]);
			        stop_idct_timer();
			        
		}
	}


	start_timer();
	if (cbp & 32)
		transfer_16to8add(pY_Cur, &data[0 ], stride);
	if (cbp & 16)
		transfer_16to8add(pY_Cur + 8, &data[ 64], stride);
	if (cbp & 8)
		transfer_16to8add(pY_Cur + next_block, &data[128], stride);
	if (cbp & 4)
		transfer_16to8add(pY_Cur + next_block + 8, &data[192], stride);
	if (cbp & 2)
		transfer_16to8add(pU_Cur, &data[256], stride2);
	if (cbp & 1)
		transfer_16to8add(pV_Cur, &data[320], stride2);
	stop_transfer_timer();


	return cbp;

}
#endif

#ifndef  _TRIMEDIA
uint8_t											/*==> return cbp */
MBTransQuantInter(const MBParam * pParam,		/*<-- macroblcok param struct */
				  FRAMEINFO * frame,			/*<-- frame param struct */
				  MACROBLOCK * pMB,				/*<-- macroblock struct */
				  const uint32_t x_pos,			/*<-- macroblock row pos */
				  const uint32_t y_pos,			/*<-- macroblock column pos*/
				  int16_t data[6 * 64],			/*<-->in:diff value/out:dequant diff value */
				  int16_t qcoeff[6 * 64]		/*<--> quant diff value*/
				  )
{
	uint32_t stride = pParam->edged_width;
	uint32_t stride2 = stride / 2;
	uint32_t next_block = stride * 8;
	uint32_t i;
	uint32_t iQuant = frame->quant;
	uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
	uint8_t cbp = 0;
	uint32_t sum;
	IMAGE *pCurrent = &frame->image;

	pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
	pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
	pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);

	for (i = 0; i < 6; i++) {
	/* 
	*  no need to transfer 8->16-bit
	* (this is performed already in motion compensation) 
		*/
		start_timer();
		fdct(&data[i * 64]);
		stop_dct_timer();

		start_timer();
		sum = quant4_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
		stop_quant_timer();

		if (sum >= TOOSMALL_LIMIT) {	/*not skip block */
			start_timer();
			dequant4_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
   
			stop_iquant_timer();

			cbp |= 1 << (5 - i);
			/*cbp = calc_cbp(qcoeff);*/

			start_timer();
			idct(&data[i * 64]);
			stop_idct_timer();
		}
	}

	start_timer();
	if (cbp & 32)
		transfer_16to8add(pY_Cur, &data[0 * 64], stride);
	if (cbp & 16)
		transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
	if (cbp & 8)
		transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
	if (cbp & 4)
		transfer_16to8add(pY_Cur + next_block + 8, &data[3 * 64], stride);
	if (cbp & 2)
		transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
	if (cbp & 1)
		transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
	stop_transfer_timer();

	return cbp;
}
#endif