ztscan_dec.cpp

MPEG-4编解码的实现(包括MPEG4视音频编解码)

	  break;
	case S_ZTR_D:
	  czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_ZTR_D]);
	  coeffinfo[h][w].type=zt_type=czt_type;
	  break;
	case S_IZ:
	  czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_IZ]);
	  coeffinfo[h][w].type=zt_type = czt_type ? VAL : IZ;
	  break;
	case S_LINIT: 
	  czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_LINIT]);
	  coeffinfo[h][w].type=zt_type = czt_type ? VZTR : ZTR;
	  break;
	case S_LZTR:
	  czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_LZTR]);
	  coeffinfo[h][w].type=zt_type = czt_type ? VZTR : ZTR;
	  break;
	case S_LZTR_D:
	  czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_LZTR_D]);
	  coeffinfo[h][w].type=zt_type = czt_type ? VZTR : ZTR;
	  break;
	default:
	  errorHandler("Invalid state (%d) in multi-quant encoding.", 
		       coeffinfo[h][w].state);
      }
#ifdef _SHAPE_
    }
    else /* treat out-node as isolated zero for decoding purpose */
    {
      switch(coeffinfo[h][w].state)
      {
      case S_INIT:
      case S_ZTR:
      case S_ZTR_D:
      case S_IZ:
	zt_type = coeffinfo[h][w].type = IZ;
	break;
      case S_LINIT: 
      case S_LZTR:
      case S_LZTR_D:
	zt_type = coeffinfo[h][w].type = ZTR;
	break;
      default:
	errorHandler("Invalid state (%d) in multi-quant encoding.", 
		     coeffinfo[h][w].state);
      }
    }
#endif

  }

  /*~~~~~~~~~~~~~~~~ mark ztr_d and encode magnitudes ~~~~~~~~~~~~~~~~~*/
  switch(zt_type)
  {
    case ZTR:
#ifdef _SHAPE_
      if(coeffinfo[h][w].mask!=1)
	return;
#endif
    case ZTR_D:
      mark_ZTR_D(h,w);
    case IZ:
      coeffinfo[h][w].quantized_value=0;
      return;
    case VZTR:
      mark_ZTR_D(h,w);
    case VAL:
#ifdef _SHAPE_
      if(coeffinfo[h][w].mask==1) 
#endif
	mag_sign_decode_MQ(h,w);
      break;
    default:
      errorHandler("Invalid type in multi quant decoding.");     
  }
}



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

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

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

  Description
  -----------
  Decode AC information for one color component. 
  Multiple quant, treewise scan.

  Functions Called
  ----------------
  clear_ZTR_D();
  decode_pixel_MQ_tree()

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

********************************************************/ 
Void CVTCDecoder::cachb_decode_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;
	  decodeMQBlocks(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;
	  decodeMQBlocks(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;
	  decodeMQBlocks(sh,sw,n);
	  n++;
	}

#if 0
	decode_pixel_MQ_tree(h,w+dc_w);      /* LH */
	decode_pixel_MQ_tree(h+dc_h,w);      /* HL */
	decode_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 decode_pixel_MQ_tree(Int h,Int w)

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

  Functions Called
  ----------------
  mzte_ac_decode_symbol()
  mark_ZTR_D()
  mag_sign_decode_MQ()

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

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


Void CVTCDecoder::decode_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);

    /* decode 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=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_INIT]);
	    coeffinfo[h][w].type=zt_type=czt_type;
	    break;
	  case S_ZTR:
	    czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_ZTR]);
	    coeffinfo[h][w].type=zt_type=czt_type;
	    break;
	  case S_ZTR_D:
	    czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_ZTR_D]);
	    coeffinfo[h][w].type=zt_type=czt_type;
	    break;
	  case S_IZ:
	    czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_IZ]);
	    coeffinfo[h][w].type=zt_type = czt_type ? VAL : IZ;
	    break;
	  case S_LINIT: 
	    czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_LINIT]);
	    coeffinfo[h][w].type=zt_type = czt_type ? VZTR : ZTR;
	    break;
	  case S_LZTR:
	  czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_LZTR]);
	  coeffinfo[h][w].type=zt_type = czt_type ? VZTR : ZTR;
	  break;
	  case S_LZTR_D:
	    czt_type=mzte_ac_decode_symbol(&acd,acm_type[l][CONTEXT_LZTR_D]);
	    coeffinfo[h][w].type=zt_type = czt_type ? VZTR : ZTR;
	    break;
	default:
	  errorHandler("Invalid state (%d) in multi-quant encoding.", 
		       coeffinfo[h][w].state);
	}
#ifdef _SHAPE_
      }
      else /* treat out-node as isolated zero for decoding purpose */
      {
	switch(coeffinfo[h][w].state)
	  {
	  case S_INIT:
	  case S_ZTR:
	  case S_ZTR_D:
	  case S_IZ:
	    zt_type = coeffinfo[h][w].type = IZ;
	    break;
	  case S_LINIT: 
	  case S_LZTR:
	  case S_LZTR_D:
	    zt_type = coeffinfo[h][w].type = ZTR;
	    break;
	  default:
	    errorHandler("Invalid state (%d) in multi-quant encoding.", 
			 coeffinfo[h][w].state);
	  }
      }
#endif
      
    }
    /* mark ztr_d and decode magnitudes */
    switch(zt_type)
    {
      case ZTR:
#ifdef _SHAPE_
	if(coeffinfo[h][w].mask==1) { 
#endif
	  dcc[k]=1;
	  mark_ZTR_D(h,w); /* here it's just to zero out descendents */
#ifdef _SHAPE_
	}
	else {
	  dcc[k]=0;
	}
#endif
	coeffinfo[h][w].quantized_value=0;
	break;
      case IZ:
	dcc[k]=0;
	coeffinfo[h][w].quantized_value=0;
	break;
      case VZTR:
	dcc[k]=1;
	mark_ZTR_D(h,w); /*  here it's just to zero out descendents */
#ifdef _SHAPE_
	if(coeffinfo[h][w].mask==1) 
#endif
	mag_sign_decode_MQ(h,w);
	break;
      case VAL:
	dcc[k]=0;
#ifdef _SHAPE_
	if(coeffinfo[h][w].mask==1) 
#endif
	  mag_sign_decode_MQ(h,w);
	break;
      default:
	errorHandler("Invalid type in multi quant decoding.");     
    }
  }

  /********************* CODE CHILDREN *****************************/
  if (!IS_STATE_LEAF(coeffinfo[h0][w0].state))
  {
    Int i, j;

    for (k=0; k<nSib; ++k)
    {
      if (dcc[k]==0)
      {
	h = h0 + (k/2);
	w = w0 + (k%2);  
	
	/* scan children */
	i=h<<1; j=w<<1;
	decode_pixel_MQ_tree(i,j);
      }
    }
  }
}


#endif


/********************************************************
  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 CVTCDecoder::mark_ZTR_D(Int h,Int w)
{
  Int i,j;

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

  if(i<height && j<width)
  {
    coeffinfo[i][j].quantized_value     = 0;
    coeffinfo[i+1][j].quantized_value   = 0;
    coeffinfo[i][j+1].quantized_value   = 0;
    coeffinfo[i+1][j+1].quantized_value = 0;
    
    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);
  }
}




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

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

  Description
  -----------
  Decode the value of a coefficient.

  Functions Called
  ----------------
  mzte_ac_decode_symbol()

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

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


 
Void CVTCDecoder::mag_sign_decode_MQ(Int h,Int w)
{
  Int val,v_sign;
  Int l;

  if(coeffinfo[h][w].skip)
  {
    coeffinfo[h][w].quantized_value=0;
    return;
  }
    
  l=xy2wvtDecompLev(w,h);


  if (IS_RESID(w,h,color))
  {
    val=bitplane_res_decode(l,WVTDECOMP_RES_NUMBITPLANES(color));
    coeffinfo[h][w].quantized_value=val;
  }
  else
  {
    val=bitplane_decode(l,WVTDECOMP_NUMBITPLANES(color,l))+1;
    v_sign=mzte_ac_decode_symbol(&acd,acm_sign[l]);
    coeffinfo[h][w].quantized_value=(v_sign==0) ? val : -val;
  }

}


/*************************************************************
  Function Name
  -------------
  Void decodeSQBlocks()

  Arguments
  ---------
  Int y, Int x  - Coordinate of upper left hand corner of block.
  Int n - Number of 4 blocks in a side of the total block. 0 means do only 
   pixel at (x,y).
  Void (*pixelFunc)(Int, Int) - Function to call for pixel locations.
  
  Description
  -----------
  Call function pixelFunc(y,x) for all pixels (x,y) in block in band scan
  manner.

  Functions Called
  ----------------
  decodeBlocks recursively.

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

*************************************************************/
Void CVTCDecoder::decodeSQBlocks(Int y, Int x, Int n)
{
  /* Call the encoding function for the 4 block pixels */
  if (n == 0)
  {
    /* For checking scan-order : use 16x16 mono image
       for comparison with Figure 7-38 scan order table in 
       document.
    static Int i=4;

    noteStat("%d: y=%d, x=%d\n",i++, y,x);
    */

    decode_pixel_SQ(y,x);
  }
  else
  {
    Int k;

    --n;
    k = 1<<n;

    decodeSQBlocks(y,x,n);
    x += k;
    decodeSQBlocks(y,x,n);
    x -= k;
    y += k;
    decodeSQBlocks(y,x,n);
    x += k;
    decodeSQBlocks(y,x,n);
  }
}


/*************************************************************
  Function Name
  -------------
  Void decodeSQBlocks()

  Arguments
  ---------
  Int y, Int x  - Coordinate of upper left hand corner of block.
  Int n - Number of 4 blocks in a side of the total block. 0 means do only 
   pixel at (x,y).
  Void (*pixelFunc)(Int, Int) - Function to call for pixel locations.
  
  Description
  -----------
  Call function pixelFunc(y,x) for all pixels (x,y) in block in band scan
  manner.

  Functions Called
  ----------------
  decodeBlocks recursively.

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

*************************************************************/
Void CVTCDecoder::decodeMQBlocks(Int y, Int x, Int n)
{
  /* Call the encoding function for the 4 block pixels */
  if (n == 0)
  {
    /* For checking scan-order : use 16x16 mono image
       for comparison with Figure 7-38 scan order table in 
       document.
    static Int i=4;

    noteStat("%d: y=%d, x=%d\n",i++, y,x);
    */

    decode_pixel_MQ(y,x);
  }
  else
  {
    Int k;

    --n;
    k = 1<<n;

    decodeMQBlocks(y,x,n);
    x += k;
    decodeMQBlocks(y,x,n);
    x -= k;
    y += k;
    decodeMQBlocks(y,x,n);
    x += k;
    decodeMQBlocks(y,x,n);
  }
}