Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. #include "layer3.h"
  2.  
  3. extern SIDE_INFO        m_side_info;
  4. extern SCALE_FACTOR     m_scale_fac[2][2];      // [gr][ch]
  5. extern IS_SF_INFO       m_is_sf_info;
  6.  
  7. extern int                      m_is_mode;
  8.  
  9. static const int slen_table[16][2] =
  10. {
  11.         0, 0, 0, 1,
  12.         0, 2, 0, 3,
  13.         3, 0, 1, 1,
  14.         1, 2, 1, 3,
  15.         2, 1, 2, 2,
  16.         2, 3, 3, 1,
  17.         3, 2, 3, 3,
  18.         4, 2, 4, 3,
  19. };
  20.  
  21. /* nr_table[size+3*is_right][block type 0,1,3  2, 2+mixed][4]  */
  22. /* for bt=2 nr is count for group of 3 */
  23. static const int nr_table[6][3][4] =
  24. {
  25.         6, 5, 5, 5,
  26.         3, 3, 3, 3,
  27.         6, 3, 3, 3,
  28.  
  29.         6, 5, 7, 3,
  30.         3, 3, 4, 2,
  31.         6, 3, 4, 2,
  32.  
  33.         11, 10, 0, 0,
  34.         6, 6, 0, 0,
  35.         6, 3, 6, 0,                     /* adjusted *//* 15, 18, 0, 0,   */
  36. /*-intensity stereo right chan--*/
  37.         7, 7, 7, 0,
  38.         4, 4, 4, 0,
  39.         6, 5, 4, 0,
  40.  
  41.         6, 6, 6, 3,
  42.         4, 3, 3, 2,
  43.         6, 4, 3, 2,
  44.  
  45.         8, 8, 5, 0,
  46.         5, 4, 3, 0,
  47.         6, 6, 3, 0,
  48. };
  49.  
  50. void L3get_scale_factor1(int gr, int ch)
  51. {
  52.         SCALE_FACTOR* sf = &m_scale_fac[gr][ch];
  53.         GR_INFO* grdat = &m_side_info.gr[gr][ch];
  54.         int scfsi = m_side_info.scfsi[ch];
  55.  
  56.         int sfb;
  57.         int slen0, slen1;
  58.         int block_type, mixed_block_flag, scalefac_compress;
  59.  
  60.         block_type = grdat->block_type;
  61.         mixed_block_flag = grdat->mixed_block_flag;
  62.         scalefac_compress = grdat->scalefac_compress;
  63.  
  64.         slen0 = slen_table[scalefac_compress][0];
  65.         slen1 = slen_table[scalefac_compress][1];
  66.  
  67.         if (block_type == 2) {
  68.                 if (mixed_block_flag) {                         /* mixed */
  69.                         for (sfb = 0; sfb < 8; sfb++)
  70.                                 sf[0].l[sfb] = bitget(slen0);
  71.                         for (sfb = 3; sfb < 6; sfb++) {
  72.                                 sf[0].s[0][sfb] = bitget(slen0);
  73.                                 sf[0].s[1][sfb] = bitget(slen0);
  74.                                 sf[0].s[2][sfb] = bitget(slen0);
  75.                         }
  76.                         for (sfb = 6; sfb < 12; sfb++) {
  77.                                 sf[0].s[0][sfb] = bitget(slen1);
  78.                                 sf[0].s[1][sfb] = bitget(slen1);
  79.                                 sf[0].s[2][sfb] = bitget(slen1);
  80.                         }
  81.                         return;
  82.                 }
  83.                 for (sfb = 0; sfb < 6; sfb++) {
  84.                         sf[0].s[0][sfb] = bitget(slen0);
  85.                         sf[0].s[1][sfb] = bitget(slen0);
  86.                         sf[0].s[2][sfb] = bitget(slen0);
  87.                 }
  88.                 for (; sfb < 12; sfb++) {
  89.                         sf[0].s[0][sfb] = bitget(slen1);
  90.                         sf[0].s[1][sfb] = bitget(slen1);
  91.                         sf[0].s[2][sfb] = bitget(slen1);
  92.                 }
  93.                 return;
  94.         }
  95.  
  96. /* long blocks types 0 1 3, first granule */
  97.    if (gr == 0)
  98.    {
  99.       for (sfb = 0; sfb < 11; sfb++)
  100.          sf[0].l[sfb] = bitget(slen0);
  101.       for (; sfb < 21; sfb++)
  102.          sf[0].l[sfb] = bitget(slen1);
  103.       return;
  104.    }
  105.  
  106. /* long blocks 0, 1, 3, second granule */
  107.    sfb = 0;
  108.    if (scfsi & 8)
  109.       for (; sfb < 6; sfb++)
  110.          sf[0].l[sfb] = sf[-2].l[sfb];
  111.    else
  112.       for (; sfb < 6; sfb++)
  113.          sf[0].l[sfb] = bitget(slen0);
  114.    if (scfsi & 4)
  115.       for (; sfb < 11; sfb++)
  116.          sf[0].l[sfb] = sf[-2].l[sfb];
  117.    else
  118.       for (; sfb < 11; sfb++)
  119.          sf[0].l[sfb] = bitget(slen0);
  120.    if (scfsi & 2)
  121.       for (; sfb < 16; sfb++)
  122.          sf[0].l[sfb] = sf[-2].l[sfb];
  123.    else
  124.       for (; sfb < 16; sfb++)
  125.          sf[0].l[sfb] = bitget(slen1);
  126.    if (scfsi & 1)
  127.       for (; sfb < 21; sfb++)
  128.          sf[0].l[sfb] = sf[-2].l[sfb];
  129.    else
  130.       for (; sfb < 21; sfb++)
  131.          sf[0].l[sfb] = bitget(slen1);
  132. }
  133.  
  134. void L3get_scale_factor2(int gr, int ch)
  135. {
  136.         SCALE_FACTOR* sf = &m_scale_fac[gr][ch];
  137.         GR_INFO* grdat = &m_side_info.gr[gr][ch];
  138.         int is_and_ch = m_is_mode & ch;
  139.  
  140.    int sfb;
  141.    int slen1, slen2, slen3, slen4;
  142.    int nr1, nr2, nr3, nr4;
  143.    int i, k;
  144.    int preflag, intensity_scale;
  145.    int block_type, mixed_block_flag, scalefac_compress;
  146.  
  147.  
  148.    block_type = grdat->block_type;
  149.    mixed_block_flag = grdat->mixed_block_flag;
  150.    scalefac_compress = grdat->scalefac_compress;
  151.  
  152.    preflag = 0;
  153.    intensity_scale = 0;         /* to avoid compiler warning */
  154.    if (is_and_ch == 0)
  155.    {
  156.       if (scalefac_compress < 400)
  157.       {
  158.          slen2 = scalefac_compress >> 4;
  159.          slen1 = slen2 / 5;
  160.          slen2 = slen2 % 5;
  161.          slen4 = scalefac_compress & 15;
  162.          slen3 = slen4 >> 2;
  163.          slen4 = slen4 & 3;
  164.          k = 0;
  165.       }
  166.       else if (scalefac_compress < 500)
  167.       {
  168.          scalefac_compress -= 400;
  169.          slen2 = scalefac_compress >> 2;
  170.          slen1 = slen2 / 5;
  171.          slen2 = slen2 % 5;
  172.          slen3 = scalefac_compress & 3;
  173.          slen4 = 0;
  174.          k = 1;
  175.       }
  176.       else
  177.       {
  178.          scalefac_compress -= 500;
  179.          slen1 = scalefac_compress / 3;
  180.          slen2 = scalefac_compress % 3;
  181.          slen3 = slen4 = 0;
  182.          if (mixed_block_flag)
  183.          {
  184.             slen3 = slen2;      /* adjust for long/short mix logic */
  185.             slen2 = slen1;
  186.          }
  187.          preflag = 1;
  188.          k = 2;
  189.       }
  190.    }
  191.    else
  192.    {                            /* intensity stereo ch = 1 (right) */
  193.       intensity_scale = scalefac_compress & 1;
  194.       scalefac_compress >>= 1;
  195.       if (scalefac_compress < 180)
  196.       {
  197.          slen1 = scalefac_compress / 36;
  198.          slen2 = scalefac_compress % 36;
  199.          slen3 = slen2 % 6;
  200.          slen2 = slen2 / 6;
  201.          slen4 = 0;
  202.          k = 3 + 0;
  203.       }
  204.       else if (scalefac_compress < 244)
  205.       {
  206.          scalefac_compress -= 180;
  207.          slen3 = scalefac_compress & 3;
  208.          scalefac_compress >>= 2;
  209.          slen2 = scalefac_compress & 3;
  210.          slen1 = scalefac_compress >> 2;
  211.          slen4 = 0;
  212.          k = 3 + 1;
  213.       }
  214.       else
  215.       {
  216.          scalefac_compress -= 244;
  217.          slen1 = scalefac_compress / 3;
  218.          slen2 = scalefac_compress % 3;
  219.          slen3 = slen4 = 0;
  220.          k = 3 + 2;
  221.       }
  222.    }
  223.  
  224.    i = 0;
  225.    if (block_type == 2)
  226.       i = (mixed_block_flag & 1) + 1;
  227.    nr1 = nr_table[k][i][0];
  228.    nr2 = nr_table[k][i][1];
  229.    nr3 = nr_table[k][i][2];
  230.    nr4 = nr_table[k][i][3];
  231.  
  232.  
  233. /* return is scale factor info (for right chan is mode) */
  234.    if (is_and_ch)
  235.    {
  236.       m_is_sf_info.nr[0] = nr1;
  237.       m_is_sf_info.nr[1] = nr2;
  238.       m_is_sf_info.nr[2] = nr3;
  239.       m_is_sf_info.slen[0] = slen1;
  240.       m_is_sf_info.slen[1] = slen2;
  241.       m_is_sf_info.slen[2] = slen3;
  242.       m_is_sf_info.intensity_scale = intensity_scale;
  243.    }
  244.    grdat->preflag = preflag;    /* return preflag */
  245.  
  246. /*--------------------------------------*/
  247.    if (block_type == 2)
  248.    {
  249.       if (mixed_block_flag)
  250.       {                         /* mixed */
  251.          if (slen1 != 0)        /* long block portion */
  252.             for (sfb = 0; sfb < 6; sfb++)
  253.                sf[0].l[sfb] = bitget(slen1);
  254.          else
  255.             for (sfb = 0; sfb < 6; sfb++)
  256.                sf[0].l[sfb] = 0;
  257.          sfb = 3;               /* start sfb for short */
  258.       }
  259.       else
  260.       {                         /* all short, initial short blocks */
  261.          sfb = 0;
  262.          if (slen1 != 0)
  263.             for (i = 0; i < nr1; i++, sfb++)
  264.             {
  265.                sf[0].s[0][sfb] = bitget(slen1);
  266.                sf[0].s[1][sfb] = bitget(slen1);
  267.                sf[0].s[2][sfb] = bitget(slen1);
  268.             }
  269.          else
  270.             for (i = 0; i < nr1; i++, sfb++)
  271.             {
  272.                sf[0].s[0][sfb] = 0;
  273.                sf[0].s[1][sfb] = 0;
  274.                sf[0].s[2][sfb] = 0;
  275.             }
  276.       }
  277. /* remaining short blocks */
  278.       if (slen2 != 0)
  279.          for (i = 0; i < nr2; i++, sfb++)
  280.          {
  281.             sf[0].s[0][sfb] = bitget(slen2);
  282.             sf[0].s[1][sfb] = bitget(slen2);
  283.             sf[0].s[2][sfb] = bitget(slen2);
  284.          }
  285.       else
  286.          for (i = 0; i < nr2; i++, sfb++)
  287.          {
  288.             sf[0].s[0][sfb] = 0;
  289.             sf[0].s[1][sfb] = 0;
  290.             sf[0].s[2][sfb] = 0;
  291.          }
  292.       if (slen3 != 0)
  293.          for (i = 0; i < nr3; i++, sfb++)
  294.          {
  295.             sf[0].s[0][sfb] = bitget(slen3);
  296.             sf[0].s[1][sfb] = bitget(slen3);
  297.             sf[0].s[2][sfb] = bitget(slen3);
  298.          }
  299.       else
  300.          for (i = 0; i < nr3; i++, sfb++)
  301.          {
  302.             sf[0].s[0][sfb] = 0;
  303.             sf[0].s[1][sfb] = 0;
  304.             sf[0].s[2][sfb] = 0;
  305.          }
  306.       if (slen4 != 0)
  307.          for (i = 0; i < nr4; i++, sfb++)
  308.          {
  309.             sf[0].s[0][sfb] = bitget(slen4);
  310.             sf[0].s[1][sfb] = bitget(slen4);
  311.             sf[0].s[2][sfb] = bitget(slen4);
  312.          }
  313.       else
  314.          for (i = 0; i < nr4; i++, sfb++)
  315.          {
  316.             sf[0].s[0][sfb] = 0;
  317.             sf[0].s[1][sfb] = 0;
  318.             sf[0].s[2][sfb] = 0;
  319.          }
  320.       return;
  321.    }
  322.  
  323.  
  324. /* long blocks types 0 1 3 */
  325.    sfb = 0;
  326.    if (slen1 != 0)
  327.       for (i = 0; i < nr1; i++, sfb++)
  328.          sf[0].l[sfb] = bitget(slen1);
  329.    else
  330.       for (i = 0; i < nr1; i++, sfb++)
  331.          sf[0].l[sfb] = 0;
  332.  
  333.    if (slen2 != 0)
  334.       for (i = 0; i < nr2; i++, sfb++)
  335.          sf[0].l[sfb] = bitget(slen2);
  336.    else
  337.       for (i = 0; i < nr2; i++, sfb++)
  338.          sf[0].l[sfb] = 0;
  339.  
  340.    if (slen3 != 0)
  341.       for (i = 0; i < nr3; i++, sfb++)
  342.          sf[0].l[sfb] = bitget(slen3);
  343.    else
  344.       for (i = 0; i < nr3; i++, sfb++)
  345.          sf[0].l[sfb] = 0;
  346.  
  347.    if (slen4 != 0)
  348.       for (i = 0; i < nr4; i++, sfb++)
  349.          sf[0].l[sfb] = bitget(slen4);
  350.    else
  351.       for (i = 0; i < nr4; i++, sfb++)
  352.          sf[0].l[sfb] = 0;
  353. }
  354.