javazoom.jl.decoder.LayerIIIDecoder.get_LSF_scale_data C# (CSharp) Метод

        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] = (SupportClass.URShift(scalefac_comp, 4)) / 5;
                    new_slen[1] = (SupportClass.URShift(scalefac_comp, 4)) % 5;
                    new_slen[2] = SupportClass.URShift((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] = (SupportClass.URShift((scalefac_comp - 400), 2)) / 5;
                    new_slen[1] = (SupportClass.URShift((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 = SupportClass.URShift(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] = SupportClass.URShift(((int_scalefac_comp - 180) & 0x3F), 4);
                    new_slen[1] = SupportClass.URShift(((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 ...
        }