vlc.c

来自「此code含H.264解码需要的 lib和 src」· C语言 代码 · 共 1,387 行 · 第 1/3 页

//    return -1;
//
//  // make infoword
//  inf = 0;                          // shortest possible code is 1, then info is always 0    
//
//  while (len--)
//  {
//    bitcounter++;
//    bitoffset --;
//    bitoffset &= 0x07;
//    cur_byte  += (bitoffset == 7);
//    inf <<= 1;
//    inf |= ((*cur_byte)>> (bitoffset)) & 0x01;
//  }
//
//  *info = inf;
//  return bitcounter;           // return absolute offset in bit from start of frame
//}


/*!
 ************************************************************************
 * \brief
 *    test if bit buffer contains only stop bit
 *
 * \param buffer
 *    buffer containing VLC-coded data bits
 * \param totbitoffset
 *    bit offset from start of partition
 * \param bytecount
 *    buffer length
 * \return
 *    true if more bits available
 ************************************************************************
 */
int more_rbsp_data (byte buffer[],int totbitoffset,int bytecount)
{
  int bitoffset   = (7 - (totbitoffset & 0x07));      // bit from start of byte
  long byteoffset = (totbitoffset >> 3);      // byte from start of buffer
  byte *cur_byte  = &(buffer[byteoffset]);
  int ctr_bit     = 0;      // control bit for current bit posision
  int cnt         = 0;

  assert (byteoffset<bytecount);

  // there is more until we're in the last byte
  if (byteoffset < (bytecount - 1)) return TRUE;

  // read one bit
  ctr_bit = ((*cur_byte)>> (bitoffset--)) & 0x01;

  // a stop bit has to be one
  if (ctr_bit==0) return TRUE;  

  while (bitoffset>=0 && !cnt)
  {
    cnt |= ((*cur_byte)>> (bitoffset--)) & 0x01;   // set up control bit
  }

  return (cnt);
}


/*!
 ************************************************************************
 * \brief
 *    Check if there are symbols for the next MB
 ************************************************************************
 */
//int uvlc_startcode_follows(struct img_par *img, int dummy)
//{
//  int dp_Nr = assignSE2partition[img->currentSlice->dp_mode][SE_MBTYPE];
//  DataPartition *dP = &(img->currentSlice->partArr[dp_Nr]);
//  Bitstream   *currStream = dP->bitstream;
//  byte *buf  = currStream->streamBuffer;
//
//  //KS: new function test for End of Buffer
//  return (!(more_rbsp_data(buf, currStream->frame_bitoffset,currStream->bitstream_length)));
//}



/*!
 ************************************************************************
 * \brief
 *  read one exp-golomb VLC symbol
 *
 * \param buffer
 *    containing VLC-coded data bits
 * \param totbitoffset
 *    bit offset from start of partition
 * \param  info
 *    returns the value of the symbol
 * \param bytecount
 *    buffer length
 * \return
 *    bits read
 ************************************************************************
 */
int GetVLCSymbol (byte buffer[],int totbitoffset,int *info, int bytecount)
{

  register int inf;
  long byteoffset = (totbitoffset>>3);       // byte from start of buffer
  int  bitoffset  = (7-(totbitoffset&0x07)); // bit from start of byte
  int  bitcounter = 1;
  int  len        = 0;
  byte *cur_byte = &(buffer[byteoffset]);
  int  ctr_bit    = ((*cur_byte) >> (bitoffset)) & 0x01;  // control bit for current bit posision

  while (ctr_bit == 0)
  {                 // find leading 1 bit
    len++;
    bitcounter++;
    bitoffset--;
    bitoffset &= 0x07;
    cur_byte  += (bitoffset == 7);
    byteoffset+= (bitoffset == 7);      
    ctr_bit    = ((*cur_byte) >> (bitoffset)) & 0x01;
  }

  if (byteoffset + ((len + 7) >> 3) > bytecount)
    return -1;

  // make infoword
  inf = 0;                          // shortest possible code is 1, then info is always 0    

  while (len--)
  {
    bitoffset --;    
    bitoffset &= 0x07;
    cur_byte  += (bitoffset == 7);
    bitcounter++;
    inf <<= 1;    
    inf |= ((*cur_byte) >> (bitoffset)) & 0x01;
  }

  *info = inf;
  return bitcounter;           // return absolute offset in bit from start of frame
}

extern void tracebits2(const char *trace_str,  int len,  int info) ;

/*!
 ************************************************************************
 * \brief
 *    code from bitstream (2d tables)
 ************************************************************************
 */

//int code_from_bitstream_2d(SyntaxElement *sym,
//                           Bitstream *currStream,
//                           const int *lentab,
//                           const int *codtab,
//                           int tabwidth,
//                           int tabheight,
//                           int *code)
//{
//  int frame_bitoffset        = currStream->frame_bitoffset;
//  int BitstreamLengthInBytes = currStream->bitstream_length - (frame_bitoffset >> 3);
//  byte *buf                  = &currStream->streamBuffer[frame_bitoffset>>3];
//  int current_bit_pos        = 7 - (frame_bitoffset & 0x07);
//
//  int i, j;
//  const int *len = &lentab[0], *cod = &codtab[0];
//
//  // this VLC decoding method is not optimized for speed
//  for (j = 0; j < tabheight; j++) 
//  {
//    for (i = 0; i < tabwidth; i++)
//    {
//      //if ((*len == 0) || (ShowBits(buf, frame_bitoffset, BitstreamLengthInBytes, *len) != *cod))
//      if ((*len == 0) || (ShowBitsThres(buf, current_bit_pos, BitstreamLengthInBytes, *len, *cod) != *cod))
//      {
//        len++;
//        cod++;
//      }
//      else
//      {
//        sym->value1 = i;
//        sym->value2 = j;        
//        sym->len = *len;
//        currStream->frame_bitoffset += *len; // move bitstream pointer
//        *code = *cod;                        // found code and return
//        return 0;
//      }
//    }
//  }
//  return -1;  // failed to find code
//}


/*!
 ************************************************************************
 * \brief
 *    read FLC codeword from UVLC-partition
 ************************************************************************
 */
int readSyntaxElement_FLC(SyntaxElement *sym, Bitstream *currStream)
{
  int frame_bitoffset        = currStream->frame_bitoffset;
  int BitstreamLengthInBytes = currStream->bitstream_length;
  byte *buf                  = currStream->streamBuffer;

  if ((GetBits(buf, frame_bitoffset, &(sym->inf), BitstreamLengthInBytes, sym->len)) < 0)
    return -1;

  sym->value1 = sym->inf;
  currStream->frame_bitoffset += sym->len; // move bitstream pointer

#if TRACE
  tracebits2(sym->tracestring, sym->len, sym->inf);
#endif

  return 1;
}



/*!
 ************************************************************************
 * \brief
 *    read NumCoeff/TrailingOnes codeword from UVLC-partition
 ************************************************************************
 */

//int readSyntaxElement_NumCoeffTrailingOnes(SyntaxElement *sym,  
//                                           Bitstream *currStream,
//                                           char *type)
//{
//  int frame_bitoffset        = currStream->frame_bitoffset;
//  int BitstreamLengthInBytes = currStream->bitstream_length;
//  byte *buf                  = currStream->streamBuffer;
//
//  static const int lentab[3][4][17] =
//  {
//    {   // 0702
//      { 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
//      { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
//      { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
//      { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16},
//    },
//    {
//      { 2, 6, 6, 7, 8, 8, 9,11,11,12,12,12,13,13,13,14,14},
//      { 0, 2, 5, 6, 6, 7, 8, 9,11,11,12,12,13,13,14,14,14},
//      { 0, 0, 3, 6, 6, 7, 8, 9,11,11,12,12,13,13,13,14,14},
//      { 0, 0, 0, 4, 4, 5, 6, 6, 7, 9,11,11,12,13,13,13,14},
//    },
//    {
//      { 4, 6, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9,10,10,10,10},
//      { 0, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8, 9, 9, 9,10,10,10},
//      { 0, 0, 4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,10},
//      { 0, 0, 0, 4, 4, 4, 4, 4, 5, 6, 7, 8, 8, 9,10,10,10},
//    },
//  };
//
//  static const int codtab[3][4][17] =
//  {
//    {
//      { 1, 5, 7, 7, 7, 7,15,11, 8,15,11,15,11,15,11, 7,4},
//      { 0, 1, 4, 6, 6, 6, 6,14,10,14,10,14,10, 1,14,10,6},
//      { 0, 0, 1, 5, 5, 5, 5, 5,13, 9,13, 9,13, 9,13, 9,5},
//      { 0, 0, 0, 3, 3, 4, 4, 4, 4, 4,12,12, 8,12, 8,12,8},
//    },
//    {
//      { 3,11, 7, 7, 7, 4, 7,15,11,15,11, 8,15,11, 7, 9,7},
//      { 0, 2, 7,10, 6, 6, 6, 6,14,10,14,10,14,10,11, 8,6},
//      { 0, 0, 3, 9, 5, 5, 5, 5,13, 9,13, 9,13, 9, 6,10,5},
//      { 0, 0, 0, 5, 4, 6, 8, 4, 4, 4,12, 8,12,12, 8, 1,4},
//    },
//    {
//      {15,15,11, 8,15,11, 9, 8,15,11,15,11, 8,13, 9, 5,1},
//      { 0,14,15,12,10, 8,14,10,14,14,10,14,10, 7,12, 8,4},
//      { 0, 0,13,14,11, 9,13, 9,13,10,13, 9,13, 9,11, 7,3},
//      { 0, 0, 0,12,11,10, 9, 8,13,12,12,12, 8,12,10, 6,2},
//    },
//  };
//
//  int retval = 0, code;
//  int vlcnum = sym->value1;
//  // vlcnum is the index of Table used to code coeff_token
//  // vlcnum==3 means (8<=nC) which uses 6bit FLC
//
//  if (vlcnum == 3)
//  {
//    // read 6 bit FLC
//    code = ShowBits(buf, frame_bitoffset, BitstreamLengthInBytes, 6);
//    currStream->frame_bitoffset += 6;
//    sym->value2 = (code & 3);
//    sym->value1 = (code >> 2);
//
//    if (!sym->value1 && sym->value2 == 3)
//    {
//      // #c = 0, #t1 = 3 =>  #c = 0
//      sym->value2 = 0;
//    }
//    else
//      sym->value1++;
//
//    sym->len = 6;
//  }
//  else
//  {
//    //retval = code_from_bitstream_2d(sym, currStream, &lentab[vlcnum][0][0], &codtab[vlcnum][0][0], 17, 4, &code);    
//    retval = code_from_bitstream_2d(sym, currStream, lentab[vlcnum][0], codtab[vlcnum][0], 17, 4, &code);
//    if (retval)
//    {
//      printf("ERROR: failed to find NumCoeff/TrailingOnes\n");
//      exit(-1);
//    }
//  }
//
//#if TRACE
//  snprintf(sym->tracestring,
//    TRACESTRING_SIZE, "%s # c & tr.1s vlc=%d #c=%d #t1=%d",
//           type, vlcnum, sym->value1, sym->value2);
//  tracebits2(sym->tracestring, sym->len, code);
//#endif
//
//  return retval;
//}


/*!
 ************************************************************************
 * \brief
 *    read NumCoeff/TrailingOnes codeword from UVLC-partition ChromaDC
 ************************************************************************
 */
//int readSyntaxElement_NumCoeffTrailingOnesChromaDC(SyntaxElement *sym,  Bitstream *currStream)
//{
//  static const int lentab[3][4][17] =
//  {
//    //YUV420
//   {{ 2, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 1, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 0, 3, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
//    //YUV422
//   {{ 1, 7, 7, 9, 9,10,11,12,13, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 2, 7, 7, 9,10,11,12,12, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 0, 3, 7, 7, 9,10,11,12, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 0, 0, 5, 6, 7, 7,10,11, 0, 0, 0, 0, 0, 0, 0, 0}},
//    //YUV444
//   {{ 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
//    { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
//    { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
//    { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16}}
//  };
//
//  static const int codtab[3][4][17] =
//  {
//    //YUV420
//   {{ 1, 7, 4, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 1, 6, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 0, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
//    //YUV422
//   {{ 1,15,14, 7, 6, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 1,13,12, 5, 6, 6, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 0, 1,11,10, 4, 5, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0},
//    { 0, 0, 0, 1, 1, 9, 8, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0}},
//    //YUV444
//   {{ 1, 5, 7, 7, 7, 7,15,11, 8,15,11,15,11,15,11, 7, 4},
//    { 0, 1, 4, 6, 6, 6, 6,14,10,14,10,14,10, 1,14,10, 6},
//    { 0, 0, 1, 5, 5, 5, 5, 5,13, 9,13, 9,13, 9,13, 9, 5},
//    { 0, 0, 0, 3, 3, 4, 4, 4, 4, 4,12,12, 8,12, 8,12, 8}}
//
//  };
//   
//  int code;
//  int yuv = active_sps->chroma_format_idc - 1;
//  int retval = code_from_bitstream_2d(sym, currStream, &lentab[yuv][0][0], &codtab[yuv][0][0], 17, 4, &code);
//
//  if (retval)
//  {
//    printf("ERROR: failed to find NumCoeff/TrailingOnes ChromaDC\n");
//    exit(-1);
//  }
//
//#if TRACE
//    snprintf(sym->tracestring,
//      TRACESTRING_SIZE, "ChrDC # c & tr.1s  #c=%d #t1=%d",
//              sym->value1, sym->value2);
//    tracebits2(sym->tracestring, sym->len, code);
//
//#endif
//
//  return retval;
//}




/*!
 ************************************************************************
 * \brief
 *    read Level VLC0 codeword from UVLC-partition
 ************************************************************************
 */
//int readSyntaxElement_Level_VLC0(SyntaxElement *sym, Bitstream *currStream)
//{
//  int frame_bitoffset        = currStream->frame_bitoffset;
//  int BitstreamLengthInBytes = currStream->bitstream_length;
//  byte *buf                  = currStream->streamBuffer;
//  int len = 0, sign=0, level=0, code = 1;
//  int offset, addbit;
//
//  while (!ShowBits(buf, frame_bitoffset+len, BitstreamLengthInBytes, 1))
//    len++;
//
//  len++;
//  frame_bitoffset += len;
//
//  if (len < 15)
//  {
//    sign  = (len - 1) & 1;
//    level = ((len - 1) >> 1) + 1;
//  }
//  else if (len == 15)
//  {
//    // escape code
//    code <<= 4;
//    code |= ShowBits(buf, frame_bitoffset, BitstreamLengthInBytes, 4);
//    len  += 4;
//    frame_bitoffset += 4;
//    sign = (code & 0x01);
//    level = ((code >> 1) & 0x07) + 8;
//  }
//  else if (len >= 16)
//  {
//    // escape code
//    addbit = (len - 16);
//    len   -= 4;
//    code   = ShowBits(buf, frame_bitoffset, BitstreamLengthInBytes, len);
//    sign   =  (code & 0x01);
//    frame_bitoffset += len;    
//
//    offset=(2048<<addbit) - 2032;
//    level = (code >> 1) + offset;
//    code |= (1 << (len)); // for display purpose only
//    len += addbit + 16;
// }
//
//  sym->inf = (sign) ? -level : level ;
//  sym->len = len;
//
//#if TRACE
//  tracebits2(sym->tracestring, sym->len, code);
//#endif
//  currStream->frame_bitoffset = frame_bitoffset;
//  return 0;
//
//}

/*!
 ************************************************************************
 * \brief
 *    read Level VLC codeword from UVLC-partition
 ************************************************************************
 */
//int readSyntaxElement_Level_VLCN(SyntaxElement *sym, int vlc, Bitstream *currStream)
//{