/* MPEG AUDIO LAYER 3 DECODER */
/* Bjorn Wesen 1997           */

/*#define USE_DATA */

#undef ROCKFORD

#ifndef DSP
#define DECVERBOSE
#endif

#include "mp3dec.h"

#ifdef DSPSIMUL
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#else
#ifdef DSP
#include "c3x_start.h"
#include "c3x_control.h"
#endif
#endif

#ifdef INT_MATH

mpfloat
operator+(mpfloat a, mpfloat b) {
    return mpfloat(a._val + b._val);
}

mpfloat
operator-(mpfloat a, mpfloat b) {
    return mpfloat(a._val - b._val);
}

mpfloat
operator-(mpfloat a) {
    return mpfloat(-a._val);
}

mpfloat
operator*(mpfloat a, mpfloat b) {
    return mpfloat(a._val * b._val);
}

mpfloat operator/(mpfloat a, mpfloat b) {
    return mpfloat(a._val / b._val);
}

#endif


static float Frame_sampfreqs[4] = { 44.1, 48, 32, 0 };
static int Frame_bitrates[15] = { 0, 32, 40, 48, 56, 64, 80, 96, 
				  112, 128, 160, 192, 224, 256, 320 };

/* scalefac_compress indexes into this table to find the sizes of the 
   scalefactor bitfields */

static int Frame_slen[2][16] = { { 0, 0, 0, 0, 3, 1, 1, 1,
				   2, 2, 2, 3, 3, 3, 4, 4 },
				 { 0, 1, 2, 3, 0, 1, 2, 3,
				   1, 2, 3, 1, 2, 3, 2, 3 } };

/* for each samplerate there is a special division of the 576 frequency
   lines into bands */

struct Frame_band Frame_bands[3] = {
    
    { { 0,4,8,12,16,20,24,30,36,44,52,
	62,74,90,110,134,162,196,238,288,342,418,576 },
      { 0,4,8,12,16,22,30,40,52,66,84,106,136,192 }},

    { { 0,4,8,12,16,20,24,30,36,42,50,
	60,72,88,106,128,156,190,230,276,330,384,576 },
      { 0,4,8,12,16,22,28,38,50,64,80,100,126,192 }},

    { { 0,4,8,12,16,20,24,30,36,44,54,
	66,82,102,126,156,194,240,296,364,448,550,576 },
      { 0,4,8,12,16,22,30,42,58,78,104,138,180,192 }}
};


static Bitstream Frame_bitbuf;   /* used for keeping the main data */


#ifdef DECVERBOSE

void dump_floats(mpfloat *f, int num)
{
    int i;
    printf("\n");
    for(i = 0; i < num; i++) {
	if(i && !(i % 5))
	    printf("\n");
	printf("%10f ", f[i]);
    }
    printf("\n");
}


void dump_ints(int *f, int num)
{
    int i;
    printf("\n");
    for(i = 0; i < num; i++) {
	if(i && !(i % 5))
	    printf("\n");
	printf("%8d ", f[i]);
    }
    printf("\n");
}
#endif

int frameNum = 0;
#ifdef UNIX
int
main(int argc, char **argv)
{
    FILE *fp; 
    int i = 0;
    char nameb[256];
    PCMSample samples[576*4];
    int numframes = 1024;
    Bitstream my_bs;
    Frame my_frame;

    my_bs.buffer32 = (unsigned long *)malloc(0x2000 * 4);
    
    if(argc < 2)
	exit(0);
    
    if(argc == 3)
	numframes = atoi(argv[2]);

    Frame_init();
    HuffmanTable_init();
    Granule_init();
    sprintf(nameb, "%s.mp3", argv[1]);
    Bitstream_open(&my_bs, nameb);
    sprintf(nameb, "%s.raw", argv[1]);
    fp = fopen(nameb, "wb");
    printf("Decoding...\n");
    do {
	fprintf(stderr, "\r[%6d]", i++);
	fflush(stderr);
	frameNum++;
	Frame_load(&my_frame, &my_bs, samples);
	fwrite(samples, 2, 576*4, fp);
/*    Frame_dump(&my_frame); */
    } while(!Bitstream32_fillbuffer(&my_bs) && i < numframes);
    printf("\n");
    Bitstream_close(&my_bs);
    fclose(fp);
    
    exit(0);
}

#endif

#ifdef DSP
 
#include "testmp.h"
//static unsigned char inbuffer[20000];

main()
{
    int i, jayjay;
#ifdef DSP_LOFI
    PCMSample samples[288*40];
#else
    PCMSample samples[576*4];
#endif
    int numframes = 40;
    Bitstream my_bs;
    Frame my_frame;
    static unsigned char bit_reservoir[BITSTREAM_BUFSIZE + 4];
    static unsigned char buffel[BITSTREAM_BUFSIZE + 4];

#ifdef DSPSIMUL
    FILE *output;
#else
#ifndef ROCKFORD
    init_da();
#endif
#endif

#ifdef ROCKFORD
    for(jayjay = 0; jayjay < 10;) {
#endif
    i = 0;
    Frame_init();
    Frame_bitbuf.buffer = bit_reservoir;

    HuffmanTable_init();
    Granule_init();

    Bitstream_open(&my_bs, 0);
    my_bs.buffer = buffel;
    Bitstream_fillbuffer(&my_bs);
#ifdef DSPSIMUL
    output = fopen("outfil.raw", "wb");
#endif
    do {
	frameNum++;
	Frame_load(&my_frame, &my_bs, samples + 288*i);
#ifdef DSPSIMUL
	fprintf(stderr, ".");
	fflush(stderr);
	fwrite(samples, 1, 576*4, output);
#else
	/*play_buffer((void *)(samples + 288*i));*/
#endif
	i++;
	Bitstream_fillbuffer(&my_bs);
    } while(i < numframes);
#ifdef ROCKFORD
    }
#else
    play_buffer((void *)samples);
#endif
#ifdef DSPSIMUL
    fprintf(stderr, "\n");
    fclose(output);
    exit(0);
#endif
    while(1);

}
#endif

static int Frame_bitbuf_framestart = 0;

void
Frame_init()
{
    Bitstream_open(&Frame_bitbuf, 0);
}


void
Frame_load(Frame *f, Bitstream *bs, PCMSample *samps)
{
  int ch, scfsi_band, gr, i, previous_end, alignbits,
      trash, part2_start;

  f->samples = samps;

  /* seek the sync word */
  if(!Bitstream_seek_sync(bs)) {
#ifndef DSP
    printf("Couldn't find sync.\n");
#endif
    return;
  }

  /* check that the ID is 1, describing ISO/IEC 11172-3 audio */
  if(!Bitstream32_get1(bs)) {
#ifndef DSP
    printf("Incorrect frame ID = 0!\n");
#endif
    return;
  }

  /* check that its a layer 3 frame */
  if(Bitstream32_get(bs, 2) != LAYER3) {
#ifndef DSP
      printf("Not a layer-3 frame!\n");
#endif
      return;
  }

  /* read the header */

  f->CRC_enable = !Bitstream32_get1(bs);  /* meaning of this bit is inverted */
  f->bitrate_index = Bitstream32_get(bs, 4);
  f->sampling_frequency = Bitstream32_get(bs, 2); 
  f->padding_bit = Bitstream32_get1(bs);
  (void)Bitstream32_get1(bs);  /* skip the private bit, we dont use it */
  f->mode = Bitstream32_get(bs, 2);
  f->channels = (f->mode == MODE_SINGLE_CHANNEL) ? 1 : 2;
  f->mode_extension = Bitstream32_get(bs, 2);
  f->copyright = Bitstream32_get1(bs);
  f->originality = Bitstream32_get1(bs);
  f->emphasis = Bitstream32_get(bs, 2);

  /* if this frame has a CRC, read it */
  
  if(f->CRC_enable)
    f->CRC = Bitstream32_get(bs, 16);

  /* now read the Layer-3 audio_data part of the frame */

  /* the following data constitutes the side information stream -
       - main_data_begin pointer
       - side info for both granules (scfsi)
       - side info granule 1
       - side info granule 2
  */

  /* read the starting offset of the main data */
  
  f->main_data_begin = Bitstream32_get(bs, 9);

  /* read private parts */
  
  if(f->channels == 1)
    (void)Bitstream32_get(bs, 5);   /* 5 private bits for single_channel */
  else
    (void)Bitstream32_get(bs, 3);   /* 3 private bits for other modes */

  /* read scalefactor selection information, 4 bits per channel */
  
  for(ch = 0; ch < f->channels; ch++)
    for(scfsi_band = 0; scfsi_band < 4; scfsi_band++)
      f->scfsi[ch][scfsi_band] = Bitstream32_get1(bs);
  
  /* read the side info for the channels for each granule */
  
  for(gr = 0; gr < 2; gr++)  
    for(ch = 0; ch < f->channels; ch++)
	Granule_decode_info(&f->gr[gr][ch], bs);
    
  /* calculate the size of this header in bytes */

  f->header_size = 4 + 2 * f->CRC_enable + (f->channels == 1 ? 17 : 32);

  /* calculate the size of the main_data block of this frame */

  /* the distance between two consequitive syncwords is determined from
     the formula: N = 144 * bitrate / sampling_frequency + padding */

  /* then we find the size of the main data by taking that number and
     subtracting the size of the header and padding */

  f->main_data_size = (int)(((144 * Frame_bitrates[f->bitrate_index]) /
    Frame_sampfreqs[f->sampling_frequency])) + f->padding_bit - f->header_size;

  /* extract all main data of this frame and insert it into the bitbuffer */
  /* ## TODO check if main data is bytealigned, if so, we can copy it much
     faster */
  
  for(i = f->main_data_size; i > 0; i--)
    Bitstream_putbyte(&Frame_bitbuf, Bitstream32_get(bs, 8));

/*   
  printf("Inserted %d bytes of main data into buffer.\n", f->main_data_size);
  */

  /* get the end (in bytes) of the last used main data */
  
  previous_end = Bitstream_tell(&Frame_bitbuf) / 8;  
/*
  printf("previous_end %d\n", previous_end);
  */
 
  /* align the bit buffer to a byte boundary */
  
  if((alignbits = Bitstream_tell(&Frame_bitbuf) % 8)) {
    Bitstream_get(&Frame_bitbuf, 8 - alignbits);
    previous_end++;
  }

  /* see if there is a gap between the end of the last framedata and
     the start of the new framedata, and if so, discard it. If trash 
     is negative, it means there was an error and there isn't enough
     data to decode this frame */
 
  trash = Frame_bitbuf_framestart - previous_end - f->main_data_begin;

  if(previous_end > BITSTREAM_BUFSIZE) {
    Frame_bitbuf_framestart -= BITSTREAM_BUFSIZE;
    Bitstream_rewindbytes(&Frame_bitbuf, BITSTREAM_BUFSIZE);
  }

  if(trash < 0) {
#ifndef DSP
    printf("Too little data to decode frame.\n");
#endif
    return;
  } else if(trash > 0) {
#ifndef DSP
    printf("%d bytes of trash\n", trash);
#endif
    Bitstream_get(&Frame_bitbuf, 8 * trash);
  }

  /* duplicate the end to reduce the need for modulo calcs in huffman */
  
  Frame_bitbuf.buffer[BITSTREAM_BUFSIZE] = Frame_bitbuf.buffer[0];
  Frame_bitbuf.buffer[BITSTREAM_BUFSIZE + 1] = Frame_bitbuf.buffer[1];
  Frame_bitbuf.buffer[BITSTREAM_BUFSIZE + 2] = Frame_bitbuf.buffer[2];
  Frame_bitbuf.buffer[BITSTREAM_BUFSIZE + 3] = Frame_bitbuf.buffer[3];

  /* remember the start of the next frame */

  Frame_bitbuf_framestart += f->main_data_size;

  /* the Frame_bitbuf stream is now positioned at the start of the
     main_data for this frame, and we know there is enough data to
     decode it, so start reading the granules now. */

  /* the following data constitute the main data stream -
       - scalefactors and Huffman code data granule 1
       - scalefactors and Huffman code data granule 2
       - ancillary data
  */

  /* Bands, scalefactors etc:
       The spectrum of 576 frequency lines, is divided into bands 
       differently depending on sampling frequency and block type.
       Each band has its own scalefactor, which is read below.
       Each band also has its own huffman coded energies, read further
       below.
  */

  /* read the main data stream for both granules */

  for(gr = 0; gr < 2; gr++) {
      
      /* read the main data stream for all channels in the granule */

      Granule_floatfreqs xr[2];     /* 2*576 = 1152 */
      Granule_floatfreqs lr[2];     /* 2*576 = 1152 */

      for(ch = 0; ch < f->channels; ch++) {
	  Granule_intfreqs is;  /* for storing the de-huffmanized energies */

	  part2_start = Bitstream_tell(&Frame_bitbuf);
	  
	  /* decode the scalefactors */

	  Granule_decode_scalefactors(&f->gr[gr][ch], &Frame_bitbuf,
				      ch, gr, f);
	  
	  /* now comes the Huffman coded bits */
	  PROFSTART;

	  Granule_decode_huffman(&f->gr[gr][ch], &Frame_bitbuf, 
				 part2_start, is, f);
	  PROFSTOP;
/*
	  if(frameNum == 85)
	      dump_ints(is, 576);
	      */      
	  Granule_requantize(&f->gr[gr][ch], is, xr[ch], f);

      } /* end of channel loop */

      /* we have the decoded and requantized spectrum for both channels,
	 so we can apply stereo processing */
      /* xr -> lr */

      Granule_process_stereo(&f->gr[gr][0], &f->gr[gr][1], xr, lr, f);
      
      /* now we can, for each channel, synthesize the PCM output */

      for(ch = 0; ch < f->channels; ch++) {
	  
	  /* first we have to reorder short block data */
	  /* lr -> xr */
	  Granule_reorder(&f->gr[gr][ch], lr[ch], xr[ch], f);
/*
	  if(frameNum == 10) {
	      printf("Granule %d\n", gr);
	      dump_floats(lr2[ch], 576);
	  }
	  */
	  /* now we do the alias reduction */
	  /* xr -> xr */
	  Granule_antialias(&f->gr[gr][ch], xr[ch]);
	      
	  /* apply the IMDCT transform */
	  /* xr -> xr */
	  Granule_imdct(&f->gr[gr][ch], ch, xr[ch]);
	  /* frequency inversion to compensate for the polyphase filterbank */
	  /* xr -> xr */
	  
	  Granule_freqinverse(&f->gr[gr][ch], xr[ch]);

	  /* finally generate the PCM samples from the filterbank */
/*
	  if(frameNum == 10) {
	      int z;
	      for(z = 0; z < 576; z++) {
		  if(z && !(z % 5))
		      printf("\n");
		  printf("%6d ", f->samples[gr][z][0]);
	      }
	  }
	  */
      }

#ifdef WIN32
#define FABS(x) (x > 0.0 ? x : -x)
	  /* the windows player has a nice spectrum analyser.. */
	  {
	      int z, y;
	      for(z = 0; z < 32; z++) {
		  f->spectrum[z] = 0.0f;
		  for(y = 0; y < 18; y++)
		      f->spectrum[z] +=
			  FABS(xr[0][z*18+y]) +
			  FABS(xr[1][z*18+y]);
	      }
	  }
#endif

      /* for stereo, use an optimized subband synthesis routine that
	 processes both channels at once */
      /* xr -> samples */

#ifdef DSP_LOFI
      /* do lo-fidelity processing, mono in 11khz *shiver* */
      Granule_subband_synthesis(&f->gr[gr][0], 0, xr[0],
				&f->samples[gr*144]);
#else

      if(f->channels == 2)
	  Granule_subband_synthesis2(&f->gr[gr][ch], xr[0],
				     xr[1],
				     &f->samples[gr*576*2]);
      else
	  Granule_subband_synthesis(&f->gr[gr][0], 0, xr[0],
				    &f->samples[gr*576*2]);
#endif  

  } /* end of granule loop */

}

#ifdef MAKE_DATA

void
make_data_file(const char *fname, const char *datname, mpfloat *nbrs, int len)
{
    int i;
    FILE *f = fopen(fname, "w");
    fprintf(f, "static mpfloat %s[%d] = {\n", datname, len);
    for(i = 0; i < len; i++) {
	if(i && !(i % 4))
	    fprintf(f, "\n");
	fprintf(f, "%.12g, ", nbrs[i]);
    }
    fprintf(f, "\n};\n\n");

    fclose(f);
}

void
make_data_file_2d(const char *fname,
		  const char *datname, mpfloat *nbrs, int len1, int len2)
{
    int i, j;
    FILE *f = fopen(fname, "w");
    fprintf(f, "static mpfloat %s[%d][%d] = {\n", datname, len1, len2);
    for(j = 0; j < len1; j++) {
	fprintf(f, "{\n");
	for(i = 0; i < len2; i++) {