cabac.c

Mobile IP VCEG的信道模拟程序

		else
			act_ctx=5*k+2;
	}
	se->context = act_ctx;
					
    act_ctx1 = act_ctx;

    act_sym = biari_decode_symbol(dep_dp,&ctx->mv_res_contexts[0][act_ctx] );

    if (act_sym != 0)
    {
        act_ctx = 5*k+4;
  	    mv_sign = biari_decode_symbol(dep_dp, &ctx->mv_res_contexts[1][act_ctx] );
		act_ctx=5*k;
		act_sym = unary_mv_decode(dep_dp,ctx->mv_res_contexts[1]+act_ctx,3);
        act_sym++;

        if(mv_sign)
        act_sym = -act_sym;
    }
	se->value1 = act_sym;
   
#if TRACE
    fprintf(p_trace, "@%d      %s\t\t\t%d ",symbolCount++, se->tracestring, se->value1);					
    fflush(p_trace);
#endif
}


/****************************************************************************
*
* Function:        readBiDirBlkSize2Buffer_CABAC()
*
* Purpose:         This function is used to arithmetically decode the forward
*                  or backward bidirectional blocksize (for B frames only) 
*
*
***************************************************************************/
void readBiDirBlkSize2Buffer_CABAC( SyntaxElement *se,
								    struct inp_par *inp,
									struct img_par *img,
									DecodingEnvironmentPtr dep_dp)
{
	int act_ctx;
    MotionInfoContexts *ctx = img->currentSlice->mot_ctx;

    act_ctx=4;

	/* using the context models of mb_type */			
    se->value1 = unary_bin_max_decode(dep_dp,ctx->mb_type_contexts[1]+act_ctx,1,6);	

#if TRACE
    fprintf(p_trace, "@%d%s\t\t\t%d",symbolCount++, se->tracestring, se->value1);
    fflush(p_trace);
#endif
}


/****************************************************************************
*
* Function:        readMB_typeInfoFromBuffer_CABAC()
*
* Purpose:         This function is used to arithmetically decode the macroblock
*                  type info of a given MB. 
*
*
***************************************************************************/

void readMB_typeInfoFromBuffer_CABAC(   SyntaxElement *se,
								        struct inp_par *inp,
								        struct img_par *img,
						                DecodingEnvironmentPtr dep_dp)
{
	int a, b;
	int act_ctx;
	int act_sym;
	int log_sym;
    int bin_sym;
	int mode_sym;
    int ct = 0;

	MotionInfoContexts *ctx = (img->currentSlice)->mot_ctx;
	Macroblock *currMB = &img->mb_data[img->current_mb_nr];

	int curr_mb_type;
	
	if(img->type == INTRA_IMG)  // INTRA-frame 
	{			
		if (currMB->mb_available[0][1] == NULL)
			b = 0;
		else 
			b = (( (currMB->mb_available[0][1])->mb_type != 0) ? 1 : 0 );
		if (currMB->mb_available[1][0] == NULL)
			a = 0;
		else 
			a = (( (currMB->mb_available[1][0])->mb_type != 0) ? 1 : 0 );
		
		act_ctx = a + 2*b;
		act_sym = biari_decode_symbol(dep_dp, ctx->mb_type_contexts[0] + act_ctx);
		se->context = act_ctx; // store context
				
		if (act_sym==0)	// 4x4 Intra 
			curr_mb_type = act_sym;
		else // 16x16 Intra 
		{
	        act_sym = 1;
			act_ctx = 4;
			mode_sym = 	biari_decode_symbol(dep_dp, ctx->mb_type_contexts[0] + act_ctx ); /* decoding of AC/no AC */
			act_sym += mode_sym*12;
			act_ctx = 5;
			// decoding of cbp: 0,1,2 
		    mode_sym = 	biari_decode_symbol(dep_dp, ctx->mb_type_contexts[0] + act_ctx );
			if (mode_sym!=0) 
			{
			    act_ctx=6;
				mode_sym = biari_decode_symbol(dep_dp, ctx->mb_type_contexts[0] + act_ctx );
				act_sym+=4;
				if (mode_sym!=0)
				    act_sym+=4;
	        }   
		    /* decoding of I pred-mode: 0,1,2,3 */
		    act_ctx = 7;
		    mode_sym = 	biari_decode_symbol(dep_dp, ctx->mb_type_contexts[0] + act_ctx );
		    act_sym += mode_sym*2;
		    act_ctx = 8;
		    mode_sym = 	biari_decode_symbol(dep_dp, ctx->mb_type_contexts[0] + act_ctx );
		    act_sym += mode_sym;
		    curr_mb_type = act_sym;
		}
	}
	else 
	{
		ct = 1;
		if (currMB->mb_available[0][1] == NULL)
			b = 0;
		else 
			b = (( (currMB->mb_available[0][1])->mb_type != 0) ? 1 : 0 );
		if (currMB->mb_available[1][0] == NULL)
			a = 0;
		else 
			a = (( (currMB->mb_available[1][0])->mb_type != 0) ? 1 : 0 );
		
	    act_ctx = a + 2*b;	

	    // decode unary part 
		log_sym = biari_decode_symbol(dep_dp, &ctx->mb_type_contexts[1][act_ctx] );
					
		if (log_sym != 0)
		{
            act_ctx=4;
			log_sym=0;
	        do
			{					
	            act_sym = biari_decode_symbol(dep_dp, &ctx->mb_type_contexts[1][act_ctx] );
	            if (log_sym==0) act_ctx=5;
				log_sym++;
			}
			while ( (act_sym!=0) && (log_sym<2+((img->type == B_IMG_1 || img->type == B_IMG_MULT)?1:0)));
//tobias
	        if( (act_sym!=0) && (log_sym==2+((img->type == B_IMG_1 || img->type == B_IMG_MULT)?1:0))  )
  			    log_sym++;
		}
		act_sym = (1<<log_sym);


		//	decode binary part 
		if (log_sym!=0)
		{
			act_ctx=6;
			if (log_sym==(3+((img->type == B_IMG_1 || img->type == B_IMG_MULT)?1:0)) ) log_sym=2; // only 2 LSBs are actually set for mode 7-9 (P-frame) or 15-17 (B-frame)
//tobias
            bin_sym=0;
			do
			{
				log_sym--;	
				bin_sym <<=1;
				bin_sym |=  (biari_decode_symbol(dep_dp,  &ctx->mb_type_contexts[1][act_ctx] ));					
			}
			while (log_sym!=0);
			    act_sym += bin_sym;
		}
		act_sym--;

		if (act_sym<=8 || (((img->type == B_IMG_1 || img->type == B_IMG_MULT)?1:0) && act_sym<=16))
			curr_mb_type = act_sym;
		else	// additional info for 16x16 Intra-mode 
		{
			act_ctx = 7;
			mode_sym = 	biari_decode_symbol(dep_dp, ctx->mb_type_contexts[1] + act_ctx ); // decoding of AC/no AC 
//			act_sym = 9+mode_sym*12;
			act_sym += mode_sym*12;
					
			// decoding of cbp: 0,1,2 
			act_ctx = 8;
			mode_sym = biari_decode_symbol(dep_dp, ctx->mb_type_contexts[1] + act_ctx ); 
			if (mode_sym != 0)
			{
				act_sym+=4;
				mode_sym = biari_decode_symbol(dep_dp, ctx->mb_type_contexts[1] + act_ctx ); 
				if (mode_sym != 0)
					act_sym+=4;
			}

			// decoding of I pred-mode: 0,1,2,3 
			act_ctx = 9;									
			mode_sym = biari_decode_symbol(dep_dp, ctx->mb_type_contexts[1] + act_ctx );
			act_sym += mode_sym*2;
			mode_sym = biari_decode_symbol(dep_dp, ctx->mb_type_contexts[1] + act_ctx );
			act_sym += mode_sym;
			curr_mb_type = act_sym;
		}				
	}
    se->value1 = curr_mb_type;

#if TRACE
    fprintf(p_trace, "@%d%s\t\t\t%d",symbolCount++, se->tracestring, se->value1);				
    fflush(p_trace);
#endif
}
/****************************************************************************
*
* Function:        readIntraPredModeFromBuffer_CABAC()
*
* Purpose:         This function is used to arithmetically decode a pair of 
*                  intra prediction modes of a given MB. 
*
*
***************************************************************************/
void readIntraPredModeFromBuffer_CABAC( SyntaxElement *se,
									    struct inp_par *inp,
										struct img_par *img,		
										DecodingEnvironmentPtr dep_dp)
{
	static int prev_sym = 0;
	static int count = 0; /* to detect a new row of intra prediction modes */

	TextureInfoContexts *ctx = img->currentSlice->tex_ctx;

	if (count % 2 == 0)
		prev_sym = 0;

    se->value1 = unary_bin_max_decode(dep_dp,ctx->ipr_contexts[prev_sym],1,5);	
	prev_sym = se->value1;
    se->value2 = unary_bin_max_decode(dep_dp,ctx->ipr_contexts[prev_sym],1,5);
	prev_sym = se->value2;


	if(++count == MB_BLOCK_SIZE/2) /* all modes of one MB have been processed */
		count=0;

#if TRACE
    fprintf(p_trace, "@%d%s\t\t\t%d\n",symbolCount++, se->tracestring, se->value1);
    fflush(p_trace);
#endif

}

/****************************************************************************
*
* Function:        readRefFrameFromBuffer_CABAC()
*
* Purpose:         This function is used to arithmetically decode the reference 
*                  parameter of a given MB. 
*
*
***************************************************************************/
void readRefFrameFromBuffer_CABAC(  SyntaxElement *se,
								    struct inp_par *inp,
									struct img_par *img,		
									DecodingEnvironmentPtr dep_dp)
{
	MotionInfoContexts *ctx = img->currentSlice->mot_ctx;
	Macroblock *currMB = &img->mb_data[img->current_mb_nr];
 
	int a, b;
	int act_ctx;
	int act_sym;
	
	if (currMB->mb_available[0][1] == NULL)
		b = 0;
	else 
		  //b = ( ((currMB->mb_available[0][1])->ref_frame != 0) ? 1 : 0);
    	b = ( ((currMB->mb_available[0][1])->predframe_no != 0) ? 1 : 0);
	if (currMB->mb_available[1][0] == NULL)
		a = 0;
	else 
		  //a = ( ((currMB->mb_available[1][0])->ref_frame != 0) ? 1 : 0);
		  a = ( ((currMB->mb_available[1][0])->predframe_no != 0) ? 1 : 0);	
	act_ctx = a + 2*b;
	se->context = act_ctx; // store context
	
    act_sym = biari_decode_symbol(dep_dp,ctx->ref_no_contexts + act_ctx );

    if (act_sym != 0)
    {
        act_ctx = 4;
        act_sym = unary_bin_decode(dep_dp,ctx->ref_no_contexts+act_ctx,1);
        act_sym++;
    }
	se->value1 = act_sym;
   
#if TRACE
    fprintf(p_trace, "@%d%s\t\t\t%d",symbolCount++, se->tracestring, se->value1);
    fprintf(p_trace," c: %d :%d \n",ctx->ref_no_contexts[act_ctx].cum_freq[0],ctx->ref_no_contexts[act_ctx].cum_freq[1]);
    fflush(p_trace);
#endif
}
/****************************************************************************
*
* Function:        readMVDFromBuffer_CABAC()
*
* Purpose:         This function is used to arithmetically decode the motion
*                  vector data of a given MB. 
*
*
***************************************************************************/
void readMVDFromBuffer_CABAC(SyntaxElement *se,
							 struct inp_par *inp,
							 struct img_par *img,
							 DecodingEnvironmentPtr dep_dp)
{
	int step_h, step_v;
	int i = img->subblock_x;
	int j = img->subblock_y;
	int a, b;
	int act_ctx;
	int act_sym;
	int mv_pred_res;
	int mv_local_err;
	int mv_sign;
	int k = se->value2; /* MVD component */
	
	MotionInfoContexts *ctx = img->currentSlice->mot_ctx;
	Macroblock *currMB = &img->mb_data[img->current_mb_nr];
	//	int curr_mb_type = currMB->mb_type;
	

	step_h=BLOCK_STEP[img->mb_mode][0];     
	step_v=BLOCK_STEP[img->mb_mode][1];     
	
	if (j==0)
	{
		if (currMB->mb_available[0][1] == NULL)
			b = 0;
		else 
			b = absm((currMB->mb_available[0][1])->mvd[0][BLOCK_SIZE-1][i][k]);
	}
	else
		b = absm(currMB->mvd[0][j-step_v][i][k]);
					
	if (i==0)
	{
		if (currMB->mb_available[1][0] == NULL)
			a = 0;
		else 
			a = absm((currMB->mb_available[1][0])->mvd[0][j][BLOCK_SIZE-1][k]);
	}
	else
		a = absm(currMB->mvd[0][j][i-step_h][k]);
					
	if ((mv_local_err=a+b)<3)
		act_ctx = 5*k; 
	else
	{
		if (mv_local_err>32)
			act_ctx=5*k+3;
		else
			act_ctx=5*k+2;
	}
    se->context = act_ctx;

    act_sym = biari_decode_symbol(dep_dp, &ctx->mv_res_contexts[0][act_ctx] ); 
    
    if (act_sym == 0) 
        mv_pred_res = 0;
    else
    { 
        act_ctx=5*k+4;
        mv_sign = biari_decode_symbol(dep_dp,&ctx->mv_res_contexts[1][act_ctx] );
       
        act_ctx=5*k;
        act_sym = unary_mv_decode(dep_dp,ctx->mv_res_contexts[1]+act_ctx,3);
        act_sym++;
        mv_pred_res = ((mv_sign != 0) ? (-act_sym) : act_sym);
    }
    se->value1 = mv_pred_res;
    
#if TRACE
    fprintf(p_trace, "@%d%s\t\t\t%d\n",symbolCount++, se->tracestring, se->value1);
    fflush(p_trace);
#endif
}
/****************************************************************************
*
* Function:        readCBPFromBuffer_CABAC()
*
* Purpose:         This function is used to arithmetically decode the coded 
*                  block pattern of a given MB. 
*