vlc.c

davinci avs.......................................................

				{
					abs_lev_diff = (symbol2D -71)/2+2;
					sign = symbol2D&0x1;//MAZHAN for "sign"
					currSE.type = Golomb_se_type;
					currSE.golomb_grad = 0;         
					currSE.golomb_maxlevels = VLC_GC_Order_INTER[tableindex][1];    
					read_GOLOMB(&currSE);  
					symbol2D = currSE.value1;
					run = symbol2D;
				}

				find_level(sign, &level, run, intra, tableindex, abs_lev_diff);
			}

#if TRACE  //transferred before table switch
		 snprintf(currSE.tracestring,TRACESTRING_SIZE, "%s (run, level) (%d,%3d) k=%d vlc=%d ",
            "LUMA4x4_INTER", run, level, VLC_GC_Order_INTER[tableindex][0], tableindex);
		 
     tracebits(currSE.tracestring,currSE.len,currSE.inf,currSE.value1);
		 fflush(p_trace);
#endif
			 // added by PSL 20041228
			previousRunCnt += run+1;
			buffer_level[k] = level;
			buffer_run[k]   = run;

			abslevel = abs(level);  //!< checked by Zhan Ma

			if(abslevel>=incLevel_inter[tableindex])
			{
				if(abslevel == 1)
        	tableindex = (run>incRun_inter[tableindex])?level1_inter[run]:tableindex;
        else if(abslevel == 2)
					tableindex = 4;
				else if(abslevel <= 4)
					tableindex = 5;
				else
					tableindex = 6;
			}

			// added by PSL 20041228
			if (previousRunCnt==16)
			{
				vlc_numcoef = k+1;
				break;
			}

		}//loop for k
		ipos  = -1;
		for(i=(vlc_numcoef-1); i>=0; i--)
		{
			ipos += (buffer_run[i]+1);          
			ii = SCAN[ipos][0];
			jj = SCAN[ipos][1];
			pgImage->m7[boff_x + ii][boff_y + jj] = buffer_level[i];
		}
	}
}
/*!
 ************************************************************************
 *  \brief
 *     read chroma coefficents
 ************************************************************************
 */
void readChromaCoeff_4x4_UVLC(int b8, int b4)    //qwang 2004-4-27
{
  int mb_nr          = pgImage->current_mb_nr;
  SyntaxElement currSE;
  int ipos;
  int run, level;
  int ii,jj,k,tableindex,i,vlc_numcoef;
  int boff_x, boff_y;
  int symbol2D,Golomb_se_type;
  int buffer_level[16], buffer_run[16],abslevel;
  const char (*table2D)[13];
  
  int previousRunCnt = 0; // added by PSL 20041228	
	int incLevel_chroma[4]={0,1,2,3000}; // dongjie

  boff_x = ((b4 &1)<<2);
  boff_y = ((b4>>1)<<2);

  Golomb_se_type=SE_LUM_AC_INTER;
  //make decoder table for VLC_CHROMA code
  if(VLC_CHROMA_dec[0][0][1]<0)                                                          // Don't need to set this every time. rewrite later.
  {
    memset(VLC_CHROMA_dec,-1,sizeof(VLC_CHROMA_dec));
		for(i=0;i<4;i++)
		{
      table2D=VLC_CHROMA[i];
      for(run=0;run<16;run++)
        for(level=0;level<13;level++)
        {
          ipos=table2D[run][level];
          assert(ipos<40);
          if(ipos>=0)
          {						
						if(i==0)
						{
							VLC_CHROMA_dec[i][ipos][0]=level+1;
							VLC_CHROMA_dec[i][ipos][1]=run;
							
							VLC_CHROMA_dec[i][ipos+1][0]=-(level+1);
							VLC_CHROMA_dec[i][ipos+1][1]=run;
						}
						else
						{
							VLC_CHROMA_dec[i][ipos][0]=level;
							VLC_CHROMA_dec[i][ipos][1]=run;              
							if(level)
							{
								VLC_CHROMA_dec[i][ipos+1][0]=-(level);
								VLC_CHROMA_dec[i][ipos+1][1]=run;
							}
						}

          }
        }
		}
    assert(VLC_CHROMA_dec[0][1]>=0);        //otherwise, tables are bad.
  }

  ipos  = -1;
  level=1;                        // get inside loop
	tableindex = 0;
	for(k=0; k<17; k++)
	{
		currSE.type = Golomb_se_type;
		currSE.golomb_grad = VLC_GC_Order_CHROMA[tableindex][0];         
		currSE.golomb_maxlevels = VLC_GC_Order_CHROMA[tableindex][1];    
		read_GOLOMB(&currSE);
		symbol2D = currSE.value1; 
		
		if((symbol2D==0)&&(tableindex!=0))      
		{
			vlc_numcoef = k;
			break;
		}
		
		if(symbol2D < CODE2D_ESCAPE_SYMBOL)
		{
			level = VLC_CHROMA_dec[tableindex][symbol2D][0];   
			run   = VLC_CHROMA_dec[tableindex][symbol2D][1];   
		}
		else
		{
			// commented by PSL 20041228
			//symbol2D_levrun_chroma(&level, &run, symbol2D, tableindex);
			// added by PSL 20041228
			int abs_lev_diff;
			int sign;
			
			if(symbol2D<32+39)
			{				
				sign = symbol2D&0x1; //MAZHAN for "sign"
				run = ((symbol2D-39)%32)/2;				
				abs_lev_diff = 1;
			}
			else
			{
				abs_lev_diff = (symbol2D -39-32)/2+2;
				sign = symbol2D&0x1;//MAZHAN for "sign"
				 currSE.type = Golomb_se_type;
				currSE.golomb_grad = 0;         
				currSE.golomb_maxlevels = VLC_GC_Order_CHROMA[tableindex][1];    
				read_GOLOMB(&currSE);
				symbol2D = currSE.value1;
				run = symbol2D;
			}
			find_level_chroma(sign, &level, run, tableindex, abs_lev_diff);
		}

#if TRACE  //transferred before table swich
		 snprintf(currSE.tracestring, TRACESTRING_SIZE, "%s (run, level) (%d,%3d) k=%d vlc=%d ",
             "CHR4x4",run, level, VLC_GC_Order_CHROMA[tableindex][0], tableindex);
		 tracebits(currSE.tracestring,currSE.len,currSE.inf,currSE.value1);
		 fflush(p_trace);

#endif

		// added by PSL 20041228
		previousRunCnt += run+1;
		buffer_level[k] = level;
		buffer_run[k]   = run;
		abslevel = abs(level);

		if(abslevel>incLevel_chroma[tableindex])
		{
			if(abslevel<3)
				tableindex = abslevel;
			else
				tableindex = 3;
		}
		// added by PSL 20041228
		if (previousRunCnt==16)
		{
			vlc_numcoef = k+1;
			break;
		}

	}//loop for k
	
		ipos  = -1;
		for(i=(vlc_numcoef-1); i>=0; i--)
		{
			ipos += (buffer_run[i]+1);          
			ii = SCAN[ipos][0];
			jj = SCAN[ipos][1];
			pgImage->m8[b8-4][boff_x + ii][boff_y + jj] = buffer_level[i];
		}
}
// end


#if TRACE
/*!
 ************************************************************************
 *  \brief
 *     
 ************************************************************************
 */
void encode_golomb_word(unsigned int symbol,unsigned int grad0,unsigned int max_levels,unsigned int *res_bits,unsigned int *res_len)
{
  unsigned int level,res,numbits;
  res=1UL<<grad0;
  level=1UL;numbits=1UL+grad0;
  //find golomb level
  while( symbol>=res && level<max_levels )
  {
    symbol-=res;
    res=res<<1;
    level++;
    numbits+=2UL;
  }
  if(level>=max_levels)
  {
    if(symbol>=res)
      symbol=res-1UL;  //crop if too large.
  }
  //set data bits
  *res_bits=res|symbol;
  *res_len=numbits;
}
/*!
 ************************************************************************
 *  \brief
 *     
 ************************************************************************
 */
void encode_multilayer_golomb_word(unsigned int symbol,const unsigned int *grad,const unsigned int *max_levels,unsigned int *res_bits,unsigned int *res_len)
{
  unsigned accbits,acclen,bits,len,tmp;
  accbits=acclen=0UL;
  while(1)
  {
    encode_golomb_word(symbol,*grad,*max_levels,&bits,&len);
    accbits=(accbits<<len)|bits;
    acclen+=len;
    assert(acclen<=32UL);  //we'l be getting problems if this gets longer than 32 bits.
    tmp=*max_levels-1UL;
    if(!(( len == (tmp<<1)+(*grad) )&&( bits == (1UL<<(tmp+*grad))-1UL )))  //is not last possible codeword? (Escape symbol?)
      break;
    tmp=*max_levels;
    symbol-=(((1UL<<tmp)-1UL)<<(*grad))-1UL;
    grad++;max_levels++;
  }
  *res_bits=accbits;
  *res_len=acclen;
}
#endif

/*!
 ************************************************************************
 *  \brief
 *     
 ************************************************************************
 */
unsigned int decode_golomb_word(unsigned char **buffer,unsigned int *bitoff,unsigned int grad0,unsigned int max_levels)
{
  unsigned char *rd;
  unsigned int bit,byte,level,databits,t,testbit;

  rd=*buffer;
  bit=*bitoff;
  byte=*rd;
  level=0UL;
  while( level<max_levels )//( level+1UL<max_levels )
  {
    testbit=byte&(1UL<<bit);
    bit = (bit-1UL) & 7UL ;
    if(bit==7UL)byte=*(++rd);
    if( testbit )break;
    level++;
  }
  databits=0UL;
  for( t=0UL ; t<(grad0+level) ; t++ )
  {
    databits = (databits<<1UL) | ((byte>>bit)&1UL) ;
    bit = (bit-1UL) & 7UL ;
    if(bit==7UL)byte=*(++rd);
  }
  *buffer=rd;
  *bitoff=bit;

  return (((1UL<<level)-1UL)<<grad0)+databits;
}
/*!
 ************************************************************************
 *  \brief
 *     
 ************************************************************************
 */
unsigned int decode_multilayer_golomb_word(unsigned char **buffer,unsigned int *bitoff, unsigned int *grad0,unsigned int *max_levels)
{
  unsigned int symbol,partsymbol,tmp;
  symbol=0UL;
  while(1)
  {
    partsymbol=decode_golomb_word(buffer,bitoff,*grad0,*max_levels);
    symbol+=partsymbol;
    tmp=*max_levels;
    if( partsymbol < (((1UL<<tmp)-1UL)<<(*grad0))-1UL )  //not escape symbol?
      break;
    grad0++;
    max_levels++;
  }
  return symbol;
}
/*!
 ************************************************************************
 *  \brief
 *     
 ************************************************************************
 */
int  read_GOLOMB(SyntaxElement *se)
{
  int frame_bitoffset;
  unsigned char *buf,*read;
  int BitstreamLengthInBytes;
  unsigned int bit,i;
  unsigned int grad[4],max_lev[4];
	
#if TRACE
  unsigned int len;
#endif  
	
  frame_bitoffset = currStream->frame_bitoffset;
  buf = (unsigned char*)currStream->streamBuffer;
  BitstreamLengthInBytes = currStream->bitstream_length;
  
  bit=7UL-(frame_bitoffset&7);
  read=buf+(frame_bitoffset>>3);
  
  if(!( se->golomb_maxlevels&~0xFF ))
  {
    se->value1=decode_golomb_word(&read,&bit,se->golomb_grad,se->golomb_maxlevels);
  }
  else
  {
    for(i=0UL;i<4UL;i++)
    {
      grad[i]=(se->golomb_grad>>(i<<3))&0xFFUL;
      max_lev[i]=(se->golomb_maxlevels>>(i<<3))&0xFFUL;
    }
    se->value1=decode_multilayer_golomb_word(&read,&bit,grad,max_lev);
  }
  
  se->len=(((read-buf)<<3)+(7-bit))-frame_bitoffset;
  
#if TRACE
  if(!( se->golomb_maxlevels&~0xFF ))    //only bits 0-7 used? This means normal Golomb word.
    encode_golomb_word(se->value1,se->golomb_grad,se->golomb_maxlevels,&(se->value2),&len);
  else
  {
    for(i=0UL;i<4UL;i++)
    {
      grad[i]=(se->golomb_grad>>(i<<3))&0xFFUL;
      max_lev[i]=(se->golomb_maxlevels>>(i<<3))&0xFFUL;
    }
    encode_multilayer_golomb_word(se->value1,grad,max_lev,&(se->value2),&len);
  }

#endif

  se->value2=0;
  currStream->frame_bitoffset += se->len;
  
  return 1;
}