/*
	Huffman Decoding Unit Simulation		Rich Webb  2/28/94
    
    Version #1: rww 2/28/94
	Basic table structure and stream parsing.
*/

#include <values.h>
#include <stdio.h>

#include "huf.h"
#include "huf_mpeg1_ac_tabs.h"
#include "huf_mpeg1_mbh_tabs.h"

int huf_start_tab = AC_START;
int huf_cur_tab = AC_FIRST;

HufControl **huf_tabs = &(huf_mpeg1_ac_tabs[0]);

#define HUF_READY	(0)
#define HUF_STOPPED	(1)

int huf_status = HUF_READY;

int huf_trace = 1;

int huf_skip_sign = 0;

unsigned int huf_fpeek( int );
unsigned int huf_fread( int );

unsigned int huf_peek( int );
unsigned int huf_read( int );

int huf_set_next_ac_tab = AC_FIRST;

void
huf_set_trace( int val )
{
    huf_trace = val;
}

void
huf_set_ac_first( void )
{
    huf_set_next_ac_tab = AC_FIRST;
}


void
huf_set_ac_start( void )
{
    huf_set_next_ac_tab = AC_START;
}

int
huf_check_ac_first( void )
{
    return( huf_set_next_ac_tab == AC_FIRST );
}

int
huf_set_state( int state )
{
}


#define NEXTBITS(x) ((bits>>(32-x)) & ((1<<x)-1))

#define BIT_BUFSIZE (1024*1024/(sizeof(BIT_BUFTYPE)))

FILE *huf_file;
char *huf_filename;


unsigned int
huf_fpeek( int len )
{
    int nbits;
    int val;
    int tmp_cur_word;
    int tmp_cur_bits;

    tmp_cur_word = in_cur_word;
    tmp_cur_bits = in_cur_bits;

    if( (tmp_cur_bits + len) >= BITS(BIT_BUFTYPE) )
	{
	    if( (in_cur_used+1) == in_buf_len )
		return( -1 );

	    nbits = BITS(BIT_BUFTYPE) - tmp_cur_bits;

	    if( nbits == BITS(BIT_BUFTYPE) )
		val = tmp_cur_word;
	    else
		val = (tmp_cur_word & ((1<<nbits)-1)) << (len-nbits);
	    tmp_cur_word = in_bit_buf[in_cur_used];

	    len -= nbits;

	    if( len > 0 )
		val |= (tmp_cur_word >> (BITS(BIT_BUFTYPE) - len))
			& ((1<<len)-1);
    } else
	    val = (tmp_cur_word >> (BITS(BIT_BUFTYPE) - tmp_cur_bits - len))
		    & ((1<<len)-1);

    return(  val );
}


int
huf_parse( void )
{
    HufControl *tab;
    HufControl cont;

    int bits, out_val, level, run;
    int nb = 0;

    out_val = huf_fpeek( 20 );
    run = 16;

    if( out_val < 0 )
	return( out_val );

    do {
	bits = (out_val >> run) & 0xf ;

	if( bits < 0 )
	    return( bits );

	tab = huf_tabs[ huf_cur_tab ];

	cont = tab[bits];

	if( (!cont.stop) || cont.end ) {
	    nb += cont.nbits + 1;
	    run -= cont.nbits + 1;
	};

	huf_cur_tab = cont.value;

    } while( (cont.end == 0) && (cont.stop == 0) );
    
    out_val = cont.value;

    if( cont.stop ) {

	if( cont.sign ) {
	    if( (huf_fread(nb+1)&1) )
		out_val = -out_val;
	} else
	    huf_fread(nb);

	return( out_val );
    };
    
    level = out_val >> HUF_LEVEL_SHIFT;
    run   = out_val & ((1<<HUF_LEVEL_SHIFT) - 1);

    if( cont.sign ) {
	if( (huf_fread(nb+1)&1) )
	    level = -level;
    } else
	huf_fread(nb);

    huf_cur_tab = huf_start_tab;

    return( (level<<16) + run );
}

int
huf_align( int len )
{
  int val = 0;

  if( (len = ((BITS(BIT_BUFTYPE)-in_cur_bits)%len)) )
	  val = huf_read( len );

  if( val == 0 )
    return( -1-len );

  for(len=0;len<32;len++)
    if( val & (1<<len) )
      return(len);

  return(32);
}

#include <string.h>
#include <malloc.h>

char *strdup( char * );

int in_cur_word=0,
    in_buf_len=0;

int in_cur_bits=0,
    in_cur_used=0;

BIT_BUFTYPE *in_bit_buf = (BIT_BUFTYPE *) NULL;

huf_init( char *filename )
{
    huf_filename = strdup( filename );

    huf_file = fopen( filename, "r" );


    in_bit_buf = (BIT_BUFTYPE *) malloc( BIT_BUFSIZE * sizeof(BIT_BUFTYPE));

    in_buf_len = fread( in_bit_buf, sizeof(BIT_BUFTYPE), BIT_BUFSIZE,
			huf_file);
    
    in_cur_bits = 0;
    in_cur_used = 0;
    in_cur_word = in_bit_buf[in_cur_used++];

    if( huf_trace > 1 )
	fprintf(stderr, "HUF_INIT: Filling buffer with %d bits\n",
		in_buf_len*BITS(BIT_BUFTYPE) );

}

/* BITwise I/O routines */

unsigned int
huf_peek( int len )
{
    int nbits;
    int val;
    char *b2s( int, int );
    int tmp_cur_word;
    int tmp_cur_bits;

    if( len == 0 )
	{
	    fprintf(stderr,"HUF_PEEK: Tried to input %d bits\n", len);
	    return( 0 );
    };

    if( len > BITS(BIT_BUFTYPE) )
	{
	    fprintf(stderr,"HUF_PEEK: Tried to input %d bits (max=%d)\n",
		    len, BITS(BIT_BUFTYPE) );
	    return( 0 );
    };

    if( in_bit_buf == NULL )
	{
	    fprintf(stderr,"HUF_PEEK: Don't call this first!\n" );
	    return( -1 );
    };
    
    val = 0;
    tmp_cur_word = in_cur_word;
    tmp_cur_bits = in_cur_bits;

    while( (tmp_cur_bits + len) >= BITS(BIT_BUFTYPE) )
	{
	    nbits = BITS(BIT_BUFTYPE) - tmp_cur_bits;

	    if( nbits == BITS(BIT_BUFTYPE) )
		val = tmp_cur_word;
	    else
		val = (tmp_cur_word & ((1<<nbits)-1)) << (len-nbits);
	    tmp_cur_word = in_bit_buf[in_cur_used];
	    tmp_cur_bits = 0;

	    len -= nbits;

	    if( (in_cur_used+1) == in_buf_len )
		return( -1 );
    };

    if( len > 0 )
	    val |= (tmp_cur_word >> (BITS(BIT_BUFTYPE) - tmp_cur_bits - len))
		    & ((1<<len)-1);

    return(  val );
}


unsigned int
huf_fread( int len )
{
    int nbits, ilen;
    int val;
    char *b2s(int, int);

    if( huf_trace )
	fprintf(stderr,"HGET: Recv <");

    ilen = 0;
    val = 0;
    while( (in_cur_bits + len) >= BITS(BIT_BUFTYPE) )
	{
	    nbits = BITS(BIT_BUFTYPE) - in_cur_bits;

	    if( nbits == BITS(BIT_BUFTYPE) )
		val = in_cur_word;
	    else
		val = (in_cur_word & ((1<<nbits)-1)) << (len-nbits);

	    if( huf_trace )
		fprintf(stderr,"%s%s", b2s((val>>(len-nbits)),nbits),
				 (len-nbits)?" | ":">");

	    in_cur_word = in_bit_buf[in_cur_used++];
	    in_cur_bits = 0;

	    len -= nbits;
	    ilen += nbits;
	    if( in_cur_used == in_buf_len )
		{
		    in_buf_len = fread( in_bit_buf, sizeof(BIT_BUFTYPE), 
					BIT_BUFSIZE, huf_file);
		    if( in_buf_len == 0 )
			{
			    free( in_bit_buf );
			    in_bit_buf = NULL;
			    fprintf(stderr,"HUF Input EOF <%s>\n",
				    huf_filename );
			    return(-1);
		    };

		    in_cur_used = 0;
/*		    in_cur_word = in_bit_buf[in_cur_used++]; 	*/

/*		    huf_trace = trace_out = trace_bs = 1;	*/

		    if( huf_trace > 1 )
			fprintf(stderr, "HGET: Filling buffer with %d bits\n",
				in_buf_len*BITS(BIT_BUFTYPE) );
	    };
    };

    if( len > 0 )
	{
	    val |= (in_cur_word >> (BITS(BIT_BUFTYPE) - in_cur_bits - len))
		    & ((1<<len)-1);
	    in_cur_bits += len;
	    ilen += len;
	    if( huf_trace )
		fprintf(stderr,"%s>", b2s(val,len));
    };

    if( huf_trace )
	fprintf(stderr," (val=0x%x,len=%d)\n", val, ilen );

    return(  val );
}


unsigned int
huf_read( int len )
{
    extern FILE *huf_file;
    int nbits, ilen;
    int val;
    char *b2s(int, int);

    if( len == 0 )
	{
	    fprintf(stderr,"HGET: Tried to input %d bits\n", len);
	    return( 0 );
    };

    if( len > BITS(BIT_BUFTYPE) )
	{
	    fprintf(stderr,"HGET: Tried to input %d bits (max=%d)\n",
		    len, BITS(BIT_BUFTYPE) );
	    return( 0 );
    };

    if( in_bit_buf == NULL )
	{
	in_bit_buf = (BIT_BUFTYPE *) malloc( BIT_BUFSIZE * sizeof(BIT_BUFTYPE));

	in_buf_len = fread( in_bit_buf, sizeof(BIT_BUFTYPE), BIT_BUFSIZE,
			    huf_file);
	
	in_cur_bits = 0;
	in_cur_used = 0;
	in_cur_word = in_bit_buf[in_cur_used++];

	if( huf_trace > 1 )
	    fprintf(stderr, "HGET: Filling buffer with %d bits\n",
		    in_buf_len*BITS(BIT_BUFTYPE) );
    }
    
    if( huf_trace )
	fprintf(stderr,"HGET: Recv <");

    ilen = 0;
    val = 0;
    while( (in_cur_bits + len) >= BITS(BIT_BUFTYPE) )
	{
	    nbits = BITS(BIT_BUFTYPE) - in_cur_bits;

	    if( nbits == BITS(BIT_BUFTYPE) )
		val = in_cur_word;
	    else
		val = (in_cur_word & ((1<<nbits)-1)) << (len-nbits);

	    in_cur_word = in_bit_buf[in_cur_used++];
	    in_cur_bits = 0;
	    if( huf_trace )
		fprintf(stderr,"%s%s", b2s((val>>(len-nbits)),nbits),
				 (len-nbits)?" | ":">");
	    len -= nbits;
	    ilen += nbits;
	    if( in_cur_used == in_buf_len )
		{
		    in_buf_len = fread( in_bit_buf, sizeof(BIT_BUFTYPE), 
					BIT_BUFSIZE, huf_file);
		    if( in_buf_len == 0 )
			{
			    free( in_bit_buf );
			    in_bit_buf = NULL;
			    fprintf(stderr,"HUF Input EOF <%s>\n",
				    huf_filename );
			    return(-1);
		    };

		    in_cur_used = 0;
/*		    in_cur_word = in_bit_buf[in_cur_used++]; 	*/

/*		    huf_trace = trace_out = trace_bs = 1;	*/

		    if( huf_trace > 1 )
			fprintf(stderr, "HGET: Filling buffer with %d bits\n",
				in_buf_len*BITS(BIT_BUFTYPE) );
	    };
    };

    if( len > 0 )
	{
	    val |= (in_cur_word >> (BITS(BIT_BUFTYPE) - in_cur_bits - len))
		    & ((1<<len)-1);
	    in_cur_bits += len;
	    ilen += len;
	    if( huf_trace )
		fprintf(stderr,"%s>", b2s(val,len));
    };

    if( huf_trace )
	fprintf(stderr," (val=0x%x,len=%d)\n", val, ilen );

    return(  val );
}

char *
b2s( int val, int len )
{
    static char buf[150];
    unsigned int mask;
    int i;

    mask = 1<<(len-1);
    for(i=0;i<len;i++,mask>>=1)
	buf[i] = (val & mask)?'1':'0';
    
    buf[len] = '\0';

    return( buf );
}

#if 0


int
huf_slow_parse()
{
    HufControl *tab;
    HufControl cont;

    int bits, out_val, level, run;

    do {
	bits = huf_peek( 4 );

	if( bits < 0 )
	    return( bits );

	tab = huf_tabs[ huf_cur_tab ];

	cont = tab[bits];

	if( (cont.stop) && (cont.end == 0) ) {
	    if( huf_trace )
		fprintf(stderr,"HUF_PARSE: Don't consume bits on error %d\n",
			cont.value );
	} else {
	    bits = huf_read( cont.nbits + 1 );
	    if( bits < 0 )
		return( bits );
	};

	huf_cur_tab = cont.value;

    } while( (cont.end == 0) && (cont.stop == 0) );
    
    out_val = cont.value;

    if( cont.stop ) {
	huf_status = HUF_STOPPED;

	if( huf_skip_sign == 0 )
	    if( cont.sign && huf_read(1) )
		out_val = -out_val;

	return( out_val );
    };
    
    level = out_val >> HUF_LEVEL_SHIFT;
    run   = out_val & ((1<<HUF_LEVEL_SHIFT) - 1);

    if( huf_skip_sign == 0 )
	if( cont.sign && huf_read(1) )
	    level = -level;

    huf_cur_tab = huf_start_tab;

    return( (level<<16) + run );
}

int
huf_slower_parse()
{
    HufControl *tab;
    HufControl cont;

    int bits, out_val, level, run;
    int nb;

    int fbits;

    fbits = huf_fpeek( 31 );

    if( fbits < 0 )
	return( fbits );

    fbits <<=1;

    nb = 0;
    do {
	bits = fbits>>28;
	bits &= 0xf;

	tab = huf_tabs[ huf_cur_tab ];

	cont = tab[bits];

	if( (cont.stop) && (cont.end == 0) ) {
	    if( huf_trace )
		fprintf(stderr,"HUF_PARSE: Don't consume bits on error %d\n",
			cont.value );
	} else {
	    fbits <<= cont.nbits + 1;
	    nb += cont.nbits + 1;
	};

	huf_cur_tab = cont.value;

    } while( (cont.end == 0) && (cont.stop == 0) );
    
    out_val = cont.value;

    if( cont.stop ) {
	huf_status = HUF_STOPPED;

	if( huf_skip_sign == 0 )
	    if( cont.sign ) {
		nb++;
		if( fbits < 0 )
		    out_val = -out_val;
	    };

	huf_fread( nb );

	return( out_val );
    };
    
    level = out_val >> HUF_LEVEL_SHIFT;
    run   = out_val & ((1<<HUF_LEVEL_SHIFT) - 1);

    if( huf_skip_sign == 0 ) {
	nb++;
	if( cont.sign && (fbits<0) )
	    level = -level;
    };

    huf_cur_tab = huf_start_tab;

    huf_fread( nb );

    return( (level<<16) + run );
}

#endif