vtc_shape_shapeenhencode.cpp

完整的RTP RTSP代码库

 * Author :		
 *	Dae-Sung Cho (Samsung AIT)
 *
 * Created :		
 *	09-Feb-98
 * 
 * Arguments: 	
 *
 *
 * Return values :	
 *
 * Side effects :	
 *	-
 *
 * Description :	A binary alpha block will be coded using bac.
 *			These bits are added to the <shape_stream>. 
 *
 * See also :
 *
 ***********************************************************CommentEnd********/

Int	CVTCEncoder::
ShapeEnhContentEncode(UChar *bordered_lower_bab, 
		      UChar *bordered_half_bab, 
		      UChar *bordered_curr_bab, 
			Int bab_type, 
			Int scan_order, // SAIT_PDAM: ADDED by D.-S.Cho (Samsung AIT) 
			Int mbsize,
				FILTER *filter,
			BSS *bitstream,	
			ArCoder *ar_coder)
{
	if (bab_type==0) 		/* Interleaved Scan-Line (ISL) coding */
	{  
	      ExclusiveORencoding (bordered_lower_bab,
				   bordered_half_bab,
				   bordered_curr_bab,
				   mbsize,
				   scan_order, // SAIT_PDAM: ADDED by D.-S.Cho (Samsung AIT) 
				   bitstream,
				   ar_coder);

	} else if(bab_type ==1)		/* Raster Scan-Line (RSL) coding */
	{	

	  FullEncoding (bordered_lower_bab,
			    bordered_half_bab,
			    bordered_curr_bab,
				mbsize,
			        filter,
				bitstream,
				ar_coder);
	} else 
	{
	      fprintf(stderr,"BAB type[%d] ERROR in Enhancement layer coding!\n", bab_type);
	}

        return 0;
}
	     
Void CVTCEncoder::
ExclusiveORencoding (UChar *bordered_lower_bab,
		     UChar *bordered_half_bab,
		     UChar *bordered_curr_bab,
		     Int mbsize,
			 Int scan_order, // SAIT_PDAM: ADDED by D.-S.Cho (Samsung AIT) 
		     BSS *bitstream, 
		     ArCoder *ar_coder)
{
	Int             i2,j2,k,curr,prev,next;
	Int				i,j;	// SAIT_PDAM: ADDED by D.-S.Cho (Samsung AIT) 
	Int             mborder = MBORDER;
	Int             mbsize_ext = mbsize+(mborder<<1);
	Int             border = BORDER;
	Int             bsize = mbsize >> 1;
	Int             bsize_ext = bsize+(border<<1);
	Int             context = 0, prob=0;
	Int		start_bit, end_bit, bitnum=0;
	UChar           *lower_bab_data,
                        *curr_bab_data;
	UChar			*curr_bab_data_tr = NULL;	// SAIT_PDAM: ADDED by D.-S.Cho (Samsung AIT) 

        lower_bab_data = bordered_lower_bab + border * bsize_ext + border;
		// SAIT_PDAM: BEGIN - ADDED by D.-S.Cho (Samsung AIT) 
		if (scan_order == 1) {
			curr_bab_data_tr = (UChar *)calloc(mbsize_ext*mbsize_ext, sizeof(UChar));
			for(j=0; j<mbsize_ext; j++)
				for(i=0; i<mbsize_ext; i++)
					curr_bab_data_tr[j*mbsize_ext+i]=bordered_curr_bab[i*mbsize_ext+j];
			curr_bab_data = curr_bab_data_tr + mborder * mbsize_ext + mborder;
		} else
		// SAIT_PDAM: END - ADDED by D.-S.Cho (Samsung AIT) 
        curr_bab_data= bordered_curr_bab + mborder * mbsize_ext + mborder;

	start_bit = bitstream->cnt;


	/*-- P1 pixels encoding --*/
	// SAIT_PDAM BEGIN - MODIFIED by D.-S.Cho (Samsung AIT) 
	//for(j2=k=0; j2<mbsize; j2+=2, k+=(mbsize_ext<<1) )
    //    {
	//   for(i2=1; i2<mbsize; i2+=2)
	//   {
	   for(i2=1; i2<mbsize; i2+=2)
	   {
	for(j2=k=0; j2<mbsize; j2+=2, k+=(mbsize_ext<<1) )
        {
	// SAIT_PDAM END - MODIFIED by D.-S.Cho (Samsung AIT) 
		curr= curr_bab_data[k+i2];
		prev= curr_bab_data[k+i2-1];
		next= curr_bab_data[k+i2+1];
                       
		if(prev!=next) 
		{
		   context = GetContextEnhBAB_XOR(curr_bab_data,
					i2, 
					j2, 
					mbsize_ext, 
					0); /* pixel type : 0-P1, 1-P2/P3 */

		   prob=scalable_xor_prob_1[context];
		   ArCodeSymbol_Still(ar_coder, bitstream, curr, prob);

		} 
		else 
		{
		   if(prev!=curr)
		   {
			fprintf(stderr, "Error: BAB coding mode mismatch in XOR coding : P1!\n");
			fprintf(stderr, "Error: P1[%d,%d,%d]!\n",prev,curr,next);
			fprintf(stderr,"1, j2=%d i2=%d prev=%d curr=%d next=%d context=%d bits=%d\n", 
				j2, i2, prev, curr, next, context, bitstream->cnt);
			exit(0);
		   }
		}
	   }
	}

	/*-- P2/P3 pixel coding --*/
        for(j2=1,k=mbsize_ext; j2<mbsize; j2+=2, k+=(mbsize_ext<<1) )
        {
	   for(i2=0; i2<mbsize; i2++)
	   {
		curr= curr_bab_data[k+i2];
		prev= curr_bab_data[k-mbsize_ext+i2];	
		next= curr_bab_data[k+mbsize_ext+i2];	

		if(prev!=next) 
		{
		   context = GetContextEnhBAB_XOR(curr_bab_data,
					i2, 
					j2, 
					mbsize_ext, 
					1);	/* pixel type : 0-P1, 1-P2/P3 */

		   prob=scalable_xor_prob_23[context];
		   ArCodeSymbol_Still(ar_coder, bitstream, curr, prob);
		} 
		else 
		{
		   if(prev!=curr)
		   {
			fprintf(stderr, "Error: BAB coding mode mismatch in XOR coding : P2, P3!\n");
			exit(0);
		   }
		}
	   }
	}

	if(scan_order==1) free(curr_bab_data_tr); // SAIT_PDAM: ADDED by D.-S.Cho (Samsung AIT) 
	end_bit = bitstream->cnt;
	bitnum = end_bit - start_bit;

}

/* Modified by shson */
Void CVTCEncoder::
FullEncoding (UChar *bordered_lower_bab,
	      UChar *bordered_half_bab,
	      UChar *bordered_curr_bab,
	      Int mbsize,
				FILTER *filter,
			BSS *bitstream, 
			ArCoder *ar_coder)
{
	Int		i,j,i2,j2,k,l,curr;

	Int		mborder = MBORDER;
	Int		mbsize_ext = mbsize+(mborder<<1);
	Int		border = BORDER;
	Int		bsize = mbsize >> 1;
	Int		bsize_ext = bsize+(border<<1);
//	Int		not_coded, low_value;
	Int		context, prob=0;
	Int		start_bit, end_bit, bitnum=0;

	UChar		*lower_bab_data,
	  *half_bab_data,			
	  *curr_bab_data;

	lower_bab_data = bordered_lower_bab + border * bsize_ext + border;
	half_bab_data= bordered_half_bab + mborder * bsize_ext + border;
	curr_bab_data= bordered_curr_bab + mborder * mbsize_ext + mborder;

	start_bit = bitstream->cnt;
	/* vertical pass first for half-higher layer encoding*/

	for(j2=k=0; j2<mbsize; j2+=2, k+=2*bsize_ext)
	{
	   for(i=0; i<bsize; i++)
	   {
	     j = j2>>1;
	     l = j*bsize_ext;

	     /* T1 */
	     curr = half_bab_data[k+i];
	     context =  (half_bab_data[k-bsize_ext+i]<<7) /* T9*/
	       | ( half_bab_data[k-bsize_ext+i+1] <<6) /* T8 */
	       | (half_bab_data[k+bsize_ext+i-1] <<5) /* T7 */
	       | (half_bab_data[k+i-1] <<4) /* T6 */
	       | (lower_bab_data[l+i] <<3) /* T5 */
	       | (lower_bab_data[l+i+1] <<2) /* T4 */
	       | (lower_bab_data[l+bsize_ext+i] <<1) /* T3 */
	       | (lower_bab_data[l+bsize_ext+i+1]); /* T2 */

	     if(filter->DWT_Class==DWT_ODD_SYMMETRIC){
	       prob=prob_odd0[context];
	     } else if(filter->DWT_Class==DWT_EVEN_SYMMETRIC) {
	       prob=prob_even0[context];
	     } else {
	       fprintf(stderr,"Error: filter type in FullEncoding() !\n");
	       exit(0);
	     }
	     ArCodeSymbol_Still(ar_coder, bitstream, curr, prob);

	       /* T0 */
	     curr = half_bab_data[k+bsize_ext+i];
	     context =  (half_bab_data[k+i]<<7) /* T1*/
	       | ( lower_bab_data[l+bsize_ext+i-1] <<6) /* T10 */
	       | (half_bab_data[k+bsize_ext+i-1] <<5) /* T7 */
	       | (half_bab_data[k+i-1] <<4) /* T6 */
	       | (lower_bab_data[l+i] <<3) /* T5 */
	       | (lower_bab_data[l+i+1] <<2) /* T4 */
	       | (lower_bab_data[l+bsize_ext+i] <<1) /* T3 */
	       | (lower_bab_data[l+bsize_ext+i+1]); /* T2 */

	     if(filter->DWT_Class==DWT_ODD_SYMMETRIC){
	       prob=prob_odd1[context];
	     } else if(filter->DWT_Class==DWT_EVEN_SYMMETRIC) {
	       prob=prob_even1[context];
	     } else {
	       fprintf(stderr,"Error: filter type in FullEncoding() !\n");
	       exit(0);
	     }
	     ArCodeSymbol_Still(ar_coder, bitstream, curr, prob);
	   }
	}

	/* horizontal */
	for(i2=0; i2<mbsize; i2+=2)
	  {
	    for(j=k=0; j<mbsize; j++, k+=mbsize_ext)
	      {
	   
		i = i2>>1;
		l = j*bsize_ext;
		/* T1 */
		curr = curr_bab_data[k+i2];
		context =  (curr_bab_data[k+i2-1]<<7) /* T9*/
		  | ( curr_bab_data[k+mbsize_ext+i2-1] <<6) /* T8 */
		  | (curr_bab_data[k-mbsize_ext+i2+1] <<5) /* T7 */
		  | (curr_bab_data[k-mbsize_ext+i2] <<4) /* T6 */
		  | (half_bab_data[l+i] <<3) /* T5 */
		  | (half_bab_data[l+bsize_ext+i] <<2) /* T4 */
		  | (half_bab_data[l+i+1] <<1) /* T3 */
		  | (half_bab_data[l+bsize_ext+i+1]); /* T2 */

		if(filter->DWT_Class==DWT_ODD_SYMMETRIC){
		  prob=prob_odd0[context];
		} else if(filter->DWT_Class==DWT_EVEN_SYMMETRIC) {
		  prob=prob_even0[context];
		} else {
		  fprintf(stderr,"Error: filter type in FullEncoding() !\n");
		  exit(0);
		}
		ArCodeSymbol_Still(ar_coder, bitstream, curr, prob);
		/* T0 */
		curr = curr_bab_data[k+i2+1];
		context =  (curr_bab_data[k+i2]<<7) /* T1*/
		  | ( half_bab_data[l-bsize_ext+i+1] <<6) /* T10 */
		  | (curr_bab_data[k-mbsize_ext+i2+1] <<5) /* T7 */
		  | (curr_bab_data[k-mbsize_ext+i2] <<4) /* T6 */
		  | (half_bab_data[l+i] <<3) /* T5 */
		  | (half_bab_data[l+bsize_ext+i] <<2) /* T4 */
		  | (half_bab_data[l+i+1] <<1) /* T3 */
		  | (half_bab_data[l+bsize_ext+i+1]); /* T2 */

		if(filter->DWT_Class==DWT_ODD_SYMMETRIC){
		  prob=prob_odd1[context];
		} else if(filter->DWT_Class==DWT_EVEN_SYMMETRIC) {
		  prob=prob_even1[context];
		} else {
		  fprintf(stderr,"Error: filter type in FullEncoding() !\n");
		  exit(0);
		}
		ArCodeSymbol_Still(ar_coder, bitstream, curr, prob);
	      }
	  }

	end_bit = bitstream->cnt;
	bitnum = end_bit - start_bit;

}

/*********************************************************************************
 *
 *      Bitstream Manipulation  
 *
*********************************************************************************/
/* Merge Shape Bitstream into main bit stream */
Void CVTCEncoder::
MergeEnhShapeBitstream()
{
  if(ShapeBitstream==NULL) {
    fprintf(stderr,"EnhShapeBitStream Not Available\n");
    exit(1);
  }
  InitBitstream(0,ShapeBitstream);
  BitStreamMerge(ShapeBitstreamLength, ShapeBitstream);
 
  free(ShapeBitstream->bs);
  free(ShapeBitstream);
  ShapeBitstream = NULL;
}