javazoom.jl.decoder.LayerIIIDecoder.decode C# (CSharp) Méthode

        public void decode()
        {
            int nSlots = header.slots();
            int flush_main;
            int gr, ch, ss, sb, sb18;
            int main_data_end;
            int bytes_to_discard;
            int i;

            get_side_info();

            for (i = 0; i < nSlots; i++)
                br.hputbuf(stream.get_bits(8));

            main_data_end = SupportClass.URShift(br.hsstell(), 3); // of previous frame

            if ((flush_main = (br.hsstell() & 7)) != 0)
            {
                br.hgetbits(8 - flush_main);
                main_data_end++;
            }

            bytes_to_discard = frame_start - main_data_end - si.main_data_begin;

            frame_start += nSlots;

            if (bytes_to_discard < 0)
                return ;

            if (main_data_end > 4096)
            {
                frame_start -= 4096;
                br.rewindNbytes(4096);
            }

            for (; bytes_to_discard > 0; bytes_to_discard--)
                br.hgetbits(8);

            for (gr = 0; gr < max_gr; gr++)
            {

                for (ch = 0; ch < channels; ch++)
                {
                    part2_start = br.hsstell();

                    if (header.version() == Header.MPEG1)
                        get_scale_factors(ch, gr);
                    // MPEG-2 LSF, SZD: MPEG-2.5 LSF
                    else
                        get_LSF_scale_factors(ch, gr);

                    huffman_decode(ch, gr);
                    // System.out.println("CheckSum HuffMan = " + CheckSumHuff);
                    dequantize_sample(ro[ch], ch, gr);
                }

                stereo(gr);

                if ((which_channels == OutputChannels.DOWNMIX_CHANNELS) && (channels > 1))
                    do_downmix();

                for (ch = first_channel; ch <= last_channel; ch++)
                {

                    reorder(lr[ch], ch, gr);
                    antialias(ch, gr);
                    //for (int hb = 0;hb<576;hb++) CheckSumOut1d = CheckSumOut1d + out_1d[hb];
                    //System.out.println("CheckSumOut1d = "+CheckSumOut1d);

                    hybrid(ch, gr);

                    //for (int hb = 0;hb<576;hb++) CheckSumOut1d = CheckSumOut1d + out_1d[hb];
                    //System.out.println("CheckSumOut1d = "+CheckSumOut1d);

                    for (sb18 = 18; sb18 < 576; sb18 += 36)
                    // Frequency inversion
                        for (ss = 1; ss < SSLIMIT; ss += 2)
                            out_1d[sb18 + ss] = - out_1d[sb18 + ss];

                    if ((ch == 0) || (which_channels == OutputChannels.RIGHT_CHANNEL))
                    {
                        for (ss = 0; ss < SSLIMIT; ss++)
                        {
                            // Polyphase synthesis
                            sb = 0;
                            for (sb18 = 0; sb18 < 576; sb18 += 18)
                            {
                                samples1[sb] = out_1d[sb18 + ss];
                                //filter1.input_sample(out_1d[sb18+ss], sb);
                                sb++;
                            }
                            //buffer.appendSamples(0, samples1);
                            //Console.WriteLine("Adding samples right into output buffer");
                            filter1.input_samples(samples1);
                            filter1.calculate_pcm_samples(buffer);
                        }
                    }
                    else
                    {
                        for (ss = 0; ss < SSLIMIT; ss++)
                        {
                            // Polyphase synthesis
                            sb = 0;
                            for (sb18 = 0; sb18 < 576; sb18 += 18)
                            {
                                samples2[sb] = out_1d[sb18 + ss];
                                //filter2.input_sample(out_1d[sb18+ss], sb);
                                sb++;
                            }
                            //buffer.appendSamples(1, samples2);
                            //Console.WriteLine("Adding samples right into output buffer");
                            filter2.input_samples(samples2);
                            filter2.calculate_pcm_samples(buffer);
                        }
                    }
                }
                // channels
            }
            // granule

            // System.out.println("Counter = ................................."+counter);
            //if (counter <  609)
            //{
            counter++;
            buffer.write_buffer(1);
            //}
            //else if (counter == 609)
            //{
            //    buffer.close();
            //    counter++;
            //}
            //else
            //{
            //}
        }