vtc_zte_ztscan_enc.cpp

完整的RTP RTSP代码库

    val=-val;
    v_sign=1;
  }
    
  l=xy2wvtDecompLev(w,h);

  bitplane_encode(val-1,l,WVTDECOMP_NUMBITPLANES(color,l));
  mzte_ac_encode_symbol(&ace,acm_sign[l],v_sign);

}



/*********************************************************************/
/******************************  AC  *********************************/
/**************************  Multi quant  ****************************/
/*********************************************************************/

Void CVTCEncoder::bitplane_res_encode(Int val,Int l,Int max_bplane)
{
  register int  i,k=0;

  for(i=max_bplane-1;i>=0;i--,k++)
    mzte_ac_encode_symbol(&ace,&acm_bpres[l][k],(val>>i)&1);
}

/*********************************************************************/
/******************************  AC  *********************************/
/**************************  Multi quant  ****************************/
/*********************************************************************/


/********************************************************
  Function Name
  -------------
  Void wavelet_higher_bands_encode_MQ(Int scanDirection)

  Arguments
  ---------
  Int scanDirection - 0 <=> tree, 1 <=> band

  Description
  -----------
  Control program for encoding AC information for one 
  color component. Multi quant mode.

  Functions Called
  ----------------
  cachb_encode_MQ_band()
  mzte_ac_encoder_init()
  mzte_ac_model_init()
  mzte_ac_model_done()
  mzte_ac_encoder_done()
  initContext_ * ()
  freeContext_ * ()

  Return Value
  ------------
  None.

********************************************************/ 
Void CVTCEncoder::wavelet_higher_bands_encode_MQ(Int scanDirection)
{
  noteDetail("Encoding AC (wavelet_higher_bands_encode_MQ)....");

  /* init arithmetic coder */
  mzte_ac_encoder_init(&ace);

  if (scanDirection==0)
    cachb_encode_MQ_tree();
  else
    cachb_encode_MQ_band();

  /* close arithmetic coder */
  bit_stream_length=mzte_ac_encoder_done(&ace);
}



/********************************************************
  Function Name
  -------------
  static Void mark_ZTR_D(Int h,Int w)

  Arguments
  ---------
  Int h,Int w - position of a pixel

  
  Description
  -----------
  Mark the coefficient at (h,w) and its descendents as
  zerotree descendents. 

  Functions Called
  ----------------
  mark_ZTR_D()


  Return Value
  ------------
  None.

********************************************************/ 
Void CVTCEncoder::mark_ZTR_D(Int h,Int w)
{
  Int i,j;

  i=h<<1; j=w<<1;

  if(i<height && j<width){
    coeffinfo[i][j].type     = ZTR_D;
    coeffinfo[i+1][j].type   = ZTR_D; 
    coeffinfo[i][j+1].type   = ZTR_D; 
    coeffinfo[i+1][j+1].type = ZTR_D; 
    mark_ZTR_D(i,j);
    mark_ZTR_D(i+1,j);
    mark_ZTR_D(i,j+1);
    mark_ZTR_D(i+1,j+1);
  }
}



/**********************************************************************/
/***************       MQ BAND         ********************************/
/**********************************************************************/


/********************************************************
  Function Name
  -------------
  static Void cachb_encode_MQ_band()

  Arguments
  ---------
  None.

  Description
  -----------
  Encode AC information for all color components for spatial level. 
  Multiple quant, bandwise scan.

  Functions Called
  ----------------
  clear_ZTR_D();
  codeBlocks();
  encode_pixel_MQ()

  Return Value
  ------------
  None.

********************************************************/ 
Void CVTCEncoder::cachb_encode_MQ_band()
{
  Int h,w;
  Int ac_h,ac_w,ac_h2,ac_w2;
  Int acH,acW,acH2,acW2;
  Int layer, nCol;
  Int n; /* layer index - for codeBlocks function */
  Int k; /* block jump for the layer */
     
  /* clear the ZTR_D type from the previous pass */
  for (color=0; color<NCOL; ++color)
  {      
    coeffinfo=mzte_codec.m_SPlayer[color].coeffinfo;
    height=mzte_codec.m_SPlayer[color].height;
    width=mzte_codec.m_SPlayer[color].width;

    clear_ZTR_D(coeffinfo, width, height);
  }
  for (color=0; color<NCOL; ++color)
    probModelInitMQ(color); // hjlee 0901

  acH=mzte_codec.m_iDCHeight;
  acW=mzte_codec.m_iDCWidth;
  acH2=acH<<1;
  acW2=acW<<1;

  /* scan each coefficients in the spatial layer */
  /* assume luma dimensions are >= chroma dimensions */
  layer=0;
  while(acH2<=mzte_codec.m_SPlayer[0].height 
	&& acW2<=mzte_codec.m_SPlayer[0].width)
  {
    nCol = (layer==0) ? 1 : NCOL;
    for (color=0; color < nCol; ++color)
    {      
      SNR_IMAGE *snr_image;

      noteProgress("  Coding Layer %d, Color %d", layer - (color!=0), color);

      ac_h2=acH2;
      ac_w2=acW2;
      ac_h=acH;
      ac_w=acW;

      if (color)
      {
	ac_h2>>=1;
	ac_w2>>=1;
	ac_h>>=1;
	ac_w>>=1;
      }
    
      snr_image=&(mzte_codec.m_SPlayer[color].SNRlayer.snr_image);

      coeffinfo=mzte_codec.m_SPlayer[color].coeffinfo;
      height=mzte_codec.m_SPlayer[color].height;
      width=mzte_codec.m_SPlayer[color].width;


      setProbModelsMQ(color);      
	  
      /* Go through bands */
      n = layer - (color>0);
      k = 1<<n;
      for(h=0;h<ac_h;h+=k)
		for(w=ac_w;w<ac_w2;w+=k)
		{
		  /* LH */
		  encodeMQBlocks(h,w,n);
		  
		  /* HL */
		  h += ac_h;
		  w -= ac_w;
		  encodeMQBlocks(h,w,n);
		  
		  /* HH */
		  w += ac_w;
		  encodeMQBlocks(h,w,n);
		  
		  /* Set h back to where it started. w is already there */
		  h -= ac_h;
		}
    }

    /* update ranges */
    acH=acH2;
    acW=acW2;
    acW2<<=1;
    acH2<<=1;

    ++layer;
  }

  for (color=0; color<NCOL; ++color)
    probModelFreeMQ(color);

}




/********************************************************
  Function Name
  -------------
  static Void encode_pixel_MQ_band(Int h,Int w)

  Arguments
  ---------
  Int h,Int w - position of a pixel in height and width
  
  Description
  -----------
  Encoding the type and/or value of a coefficient, a
  recursive function, multi quant mode.

  Functions Called
  ----------------
  mzte_ac_encode_symbol()
  mark_ZTR_D()
  mag_sign_encode_MQ()
 
  Return Value
  ------------
  None.

********************************************************/ 

Void CVTCEncoder::encode_pixel_MQ(Int h,Int w)
{
  Int zt_type;

  /*~~~~~~~~~~~~~~~~~ zerotree descendent or skip  ~~~~~~~~~~~~~~~~~~~*/
  if(coeffinfo[h][w].type==ZTR_D)
    return;

  /*~~~~~~~~~~~~~~ encode zero tree symbol ~~~~~~~~~~~~~~~~~~*/
  if (IS_RESID(w,h,color))
  {
    zt_type = VAL;
  }
  else
  {
    Int czt_type; /* what to put on bitstream */
    Int l;

    l=xy2wvtDecompLev(w,h);  

    zt_type = coeffinfo[h][w].type;
#ifdef _SHAPE_
    if(coeffinfo[h][w].mask==1) /* skip out-node */  
#endif
      switch(coeffinfo[h][w].state)
      {
	case S_INIT:
	  czt_type=zt_type;
	  mzte_ac_encode_symbol(&ace,acm_type[l][CONTEXT_INIT],czt_type);
	  break;
	case S_ZTR:
	  czt_type=zt_type;
	  mzte_ac_encode_symbol(&ace,acm_type[l][CONTEXT_ZTR],czt_type);
	  break;
	case S_ZTR_D:
	  czt_type=zt_type;
	  mzte_ac_encode_symbol(&ace,acm_type[l][CONTEXT_ZTR_D],czt_type);
	  break;
	case S_IZ:
	  czt_type = (zt_type!=IZ);
	  mzte_ac_encode_symbol(&ace,acm_type[l][CONTEXT_IZ],czt_type);
	  break;
	case S_LINIT: 
	  czt_type = (zt_type!=ZTR);
	  mzte_ac_encode_symbol(&ace,acm_type[l][CONTEXT_LINIT],czt_type);
	  break;
	case S_LZTR:
	  czt_type = (zt_type!=ZTR);
	  mzte_ac_encode_symbol(&ace,acm_type[l][CONTEXT_LZTR],czt_type);
	  break;
	case S_LZTR_D:
	  czt_type = (zt_type!=ZTR);
	  mzte_ac_encode_symbol(&ace,acm_type[l][CONTEXT_LZTR_D],czt_type);
	  break;
	default:
	  errorHandler("Invalid state (%d) in multi-quant encoding.", 
		       coeffinfo[h][w].state);
      }
  }


  /*~~~~~~~~~~~~~~~~ mark ztr_d and encode magnitudes ~~~~~~~~~~~~~~~~~*/
  switch(zt_type)
  {
    case ZTR:
    case ZTR_D:
#ifdef _SHAPE_
      if(coeffinfo[h][w].mask==1) /* mark ZTR-D for in-node root */
#endif
	mark_ZTR_D(h,w);
    case IZ:
      return;
    case VZTR:
      mark_ZTR_D(h,w);
    case VAL:
#ifdef _SHAPE_
      if(coeffinfo[h][w].mask==1) /* only code for in-node*/
#endif
	mag_sign_encode_MQ(h,w);
      break;
    default:
      errorHandler("Invalid type (%d) in multi-quant encoding.", zt_type);     
  }
}



/**********************************************************************/
/***************       MQ TREE         ********************************/
/**********************************************************************/


/********************************************************
  Function Name
  -------------
  static Void cachb_encode_MQ_tree()

  Arguments
  ---------
  None.

  Description
  -----------
  Encode AC information for all color components for spatial level. 
  Multiple quant, bandwise scan.

  Functions Called
  ----------------
  clear_ZTR_D();
  encode_pixel_MQ_tree()

  Return Value
  ------------
  None.

********************************************************/ 
// hjlee 0901
Void CVTCEncoder::cachb_encode_MQ_tree()
{
  Int h,w, dc_h, dc_w;

  /* clear the ZTR_D type from the previous pass */
  for (color=0; color<NCOL; ++color)
  {      
    coeffinfo=mzte_codec.m_SPlayer[color].coeffinfo;
    height=mzte_codec.m_SPlayer[color].height;
    width=mzte_codec.m_SPlayer[color].width;

    clear_ZTR_D(coeffinfo, width, height);
  }

  for (color=0; color<NCOL; ++color)
    probModelInitMQ(color);

  /* ac_h, ac_w init */
  dc_h=mzte_codec.m_iDCHeight;
  dc_w=mzte_codec.m_iDCWidth;

  for (h=0; h<dc_h; ++h)
    for (w=0; w<dc_w; ++w)
    {
      for (color=0; color<NCOL; ++color)
      {      
	SNR_IMAGE *snr_image;
	Int tw,sw,sh,n; // 1124
	
	snr_image=&(mzte_codec.m_SPlayer[color].SNRlayer.snr_image);
	
	coeffinfo=mzte_codec.m_SPlayer[color].coeffinfo;
	height=mzte_codec.m_SPlayer[color].height;
	width=mzte_codec.m_SPlayer[color].width;
      
	setProbModelsMQ(color);

	/* LH */
	n = 0;
	for (tw=mzte_codec.m_iDCWidth; tw < width; tw<<=1)
	{
	  sh = h << n;
	  sw = (w+dc_w) << n;
	  encodeMQBlocks(sh,sw,n);
	  n++;
	}
	/* HL */
	n = 0;
	for (tw=mzte_codec.m_iDCWidth; tw < width; tw<<=1)
	{
	  sh = (h+dc_h) << n;
	  sw = w << n;
	  encodeMQBlocks(sh,sw,n);
	  n++;
	}
	/* HH */
	n = 0;
	for (tw=mzte_codec.m_iDCWidth; tw < width; tw<<=1)
	{
	  sh = (h+dc_h) << n;
	  sw = (w+dc_w) << n;
	  encodeMQBlocks(sh,sw,n);
	  n++;
	}
	
#if 0
	encode_pixel_MQ_tree(h,w+dc_w);           /* LH */
	encode_pixel_MQ_tree(h+dc_h,w);           /* HL */
	encode_pixel_MQ_tree(h+dc_h,w+dc_w);      /* HH */
#endif

      }
    }

  for (color=0; color<NCOL; ++color)
    probModelFreeMQ(color);
}


#if 0
/********************************************************
  Function Name
  -------------
  static Void encode_pixel_MQ_tree(Int h,Int w)

  Arguments
  ---------
  Int h,Int w - position of a pixel in height and width
  
  Description
  -----------
  Encoding the type and/or value of a coefficient, a
  recursive function, multi quant mode.

  Functions Called
  ----------------
  mzte_ac_encode_symbol()
  mark_ZTR_D()
  mag_sign_encode_MQ()
 
  Return Value
  ------------
  None.

********************************************************/ 
// hjlee 0901


Void CVTCEncoder::encode_pixel_MQ_tree(Int h0,Int w0)
{
  Int zt_type, h, w, k;
  Int dcc[4]; /* Don't Code Children */
  Int nSib; /* number siblings */

  nSib = (h0<(mzte_codec.m_iDCHeight<<1) && w0<(mzte_codec.m_iDCWidth<<1)) ? 1 : 4;

  /********************* CODE SIBLINGS *****************************/
  for (k=0; k<nSib; ++k)
  {
    h = h0 + (k/2);
    w = w0 + (k%2);

    /* encode zero tree symbol */  
    if (IS_RESID(w,h,color))
    {
      zt_type = VAL;