vlc.c

avs源代码

/*
*************************************************************************
* Function:Makes code word and passes it back
      A code word has the following format: 0 0 0 ... 1 Xn ...X2 X1 X0.
* Input: Info   : Xn..X2 X1 X0                                             \n
         Length : Total number of bits in the codeword
* Output:
* Return: 
* Attention:this function is called with sym->inf > (1<<(sym->len/2)). 
   The upper bits of inf are junk
*************************************************************************
*/

int symbol2uvlc(SyntaxElement *sym)
{
  int suffix_len=sym->len/2;  
  sym->bitpattern = (1<<suffix_len)|(sym->inf&((1<<suffix_len)-1));
  return 0;
}

/*
*************************************************************************
* Function:generates UVLC code and passes the codeword to the buffer
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

int writeSyntaxElement_UVLC(SyntaxElement *se, Bitstream *bitstream)
{
  if( se->golomb_maxlevels && (se->type==SE_LUM_DC_INTRA||se->type==SE_LUM_AC_INTRA||se->type==SE_LUM_DC_INTER||se->type==SE_LUM_AC_INTER) )
    return writeSyntaxElement_GOLOMB(se,bitstream);

  if(se->type == SE_REFFRAME)
  {
	  se->bitpattern = se->value1;
	  se->len = 1;
  }
  else
  {
	  se->mapping(se->value1,se->value2,&(se->len),&(se->inf));
	  symbol2uvlc(se);
  }

  writeUVLC2buffer(se, bitstream);

#if TRACE
  if(se->type <= 1)
    trace2out (se);
#endif

  return (se->len);
}

/*
*************************************************************************
* Function:passes the fixed codeword to the buffer
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/
int writeSyntaxElement_fixed(SyntaxElement *se, Bitstream *bitstream)
{  
  writeUVLC2buffer(se, bitstream);
 
#if TRACE
  if(se->type <= 1)
    trace2out (se);
#endif

  return (se->len);
}

/*
*************************************************************************
* Function:generates code and passes the codeword to the buffer
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/
int writeSyntaxElement_Intra4x4PredictionMode(SyntaxElement *se, Bitstream *bitstream)
{
  if (se->value1 == -1)
  {
    se->len = 1;
    se->inf = 1;
  }
  else 
  {
    se->len = 3;  
    se->inf = se->value1;
  }

  se->bitpattern = se->inf;
  writeUVLC2buffer(se, bitstream);

#if TRACE
  if(se->type <= 1)
    trace2out (se);
#endif

  return (se->len);
}

/*
*************************************************************************
* Function:writes UVLC code to the appropriate buffer
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

void  writeUVLC2buffer(SyntaxElement *se, Bitstream *currStream)
{
  int i;
  unsigned int mask = 1 << (se->len-1);

  // Add the new bits to the bitstream.
  // Write out a byte if it is full
  for (i=0; i<se->len; i++)
  {
    currStream->byte_buf <<= 1;
    if (se->bitpattern & mask)
      currStream->byte_buf |= 1;
    currStream->bits_to_go--;
    mask >>= 1;
    if (currStream->bits_to_go==0)
    {
      currStream->bits_to_go = 8;
      currStream->streamBuffer[currStream->byte_pos++]=currStream->byte_buf;
      currStream->byte_buf = 0;
    }
  }

}

/*
*************************************************************************
* Function:generates UVLC code and passes the codeword to the buffer
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

int writeSyntaxElement2Buf_Fixed(SyntaxElement *se, Bitstream* this_streamBuffer )
{
  writeUVLC2buffer(se, this_streamBuffer );

#if TRACE
  if(se->type <= 1)
    trace2out (se);
#endif

  return (se->len);
}

/*
*************************************************************************
* Function:Makes code word and passes it back
* Input:
		Info   : Xn..X2 X1 X0                                             \n
       Length : Total number of bits in the codeword
* Output:
* Return: 
* Attention:
*************************************************************************
*/

int symbol2vlc(SyntaxElement *sym)
{
  int info_len = sym->len;

  // Convert info into a bitpattern int
  sym->bitpattern = 0;

  // vlc coding
  while(--info_len >= 0)
  {
    sym->bitpattern <<= 1;
    sym->bitpattern |= (0x01 & (sym->inf >> info_len));
  }

  return 0;
}

/*
*************************************************************************
* Function:write VLC for Run Before Next Coefficient, VLC0
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

int writeSyntaxElement_Run(SyntaxElement *se, Bitstream *bitstream)
{
  int lentab[TOTRUN_NUM][16] = 
  {
    {1,1},
    {1,2,2},
    {2,2,2,2},
    {2,2,2,3,3},
    {2,2,3,3,3,3},
    {2,3,3,3,3,3,3},
    {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
  };

  int codtab[TOTRUN_NUM][16] = 
  {
    {1,0},
    {1,1,0},
    {3,2,1,0},
    {3,2,1,1,0},
    {3,2,3,2,1,0},
    {3,0,1,3,2,5,4},
    {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
  };
  int vlcnum;

  vlcnum = se->len;

  // se->value1 : run
  se->len = lentab[vlcnum][se->value1];
  se->inf = codtab[vlcnum][se->value1];

  if (se->len == 0)
  {
    printf("ERROR: (run) not valid: (%d)\n",se->value1);
    exit(-1);
  }

  symbol2vlc(se);

  writeUVLC2buffer(se, bitstream);

#if TRACE
  if (se->type <= 1)
    trace2out (se);
#endif

  return (se->len);
}

/*
*************************************************************************
* Function:Write out a trace string on the trace file
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

#if TRACE
void trace2out(SyntaxElement *sym)
{
  static int bitcounter = 0;
  int i, chars;

  if (p_trace != NULL)
  {
    putc('@', p_trace);
    chars = fprintf(p_trace, "%i", bitcounter);
    while(chars++ < 6)
      putc(' ',p_trace);

    chars += fprintf(p_trace, "%s", sym->tracestring);
    while(chars++ < 55)
      putc(' ',p_trace);

  // Align bitpattern
    if(sym->len<15)
    {
      for(i=0 ; i<15-sym->len ; i++)
        fputc(' ', p_trace);
    }
    
    // Print bitpattern
    bitcounter += sym->len;
    for(i=1 ; i<=sym->len ; i++)
    {
      if((sym->bitpattern >> (sym->len-i)) & 0x1)
        fputc('1', p_trace);
      else
        fputc('0', p_trace);
    }
    fprintf(p_trace, " (%3d) \n",sym->value1);
  }
  fflush (p_trace);
}
#endif

/*
*************************************************************************
* Function:puts the less than 8 bits in the byte buffer of the Bitstream into
      the streamBuffer.  
* Input:
	 currStream: the Bitstream the alignment should be established
* Output:
* Return: 
* Attention:
*************************************************************************
*/

void writeVlcByteAlign(Bitstream* currStream)
{
  if (currStream->bits_to_go < 8)
  { // trailing bits to process
    currStream->byte_buf = (currStream->byte_buf <<currStream->bits_to_go) | (0xff >> (8 - currStream->bits_to_go));
    stat->bit_use_stuffingBits[img->type]+=currStream->bits_to_go;
    currStream->streamBuffer[currStream->byte_pos++]=currStream->byte_buf;
    currStream->bits_to_go = 8;
  }
}