layeriiidecoder.java

JLayer is a library that decodes/plays/converts MPEG 1/2/2.5 Layer 1/2/3 (i.e. MP3) in real time fo

		               si.ch[ch].gr[gr].region0_count = 7;
	               }
						si.ch[ch].gr[gr].region1_count = 20 -
								si.ch[ch].gr[gr].region0_count;
					} else {
						si.ch[ch].gr[gr].table_select[0] = stream.get_bits(5);
						si.ch[ch].gr[gr].table_select[1] = stream.get_bits(5);
						si.ch[ch].gr[gr].table_select[2] = stream.get_bits(5);
						si.ch[ch].gr[gr].region0_count = stream.get_bits(4);
						si.ch[ch].gr[gr].region1_count = stream.get_bits(3);
						si.ch[ch].gr[gr].block_type = 0;
					}
					si.ch[ch].gr[gr].preflag = stream.get_bits(1);
					si.ch[ch].gr[gr].scalefac_scale = stream.get_bits(1);
					si.ch[ch].gr[gr].count1table_select = stream.get_bits(1);
	         }
	      }

		} else {  	// MPEG-2 LSF, SZD: MPEG-2.5 LSF

	      si.main_data_begin = stream.get_bits(8);
	      if (channels == 1)
	      	si.private_bits = stream.get_bits(1);
	      else si.private_bits = stream.get_bits(2);

	      for (ch=0; ch<channels; ch++) {

	          si.ch[ch].gr[0].part2_3_length = stream.get_bits(12);
	          si.ch[ch].gr[0].big_values = stream.get_bits(9);
	          si.ch[ch].gr[0].global_gain = stream.get_bits(8);
	          si.ch[ch].gr[0].scalefac_compress = stream.get_bits(9);
	          si.ch[ch].gr[0].window_switching_flag = stream.get_bits(1);

	          if ((si.ch[ch].gr[0].window_switching_flag) != 0) {

	             si.ch[ch].gr[0].block_type = stream.get_bits(2);
	             si.ch[ch].gr[0].mixed_block_flag = stream.get_bits(1);
	             si.ch[ch].gr[0].table_select[0] = stream.get_bits(5);
	             si.ch[ch].gr[0].table_select[1] = stream.get_bits(5);

	             si.ch[ch].gr[0].subblock_gain[0] = stream.get_bits(3);
	             si.ch[ch].gr[0].subblock_gain[1] = stream.get_bits(3);
	             si.ch[ch].gr[0].subblock_gain[2] = stream.get_bits(3);

	            // Set region_count parameters since they are implicit in this case.

	             if (si.ch[ch].gr[0].block_type == 0) {
	                // Side info bad: block_type == 0 in split block
	                return false;
	             } else if (si.ch[ch].gr[0].block_type == 2
	                      && si.ch[ch].gr[0].mixed_block_flag == 0) {
	             	 si.ch[ch].gr[0].region0_count = 8;
					 } else {
	             	 si.ch[ch].gr[0].region0_count = 7;
	                si.ch[ch].gr[0].region1_count = 20 -
	                											si.ch[ch].gr[0].region0_count;
	             }

	          } else {
	             si.ch[ch].gr[0].table_select[0] = stream.get_bits(5);
	             si.ch[ch].gr[0].table_select[1] = stream.get_bits(5);
	             si.ch[ch].gr[0].table_select[2] = stream.get_bits(5);
	             si.ch[ch].gr[0].region0_count = stream.get_bits(4);
	             si.ch[ch].gr[0].region1_count = stream.get_bits(3);
	             si.ch[ch].gr[0].block_type = 0;
	          }

	          si.ch[ch].gr[0].scalefac_scale = stream.get_bits(1);
	          si.ch[ch].gr[0].count1table_select = stream.get_bits(1);
	      }   // for(ch=0; ch<channels; ch++)
	   } // if (header.version() == MPEG1)
	  return true;
	}

    /**
	 *
	 */
	private void get_scale_factors(int ch, int gr)
	{
	   int sfb, window;
	   gr_info_s gr_info = (si.ch[ch].gr[gr]);
	   int scale_comp   = gr_info.scalefac_compress;
	   int length0      = slen[0][scale_comp];
	   int length1      = slen[1][scale_comp];

		if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {
			if ((gr_info.mixed_block_flag) != 0) { // MIXED
				for (sfb = 0; sfb < 8; sfb++)
					scalefac[ch].l[sfb] = br.hgetbits(
						  slen[0][gr_info.scalefac_compress]);
				for (sfb = 3; sfb < 6; sfb++)
					for (window=0; window<3; window++)
						scalefac[ch].s[window][sfb] = br.hgetbits(
						  slen[0][gr_info.scalefac_compress]);
				for (sfb = 6; sfb < 12; sfb++)
					for (window=0; window<3; window++)
						scalefac[ch].s[window][sfb] = br.hgetbits(
						  slen[1][gr_info.scalefac_compress]);
				for (sfb=12,window=0; window<3; window++)
					scalefac[ch].s[window][sfb] = 0;

	      } else {  // SHORT

	         scalefac[ch].s[0][0]  = br.hgetbits(length0);
	         scalefac[ch].s[1][0]  = br.hgetbits(length0);
	         scalefac[ch].s[2][0]  = br.hgetbits(length0);
	         scalefac[ch].s[0][1]  = br.hgetbits(length0);
	         scalefac[ch].s[1][1]  = br.hgetbits(length0);
	         scalefac[ch].s[2][1]  = br.hgetbits(length0);
	         scalefac[ch].s[0][2]  = br.hgetbits(length0);
	         scalefac[ch].s[1][2]  = br.hgetbits(length0);
	         scalefac[ch].s[2][2]  = br.hgetbits(length0);
	         scalefac[ch].s[0][3]  = br.hgetbits(length0);
	         scalefac[ch].s[1][3]  = br.hgetbits(length0);
	         scalefac[ch].s[2][3]  = br.hgetbits(length0);
	         scalefac[ch].s[0][4]  = br.hgetbits(length0);
	         scalefac[ch].s[1][4]  = br.hgetbits(length0);
	         scalefac[ch].s[2][4]  = br.hgetbits(length0);
	         scalefac[ch].s[0][5]  = br.hgetbits(length0);
	         scalefac[ch].s[1][5]  = br.hgetbits(length0);
	         scalefac[ch].s[2][5]  = br.hgetbits(length0);
	         scalefac[ch].s[0][6]  = br.hgetbits(length1);
	         scalefac[ch].s[1][6]  = br.hgetbits(length1);
	         scalefac[ch].s[2][6]  = br.hgetbits(length1);
	         scalefac[ch].s[0][7]  = br.hgetbits(length1);
	         scalefac[ch].s[1][7]  = br.hgetbits(length1);
	         scalefac[ch].s[2][7]  = br.hgetbits(length1);
	         scalefac[ch].s[0][8]  = br.hgetbits(length1);
	         scalefac[ch].s[1][8]  = br.hgetbits(length1);
	         scalefac[ch].s[2][8]  = br.hgetbits(length1);
	         scalefac[ch].s[0][9]  = br.hgetbits(length1);
	         scalefac[ch].s[1][9]  = br.hgetbits(length1);
	         scalefac[ch].s[2][9]  = br.hgetbits(length1);
	         scalefac[ch].s[0][10] = br.hgetbits(length1);
	         scalefac[ch].s[1][10] = br.hgetbits(length1);
	         scalefac[ch].s[2][10] = br.hgetbits(length1);
	         scalefac[ch].s[0][11] = br.hgetbits(length1);
	         scalefac[ch].s[1][11] = br.hgetbits(length1);
	         scalefac[ch].s[2][11] = br.hgetbits(length1);
	         scalefac[ch].s[0][12] = 0;
				scalefac[ch].s[1][12] = 0;
				scalefac[ch].s[2][12] = 0;
			} // SHORT

		} else {   // LONG types 0,1,3

	      if ((si.ch[ch].scfsi[0] == 0) || (gr == 0)) {
	           scalefac[ch].l[0]  = br.hgetbits(length0);
	           scalefac[ch].l[1]  = br.hgetbits(length0);
	           scalefac[ch].l[2]  = br.hgetbits(length0);
	           scalefac[ch].l[3]  = br.hgetbits(length0);
	           scalefac[ch].l[4]  = br.hgetbits(length0);
	           scalefac[ch].l[5]  = br.hgetbits(length0);
			}
	      if ((si.ch[ch].scfsi[1] == 0) || (gr == 0)) {
	           scalefac[ch].l[6]  = br.hgetbits(length0);
	           scalefac[ch].l[7]  = br.hgetbits(length0);
	           scalefac[ch].l[8]  = br.hgetbits(length0);
	           scalefac[ch].l[9]  = br.hgetbits(length0);
	           scalefac[ch].l[10] = br.hgetbits(length0);
			}
	      if ((si.ch[ch].scfsi[2] == 0) || (gr == 0)) {
	           scalefac[ch].l[11] = br.hgetbits(length1);
	           scalefac[ch].l[12] = br.hgetbits(length1);
	           scalefac[ch].l[13] = br.hgetbits(length1);
	           scalefac[ch].l[14] = br.hgetbits(length1);
	           scalefac[ch].l[15] = br.hgetbits(length1);
			}
	      if ((si.ch[ch].scfsi[3] == 0) || (gr == 0)) {
	           scalefac[ch].l[16] = br.hgetbits(length1);
	           scalefac[ch].l[17] = br.hgetbits(length1);
	           scalefac[ch].l[18] = br.hgetbits(length1);
	           scalefac[ch].l[19] = br.hgetbits(length1);
	           scalefac[ch].l[20] = br.hgetbits(length1);
			}

	      scalefac[ch].l[21] = 0;
		  scalefac[ch].l[22] = 0;
		}
	}

    /**
	 *
	 */
	// MDM: new_slen is fully initialized before use, no need
	// to reallocate array.
	private final int[] new_slen = new int[4];

	private void get_LSF_scale_data(int ch, int gr)
	{

	  	int scalefac_comp, int_scalefac_comp;
	    int mode_ext = header.mode_extension();
		int m;
		int blocktypenumber;
		int blocknumber = 0;

		gr_info_s gr_info = (si.ch[ch].gr[gr]);

		scalefac_comp =  gr_info.scalefac_compress;

	    if (gr_info.block_type == 2) {
	     if (gr_info.mixed_block_flag == 0)
	      	blocktypenumber = 1;
	      else if (gr_info.mixed_block_flag == 1)
				blocktypenumber = 2;
	      else
	      	blocktypenumber = 0;
	    } else {
	   	blocktypenumber = 0;
	    }

	   if(!(((mode_ext == 1) || (mode_ext == 3)) && (ch == 1))) {

			if(scalefac_comp < 400) {

				new_slen[0] = (scalefac_comp >>> 4) / 5 ;
				new_slen[1] = (scalefac_comp >>> 4) % 5 ;
				new_slen[2] = (scalefac_comp & 0xF) >>> 2 ;
				new_slen[3] = (scalefac_comp & 3);
	         	si.ch[ch].gr[gr].preflag = 0;
	         	blocknumber = 0;

	       } else if (scalefac_comp  < 500) {

				new_slen[0] = ((scalefac_comp - 400) >>> 2) / 5 ;
				new_slen[1] = ((scalefac_comp - 400) >>> 2) % 5 ;
				new_slen[2] = (scalefac_comp - 400 ) & 3 ;
				new_slen[3] = 0;
	         	si.ch[ch].gr[gr].preflag = 0;
	         	blocknumber = 1;

		   } else if (scalefac_comp < 512) {

				new_slen[0] = (scalefac_comp - 500 ) / 3 ;
				new_slen[1] = (scalefac_comp - 500)  % 3 ;
				new_slen[2] = 0;
				new_slen[3] = 0;
	      		si.ch[ch].gr[gr].preflag = 1;
		      	blocknumber = 2;
	 	   }
	   }

	   if((((mode_ext == 1) || (mode_ext == 3)) && (ch == 1)))
	   {
	      int_scalefac_comp = scalefac_comp >>> 1;

	      if (int_scalefac_comp < 180)
	      {
				new_slen[0] = int_scalefac_comp  / 36 ;
				new_slen[1] = (int_scalefac_comp % 36 ) / 6 ;
				new_slen[2] = (int_scalefac_comp % 36) % 6;
				new_slen[3] = 0;
	         	si.ch[ch].gr[gr].preflag = 0;
	         	blocknumber = 3;
	      } else if (int_scalefac_comp < 244) {
				new_slen[0] = ((int_scalefac_comp - 180 )  & 0x3F) >>> 4 ;
				new_slen[1] = ((int_scalefac_comp - 180) & 0xF) >>> 2 ;
				new_slen[2] = (int_scalefac_comp - 180 ) & 3 ;
				new_slen[3] = 0;
	         	si.ch[ch].gr[gr].preflag = 0;
	         	blocknumber = 4;
	      } else if (int_scalefac_comp < 255) {
				new_slen[0] = (int_scalefac_comp - 244 ) / 3 ;
				new_slen[1] = (int_scalefac_comp - 244 )  % 3 ;
				new_slen[2] = 0 ;
				new_slen[3] = 0;
	         	si.ch[ch].gr[gr].preflag = 0;
	         	blocknumber = 5;
	      }
	   }

	   for (int x=0; x<45; x++) // why 45, not 54?
	   	scalefac_buffer[x] = 0;

	   m = 0;
	   for (int i=0; i<4;i++) {
	     	for (int j = 0; j < nr_of_sfb_block[blocknumber][blocktypenumber][i];
	      	 j++)
	      {
	        scalefac_buffer[m] = (new_slen[i] == 0) ? 0 :
	        							  br.hgetbits(new_slen[i]);
	        m++;

	      } // for (unint32 j ...
   		} // for (uint32 i ...
	}

	/**
	 *
	 */
    private void get_LSF_scale_factors(int ch, int gr)
	{
		int m = 0;
	    int sfb, window;
		gr_info_s gr_info = (si.ch[ch].gr[gr]);

	    get_LSF_scale_data(ch, gr);

	    if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {
	      if (gr_info.mixed_block_flag != 0) { 	// MIXED
	         for (sfb = 0; sfb < 8; sfb++)
	         {
	              scalefac[ch].l[sfb] = scalefac_buffer[m];
	              m++;
	         }
	         for (sfb = 3; sfb < 12; sfb++) {
	            for (window=0; window<3; window++)
	            {
	               scalefac[ch].s[window][sfb] = scalefac_buffer[m];
	               m++;
	            }
	         }
	         for (window=0; window<3; window++)
	            scalefac[ch].s[window][12] = 0;

	      } else {  // SHORT

	           for (sfb = 0; sfb < 12; sfb++) {
	               for (window=0; window<3; window++)
	               {
	                  scalefac[ch].s[window][sfb] = scalefac_buffer[m];
	                  m++;
	               }
	           }

	           for (window=0; window<3; window++)
	               scalefac[ch].s[window][12] = 0;
	      }
	   } else {   // LONG types 0,1,3

	      for (sfb = 0; sfb < 21; sfb++) {
	          scalefac[ch].l[sfb] = scalefac_buffer[m];
	          m++;
	      }
	      scalefac[ch].l[21] = 0; // Jeff
	      scalefac[ch].l[22] = 0;
		}
	}

	/**
	 *
	 */
    int[] x = {0};
	int[] y = {0};
	int[] v = {0};
	int[] w = {0};
	private void huffman_decode(int ch, int gr)
	{
		x[0] = 0;
		y[0] = 0;
		v[0] = 0;
		w[0] = 0;

	   	int part2_3_end = part2_start + si.ch[ch].gr[gr].part2_3_length;
	   	int num_bits;
		int region1Start;
		int region2Start;
	    int index;

	    int buf, buf1;

	 	huffcodetab h;

		// Find region boundary for short block case

		if ( ((si.ch[ch].gr[gr].window_switching_flag) != 0) &&
			  (si.ch[ch].gr[gr].block_type == 2) ) {

			// Region2.
	    //MS: Extrahandling for 8KHZ
	    region1Start = (sfreq == 8) ? 72 : 36;  // sfb[9/3]*3=36 or in case 8KHZ = 72
			region2Start = 576; // No Region2 for short block case

	  } else {          // Find region boundary for long block case

	    buf = si.ch[ch].gr[gr].region0_count + 1;
	    buf1 = buf + si.ch[ch].gr[gr].region1_count + 1;

	    if(buf1 > sfBandIndex[sfreq].l.length - 1) buf1 = sfBandIndex[sfreq].l.length - 1;

			region1Start = sfBandIndex[sfreq].l[buf];
			region2Start = sfBandIndex[sfreq].l[buf1]; /* MI */
	   }

	   index = 0;
		// Read bigvalues area
		for (int i=0; i<(si.ch[ch].gr[gr].big_values<<1); i+=2) {
			if      (i<region1Start) h = huffcodetab.ht[si.ch[ch].gr[gr].table_select[0]];
			else if (i<region2Start) h = huffcodetab.ht[si.ch[ch].gr[gr].table_select[1]];
				  else                h = huffcodetab.ht[si.ch[ch].gr[gr].table_select[2]];

			huffcodetab.huffman_decoder(h, x, y, v, w, br);
		  //if (index >= is_1d.length) System.out.println("i0="+i+"/"+(si.ch[ch].gr[gr].big_values<<1)+" Index="+index+" is_1d="+is_1d.length);
	      
	      is_1d[index++] = x[0];
	      is_1d[index++] = y[0];
	      
	      CheckSumHuff = CheckSumHuff + x[0] + y[0];