DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1716 Commits
9 Branches
942MB
Tree: 66f686f7be
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '66f686f7be'
${ noResults }
JUCE/modules/juce_audio_formats/codecs/juce_MP3AudioFormat.cpp

3189 lines
132KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library - "Jules' Utility Class Extensions"

  5.    Copyright 2004-11 by Raw Material Software Ltd.

  6. 

  7.   ------------------------------------------------------------------------------

  8. 

  9.    JUCE can be redistributed and/or modified under the terms of the GNU General

  10.    Public License (Version 2), as published by the Free Software Foundation.

  11.    A copy of the license is included in the JUCE distribution, or can be found

  12.    online at www.gnu.org/licenses.

  13. 

  14.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  15.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  16.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  17. 

  18.   ------------------------------------------------------------------------------

  19. 

  20.    To release a closed-source product which uses JUCE, commercial licenses are

  21.    available: visit www.rawmaterialsoftware.com/juce for more information.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. /*

  27.     IMPORTANT DISCLAIMER: By choosing to enable the JUCE_USE_MP3AUDIOFORMAT flag and

  28.     to compile this MP3 code into your software, you do so AT YOUR OWN RISK! By doing so,

  29.     you are agreeing that Raw Material Software is in no way responsible for any patent,

  30.     copyright, or other legal issues that you may suffer as a result.

  31. 

  32.     The code in juce_MP3AudioFormat.cpp is NOT guaranteed to be free from infringements of 3rd-party

  33.     intellectual property. If you wish to use it, please seek your own independent advice about the

  34.     legality of doing so. If you are not willing to accept full responsibility for the consequences

  35.     of using this code, then do not enable the JUCE_USE_MP3AUDIOFORMAT setting.

  36. */

  37. #if JUCE_USE_MP3AUDIOFORMAT

  38. 

  39. BEGIN_JUCE_NAMESPACE

  40. 

  41. namespace MP3Decoder

  42. {

  43. 

  44. struct AllocationTable  { int16 bits, d; };

  45. 

  46. const struct AllocationTable allocTable0[] =

  47. {

  48.     {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},

  49.     {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},

  50.     {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},

  51.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  52.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  53.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  54.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  55.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  56.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  57.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  58.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  59.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},  {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  60.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},  {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  61.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},  {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  62.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},  {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  63.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},  {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  64.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},  {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  65.     {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}

  66. };

  67. 

  68. const struct AllocationTable allocTable1[] =

  69. {

  70.     {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},

  71.     {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},

  72.     {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},

  73.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  74.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  75.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  76.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  77.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  78.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  79.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  80.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},

  81.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  82.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  83.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  84.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  85.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  86.     {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},

  87.     {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767},

  88.     {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}

  89. };

  90. 

  91. const struct AllocationTable allocTable2[] =

  92. {

  93.     {4, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383},

  94.     {4, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383},

  95.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},

  96.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},

  97.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}

  98. };

  99. 

  100. const struct AllocationTable allocTable3[] =

  101. {

  102.     {4, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383},

  103.     {4, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383},

  104.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},

  105.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},

  106.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},

  107.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},

  108.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}

  109. };

  110. 

  111. const struct AllocationTable allocTable4[] =

  112. {

  113.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191},

  114.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191},

  115.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191},

  116.     {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191},

  117.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},

  118.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},

  119.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},

  120.     {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},

  121.     {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},

  122.     {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},

  123.     {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},

  124.     {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},

  125.     {2, 0}, {5, 3}, {7, 5}, {10, 9}

  126. };

  127. 

  128. struct BandInfoStruct

  129. {

  130.     int16 longIndex[23];

  131.     int16 longDiff[22];

  132.     int16 shortIndex[14];

  133.     int16 shortDiff[13];

  134. };

  135. 

  136. const BandInfoStruct bandInfo[9] =

  137. {

  138.   { {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576},

  139.     {4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158},

  140.     {0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 30 * 3, 40 * 3, 52 * 3, 66 * 3, 84 * 3, 106 * 3, 136 * 3, 192 * 3},

  141.     {4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56} },

  142. 

  143.   { {0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576},

  144.     {4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192},

  145.     {0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 28 * 3, 38 * 3, 50 * 3, 64 * 3, 80 * 3, 100 * 3, 126 * 3, 192 * 3},

  146.     {4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66} },

  147. 

  148.   { {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576},

  149.     {4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26},

  150.     {0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 30 * 3, 42 * 3, 58 * 3, 78 * 3, 104 * 3, 138 * 3, 180 * 3, 192 * 3},

  151.     {4, 4, 4, 4, 6, 8, 12, 16, 20, 26, 34, 42, 12} },

  152. 

  153.   { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},

  154.     {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },

  155.     {0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 24 * 3, 32 * 3, 42 * 3, 56 * 3, 74 * 3, 100 * 3, 132 * 3, 174 * 3, 192 * 3},

  156.     {4, 4, 4, 6, 6, 8, 10, 14, 18, 26, 32, 42, 18 } },

  157. 

  158.   { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576},

  159.     {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36 },

  160.     {0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 26 * 3, 36 * 3, 48 * 3, 62 * 3, 80 * 3, 104 * 3, 136 * 3, 180 * 3, 192 * 3},

  161.     {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 32, 44, 12 } },

  162. 

  163.   { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},

  164.     {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },

  165.     {0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 26 * 3, 36 * 3, 48 * 3, 62 * 3, 80 * 3, 104 * 3, 134 * 3, 174 * 3, 192 * 3},

  166.     {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18 } },

  167. 

  168.   { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},

  169.     {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54},

  170.     {0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},

  171.     {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18} },

  172. 

  173.   { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},

  174.     {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54},

  175.     {0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},

  176.     {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18} },

  177. 

  178.   { {0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576},

  179.     {12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2},

  180.     {0, 24, 48, 72, 108, 156, 216, 288, 372, 480, 486, 492, 498, 576},

  181.     {8, 8, 8, 12, 16, 20, 24, 28, 36, 2, 2, 2, 26} }

  182. };

  183. 

  184. const double decodeWindow[] =

  185. {

  186.     0.000000000, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000030518,

  187.    -0.000030518, -0.000030518, -0.000030518, -0.000045776, -0.000045776, -0.000061035, -0.000061035, -0.000076294,

  188.    -0.000076294, -0.000091553, -0.000106812, -0.000106812, -0.000122070, -0.000137329, -0.000152588, -0.000167847,

  189.    -0.000198364, -0.000213623, -0.000244141, -0.000259399, -0.000289917, -0.000320435, -0.000366211, -0.000396729,

  190.    -0.000442505, -0.000473022, -0.000534058, -0.000579834, -0.000625610, -0.000686646, -0.000747681, -0.000808716,

  191.    -0.000885010, -0.000961304, -0.001037598, -0.001113892, -0.001205444, -0.001296997, -0.001388550, -0.001480103,

  192.    -0.001586914, -0.001693726, -0.001785278, -0.001907349, -0.002014160, -0.002120972, -0.002243042, -0.002349854,

  193.    -0.002456665, -0.002578735, -0.002685547, -0.002792358, -0.002899170, -0.002990723, -0.003082275, -0.003173828,

  194.    -0.003250122, -0.003326416, -0.003387451, -0.003433228, -0.003463745, -0.003479004, -0.003479004, -0.003463745,

  195.    -0.003417969, -0.003372192, -0.003280640, -0.003173828, -0.003051758, -0.002883911, -0.002700806, -0.002487183,

  196.    -0.002227783, -0.001937866, -0.001617432, -0.001266479, -0.000869751, -0.000442505,  0.000030518,  0.000549316,

  197.     0.001098633,  0.001693726,  0.002334595,  0.003005981,  0.003723145,  0.004486084,  0.005294800,  0.006118774,

  198.     0.007003784,  0.007919312,  0.008865356,  0.009841919,  0.010848999,  0.011886597,  0.012939453,  0.014022827,

  199.     0.015121460,  0.016235352,  0.017349243,  0.018463135,  0.019577026,  0.020690918,  0.021789551,  0.022857666,

  200.     0.023910522,  0.024932861,  0.025909424,  0.026840210,  0.027725220,  0.028533936,  0.029281616,  0.029937744,

  201.     0.030532837,  0.031005859,  0.031387329,  0.031661987,  0.031814575,  0.031845093,  0.031738281,  0.031478882,

  202.     0.031082153,  0.030517578,  0.029785156,  0.028884888,  0.027801514,  0.026535034,  0.025085449,  0.023422241,

  203.     0.021575928,  0.019531250,  0.017257690,  0.014801025,  0.012115479,  0.009231567,  0.006134033,  0.002822876,

  204.    -0.000686646, -0.004394531, -0.008316040, -0.012420654, -0.016708374, -0.021179199, -0.025817871, -0.030609131,

  205.    -0.035552979, -0.040634155, -0.045837402, -0.051132202, -0.056533813, -0.061996460, -0.067520142, -0.073059082,

  206.    -0.078628540, -0.084182739, -0.089706421, -0.095169067, -0.100540161, -0.105819702, -0.110946655, -0.115921021,

  207.    -0.120697021, -0.125259399, -0.129562378, -0.133590698, -0.137298584, -0.140670776, -0.143676758, -0.146255493,

  208.    -0.148422241, -0.150115967, -0.151306152, -0.151962280, -0.152069092, -0.151596069, -0.150497437, -0.148773193,

  209.    -0.146362305, -0.143264771, -0.139450073, -0.134887695, -0.129577637, -0.123474121, -0.116577148, -0.108856201,

  210.    -0.100311279, -0.090927124, -0.080688477, -0.069595337, -0.057617187, -0.044784546, -0.031082153, -0.016510010,

  211.    -0.001068115,  0.015228271,  0.032379150,  0.050354004,  0.069168091,  0.088775635,  0.109161377,  0.130310059,

  212.     0.152206421,  0.174789429,  0.198059082,  0.221984863,  0.246505737,  0.271591187,  0.297210693,  0.323318481,

  213.     0.349868774,  0.376800537,  0.404083252,  0.431655884,  0.459472656,  0.487472534,  0.515609741,  0.543823242,

  214.     0.572036743,  0.600219727,  0.628295898,  0.656219482,  0.683914185,  0.711318970,  0.738372803,  0.765029907,

  215.     0.791213989,  0.816864014,  0.841949463,  0.866363525,  0.890090942,  0.913055420,  0.935195923,  0.956481934,

  216.     0.976852417,  0.996246338,  1.014617920,  1.031936646,  1.048156738,  1.063217163,  1.077117920,  1.089782715,

  217.     1.101211548,  1.111373901,  1.120223999,  1.127746582,  1.133926392,  1.138763428,  1.142211914,  1.144287109,

  218.     1.144989014

  219. };

  220. 

  221. const int16 huffmanTab0[] = { 0 };

  222. const int16 huffmanTab1[] = { -5,-3,-1,17,1,16,0 };

  223. const int16 huffmanTab2[] = { -15,-11,-9,-5,-3,-1,34,2,18,-1,33,32,17,-1,1,16,0 };

  224. const int16 huffmanTab3[] = { -13,-11,-9,-5,-3,-1,34,2,18,-1,33,32,16,17,-1,1,0 };

  225. const int16 huffmanTab5[] = { -29,-25,-23,-15,-7,-5,-3,-1,51,35,50,49,-3,-1,19,3,-1,48,34,-3,-1,18,33,-1,2,32,17,-1,1,16,0 };

  226. const int16 huffmanTab6[] = { -25,-19,-13,-9,-5,-3,-1,51,3,35,-1,50,48,-1,19,49,-3,-1,34,2,18,-3,-1,33,32,1,-1,17,-1,16,0 };

  227. 

  228. const int16 huffmanTab7[] =

  229. {

  230.     -69,-65,-57,-39,-29,-17,-11,-7,-3,-1,85,69,-1,84,83,-1,53,68,-3,-1,37,82,21,-5,-1,81,-1,5,52,-1,80,-1,67,51,

  231.     -5,-3,-1,36,66,20,-1,65,64,-11,-7,-3,-1,4,35,-1,50,3,-1,19,49,-3,-1,48,34,18,-5,-1,33,-1,2,32,17,-1,1,16,0

  232. };

  233. 

  234. const int16 huffmanTab8[] =

  235. {

  236.     -65,-63,-59,-45,-31,-19,-13,-7,-5,-3,-1,85,84,69,83,-3,-1,53,68,37,-3,-1,82,5,21,-5,-1,81,-1,52,67,-3,-1,80,

  237.     51,36,-5,-3,-1,66,20,65,-3,-1,4,64,-1,35,50,-9,-7,-3,-1,19,49,-1,3,48,34,-1,2,32,-1,18,33,17,-3,-1,1,16,0

  238. };

  239. 

  240. const int16 huffmanTab9[] =

  241. {

  242.     -63,-53,-41,-29,-19,-11,-5,-3,-1,85,69,53,-1,83,-1,84,5,-3,-1,68,37,-1,82,21,-3,-1,81,52,-1,67,-1,80,4,-7,-3,

  243.     -1,36,66,-1,51,64,-1,20,65,-5,-3,-1,35,50,19,-1,49,-1,3,48,-5,-3,-1,34,2,18,-1,33,32,-3,-1,17,1,-1,16,0

  244. };

  245. 

  246. const int16 huffmanTab10[] =

  247. {

  248.     -125,-121,-111,-83,-55,-35,-21,-13,-7,-3,-1,119,103,-1,118,87,-3,-1,117,102,71,-3,-1,116,86,-1,101,55,-9,-3,

  249.     -1,115,70,-3,-1,85,84,99,-1,39,114,-11,-5,-3,-1,100,7,112,-1,98,-1,69,53,-5,-1,6,-1,83,68,23,-17,-5,-1,113,

  250.     -1,54,38,-5,-3,-1,37,82,21,-1,81,-1,52,67,-3,-1,22,97,-1,96,-1,5,80,-19,-11,-7,-3,-1,36,66,-1,51,4,-1,20,

  251.     65,-3,-1,64,35,-1,50,3,-3,-1,19,49,-1,48,34,-7,-3,-1,18,33,-1,2,32,17,-1,1,16,0

  252. };

  253. 

  254. const int16 huffmanTab11[] =

  255. {

  256.     -121,-113,-89,-59,-43,-27,-17,-7,-3,-1,119,103,-1,118,117,-3,-1,102,71,-1,116,-1,87,85,-5,-3,-1,86,101,55,

  257.     -1,115,70,-9,-7,-3,-1,69,84,-1,53,83,39,-1,114,-1,100,7,-5,-1,113,-1,23,112,-3,-1,54,99,-1,96,-1,68,37,-13,

  258.     -7,-5,-3,-1,82,5,21,98,-3,-1,38,6,22,-5,-1,97,-1,81,52,-5,-1,80,-1,67,51,-1,36,66,-15,-11,-7,-3,-1,20,65,

  259.     -1,4,64,-1,35,50,-1,19,49,-5,-3,-1,3,48,34,33,-5,-1,18,-1,2,32,17,-3,-1,1,16,0

  260. };

  261. 

  262. const int16 huffmanTab12[] =

  263. {

  264.     -115,-99,-73,-45,-27,-17,-9,-5,-3,-1,119,103,118,-1,87,117,-3,-1,102,71,-1,116,101,-3,-1,86,55,-3,-1,115,

  265.     85,39,-7,-3,-1,114,70,-1,100,23,-5,-1,113,-1,7,112,-1,54,99,-13,-9,-3,-1,69,84,-1,68,-1,6,5,-1,38,98,-5,

  266.     -1,97,-1,22,96,-3,-1,53,83,-1,37,82,-17,-7,-3,-1,21,81,-1,52,67,-5,-3,-1,80,4,36,-1,66,20,-3,-1,51,65,-1,

  267.     35,50,-11,-7,-5,-3,-1,64,3,48,19,-1,49,34,-1,18,33,-7,-5,-3,-1,2,32,0,17,-1,1,16

  268. };

  269. 

  270. const int16 huffmanTab13[] =

  271. {

  272.     -509,-503,-475,-405,-333,-265,-205,-153,-115,-83,-53,-35,-21,-13,-9,-7,-5,-3,-1,254,252,253,237,255,-1,239,223,

  273.     -3,-1,238,207,-1,222,191,-9,-3,-1,251,206,-1,220,-1,175,233,-1,236,221,-9,-5,-3,-1,250,205,190,-1,235,159,-3,

  274.     -1,249,234,-1,189,219,-17,-9,-3,-1,143,248,-1,204,-1,174,158,-5,-1,142,-1,127,126,247,-5,-1,218,-1,173,188,-3,

  275.     -1,203,246,111,-15,-7,-3,-1,232,95,-1,157,217,-3,-1,245,231,-1,172,187,-9,-3,-1,79,244,-3,-1,202,230,243,-1,

  276.     63,-1,141,216,-21,-9,-3,-1,47,242,-3,-1,110,156,15,-5,-3,-1,201,94,171,-3,-1,125,215,78,-11,-5,-3,-1,200,214,

  277.     62,-1,185,-1,155,170,-1,31,241,-23,-13,-5,-1,240,-1,186,229,-3,-1,228,140,-1,109,227,-5,-1,226,-1,46,14,-1,30,

  278.     225,-15,-7,-3,-1,224,93,-1,213,124,-3,-1,199,77,-1,139,184,-7,-3,-1,212,154,-1,169,108,-1,198,61,-37,-21,-9,-5,

  279.     -3,-1,211,123,45,-1,210,29,-5,-1,183,-1,92,197,-3,-1,153,122,195,-7,-5,-3,-1,167,151,75,209,-3,-1,13,208,-1,

  280.     138,168,-11,-7,-3,-1,76,196,-1,107,182,-1,60,44,-3,-1,194,91,-3,-1,181,137,28,-43,-23,-11,-5,-1,193,-1,152,12,

  281.     -1,192,-1,180,106,-5,-3,-1,166,121,59,-1,179,-1,136,90,-11,-5,-1,43,-1,165,105,-1,164,-1,120,135,-5,-1,148,-1,

  282.     119,118,178,-11,-3,-1,27,177,-3,-1,11,176,-1,150,74,-7,-3,-1,58,163,-1,89,149,-1,42,162,-47,-23,-9,-3,-1,26,

  283.     161,-3,-1,10,104,160,-5,-3,-1,134,73,147,-3,-1,57,88,-1,133,103,-9,-3,-1,41,146,-3,-1,87,117,56,-5,-1,131,-1,

  284.     102,71,-3,-1,116,86,-1,101,115,-11,-3,-1,25,145,-3,-1,9,144,-1,72,132,-7,-5,-1,114,-1,70,100,40,-1,130,24,-41,

  285.     -27,-11,-5,-3,-1,55,39,23,-1,113,-1,85,7,-7,-3,-1,112,54,-1,99,69,-3,-1,84,38,-1,98,53,-5,-1,129,-1,8,128,-3,

  286.     -1,22,97,-1,6,96,-13,-9,-5,-3,-1,83,68,37,-1,82,5,-1,21,81,-7,-3,-1,52,67,-1,80,36,-3,-1,66,51,20,-19,-11,

  287.     -5,-1,65,-1,4,64,-3,-1,35,50,19,-3,-1,49,3,-1,48,34,-3,-1,18,33,-1,2,32,-3,-1,17,1,16,0

  288. };

  289. 

  290. const int16 huffmanTab15[] =

  291. {

  292.     -495,-445,-355,-263,-183,-115,-77,-43,-27,-13,-7,-3,-1,255,239,-1,254,223,-1,238,-1,253,207,-7,-3,-1,252,222,-1,

  293.     237,191,-1,251,-1,206,236,-7,-3,-1,221,175,-1,250,190,-3,-1,235,205,-1,220,159,-15,-7,-3,-1,249,234,-1,189,219,

  294.     -3,-1,143,248,-1,204,158,-7,-3,-1,233,127,-1,247,173,-3,-1,218,188,-1,111,-1,174,15,-19,-11,-3,-1,203,246,

  295.     -3,-1,142,232,-1,95,157,-3,-1,245,126,-1,231,172,-9,-3,-1,202,187,-3,-1,217,141,79,-3,-1,244,63,-1,243,216,

  296.     -33,-17,-9,-3,-1,230,47,-1,242,-1,110,240,-3,-1,31,241,-1,156,201,-7,-3,-1,94,171,-1,186,229,-3,-1,125,215,

  297.     -1,78,228,-15,-7,-3,-1,140,200,-1,62,109,-3,-1,214,227,-1,155,185,-7,-3,-1,46,170,-1,226,30,-5,-1,225,-1,14,

  298.     224,-1,93,213,-45,-25,-13,-7,-3,-1,124,199,-1,77,139,-1,212,-1,184,154,-7,-3,-1,169,108,-1,198,61,-1,211,210,

  299.     -9,-5,-3,-1,45,13,29,-1,123,183,-5,-1,209,-1,92,208,-1,197,138,-17,-7,-3,-1,168,76,-1,196,107,-5,-1,182,-1,

  300.     153,12,-1,60,195,-9,-3,-1,122,167,-1,166,-1,192,11,-1,194,-1,44,91,-55,-29,-15,-7,-3,-1,181,28,-1,137,152,-3,

  301.     -1,193,75,-1,180,106,-5,-3,-1,59,121,179,-3,-1,151,136,-1,43,90,-11,-5,-1,178,-1,165,27,-1,177,-1,176,105,-7,

  302.     -3,-1,150,74,-1,164,120,-3,-1,135,58,163,-17,-7,-3,-1,89,149,-1,42,162,-3,-1,26,161,-3,-1,10,160,104,-7,-3,

  303.     -1,134,73,-1,148,57,-5,-1,147,-1,119,9,-1,88,133,-53,-29,-13,-7,-3,-1,41,103,-1,118,146,-1,145,-1,25,144,-7,

  304.     -3,-1,72,132,-1,87,117,-3,-1,56,131,-1,102,71,-7,-3,-1,40,130,-1,24,129,-7,-3,-1,116,8,-1,128,86,-3,-1,101,

  305.     55,-1,115,70,-17,-7,-3,-1,39,114,-1,100,23,-3,-1,85,113,-3,-1,7,112,54,-7,-3,-1,99,69,-1,84,38,-3,-1,98,22,

  306.     -3,-1,6,96,53,-33,-19,-9,-5,-1,97,-1,83,68,-1,37,82,-3,-1,21,81,-3,-1,5,80,52,-7,-3,-1,67,36,-1,66,51,-1,

  307.     65,-1,20,4,-9,-3,-1,35,50,-3,-1,64,3,19,-3,-1,49,48,34,-9,-7,-3,-1,18,33,-1,2,32,17,-3,-1,1,16,0

  308. };

  309. 

  310. const int16 huffmanTab16[] =

  311. {

  312.     -509,-503,-461,-323,-103,-37,-27,-15,-7,-3,-1,239,254,-1,223,253,-3,-1,207,252,-1,191,251,-5,-1,175,-1,250,159,

  313.     -3,-1,249,248,143,-7,-3,-1,127,247,-1,111,246,255,-9,-5,-3,-1,95,245,79,-1,244,243,-53,-1,240,-1,63,-29,-19,

  314.     -13,-7,-5,-1,206,-1,236,221,222,-1,233,-1,234,217,-1,238,-1,237,235,-3,-1,190,205,-3,-1,220,219,174,-11,-5,

  315.     -1,204,-1,173,218,-3,-1,126,172,202,-5,-3,-1,201,125,94,189,242,-93,-5,-3,-1,47,15,31,-1,241,-49,-25,-13,

  316.     -5,-1,158,-1,188,203,-3,-1,142,232,-1,157,231,-7,-3,-1,187,141,-1,216,110,-1,230,156,-13,-7,-3,-1,171,186,

  317.     -1,229,215,-1,78,-1,228,140,-3,-1,200,62,-1,109,-1,214,155,-19,-11,-5,-3,-1,185,170,225,-1,212,-1,184,169,

  318.     -5,-1,123,-1,183,208,227,-7,-3,-1,14,224,-1,93,213,-3,-1,124,199,-1,77,139,-75,-45,-27,-13,-7,-3,-1,154,

  319.     108,-1,198,61,-3,-1,92,197,13,-7,-3,-1,138,168,-1,153,76,-3,-1,182,122,60,-11,-5,-3,-1,91,137,28,-1,192,-1,

  320.     152,121,-1,226,-1,46,30,-15,-7,-3,-1,211,45,-1,210,209,-5,-1,59,-1,151,136,29,-7,-3,-1,196,107,-1,195,167,-1,

  321.     44,-1,194,181,-23,-13,-7,-3,-1,193,12,-1,75,180,-3,-1,106,166,179,-5,-3,-1,90,165,43,-1,178,27,-13,-5,-1,177,

  322.     -1,11,176,-3,-1,105,150,-1,74,164,-5,-3,-1,120,135,163,-3,-1,58,89,42,-97,-57,-33,-19,-11,-5,-3,-1,149,104,161,

  323.     -3,-1,134,119,148,-5,-3,-1,73,87,103,162,-5,-1,26,-1,10,160,-3,-1,57,147,-1,88,133,-9,-3,-1,41,146,-3,-1,118,

  324.     9,25,-5,-1,145,-1,144,72,-3,-1,132,117,-1,56,131,-21,-11,-5,-3,-1,102,40,130,-3,-1,71,116,24,-3,-1,129,128,-3,

  325.     -1,8,86,55,-9,-5,-1,115,-1,101,70,-1,39,114,-5,-3,-1,100,85,7,23,-23,-13,-5,-1,113,-1,112,54,-3,-1,99,69,-1,

  326.     84,38,-3,-1,98,22,-1,97,-1,6,96,-9,-5,-1,83,-1,53,68,-1,37,82,-1,81,-1,21,5,-33,-23,-13,-7,-3,-1,52,67,-1,80,

  327.     36,-3,-1,66,51,20,-5,-1,65,-1,4,64,-1,35,50,-3,-1,19,49,-3,-1,3,48,34,-3,-1,18,33,-1,2,32,-3,-1,17,1,16,0

  328. };

  329. 

  330. const int16 huffmanTab24[] =

  331. {

  332.     -451,-117,-43,-25,-15,-7,-3,-1,239,254,-1,223,253,-3,-1,207,252,-1,191,251,-5,-1,250,-1,175,159,-1,249,248,-9,

  333.     -5,-3,-1,143,127,247,-1,111,246,-3,-1,95,245,-1,79,244,-71,-7,-3,-1,63,243,-1,47,242,-5,-1,241,-1,31,240,-25,-9,

  334.     -1,15,-3,-1,238,222,-1,237,206,-7,-3,-1,236,221,-1,190,235,-3,-1,205,220,-1,174,234,-15,-7,-3,-1,189,219,-1,204,

  335.     158,-3,-1,233,173,-1,218,188,-7,-3,-1,203,142,-1,232,157,-3,-1,217,126,-1,231,172,255,-235,-143,-77,-45,-25,-15,

  336.     -7,-3,-1,202,187,-1,141,216,-5,-3,-1,14,224,13,230,-5,-3,-1,110,156,201,-1,94,186,-9,-5,-1,229,-1,171,125,-1,215,

  337.     228,-3,-1,140,200,-3,-1,78,46,62,-15,-7,-3,-1,109,214,-1,227,155,-3,-1,185,170,-1,226,30,-7,-3,-1,225,93,-1,213,124,

  338.     -3,-1,199,77,-1,139,184,-31,-15,-7,-3,-1,212,154,-1,169,108,-3,-1,198,61,-1,211,45,-7,-3,-1,210,29,-1,123,183,-3,-1,

  339.     209,92,-1,197,138,-17,-7,-3,-1,168,153,-1,76,196,-3,-1,107,182,-3,-1,208,12,60,-7,-3,-1,195,122,-1,167,44,-3,-1,194,

  340.     91,-1,181,28,-57,-35,-19,-7,-3,-1,137,152,-1,193,75,-5,-3,-1,192,11,59,-3,-1,176,10,26,-5,-1,180,-1,106,166,-3,-1,121,

  341.     151,-3,-1,160,9,144,-9,-3,-1,179,136,-3,-1,43,90,178,-7,-3,-1,165,27,-1,177,105,-1,150,164,-17,-9,-5,-3,-1,74,120,135,

  342.     -1,58,163,-3,-1,89,149,-1,42,162,-7,-3,-1,161,104,-1,134,119,-3,-1,73,148,-1,57,147,-63,-31,-15,-7,-3,-1,88,133,-1,41,

  343.     103,-3,-1,118,146,-1,25,145,-7,-3,-1,72,132,-1,87,117,-3,-1,56,131,-1,102,40,-17,-7,-3,-1,130,24,-1,71,116,-5,-1,129,

  344.     -1,8,128,-1,86,101,-7,-5,-1,23,-1,7,112,115,-3,-1,55,39,114,-15,-7,-3,-1,70,100,-1,85,113,-3,-1,54,99,-1,69,84,-7,-3,

  345.     -1,38,98,-1,22,97,-5,-3,-1,6,96,53,-1,83,68,-51,-37,-23,-15,-9,-3,-1,37,82,-1,21,-1,5,80,-1,81,-1,52,67,-3,-1,36,66,

  346.     -1,51,20,-9,-5,-1,65,-1,4,64,-1,35,50,-1,19,49,-7,-5,-3,-1,3,48,34,18,-1,33,-1,2,32,-3,-1,17,1,-1,16,0

  347. };

  348. 

  349. struct newhuff

  350. {

  351.     uint32 linbits;

  352.     const int16* table;

  353. };

  354. 

  355. const newhuff huffmanTables1[] =

  356. {

  357.     { 0, huffmanTab0  }, { 0, huffmanTab1  }, { 0,  huffmanTab2  }, { 0,  huffmanTab3  },

  358.     { 0, huffmanTab0  }, { 0, huffmanTab5  }, { 0,  huffmanTab6  }, { 0,  huffmanTab7  },

  359.     { 0, huffmanTab8  }, { 0, huffmanTab9  }, { 0,  huffmanTab10 }, { 0,  huffmanTab11 },

  360.     { 0, huffmanTab12 }, { 0, huffmanTab13 }, { 0,  huffmanTab0  }, { 0,  huffmanTab15 },

  361.     { 1, huffmanTab16 }, { 2, huffmanTab16 }, { 3,  huffmanTab16 }, { 4,  huffmanTab16 },

  362.     { 6, huffmanTab16 }, { 8, huffmanTab16 }, { 10, huffmanTab16 }, { 13, huffmanTab16 },

  363.     { 4, huffmanTab24 }, { 5, huffmanTab24 }, { 6,  huffmanTab24 }, { 7,  huffmanTab24 },

  364.     { 8, huffmanTab24 }, { 9, huffmanTab24 }, { 11, huffmanTab24 }, { 13, huffmanTab24 }

  365. };

  366. 

  367. const int16 huffmanTabC0[] = { -29,-21,-13,-7,-3,-1,11,15,-1,13,14,-3,-1,7,5,9,-3,-1,6,3,-1,10,12,-3,-1,2,1,-1,4,8,0 };

  368. const int16 huffmanTabC1[] = { -15,-7,-3,-1,15,14,-1,13,12,-3,-1,11,10,-1,9,8,-7,-3,-1,7,6,-1,5,4,-3,-1,3,2,-1,1,0 };

  369. 

  370. const newhuff huffmanTables2[] = { { 0, huffmanTabC0 }, { 0, huffmanTabC1 } };

  371. 

  372. //==============================================================================

  373. struct VBRTagData

  374. {

  375.     bool read (const uint8* data) noexcept

  376.     {

  377.         flags = 0;

  378. 

  379.         const int layer = (data[1] >> 1) & 3;

  380.         if (layer != 1)

  381.             return false;

  382. 

  383.         const int type = (data[1] >> 3) & 1;

  384.         const int sampleRateIndex = (data[2] >> 2) & 3;

  385.         const int mode = (data[3] >> 6) & 3;

  386. 

  387.         static const int bitRates[3][16] =

  388.         {

  389.             { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1 }, // MPEG2

  390.             { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1 }, // MPEG1

  391.             { 0, 8, 16, 24, 32, 40, 48, 56, 64, -1, -1, -1, -1, -1, -1, -1 }, // MPEG 2.5

  392.         };

  393. 

  394.         const int bitrate = bitRates[type][((data[2] >> 4) & 15)];

  395. 

  396.         const int sampleRates[3][4] =

  397.         {

  398.             { 22050, 24000, 16000, -1 }, // MPEG2

  399.             { 44100, 48000, 32000, -1 }, // MPEG1

  400.             { 11025, 12000, 8000,  -1 }, // MPEG2.5

  401.         };

  402. 

  403.         if ((data[1] >> 4) == 0xe)

  404.             sampleRate = sampleRates[2][sampleRateIndex];

  405.         else

  406.             sampleRate = sampleRates[type][sampleRateIndex];

  407. 

  408.         data += type != 0 ? (mode != 3 ? (32 + 4) : (17 + 4))

  409.                           : (mode != 3 ? (17 + 4) : (9 + 4));

  410. 

  411.         if (! isVbrTag (data))

  412.             return false;

  413. 

  414.         data += 4;

  415.         flags = ByteOrder::bigEndianInt (data);

  416.         data += 4;

  417. 

  418.         if (flags & 1)

  419.         {

  420.             frames = ByteOrder::bigEndianInt (data);

  421.             data += 4;

  422.         }

  423. 

  424.         if (flags & 2)

  425.         {

  426.             bytes = ByteOrder::bigEndianInt (data);

  427.             data += 4;

  428.         }

  429. 

  430.         if (flags & 4)

  431.         {

  432.             if (toc != nullptr)

  433.                 for (int i = 0; i < 100; ++i)

  434.                     toc[i] = data[i];

  435. 

  436.             data += 100;

  437.         }

  438. 

  439.         vbrScale = -1;

  440. 

  441.         if (flags & 8)

  442.         {

  443.             vbrScale = ByteOrder::bigEndianInt (data);

  444.             data += 4;

  445.         }

  446. 

  447.         headersize = ((type + 1) * 72000 * bitrate) / sampleRate;

  448. 

  449.         data += 21;

  450.         int encoderDelay = data[0] << 4;

  451.         encoderDelay += data[1] >> 4;

  452.         int encoderPadding = (data[1] & 15) << 8;

  453.         encoderPadding += data[2];

  454. 

  455.         if (encoderDelay < 0 || encoderDelay > 3000)

  456.             encoderDelay = -1;

  457. 

  458.         if (encoderPadding < 0 || encoderPadding > 3000)

  459.             encoderPadding = -1;

  460. 

  461.         encoderDelay = encoderDelay;

  462.         encoderPadding = encoderPadding;

  463.         return true;

  464.     }

  465. 

  466.     uint8 toc[100];

  467.     int sampleRate, flags, frames, bytes, vbrScale;

  468.     int headersize, encoderDelay, encoderPadding;

  469. 

  470. private:

  471.     static bool isVbrTag (const uint8* const d) noexcept

  472.     {

  473.         return (d[0] == 'X' && d[1] == 'i' && d[2] == 'n' && d[3] == 'g')

  474.             || (d[0] == 'I' && d[1] == 'n' && d[2] == 'f' && d[3] == 'o');

  475.     }

  476. };

  477. 

  478. //==============================================================================

  479. struct MP3Frame

  480. {

  481.     MP3Frame()

  482.     {

  483.         zeromem (this, sizeof (MP3Frame));

  484.         single = -1;

  485.     }

  486. 

  487.     void selectLayer2Table()

  488.     {

  489.         static const int translate[3][2][16] =

  490.         {

  491.             { { 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, 0 }, { 0, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 } },

  492.             { { 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },

  493.             { { 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, 0 }, { 0, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 } }

  494.         };

  495. 

  496.         static const AllocationTable* const tables[] = { allocTable0, allocTable1, allocTable2, allocTable3, allocTable4 };

  497.         static const int limits[] = { 27, 30, 8, 12, 30 };

  498. 

  499.         const int index = lsf ? 4 : translate[sampleRateIndex][2 - numChannels][bitrateIndex];

  500.         layer2SubBandLimit = limits [index];

  501.         allocationTable = tables [index];

  502.     }

  503. 

  504.     int getFrequency() const noexcept

  505.     {

  506.         const int frequencies[] = { 44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000 };

  507.         return frequencies [sampleRateIndex];

  508.     }

  509. 

  510.     void decodeHeader (const uint32 header)

  511.     {

  512.         jassert (((header >> 10) & 3) != 3);

  513. 

  514.         mpeg25              = (header & (1 << 20)) == 0;

  515.         lsf                 = mpeg25 ? 1 : ((header & (1 << 19)) ? 0 : 1);

  516.         layer               = 4 - ((header >> 17) & 3);

  517.         sampleRateIndex     = mpeg25 ? (6 + ((header >> 10) & 3)) : (((header >> 10) & 3) + (lsf * 3));

  518.         crc16FollowsHeader  = ((header >> 16) & 1) == 0;

  519.         bitrateIndex        = (header >> 12) & 15;

  520.         padding             = (header >> 9) & 1;

  521.         mode                = (header >> 6) & 3;

  522.         modeExt             = (header >> 4) & 3;

  523.         //extension           = (header >> 8) & 1;

  524.         //copyright         = (header >> 3) & 1;

  525.         //original          = (header >> 2) & 1;

  526.         //emphasis          = header & 3;

  527.         numChannels         = (mode == 3) ? 1 : 2;

  528. 

  529.         static const int frameSizes [2][3][16] =

  530.         {

  531.             { { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },

  532.               { 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 },

  533.               { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 } },

  534. 

  535.             { { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 },

  536.               { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 },

  537.               { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 } }

  538.         };

  539. 

  540.         switch (layer)

  541.         {

  542.             case 1: frameSize = (((frameSizes[lsf][0][bitrateIndex] * 12000) / getFrequency() + padding) * 4) - 4; break;

  543.             case 2: frameSize = (frameSizes[lsf][1][bitrateIndex] * 144000)  / getFrequency() + (padding - 4); break;

  544.             case 3: frameSize = (bitrateIndex == 0) ? 0 : ((frameSizes[lsf][2][bitrateIndex] * 144000) / (getFrequency() << lsf) + (padding - 4)); break;

  545.             default: break;

  546.         }

  547.     }

  548. 

  549.     int layer, frameSize, numChannels, single;

  550.     int lsf;     // 0 = mpeg-1, 1 = mpeg-2/LSF

  551.     bool mpeg25; // true = mpeg-2.5, false = mpeg-1/2

  552.     bool crc16FollowsHeader;

  553.     int bitrateIndex, sampleRateIndex, padding;

  554.     int mode, modeExt, layer2SubBandLimit;

  555.     enum { downSampleLimit = 32 };

  556.     const AllocationTable* allocationTable;

  557. };

  558. 

  559. //==============================================================================

  560. struct Constants

  561. {

  562.     Constants()

  563.     {

  564.         pnts[0] = cos64; pnts[1] = cos32; pnts[2] = cos16; pnts[3] = cos8; pnts[4] = cos4;

  565.         initDecodeTables();

  566.         initLayer2Tables();

  567.         initLayer3Tables();

  568.     }

  569. 

  570.     const uint8* getGroupTable (const int16 d1, const int index) const noexcept

  571.     {

  572.         switch (d1)

  573.         {

  574.             case 3:   return &group3tab [3 * jmin (index, 3 * 3 * 3)];

  575.             case 5:   return &group5tab [3 * jmin (index, 5 * 5 * 5)];

  576.             case 9:   return &group9tab [3 * jmin (index, 9 * 9 * 9)];

  577.             default:  break;

  578.         }

  579. 

  580.         static uint8 dummy[] = { 0, 0, 0 };

  581.         return dummy;

  582.     }

  583. 

  584.     float muls[27][64];

  585.     float ispow[8207];

  586.     float antiAliasingCa[8], antiAliasingCs[8];

  587.     float win[4][36];

  588.     float win1[4][36];

  589.     float gainpow2[256 + 118 + 4];

  590.     float COS9[9];

  591.     float COS6_1, COS6_2;

  592.     float tfcos36[9];

  593.     float tfcos12[3];

  594.     int longLimit[9][23];

  595.     int shortLimit[9][14];

  596.     float tan1_1[16], tan2_1[16], tan1_2[16], tan2_2[16];

  597.     float pow1_1[2][16], pow2_1[2][16], pow1_2[2][16], pow2_2[2][16];

  598.     int* map[9][3];

  599.     int* mapEnd[9][3];

  600.     uint32 nLength2[512];

  601.     uint32 iLength2[256];

  602.     float decodeWin[512 + 32];

  603.     float* pnts[5];

  604. 

  605. private:

  606.     int mapbuf0[9][152];

  607.     int mapbuf1[9][156];

  608.     int mapbuf2[9][44];

  609.     float cos64[16], cos32[8], cos16[4], cos8[2], cos4[1];

  610.     uint8 group3tab [32 * 3];

  611.     uint8 group5tab [128 * 3];

  612.     uint8 group9tab [1024 * 3];

  613. 

  614.     void initDecodeTables()

  615.     {

  616.         int i, j, scaleval = -1;

  617.         float* table = decodeWin;

  618. 

  619.         for (i = 0; i < 5; ++i)

  620.         {

  621.             int kr = 0x10 >> i;

  622.             int divv = 0x40 >> i;

  623.             float* costab = pnts[i];

  624. 

  625.             for (int k = 0; k < kr; ++k)

  626.                 costab[k] = (float) (1.0 / (2.0 * cos (double_Pi * (k * 2.0 + 1.0) / divv)));

  627.         }

  628. 

  629.         for (i = 0, j = 0; i < 256; ++i, ++j, table += 32)

  630.         {

  631.             if (table < decodeWin + 512 + 16)

  632.                 table[16] = table[0] = (float) (decodeWindow[j] * scaleval);

  633.             if (i % 32 == 31)

  634.                 table -= 1023;

  635.             if (i % 64 == 63)

  636.                 scaleval = -scaleval;

  637.         }

  638. 

  639.         for (; i < 512; ++i, --j, table += 32)

  640.         {

  641.             if (table < decodeWin + 512 + 16)

  642.                 table[16] = table[0] = (float) (decodeWindow[j] * scaleval);

  643.             if (i % 32 == 31)

  644.                 table -= 1023;

  645.             if (i % 64 == 63)

  646.                 scaleval = -scaleval;

  647.         }

  648.     }

  649. 

  650.     void initLayer2Tables()

  651.     {

  652.         static const double mulmul[27] =

  653.         {

  654.             0, -2.0 / 3.0, 2.0 / 3.0, 2.0 / 7.0, 2.0 / 15.0, 2.0 / 31.0, 2.0 / 63.0, 2.0 / 127.0, 2.0 / 255.0,

  655.             2.0 / 511.0, 2.0 / 1023.0, 2.0 / 2047.0, 2.0 / 4095.0, 2.0 / 8191.0, 2.0 / 16383.0, 2.0 / 32767.0, 2.0 / 65535.0,

  656.             -4.0 / 5.0, -2.0 / 5.0, 2.0 / 5.0, 4.0 / 5.0, -8.0 / 9.0, -4.0 / 9.0, -2.0 / 9.0, 2.0 / 9.0, 4.0 / 9.0, 8.0 / 9.0

  657.         };

  658. 

  659.         static const uint8 base[3][9] =

  660.         {

  661.             { 1, 0, 2 },

  662.             { 17, 18, 0, 19, 20 },

  663.             { 21, 1, 22, 23, 0, 24, 25, 2, 26 }

  664.         };

  665. 

  666.         static const int tablen[3] = { 3, 5, 9 };

  667.         static uint8* tables[3] = { group3tab, group5tab, group9tab };

  668. 

  669.         for (int i = 0; i < 3; ++i)

  670.         {

  671.             uint8* itable = tables[i];

  672.             const int len = tablen[i];

  673. 

  674.             for (int j = 0; j < len; ++j)

  675.                 for (int k = 0; k < len; ++k)

  676.                     for (int l = 0; l < len; ++l)

  677.                     {

  678.                         *itable++ = base[i][l];

  679.                         *itable++ = base[i][k];

  680.                         *itable++ = base[i][j];

  681.                     }

  682.         }

  683. 

  684.         for (int k = 0; k < 27; ++k)

  685.         {

  686.             const double m = mulmul[k];

  687.             float* table = muls[k];

  688.             for (int j = 3, i = 0; i < 63; ++i, --j)

  689.                 *table++ = (float) (m * pow (2.0, j / 3.0));

  690.             *table++ = 0;

  691.         }

  692.     }

  693. 

  694.     void initLayer3Tables()

  695.     {

  696.         int i, j;

  697.         for (i = -256; i < 118 + 4; ++i)

  698.             gainpow2[i + 256] = pow (2.0, -0.25 * (i + 210));

  699. 

  700.         for (i = 0; i < 8207; ++i)

  701.             ispow[i] = pow ((double) i, 4.0 / 3.0);

  702. 

  703.         for (i = 0; i < 8; ++i)

  704.         {

  705.             static double Ci[] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 };

  706.             const double sq = sqrt (1.0 + Ci[i] * Ci[i]);

  707.             antiAliasingCs[i] = 1.0 / sq;

  708.             antiAliasingCa[i] = Ci[i] / sq;

  709.         }

  710. 

  711.         for (i = 0; i < 18; ++i)

  712.         {

  713.             win[0][i] = win[1][i] = 0.5 * sin (double_Pi / 72.0 * (2 * (i + 0) + 1)) / cos (double_Pi * (2 * (i + 0) + 19) / 72.0);

  714.             win[0][i + 18] = win[3][i + 18] = 0.5 * sin (double_Pi / 72.0 * (2 * (i + 18) + 1)) / cos (double_Pi * (2 * (i + 18) + 19) / 72.0);

  715.         }

  716. 

  717.         for (i = 0; i < 6; ++i)

  718.         {

  719.             win[1][i + 18] = 0.5 / cos (double_Pi * (2 * (i + 18) + 19) / 72.0);

  720.             win[3][i + 12] = 0.5 / cos (double_Pi * (2 * (i + 12) + 19) / 72.0);

  721.             win[1][i + 24] = 0.5 * sin (double_Pi / 24.0 * (2 * i + 13)) / cos (double_Pi * (2 * (i + 24) + 19) / 72.0);

  722.             win[1][i + 30] = win[3][i] = 0;

  723.             win[3][i + 6] = 0.5 * sin (double_Pi / 24.0 * (2 * i + 1)) / cos (double_Pi * (2 * (i + 6) + 19) / 72.0);

  724.         }

  725. 

  726.         for (i = 0; i < 9; ++i)   COS9[i] = cos (double_Pi / 18.0 * i);

  727.         for (i = 0; i < 9; ++i)   tfcos36[i] = 0.5 / cos (double_Pi * (i * 2 + 1) / 36.0);

  728.         for (i = 0; i < 3; ++i)   tfcos12[i] = 0.5 / cos (double_Pi * (i * 2 + 1) / 12.0);

  729. 

  730.         COS6_1 = cos (double_Pi / 6.0 * 1.0);

  731.         COS6_2 = cos (double_Pi / 6.0 * 2.0);

  732. 

  733.         for (i = 0; i < 12; ++i)

  734.             win[2][i] = 0.5 * sin (double_Pi / 24.0 * (2 * i + 1)) / cos (double_Pi * (2 * i + 7) / 24.0);

  735. 

  736.         for (j = 0; j < 4; ++j)

  737.         {

  738.             static const int len[4] = { 36, 36, 12, 36 };

  739.             for (i = 0; i < len[j]; i += 2)   win1[j][i] =  win[j][i];

  740.             for (i = 1; i < len[j]; i += 2)   win1[j][i] = -win[j][i];

  741.         }

  742. 

  743.         const double sqrt2 = 1.41421356237309504880168872420969808;

  744. 

  745.         for (i = 0; i < 16; ++i)

  746.         {

  747.             const double t = tan (i * double_Pi / 12.0);

  748.             tan1_1[i] = t / (1.0 + t);

  749.             tan2_1[i] = 1.0 / (1.0 + t);

  750.             tan1_2[i] = sqrt2 * t / (1.0 + t);

  751.             tan2_2[i] = sqrt2 / (1.0 + t);

  752. 

  753.             for (j = 0; j < 2; ++j)

  754.             {

  755.                 double p1 = 1.0, p2 = 1.0;

  756. 

  757.                 if (i > 0)

  758.                 {

  759.                     const double base = pow (2.0, -0.25 * (j + 1.0));

  760. 

  761.                     if (i & 1)

  762.                         p1 = pow (base, (i + 1.0) * 0.5);

  763.                     else

  764.                         p2 = pow (base, i * 0.5);

  765.                 }

  766. 

  767.                 pow1_1[j][i] = p1;

  768.                 pow2_1[j][i] = p2;

  769.                 pow1_2[j][i] = sqrt2 * p1;

  770.                 pow2_2[j][i] = sqrt2 * p2;

  771.             }

  772.         }

  773. 

  774.         for (j = 0; j < 9; ++j)

  775.         {

  776.             const BandInfoStruct& bi = bandInfo[j];

  777.             int cb;

  778.             int* mp = map[j][0] = mapbuf0[j];

  779.             const int16* bdf = bi.longDiff;

  780. 

  781.             for (i = 0, cb = 0; cb < 8; ++cb, i += *bdf++)

  782.             {

  783.                 *mp++ = (*bdf) >> 1;

  784.                 *mp++ = i;

  785.                 *mp++ = 3;

  786.                 *mp++ = cb;

  787.             }

  788.             bdf = bi.shortDiff + 3;

  789. 

  790.             for (cb = 3; cb < 13; ++cb)

  791.             {

  792.                 const int l = (*bdf++) >> 1;

  793. 

  794.                 for (int lwin = 0; lwin < 3; ++lwin)

  795.                 {

  796.                     *mp++ = l;

  797.                     *mp++ = i + lwin;

  798.                     *mp++ = lwin;

  799.                     *mp++ = cb;

  800.                 }

  801.                 i += 6 * l;

  802.             }

  803. 

  804.             mapEnd[j][0] = mp;

  805.             mp = map[j][1] = mapbuf1[j];

  806.             bdf = bi.shortDiff;

  807. 

  808.             for (i = 0, cb = 0; cb < 13; ++cb)

  809.             {

  810.                 const int l = (*bdf++) >> 1;

  811.                 for (int lwin = 0; lwin < 3; ++lwin)

  812.                 {

  813.                     *mp++ = l;

  814.                     *mp++ = i + lwin;

  815.                     *mp++ = lwin;

  816.                     *mp++ = cb;

  817.                 }

  818.                 i += 6 * l;

  819.             }

  820.             mapEnd[j][1] = mp;

  821. 

  822.             mp = map[j][2] = mapbuf2[j];

  823.             bdf = bi.longDiff;

  824.             for (cb = 0; cb < 22; ++cb)

  825.             {

  826.                 *mp++ = (*bdf++) >> 1;

  827.                 *mp++ = cb;

  828.             }

  829.             mapEnd[j][2] = mp;

  830. 

  831.         }

  832. 

  833.         for (j = 0; j < 9; ++j)

  834.         {

  835.             for (i = 0; i < 23; ++i)    longLimit[j][i]  = jmin (32, (bandInfo[j].longIndex[i] - 1 + 8) / 18 + 1);

  836.             for (i = 0; i < 14; ++i)    shortLimit[j][i] = jmin (32, (bandInfo[j].shortIndex[i] - 1) / 18 + 1);

  837.         }

  838. 

  839.         for (i = 0; i < 5; ++i)

  840.             for (j = 0; j < 6; ++j)

  841.                 for (int k = 0; k < 6; ++k)

  842.                 {

  843.                     const int n = k + j * 6 + i * 36;

  844.                     iLength2[n] = i | (j << 3) | (k << 6) | (3 << 12);

  845.                 }

  846. 

  847.         for (i = 0; i < 4; ++i)

  848.             for (j = 0; j < 4; ++j)

  849.                 for (int k = 0; k < 4; ++k)

  850.                 {

  851.                     const int n = k + j * 4 + i * 16;

  852.                     iLength2[n + 180] = i | (j << 3) | (k << 6) | (4 << 12);

  853.                 }

  854. 

  855.         for (i = 0; i < 4; ++i)

  856.             for (j = 0; j < 3; ++j)

  857.             {

  858.                 const int n = j + i * 3;

  859.                 iLength2[n + 244] = i | (j << 3) | (5 << 12);

  860.                 nLength2[n + 500] = i | (j << 3) | (2 << 12) | (1 << 15);

  861.             }

  862. 

  863.         for (i = 0; i < 5; ++i)

  864.             for (j = 0; j < 5; ++j)

  865.                 for (int k = 0; k < 4; ++k)

  866.                     for (int l = 0; l < 4; ++l)

  867.                     {

  868.                         const int n = l + k * 4 + j * 16 + i * 80;

  869.                         nLength2[n] = i | (j << 3) | (k << 6) | (l << 9) | (0 << 12);

  870.                     }

  871. 

  872.         for (i = 0; i < 5; ++i)

  873.             for (j = 0; j < 5; ++j)

  874.                 for (int k = 0; k < 4; ++k)

  875.                 {

  876.                     const int n = k + j * 4 + i * 20;

  877.                     nLength2[n + 400] = i | (j << 3) | (k << 6) | (1 << 12);

  878.                 }

  879.     }

  880. };

  881. 

  882. static const Constants constants;

  883. 

  884. 

  885. //==============================================================================

  886. struct Layer3SideInfo

  887. {

  888.     struct Info

  889.     {

  890.         void doAntialias (float xr[32][18]) const noexcept

  891.         {

  892.             float* xr1 = xr[1];

  893.             int sb;

  894. 

  895.             if (blockType == 2)

  896.             {

  897.                 if (mixedBlockFlag == 0)

  898.                     return;

  899. 

  900.                 sb = 1;

  901.             }

  902.             else

  903.                 sb = maxb - 1;

  904. 

  905.             for (; sb != 0; --sb, xr1 += 10)

  906.             {

  907.                 const float* cs = constants.antiAliasingCs;

  908.                 const float* ca = constants.antiAliasingCa;

  909.                 float* xr2 = xr1;

  910. 

  911.                 for (int ss = 7; ss >= 0; --ss)

  912.                 {

  913.                     const float bu = *--xr2, bd = *xr1;

  914.                     *xr2   = (bu * *cs)   - (bd * *ca);

  915.                     *xr1++ = (bd * *cs++) + (bu * *ca++);

  916.                 }

  917.             }

  918.         }

  919. 

  920.         void doIStereo (float xrBuffer[2][32][18], const int* const scaleFactors,

  921.                         const int sampleRate, const bool msStereo, const int lsf) const noexcept

  922.         {

  923.             float (*xr) [32 * 18] = (float (*) [32 * 18]) xrBuffer;

  924.             const BandInfoStruct& bi = bandInfo[sampleRate];

  925.             const float* tabl1, *tabl2;

  926. 

  927.             if (lsf != 0)

  928.             {

  929.                 const int p = scaleFactorCompression & 1;

  930.                 if (msStereo)

  931.                 {

  932.                     tabl1 = constants.pow1_2[p];

  933.                     tabl2 = constants.pow2_2[p];

  934.                 }

  935.                 else

  936.                 {

  937.                     tabl1 = constants.pow1_1[p];

  938.                     tabl2 = constants.pow2_1[p];

  939.                 }

  940.             }

  941.             else

  942.             {

  943.                 if (msStereo)

  944.                 {

  945.                     tabl1 = constants.tan1_2;

  946.                     tabl2 = constants.tan2_2;

  947.                 }

  948.                 else

  949.                 {

  950.                     tabl1 = constants.tan1_1;

  951.                     tabl2 = constants.tan2_1;

  952.                 }

  953.             }

  954. 

  955.             if (blockType == 2)

  956.             {

  957.                 bool doL = mixedBlockFlag != 0;

  958. 

  959.                 for (int lwin = 0; lwin < 3; ++lwin)

  960.                 {

  961.                     int sfb = maxBand[lwin];

  962.                     doL = doL && (sfb <= 3);

  963. 

  964.                     for (; sfb < 12; ++sfb)

  965.                     {

  966.                         const int p = scaleFactors[sfb * 3 + lwin - mixedBlockFlag];

  967.                         if (p != 7)

  968.                         {

  969.                             const float t1 = tabl1[p];

  970.                             const float t2 = tabl2[p];

  971.                             int sb = bi.shortDiff[sfb];

  972.                             int index = sb + lwin;

  973. 

  974.                             for (; sb > 0; --sb, index += 3)

  975.                             {

  976.                                 float v = xr[0][index];

  977.                                 xr[0][index] = v * t1;

  978.                                 xr[1][index] = v * t2;

  979.                             }

  980.                         }

  981.                     }

  982. 

  983.                     const int p = scaleFactors[11 * 3 + lwin - mixedBlockFlag];

  984. 

  985.                     if (p != 7)

  986.                     {

  987.                         const float t1 = tabl1[p];

  988.                         const float t2 = tabl2[p];

  989.                         int sb = bi.shortDiff[12];

  990.                         int index = sb + lwin;

  991. 

  992.                         for (; sb > 0; --sb, index += 3)

  993.                         {

  994.                             float v = xr[0][index];

  995.                             xr[0][index] = v * t1;

  996.                             xr[1][index] = v * t2;

  997.                         }

  998.                     }

  999.                 }

  1000. 

  1001.                 if (doL)

  1002.                 {

  1003.                     int index = bi.longIndex[maxBandl];

  1004. 

  1005.                     for (int sfb = maxBandl; sfb < 8; ++sfb)

  1006.                     {

  1007.                         int sb = bi.longDiff[sfb];

  1008.                         const int p = scaleFactors[sfb];

  1009. 

  1010.                         if (p != 7)

  1011.                         {

  1012.                             const float t1 = tabl1[p];

  1013.                             const float t2 = tabl2[p];

  1014. 

  1015.                             for (; sb > 0; --sb, ++index)

  1016.                             {

  1017.                                 float v = xr[0][index];

  1018.                                 xr[0][index] = v * t1;

  1019.                                 xr[1][index] = v * t2;

  1020.                             }

  1021.                         }

  1022.                         else

  1023.                             index += sb;

  1024.                     }

  1025.                 }

  1026.             }

  1027.             else

  1028.             {

  1029.                 int index = bi.longIndex[maxBandl];

  1030. 

  1031.                 for (int sfb = maxBandl; sfb < 21; ++sfb)

  1032.                 {

  1033.                     int sb = bi.longDiff[sfb];

  1034.                     const int p = scaleFactors[sfb];

  1035. 

  1036.                     if (p != 7)

  1037.                     {

  1038.                         const float t1 = tabl1[p];

  1039.                         const float t2 = tabl2[p];

  1040. 

  1041.                         for (; sb > 0; --sb, ++index)

  1042.                         {

  1043.                             const float v = xr[0][index];

  1044.                             xr[0][index] = v * t1;

  1045.                             xr[1][index] = v * t2;

  1046.                         }

  1047.                     }

  1048.                     else

  1049.                         index += sb;

  1050.                 }

  1051. 

  1052.                 const int p = scaleFactors[20];

  1053.                 if (p != 7)

  1054.                 {

  1055.                     const float t1 = tabl1[p], t2 = tabl2[p];

  1056. 

  1057.                     for (int sb = bi.longDiff[21]; sb > 0; --sb, ++index)

  1058.                     {

  1059.                         const float v = xr[0][index];

  1060.                         xr[0][index] = v * t1;

  1061.                         xr[1][index] = v * t2;

  1062.                     }

  1063.                 }

  1064.             }

  1065.         }

  1066. 

  1067.         int scfsi;

  1068.         uint32 part2_3Length, bigValues;

  1069.         uint32 scaleFactorCompression, blockType, mixedBlockFlag;

  1070.         uint32 tableSelect[3];

  1071.         uint32 maxBand[3];

  1072.         uint32 maxBandl, maxb, region1Start, region2Start;

  1073.         uint32 preflag, scaleFactorScale, count1TableSelect;

  1074.         const float* fullGain[3];

  1075.         const float* pow2gain;

  1076.     };

  1077. 

  1078.     struct InfoPair { Info gr[2]; };

  1079.     InfoPair ch[2];

  1080. 

  1081.     uint32 mainDataStart, privateBits;

  1082. };

  1083. 

  1084. //==============================================================================

  1085. namespace DCT

  1086. {

  1087.     enum { SBLIMIT = 32 };

  1088. 

  1089.     inline void dct36_0 (const int v, float* const ts, float* const out1, float* const out2,

  1090.                          const float* const wintab, float sum0, const float sum1) noexcept

  1091.     {

  1092.         const float tmp = sum0 + sum1;

  1093.         out2[9 + v] = tmp * wintab[27 + v];

  1094.         out2[8 - v] = tmp * wintab[26 - v];

  1095.         sum0 -= sum1;

  1096.         ts[SBLIMIT * (8 - v)] = out1[8 - v] + sum0 * wintab[8 - v];

  1097.         ts[SBLIMIT * (9 + v)] = out1[9 + v] + sum0 * wintab[9 + v];

  1098.     }

  1099. 

  1100.     inline void dct36_1 (const int v, float* const ts, float* const out1, float* const out2, const float* const wintab,

  1101.                          const float tmp1a, const float tmp1b, const float tmp2a, const float tmp2b) noexcept

  1102.     {

  1103.         dct36_0 (v, ts, out1, out2, wintab, tmp1a + tmp2a, (tmp1b + tmp2b) * constants.tfcos36[v]);

  1104.     }

  1105. 

  1106.     inline void dct36_2 (const int v, float* const ts, float* const out1, float* const out2, const float* const wintab,

  1107.                          const float tmp1a, const float tmp1b, const float tmp2a, const float tmp2b) noexcept

  1108.     {

  1109.         dct36_0 (v, ts, out1, out2, wintab, tmp2a - tmp1a, (tmp2b - tmp1b) * constants.tfcos36[v]);

  1110.     }

  1111. 

  1112.     void dct36 (float* const in, float* const out1, float* const out2, const float* const wintab, float* const ts) noexcept

  1113.     {

  1114.         in[17] += in[16]; in[16] += in[15]; in[15] += in[14]; in[14] += in[13]; in[13] += in[12];

  1115.         in[12] += in[11]; in[11] += in[10]; in[10] += in[9];  in[9]  += in[8];  in[8]  += in[7];

  1116.         in[7]  += in[6];  in[6]  += in[5];  in[5]  += in[4];  in[4]  += in[3];  in[3]  += in[2];

  1117.         in[2]  += in[1];  in[1]  += in[0];  in[17] += in[15]; in[15] += in[13]; in[13] += in[11];

  1118.         in[11] += in[9];  in[9]  += in[7];  in[7]  += in[5];  in[5]  += in[3];  in[3]  += in[1];

  1119. 

  1120.         const float* const c = constants.COS9;

  1121.         const float ta33 = in[2 * 3 + 0] * c[3];

  1122.         const float ta66 = in[2 * 6 + 0] * c[6];

  1123.         const float tb33 = in[2 * 3 + 1] * c[3];

  1124.         const float tb66 = in[2 * 6 + 1] * c[6];

  1125. 

  1126.         {

  1127.             const float tmp1a = in[2 * 1 + 0] * c[1] + ta33 + in[2 * 5 + 0] * c[5] + in[2 * 7 + 0] * c[7];

  1128.             const float tmp1b = in[2 * 1 + 1] * c[1] + tb33 + in[2 * 5 + 1] * c[5] + in[2 * 7 + 1] * c[7];

  1129.             const float tmp2a = in[2 * 0 + 0] + in[2 * 2 + 0] * c[2] + in[2 * 4 + 0] * c[4] + ta66 + in[2 * 8 + 0] * c[8];

  1130.             const float tmp2b = in[2 * 0 + 1] + in[2 * 2 + 1] * c[2] + in[2 * 4 + 1] * c[4] + tb66 + in[2 * 8 + 1] * c[8];

  1131.             dct36_1 (0, ts, out1, out2, wintab, tmp1a, tmp1b, tmp2a, tmp2b);

  1132.             dct36_2 (8, ts, out1, out2, wintab, tmp1a, tmp1b, tmp2a, tmp2b);

  1133.         }

  1134. 

  1135.         {

  1136.             const float tmp1a = (in[2 * 1 + 0] - in[2 * 5 + 0] - in[2 * 7 + 0]) * c[3];

  1137.             const float tmp1b = (in[2 * 1 + 1] - in[2 * 5 + 1] - in[2 * 7 + 1]) * c[3];

  1138.             const float tmp2a = (in[2 * 2 + 0] - in[2 * 4 + 0] - in[2 * 8 + 0]) * c[6] - in[2 * 6 + 0] + in[2 * 0 + 0];

  1139.             const float tmp2b = (in[2 * 2 + 1] - in[2 * 4 + 1] - in[2 * 8 + 1]) * c[6] - in[2 * 6 + 1] + in[2 * 0 + 1];

  1140.             dct36_1 (1, ts, out1, out2, wintab, tmp1a, tmp1b, tmp2a, tmp2b);

  1141.             dct36_2 (7, ts, out1, out2, wintab, tmp1a, tmp1b, tmp2a, tmp2b);

  1142.         }

  1143. 

  1144.         {

  1145.             const float tmp1a = in[2 * 1 + 0] * c[5] - ta33 - in[2 * 5 + 0] * c[7] + in[2 * 7 + 0] * c[1];

  1146.             const float tmp1b = in[2 * 1 + 1] * c[5] - tb33 - in[2 * 5 + 1] * c[7] + in[2 * 7 + 1] * c[1];

  1147.             const float tmp2a = in[2 * 0 + 0] - in[2 * 2 + 0] * c[8] - in[2 * 4 + 0] * c[2] + ta66 + in[2 * 8 + 0] * c[4];

  1148.             const float tmp2b = in[2 * 0 + 1] - in[2 * 2 + 1] * c[8] - in[2 * 4 + 1] * c[2] + tb66 + in[2 * 8 + 1] * c[4];

  1149.             dct36_1 (2, ts, out1, out2, wintab, tmp1a, tmp1b, tmp2a, tmp2b);

  1150.             dct36_2 (6, ts, out1, out2, wintab, tmp1a, tmp1b, tmp2a, tmp2b);

  1151.         }

  1152. 

  1153.         {

  1154.             const float tmp1a = in[2 * 1 + 0] * c[7] - ta33 + in[2 * 5 + 0] * c[1] - in[2 * 7 + 0] * c[5];

  1155.             const float tmp1b = in[2 * 1 + 1] * c[7] - tb33 + in[2 * 5 + 1] * c[1] - in[2 * 7 + 1] * c[5];

  1156.             const float tmp2a = in[2 * 0 + 0] - in[2 * 2 + 0] * c[4] + in[2 * 4 + 0] * c[8] + ta66 - in[2 * 8 + 0] * c[2];

  1157.             const float tmp2b = in[2 * 0 + 1] - in[2 * 2 + 1] * c[4] + in[2 * 4 + 1] * c[8] + tb66 - in[2 * 8 + 1] * c[2];

  1158.             dct36_1 (3, ts, out1, out2, wintab, tmp1a, tmp1b, tmp2a, tmp2b);

  1159.             dct36_2 (5, ts, out1, out2, wintab, tmp1a, tmp1b, tmp2a, tmp2b);

  1160.         }

  1161. 

  1162.         const float sum0 =  in[2 * 0 + 0] - in[2 * 2 + 0] + in[2 * 4 + 0] - in[2 * 6 + 0] + in[2 * 8 + 0];

  1163.         const float sum1 = (in[2 * 0 + 1] - in[2 * 2 + 1] + in[2 * 4 + 1] - in[2 * 6 + 1] + in[2 * 8 + 1]) * constants.tfcos36[4];

  1164.         dct36_0 (4, ts, out1, out2, wintab, sum0, sum1);

  1165.     }

  1166. 

  1167.     struct DCT12Inputs

  1168.     {

  1169.         float in0, in1, in2, in3, in4, in5;

  1170. 

  1171.         inline DCT12Inputs (const float* const in) noexcept

  1172.         {

  1173.             in5 = in[5*3] + (in4 = in[4*3]);

  1174.             in4 += (in3 = in[3*3]);

  1175.             in3 += (in2 = in[2*3]);

  1176.             in2 += (in1 = in[1*3]);

  1177.             in1 += (in0 = in[0*3]);

  1178.             in5 += in3; in3 += in1;

  1179.             in2 *= constants.COS6_1;

  1180.             in3 *= constants.COS6_1;

  1181.         }

  1182. 

  1183.         inline void process() noexcept

  1184.         {

  1185.             in0 += in4 * constants.COS6_2;

  1186.             in4 = in0 + in2; in0 -= in2;

  1187.             in1 += in5 * constants.COS6_2;

  1188.             in5 = (in1 + in3) * constants.tfcos12[0];

  1189.             in1 = (in1 - in3) * constants.tfcos12[2];

  1190.             in3 = in4 + in5; in4 -= in5;

  1191.             in2 = in0 + in1; in0 -= in1;

  1192.         }

  1193.     };

  1194. 

  1195.     void dct12 (const float* in, float* const out1, float* const out2, const float* wi, float* ts) noexcept

  1196.     {

  1197.         {

  1198.             ts[SBLIMIT * 0] = out1[0];

  1199.             ts[SBLIMIT * 1] = out1[1];

  1200.             ts[SBLIMIT * 2] = out1[2];

  1201.             ts[SBLIMIT * 3] = out1[3];

  1202.             ts[SBLIMIT * 4] = out1[4];

  1203.             ts[SBLIMIT * 5] = out1[5];

  1204. 

  1205.             DCT12Inputs inputs (in);

  1206. 

  1207.             {

  1208.                 float tmp1 = (inputs.in0 - inputs.in4);

  1209.                 const float tmp2 = (inputs.in1 - inputs.in5) * constants.tfcos12[1];

  1210.                 const float tmp0 = tmp1 + tmp2;

  1211.                 tmp1 -= tmp2;

  1212. 

  1213.                 ts [(17 - 1) * SBLIMIT] = out1 [17 - 1] + tmp0 * wi[11 - 1];

  1214.                 ts [(12 + 1) * SBLIMIT] = out1 [12 + 1] + tmp0 * wi[6 + 1];

  1215.                 ts [(6 + 1)  * SBLIMIT] = out1 [6 + 1]  + tmp1 * wi[1];

  1216.                 ts [(11 - 1) * SBLIMIT] = out1 [11 - 1] + tmp1 * wi[5 - 1];

  1217.             }

  1218. 

  1219.             inputs.process();

  1220. 

  1221.             ts [(17 - 0) * SBLIMIT] = out1[17 - 0] + inputs.in2 * wi[11 - 0];

  1222.             ts [(12 + 0) * SBLIMIT] = out1[12 + 0] + inputs.in2 * wi[6 + 0];

  1223.             ts [(12 + 2) * SBLIMIT] = out1[12 + 2] + inputs.in3 * wi[6 + 2];

  1224.             ts [(17 - 2) * SBLIMIT] = out1[17 - 2] + inputs.in3 * wi[11 - 2];

  1225. 

  1226.             ts [(6 + 0)  * SBLIMIT] = out1[6 + 0]  + inputs.in0 * wi[0];

  1227.             ts [(11 - 0) * SBLIMIT] = out1[11 - 0] + inputs.in0 * wi[5 - 0];

  1228.             ts [(6 + 2)  * SBLIMIT] = out1[6 + 2]  + inputs.in4 * wi[2];

  1229.             ts [(11 - 2) * SBLIMIT] = out1[11 - 2] + inputs.in4 * wi[5 - 2];

  1230.         }

  1231. 

  1232.         ++in;

  1233. 

  1234.         {

  1235.             DCT12Inputs inputs (in);

  1236.             float tmp1 = (inputs.in0 - inputs.in4);

  1237.             const float tmp2 = (inputs.in1 - inputs.in5) * constants.tfcos12[1];

  1238.             const float tmp0 = tmp1 + tmp2;

  1239.             tmp1 -= tmp2;

  1240. 

  1241.             out2 [5 - 1] = tmp0 * wi[11 - 1];

  1242.             out2 [0 + 1] = tmp0 * wi[6 + 1];

  1243.             ts [(12 + 1) * SBLIMIT] += tmp1 * wi[1];

  1244.             ts [(17 - 1) * SBLIMIT] += tmp1 * wi[5 - 1];

  1245. 

  1246.             inputs.process();

  1247. 

  1248.             out2 [5 - 0] = inputs.in2 * wi[11 - 0];

  1249.             out2 [0 + 0] = inputs.in2 * wi[6 + 0];

  1250.             out2 [0 + 2] = inputs.in3 * wi[6 + 2];

  1251.             out2 [5 - 2] = inputs.in3 * wi[11 - 2];

  1252. 

  1253.             ts [(12 + 0) * SBLIMIT] += inputs.in0 * wi[0];

  1254.             ts [(17 - 0) * SBLIMIT] += inputs.in0 * wi[5 - 0];

  1255.             ts [(12 + 2) * SBLIMIT] += inputs.in4 * wi[2];

  1256.             ts [(17 - 2) * SBLIMIT] += inputs.in4 * wi[5 - 2];

  1257.         }

  1258. 

  1259.         ++in;

  1260. 

  1261.         {

  1262.             DCT12Inputs inputs (in);

  1263.             out2[12] = out2[13] = out2[14] = out2[15] = out2[16] = out2[17] = 0;

  1264. 

  1265.             float tmp1 = (inputs.in0 - inputs.in4);

  1266.             const float tmp2 = (inputs.in1 - inputs.in5) * constants.tfcos12[1];

  1267.             const float tmp0 = tmp1 + tmp2;

  1268.             tmp1 -= tmp2;

  1269. 

  1270.             out2[11 - 1] = tmp0 * wi[11 - 1];

  1271.             out2[6 + 1]  = tmp0 * wi[6 + 1];

  1272.             out2[0 + 1] += tmp1 * wi[1];

  1273.             out2[5 - 1] += tmp1 * wi[5 - 1];

  1274. 

  1275.             inputs.process();

  1276. 

  1277.             out2[11 - 0] = inputs.in2 * wi[11 - 0];

  1278.             out2[6 + 0]  = inputs.in2 * wi[6 + 0];

  1279.             out2[6 + 2]  = inputs.in3 * wi[6 + 2];

  1280.             out2[11 - 2] = inputs.in3 * wi[11 - 2];

  1281. 

  1282.             out2[0 + 0] += inputs.in0 * wi[0];

  1283.             out2[5 - 0] += inputs.in0 * wi[5 - 0];

  1284.             out2[0 + 2] += inputs.in4 * wi[2];

  1285.             out2[5 - 2] += inputs.in4 * wi[5 - 2];

  1286.         }

  1287.     }

  1288. 

  1289.     void dct64 (float* const out0, float* const out1, float* const b1, float* const b2, const float* const samples) noexcept

  1290.     {

  1291.         {

  1292.             const float* const costab = constants.pnts[0];

  1293.             b1[0x00] = samples[0x00] + samples[0x1F];   b1[0x1F] = (samples[0x00] - samples[0x1F]) * costab[0x0];

  1294.             b1[0x01] = samples[0x01] + samples[0x1E];   b1[0x1E] = (samples[0x01] - samples[0x1E]) * costab[0x1];

  1295.             b1[0x02] = samples[0x02] + samples[0x1D];   b1[0x1D] = (samples[0x02] - samples[0x1D]) * costab[0x2];

  1296.             b1[0x03] = samples[0x03] + samples[0x1C];   b1[0x1C] = (samples[0x03] - samples[0x1C]) * costab[0x3];

  1297.             b1[0x04] = samples[0x04] + samples[0x1B];   b1[0x1B] = (samples[0x04] - samples[0x1B]) * costab[0x4];

  1298.             b1[0x05] = samples[0x05] + samples[0x1A];   b1[0x1A] = (samples[0x05] - samples[0x1A]) * costab[0x5];

  1299.             b1[0x06] = samples[0x06] + samples[0x19];   b1[0x19] = (samples[0x06] - samples[0x19]) * costab[0x6];

  1300.             b1[0x07] = samples[0x07] + samples[0x18];   b1[0x18] = (samples[0x07] - samples[0x18]) * costab[0x7];

  1301.             b1[0x08] = samples[0x08] + samples[0x17];   b1[0x17] = (samples[0x08] - samples[0x17]) * costab[0x8];

  1302.             b1[0x09] = samples[0x09] + samples[0x16];   b1[0x16] = (samples[0x09] - samples[0x16]) * costab[0x9];

  1303.             b1[0x0A] = samples[0x0A] + samples[0x15];   b1[0x15] = (samples[0x0A] - samples[0x15]) * costab[0xA];

  1304.             b1[0x0B] = samples[0x0B] + samples[0x14];   b1[0x14] = (samples[0x0B] - samples[0x14]) * costab[0xB];

  1305.             b1[0x0C] = samples[0x0C] + samples[0x13];   b1[0x13] = (samples[0x0C] - samples[0x13]) * costab[0xC];

  1306.             b1[0x0D] = samples[0x0D] + samples[0x12];   b1[0x12] = (samples[0x0D] - samples[0x12]) * costab[0xD];

  1307.             b1[0x0E] = samples[0x0E] + samples[0x11];   b1[0x11] = (samples[0x0E] - samples[0x11]) * costab[0xE];

  1308.             b1[0x0F] = samples[0x0F] + samples[0x10];   b1[0x10] = (samples[0x0F] - samples[0x10]) * costab[0xF];

  1309.         }

  1310. 

  1311.         {

  1312.             const float* const costab = constants.pnts[1];

  1313.             b2[0x00] = b1[0x00] + b1[0x0F];   b2[0x0F] = (b1[0x00] - b1[0x0F]) * costab[0];

  1314.             b2[0x01] = b1[0x01] + b1[0x0E];   b2[0x0E] = (b1[0x01] - b1[0x0E]) * costab[1];

  1315.             b2[0x02] = b1[0x02] + b1[0x0D];   b2[0x0D] = (b1[0x02] - b1[0x0D]) * costab[2];

  1316.             b2[0x03] = b1[0x03] + b1[0x0C];   b2[0x0C] = (b1[0x03] - b1[0x0C]) * costab[3];

  1317.             b2[0x04] = b1[0x04] + b1[0x0B];   b2[0x0B] = (b1[0x04] - b1[0x0B]) * costab[4];

  1318.             b2[0x05] = b1[0x05] + b1[0x0A];   b2[0x0A] = (b1[0x05] - b1[0x0A]) * costab[5];

  1319.             b2[0x06] = b1[0x06] + b1[0x09];   b2[0x09] = (b1[0x06] - b1[0x09]) * costab[6];

  1320.             b2[0x07] = b1[0x07] + b1[0x08];   b2[0x08] = (b1[0x07] - b1[0x08]) * costab[7];

  1321.             b2[0x10] = b1[0x10] + b1[0x1F];   b2[0x1F] = (b1[0x1F] - b1[0x10]) * costab[0];

  1322.             b2[0x11] = b1[0x11] + b1[0x1E];   b2[0x1E] = (b1[0x1E] - b1[0x11]) * costab[1];

  1323.             b2[0x12] = b1[0x12] + b1[0x1D];   b2[0x1D] = (b1[0x1D] - b1[0x12]) * costab[2];

  1324.             b2[0x13] = b1[0x13] + b1[0x1C];   b2[0x1C] = (b1[0x1C] - b1[0x13]) * costab[3];

  1325.             b2[0x14] = b1[0x14] + b1[0x1B];   b2[0x1B] = (b1[0x1B] - b1[0x14]) * costab[4];

  1326.             b2[0x15] = b1[0x15] + b1[0x1A];   b2[0x1A] = (b1[0x1A] - b1[0x15]) * costab[5];

  1327.             b2[0x16] = b1[0x16] + b1[0x19];   b2[0x19] = (b1[0x19] - b1[0x16]) * costab[6];

  1328.             b2[0x17] = b1[0x17] + b1[0x18];   b2[0x18] = (b1[0x18] - b1[0x17]) * costab[7];

  1329.         }

  1330. 

  1331.         {

  1332.             const float* const costab = constants.pnts[2];

  1333.             b1[0x00] = b2[0x00] + b2[0x07];   b1[0x07] = (b2[0x00] - b2[0x07]) * costab[0];

  1334.             b1[0x01] = b2[0x01] + b2[0x06];   b1[0x06] = (b2[0x01] - b2[0x06]) * costab[1];

  1335.             b1[0x02] = b2[0x02] + b2[0x05];   b1[0x05] = (b2[0x02] - b2[0x05]) * costab[2];

  1336.             b1[0x03] = b2[0x03] + b2[0x04];   b1[0x04] = (b2[0x03] - b2[0x04]) * costab[3];

  1337.             b1[0x08] = b2[0x08] + b2[0x0F];   b1[0x0F] = (b2[0x0F] - b2[0x08]) * costab[0];

  1338.             b1[0x09] = b2[0x09] + b2[0x0E];   b1[0x0E] = (b2[0x0E] - b2[0x09]) * costab[1];

  1339.             b1[0x0A] = b2[0x0A] + b2[0x0D];   b1[0x0D] = (b2[0x0D] - b2[0x0A]) * costab[2];

  1340.             b1[0x0B] = b2[0x0B] + b2[0x0C];   b1[0x0C] = (b2[0x0C] - b2[0x0B]) * costab[3];

  1341.             b1[0x10] = b2[0x10] + b2[0x17];   b1[0x17] = (b2[0x10] - b2[0x17]) * costab[0];

  1342.             b1[0x11] = b2[0x11] + b2[0x16];   b1[0x16] = (b2[0x11] - b2[0x16]) * costab[1];

  1343.             b1[0x12] = b2[0x12] + b2[0x15];   b1[0x15] = (b2[0x12] - b2[0x15]) * costab[2];

  1344.             b1[0x13] = b2[0x13] + b2[0x14];   b1[0x14] = (b2[0x13] - b2[0x14]) * costab[3];

  1345.             b1[0x18] = b2[0x18] + b2[0x1F];   b1[0x1F] = (b2[0x1F] - b2[0x18]) * costab[0];

  1346.             b1[0x19] = b2[0x19] + b2[0x1E];   b1[0x1E] = (b2[0x1E] - b2[0x19]) * costab[1];

  1347.             b1[0x1A] = b2[0x1A] + b2[0x1D];   b1[0x1D] = (b2[0x1D] - b2[0x1A]) * costab[2];

  1348.             b1[0x1B] = b2[0x1B] + b2[0x1C];   b1[0x1C] = (b2[0x1C] - b2[0x1B]) * costab[3];

  1349.         }

  1350. 

  1351.         {

  1352.             const float cos0 = constants.pnts[3][0];

  1353.             const float cos1 = constants.pnts[3][1];

  1354.             b2[0x00] = b1[0x00] + b1[0x03];   b2[0x03] = (b1[0x00] - b1[0x03]) * cos0;

  1355.             b2[0x01] = b1[0x01] + b1[0x02];   b2[0x02] = (b1[0x01] - b1[0x02]) * cos1;

  1356.             b2[0x04] = b1[0x04] + b1[0x07];   b2[0x07] = (b1[0x07] - b1[0x04]) * cos0;

  1357.             b2[0x05] = b1[0x05] + b1[0x06];   b2[0x06] = (b1[0x06] - b1[0x05]) * cos1;

  1358.             b2[0x08] = b1[0x08] + b1[0x0B];   b2[0x0B] = (b1[0x08] - b1[0x0B]) * cos0;

  1359.             b2[0x09] = b1[0x09] + b1[0x0A];   b2[0x0A] = (b1[0x09] - b1[0x0A]) * cos1;

  1360.             b2[0x0C] = b1[0x0C] + b1[0x0F];   b2[0x0F] = (b1[0x0F] - b1[0x0C]) * cos0;

  1361.             b2[0x0D] = b1[0x0D] + b1[0x0E];   b2[0x0E] = (b1[0x0E] - b1[0x0D]) * cos1;

  1362.             b2[0x10] = b1[0x10] + b1[0x13];   b2[0x13] = (b1[0x10] - b1[0x13]) * cos0;

  1363.             b2[0x11] = b1[0x11] + b1[0x12];   b2[0x12] = (b1[0x11] - b1[0x12]) * cos1;

  1364.             b2[0x14] = b1[0x14] + b1[0x17];   b2[0x17] = (b1[0x17] - b1[0x14]) * cos0;

  1365.             b2[0x15] = b1[0x15] + b1[0x16];   b2[0x16] = (b1[0x16] - b1[0x15]) * cos1;

  1366.             b2[0x18] = b1[0x18] + b1[0x1B];   b2[0x1B] = (b1[0x18] - b1[0x1B]) * cos0;

  1367.             b2[0x19] = b1[0x19] + b1[0x1A];   b2[0x1A] = (b1[0x19] - b1[0x1A]) * cos1;

  1368.             b2[0x1C] = b1[0x1C] + b1[0x1F];   b2[0x1F] = (b1[0x1F] - b1[0x1C]) * cos0;

  1369.             b2[0x1D] = b1[0x1D] + b1[0x1E];   b2[0x1E] = (b1[0x1E] - b1[0x1D]) * cos1;

  1370.         }

  1371. 

  1372.         {

  1373.             const float cos0 = constants.pnts[4][0];

  1374.             b1[0x00] = b2[0x00] + b2[0x01];   b1[0x01] = (b2[0x00] - b2[0x01]) * cos0;

  1375.             b1[0x02] = b2[0x02] + b2[0x03];   b1[0x03] = (b2[0x03] - b2[0x02]) * cos0;  b1[0x02] += b1[0x03];

  1376.             b1[0x04] = b2[0x04] + b2[0x05];   b1[0x05] = (b2[0x04] - b2[0x05]) * cos0;

  1377.             b1[0x06] = b2[0x06] + b2[0x07];   b1[0x07] = (b2[0x07] - b2[0x06]) * cos0;

  1378.             b1[0x06] += b1[0x07];   b1[0x04] += b1[0x06];  b1[0x06] += b1[0x05]; b1[0x05] += b1[0x07];

  1379.             b1[0x08] = b2[0x08] + b2[0x09];   b1[0x09] = (b2[0x08] - b2[0x09]) * cos0;

  1380.             b1[0x0A] = b2[0x0A] + b2[0x0B];   b1[0x0B] = (b2[0x0B] - b2[0x0A]) * cos0;  b1[0x0A] += b1[0x0B];

  1381.             b1[0x0C] = b2[0x0C] + b2[0x0D];   b1[0x0D] = (b2[0x0C] - b2[0x0D]) * cos0;

  1382.             b1[0x0E] = b2[0x0E] + b2[0x0F];   b1[0x0F] = (b2[0x0F] - b2[0x0E]) * cos0;

  1383.             b1[0x0E] += b1[0x0F];   b1[0x0C] += b1[0x0E];  b1[0x0E] += b1[0x0D]; b1[0x0D] += b1[0x0F];

  1384.             b1[0x10] = b2[0x10] + b2[0x11];   b1[0x11] = (b2[0x10] - b2[0x11]) * cos0;

  1385.             b1[0x12] = b2[0x12] + b2[0x13];   b1[0x13] = (b2[0x13] - b2[0x12]) * cos0;  b1[0x12] += b1[0x13];

  1386.             b1[0x14] = b2[0x14] + b2[0x15];   b1[0x15] = (b2[0x14] - b2[0x15]) * cos0;

  1387.             b1[0x16] = b2[0x16] + b2[0x17];   b1[0x17] = (b2[0x17] - b2[0x16]) * cos0;

  1388.             b1[0x16] += b1[0x17];    b1[0x14] += b1[0x16]; b1[0x16] += b1[0x15];  b1[0x15] += b1[0x17];

  1389.             b1[0x18] = b2[0x18] + b2[0x19];   b1[0x19] = (b2[0x18] - b2[0x19]) * cos0;

  1390.             b1[0x1A] = b2[0x1A] + b2[0x1B];   b1[0x1B] = (b2[0x1B] - b2[0x1A]) * cos0;  b1[0x1A] += b1[0x1B];

  1391.             b1[0x1C] = b2[0x1C] + b2[0x1D];   b1[0x1D] = (b2[0x1C] - b2[0x1D]) * cos0;

  1392.             b1[0x1E] = b2[0x1E] + b2[0x1F];   b1[0x1F] = (b2[0x1F] - b2[0x1E]) * cos0;

  1393.             b1[0x1E] += b1[0x1F];    b1[0x1C] += b1[0x1E]; b1[0x1E] += b1[0x1D];  b1[0x1D] += b1[0x1F];

  1394.         }

  1395. 

  1396.         out0[0x10 * 16] = b1[0x00];  out0[0x10 * 12] = b1[0x04]; out0[0x10 * 8]  = b1[0x02];  out0[0x10 * 4]  = b1[0x06];

  1397.         out0[0x10 * 0]  = b1[0x01];  out1[0x10 * 0]  = b1[0x01]; out1[0x10 * 4]  = b1[0x05];  out1[0x10 * 8]  = b1[0x03];

  1398.         out1[0x10 * 12] = b1[0x07];

  1399. 

  1400.         b1[0x08] += b1[0x0C];  out0[0x10 * 14] = b1[0x08];  b1[0x0C] += b1[0x0a];  out0[0x10 * 10] = b1[0x0C];

  1401.         b1[0x0A] += b1[0x0E];  out0[0x10 * 6]  = b1[0x0A];  b1[0x0E] += b1[0x09];  out0[0x10 * 2]  = b1[0x0E];

  1402.         b1[0x09] += b1[0x0D];  out1[0x10 * 2]  = b1[0x09];  b1[0x0D] += b1[0x0B];  out1[0x10 * 6]  = b1[0x0D];

  1403.         b1[0x0B] += b1[0x0F];  out1[0x10 * 10] = b1[0x0B];  out1[0x10 * 14] = b1[0x0F];

  1404. 

  1405.         b1[0x18] += b1[0x1C];  out0[0x10 * 15] = b1[0x10] + b1[0x18];   out0[0x10 * 13] = b1[0x18] + b1[0x14];

  1406.         b1[0x1C] += b1[0x1a];  out0[0x10 * 11] = b1[0x14] + b1[0x1C];   out0[0x10 * 9]  = b1[0x1C] + b1[0x12];

  1407.         b1[0x1A] += b1[0x1E];  out0[0x10 * 7]  = b1[0x12] + b1[0x1A];   out0[0x10 * 5]  = b1[0x1A] + b1[0x16];

  1408.         b1[0x1E] += b1[0x19];  out0[0x10 * 3]  = b1[0x16] + b1[0x1E];   out0[0x10 * 1]  = b1[0x1E] + b1[0x11];

  1409.         b1[0x19] += b1[0x1D];  out1[0x10 * 1]  = b1[0x11] + b1[0x19];   out1[0x10 * 3]  = b1[0x19] + b1[0x15];

  1410.         b1[0x1D] += b1[0x1B];  out1[0x10 * 5]  = b1[0x15] + b1[0x1D];   out1[0x10 * 7]  = b1[0x1D] + b1[0x13];

  1411.         b1[0x1B] += b1[0x1F];  out1[0x10 * 9]  = b1[0x13] + b1[0x1B];   out1[0x10 * 11] = b1[0x1B] + b1[0x17];

  1412.         out1[0x10 * 13] = b1[0x17] + b1[0x1F];  out1[0x10 * 15] = b1[0x1F];

  1413.     }

  1414. 

  1415.     void dct64 (float* const a, float* const b, const float* const c) noexcept

  1416.     {

  1417.         float temp[64];

  1418.         dct64 (a, b, temp, temp + 32, c);

  1419.     }

  1420. }

  1421. 

  1422. //==============================================================================

  1423. struct MP3Stream

  1424. {

  1425.     MP3Stream (InputStream& source)

  1426.         : stream (source, 8192),

  1427.           numFrames (0), currentFrameIndex (0), vbrHeaderFound (false)

  1428.     {

  1429.         reset();

  1430.     }

  1431. 

  1432.     int decodeNextBlock (float* const out0, float* const out1, int& done)

  1433.     {

  1434.         if (! headerParsed)

  1435.         {

  1436.             int nextFrameOffset = scanForNextFrameHeader (false);

  1437. 

  1438.             if (lastFrameSize == -1 || needToSyncBitStream)

  1439.             {

  1440.                 needToSyncBitStream = false;

  1441.                 readVBRHeader();

  1442. 

  1443.                 if (vbrHeaderFound)

  1444.                     return 1;

  1445.             }

  1446. 

  1447.             if (nextFrameOffset < 0)

  1448.                 return -1;

  1449. 

  1450.             if (nextFrameOffset > 0)

  1451.             {

  1452.                 int size;

  1453.                 wasFreeFormat = false;

  1454.                 needToSyncBitStream = true;

  1455.                 size = (int) (bufferPointer - (bufferSpace[bufferSpaceIndex] + 512));

  1456. 

  1457.                 if (size > 2880)

  1458.                 {

  1459.                     size = 0;

  1460.                     bufferPointer = bufferSpace[bufferSpaceIndex] + 512;

  1461.                 }

  1462. 

  1463.                 const int toSkip = (size + nextFrameOffset) - 2880;

  1464. 

  1465.                 if (toSkip > 0)

  1466.                 {

  1467.                     stream.skipNextBytes (toSkip);

  1468.                     nextFrameOffset -= toSkip;

  1469.                 }

  1470. 

  1471.                 stream.read (bufferPointer, nextFrameOffset);

  1472.                 lastFrameSize += nextFrameOffset;

  1473.             }

  1474. 

  1475.             frame.decodeHeader (stream.readIntBigEndian());

  1476.             headerParsed = true;

  1477.             frameSize = frame.frameSize;

  1478.             isFreeFormat = (frameSize == 0);

  1479.             sideInfoSize = frame.lsf != 0 ? ((frame.numChannels == 1) ? 9 : 17)

  1480.                                           : ((frame.numChannels == 1) ? 17 : 32);

  1481. 

  1482.             if (frame.crc16FollowsHeader)

  1483.                 sideInfoSize += 2;

  1484. 

  1485.             bufferSpaceIndex = 1 - bufferSpaceIndex;

  1486.             bufferPointer = bufferSpace[bufferSpaceIndex] + 512;

  1487.             bitIndex = 0;

  1488. 

  1489.             if (lastFrameSize == -1)

  1490.                 return 1;

  1491.         }

  1492. 

  1493.         if (! sideParsed)

  1494.         {

  1495.             if (frame.layer == 3)

  1496.             {

  1497.                 stream.read (bufferPointer, sideInfoSize);

  1498. 

  1499.                 if (frame.crc16FollowsHeader)

  1500.                     getBits (16);

  1501. 

  1502.                 const int bits = jmax (0, decodeLayer3SideInfo());

  1503.                 dataSize = (bits + 7) / 8;

  1504. 

  1505.                 if (! isFreeFormat)

  1506.                     dataSize = jmin (dataSize, frame.frameSize - sideInfoSize);

  1507.             }

  1508.             else

  1509.             {

  1510.                 dataSize = frame.frameSize;

  1511.                 sideInfoSize = 0;

  1512.             }

  1513. 

  1514.             sideParsed = true;

  1515.         }

  1516. 

  1517.         int result = 1;

  1518. 

  1519.         if (! dataParsed)

  1520.         {

  1521.             stream.read (bufferPointer, dataSize);

  1522. 

  1523.             if (out0 != nullptr)

  1524.             {

  1525.                 if (frame.layer < 3 && frame.crc16FollowsHeader)

  1526.                     getBits (16);

  1527. 

  1528.                 switch (frame.layer)

  1529.                 {

  1530.                     case 1:  decodeLayer1Frame (out0, out1, done); break;

  1531.                     case 2:  decodeLayer2Frame (out0, out1, done); break;

  1532.                     case 3:  decodeLayer3Frame (out0, out1, done); break;

  1533.                     default: break;

  1534.                 }

  1535.             }

  1536. 

  1537.             bufferPointer = bufferSpace[bufferSpaceIndex] + 512 + sideInfoSize + dataSize;

  1538.             dataParsed = true;

  1539.             result = 0;

  1540.         }

  1541. 

  1542.         if (isFreeFormat)

  1543.         {

  1544.             if (wasFreeFormat)

  1545.             {

  1546.                 frameSize = lastFrameSizeNoPadding + frame.padding;

  1547.             }

  1548.             else

  1549.             {

  1550.                 const int nextFrameOffset = scanForNextFrameHeader (true);

  1551.                 if (nextFrameOffset < 0)

  1552.                     return result;

  1553. 

  1554.                 frameSize = nextFrameOffset + sideInfoSize + dataSize;

  1555.                 lastFrameSizeNoPadding = frameSize - frame.padding;

  1556.             }

  1557.         }

  1558. 

  1559.         if (result == 0)

  1560.             return result;

  1561. 

  1562.         int bytes = frameSize - (sideInfoSize + dataSize);

  1563. 

  1564.         if (bytes > 0)

  1565.         {

  1566.             const int toSkip = bytes - 512;

  1567. 

  1568.             if (toSkip > 0)

  1569.             {

  1570.                 stream.skipNextBytes (toSkip);

  1571.                 bytes -= toSkip;

  1572.                 frameSize -= toSkip;

  1573.             }

  1574. 

  1575.             stream.read (bufferPointer, bytes);

  1576.             bufferPointer += bytes;

  1577.         }

  1578. 

  1579.         lastFrameSize = frameSize;

  1580.         wasFreeFormat = isFreeFormat;

  1581.         frameSize = 0;

  1582.         headerParsed = sideParsed = dataParsed = false;

  1583.         return result;

  1584.     }

  1585. 

  1586.     bool seek (int frameIndex)

  1587.     {

  1588.         frameIndex = jmax (0, frameIndex);

  1589. 

  1590.         while (frameIndex >= frameStreamPositions.size() * storedStartPosInterval)

  1591.         {

  1592.             int dummy = 0;

  1593.             const int result = decodeNextBlock (nullptr, nullptr, dummy);

  1594. 

  1595.             if (result < 0)

  1596.                 return false;

  1597.             else if (result > 0)

  1598.                 break;

  1599.         }

  1600. 

  1601.         frameIndex = jmin (frameIndex & ~(storedStartPosInterval - 1),

  1602.                            frameStreamPositions.size() * storedStartPosInterval - 1);

  1603.         stream.setPosition (frameStreamPositions.getUnchecked (frameIndex / storedStartPosInterval));

  1604.         currentFrameIndex = frameIndex;

  1605.         reset();

  1606.         return true;

  1607.     }

  1608. 

  1609.     MP3Frame frame;

  1610.     VBRTagData vbrTagData;

  1611.     BufferedInputStream stream;

  1612.     int numFrames, currentFrameIndex;

  1613.     bool vbrHeaderFound;

  1614. 

  1615. private:

  1616.     int encoderDelay, encoderPadding;

  1617.     bool headerParsed, sideParsed, dataParsed, needToSyncBitStream;

  1618.     bool isFreeFormat, wasFreeFormat;

  1619.     int sideInfoSize, dataSize;

  1620.     int frameSize, lastFrameSize, lastFrameSizeNoPadding;

  1621.     int bufferSpaceIndex;

  1622.     Layer3SideInfo sideinfo;

  1623.     uint8 bufferSpace[2][2880 + 1024];

  1624.     uint8* bufferPointer;

  1625.     int bitIndex, synthBo;

  1626.     float hybridBlock[2][2][32 * 18];

  1627.     int hybridBlockIndex[2];

  1628.     float synthBuffers[2][2][0x110];

  1629.     float hybridIn[2][32][18];

  1630.     float hybridOut[2][18][32];

  1631. 

  1632.     void reset() noexcept

  1633.     {

  1634.         headerParsed = sideParsed = dataParsed = isFreeFormat = wasFreeFormat = false;

  1635.         encoderDelay = encoderPadding = lastFrameSize = -1;

  1636.         needToSyncBitStream = true;

  1637.         frameSize = sideInfoSize = dataSize = frameSize = bitIndex = 0;

  1638.         lastFrameSizeNoPadding = bufferSpaceIndex = 0;

  1639.         bufferPointer = bufferSpace[bufferSpaceIndex] + 512;

  1640.         synthBo = 1;

  1641. 

  1642.         zerostruct (sideinfo);

  1643.         zeromem (bufferSpace, sizeof (bufferSpace));

  1644.         zeromem (hybridBlock, sizeof (hybridBlock));

  1645.         zeromem (hybridBlockIndex, sizeof (hybridBlockIndex));

  1646.         zeromem (synthBuffers, sizeof (synthBuffers));

  1647.     }

  1648. 

  1649.     enum { storedStartPosInterval = 4 };

  1650.     Array<int64> frameStreamPositions;

  1651. 

  1652.     struct SideInfoLayer1

  1653.     {

  1654.         uint8 allocation[32][2];

  1655.         uint8 scaleFactor[32][2];

  1656.     };

  1657. 

  1658.     struct SideInfoLayer2

  1659.     {

  1660.         uint8 allocation[32][2];

  1661.         uint8 scaleFactor[32][2][3];

  1662.     };

  1663. 

  1664.     static bool isValidHeader (const uint32 header, const int oldLayer) noexcept

  1665.     {

  1666.         const int newLayer = 4 - ((header >> 17) & 3);

  1667. 

  1668.         return (header & 0xffe00000) == 0xffe00000

  1669.                 && newLayer != 4

  1670.                 && (oldLayer <= 0 || newLayer == oldLayer)

  1671.                 && ((header >> 12) & 15) != 15

  1672.                 && ((header >> 10) & 3) != 3

  1673.                 && (header & 3) != 2;

  1674.     }

  1675. 

  1676.     bool rollBackBufferPointer (int backstep) noexcept

  1677.     {

  1678.         if (lastFrameSize < 0 && backstep > 0)

  1679.             return false;

  1680. 

  1681.         const uint8* oldBuffer = bufferSpace[1 - bufferSpaceIndex] + 512;

  1682.         bufferPointer -= backstep;

  1683. 

  1684.         if (backstep != 0)

  1685.             memcpy (bufferPointer, oldBuffer + lastFrameSize - backstep, (size_t) backstep);

  1686. 

  1687.         bitIndex = 0;

  1688.         return true;

  1689.     }

  1690. 

  1691.     uint32 getBits (const int numBits) noexcept

  1692.     {

  1693.         if (numBits <= 0 || bufferPointer == nullptr)

  1694.             return 0;

  1695. 

  1696.         const uint32 result = ((((((bufferPointer[0] << 8) | bufferPointer[1]) << 8)

  1697.                                | bufferPointer[2]) << bitIndex) & 0xffffff) >> (24 - numBits);

  1698.         bitIndex += numBits;

  1699.         bufferPointer += (bitIndex >> 3);

  1700.         bitIndex &= 7;

  1701.         return result;

  1702.     }

  1703. 

  1704.     uint32 getOneBit() noexcept

  1705.     {

  1706.         const uint8 result = *bufferPointer << bitIndex;

  1707.         ++bitIndex;

  1708.         bufferPointer += (bitIndex >> 3);

  1709.         bitIndex &= 7;

  1710.         return result >> 7;

  1711.     }

  1712. 

  1713.     uint32 getBitsFast (const int numBits) noexcept

  1714.     {

  1715.         const uint32 result = ((((bufferPointer[0] << 8) | bufferPointer[1]) << bitIndex) & 0xffff) >> (16 - numBits);

  1716.         bitIndex += numBits;

  1717.         bufferPointer += (bitIndex >> 3);

  1718.         bitIndex &= 7;

  1719.         return result;

  1720.     }

  1721. 

  1722.     uint8 getLeq8Bits (const int numBits) noexcept    { return (uint8)  getBitsFast (numBits); }

  1723.     uint16 getLeq16Bits (const int numBits) noexcept  { return (uint16) getBitsFast (numBits); }

  1724. 

  1725.     int scanForNextFrameHeader (const bool checkTypeAgainstLastFrame) noexcept

  1726.     {

  1727.         const int64 oldPos = stream.getPosition();

  1728.         int offset = -3;

  1729.         uint32 header = 0;

  1730. 

  1731.         for (;;)

  1732.         {

  1733.             if (stream.isExhausted() || stream.getPosition() > oldPos + 32768)

  1734.             {

  1735.                 offset = -1;

  1736.                 break;

  1737.             }

  1738. 

  1739.             header = (header << 8) | (uint8) stream.readByte();

  1740. 

  1741.             if (offset >= 0 && isValidHeader (header, frame.layer))

  1742.             {

  1743.                 if (! checkTypeAgainstLastFrame)

  1744.                     break;

  1745. 

  1746.                 const bool mpeg25         = (header & (1 << 20)) == 0;

  1747.                 const int lsf             = mpeg25 ? 1 : ((header & (1 << 19)) ? 0 : 1);

  1748.                 const int sampleRateIndex = mpeg25 ? (6 + ((header >> 10) & 3)) : (((header >> 10) & 3) + (lsf * 3));

  1749.                 const int mode            = (header >> 6) & 3;

  1750.                 const int numChannels     = (mode == 3) ? 1 : 2;

  1751. 

  1752.                 if (numChannels == frame.numChannels && lsf == frame.lsf

  1753.                       && mpeg25 == frame.mpeg25 && sampleRateIndex == frame.sampleRateIndex)

  1754.                     break;

  1755.             }

  1756. 

  1757.             ++offset;

  1758.         }

  1759. 

  1760.         if (offset >= 0)

  1761.         {

  1762.             if ((currentFrameIndex & (storedStartPosInterval - 1)) == 0)

  1763.                 frameStreamPositions.set (currentFrameIndex / storedStartPosInterval, oldPos + offset);

  1764. 

  1765.             ++currentFrameIndex;

  1766.         }

  1767. 

  1768.         stream.setPosition (oldPos);

  1769.         return offset;

  1770.     }

  1771. 

  1772.     void readVBRHeader()

  1773.     {

  1774.         int64 oldPos = stream.getPosition();

  1775.         uint8 xing[194];

  1776.         stream.read (xing, sizeof (xing));

  1777. 

  1778.         vbrHeaderFound = vbrTagData.read (xing);

  1779. 

  1780.         if (vbrHeaderFound)

  1781.         {

  1782.             numFrames = vbrTagData.frames;

  1783.             encoderDelay = vbrTagData.encoderDelay;

  1784.             encoderPadding = vbrTagData.encoderPadding;

  1785.             oldPos += jmax (vbrTagData.headersize, 1);

  1786.         }

  1787. 

  1788.         stream.setPosition (oldPos);

  1789.     }

  1790. 

  1791.     void decodeLayer1Frame (float* const pcm0, float* const pcm1, int& samplesDone) noexcept

  1792.     {

  1793.         float fraction[2][32];

  1794.         SideInfoLayer1 si;

  1795.         layer1Step1 (si);

  1796.         const int single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;

  1797. 

  1798.         if (single >= 0)

  1799.         {

  1800.             for (int i = 0; i < 12; ++i)

  1801.             {

  1802.                 layer1Step2 (si, fraction);

  1803.                 synthesise (fraction[single], 0, pcm0, samplesDone);

  1804.             }

  1805.         }

  1806.         else

  1807.         {

  1808.             for (int i = 0; i < 12; ++i)

  1809.             {

  1810.                 layer1Step2 (si, fraction);

  1811.                 synthesiseStereo (fraction[0], fraction[1], pcm0, pcm1, samplesDone);

  1812.             }

  1813.         }

  1814.     }

  1815. 

  1816.     void decodeLayer2Frame (float* const pcm0, float* const pcm1, int& samplesDone)

  1817.     {

  1818.         float fraction[2][4][32];

  1819.         frame.selectLayer2Table();

  1820.         SideInfoLayer2 si;

  1821.         layer2Step1 (si);

  1822.         const int single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;

  1823. 

  1824.         if (single >= 0)

  1825.         {

  1826.             for (int i = 0; i < 12; ++i)

  1827.             {

  1828.                 layer2Step2 (si, i >> 2, fraction);

  1829.                 for (int j = 0; j < 3; ++j)

  1830.                     synthesise (fraction[single][j], 0, pcm0, samplesDone);

  1831.             }

  1832.         }

  1833.         else

  1834.         {

  1835.             for (int i = 0; i < 12; ++i)

  1836.             {

  1837.                 layer2Step2 (si, i >> 2, fraction);

  1838.                 for (int j = 0; j < 3; ++j)

  1839.                     synthesiseStereo (fraction[0][j], fraction[1][j], pcm0, pcm1, samplesDone);

  1840.             }

  1841.         }

  1842.     }

  1843. 

  1844.     void decodeLayer3Frame (float* const pcm0, float* const pcm1, int& samplesDone) noexcept

  1845.     {

  1846.         if (! rollBackBufferPointer ((int) sideinfo.mainDataStart))

  1847.             return;

  1848. 

  1849.         const int single = frame.numChannels == 1 ? 0 : frame.single;

  1850.         const int numChans = (frame.numChannels == 1 || single >= 0) ? 1 : 2;

  1851.         const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;

  1852.         const bool iStereo  = (frame.mode == 1) && (frame.modeExt & 1) != 0;

  1853.         const int granules = frame.lsf ? 1 : 2;

  1854.         int scaleFactors[2][39];

  1855. 

  1856.         for (int gr = 0; gr < granules; ++gr)

  1857.         {

  1858.             {

  1859.                 Layer3SideInfo::Info& granule = sideinfo.ch[0].gr[gr];

  1860.                 const int part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[0], granule, 0)

  1861.                                                 : getLayer3ScaleFactors1 (scaleFactors[0], granule);

  1862. 

  1863.                 if (layer3DequantizeSample (hybridIn[0], scaleFactors[0], granule, frame.sampleRateIndex, part2bits))

  1864.                     return;

  1865.             }

  1866. 

  1867.             if (frame.numChannels == 2)

  1868.             {

  1869.                 Layer3SideInfo::Info& granule = sideinfo.ch[1].gr[gr];

  1870.                 const int part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[1], granule, iStereo)

  1871.                                                 : getLayer3ScaleFactors1 (scaleFactors[1], granule);

  1872. 

  1873.                 if (layer3DequantizeSample (hybridIn[1], scaleFactors[1], granule, frame.sampleRateIndex, part2bits))

  1874.                     return;

  1875. 

  1876.                 if (msStereo)

  1877.                 {

  1878.                     for (int i = 0; i < 32 * 18; ++i)

  1879.                     {

  1880.                         const float tmp0 = ((const float*) hybridIn[0]) [i];

  1881.                         const float tmp1 = ((const float*) hybridIn[1]) [i];

  1882.                         ((float*) hybridIn[1]) [i] = tmp0 - tmp1;

  1883.                         ((float*) hybridIn[0]) [i] = tmp0 + tmp1;

  1884.                     }

  1885.                 }

  1886. 

  1887.                 if (iStereo)

  1888.                     granule.doIStereo (hybridIn, scaleFactors[1], frame.sampleRateIndex, msStereo, frame.lsf);

  1889. 

  1890.                 if (msStereo || iStereo || single == 3)

  1891.                 {

  1892.                     if (granule.maxb > sideinfo.ch[0].gr[gr].maxb)

  1893.                         sideinfo.ch[0].gr[gr].maxb = granule.maxb;

  1894.                     else

  1895.                         granule.maxb = sideinfo.ch[0].gr[gr].maxb;

  1896.                 }

  1897. 

  1898.                 switch (single)

  1899.                 {

  1900.                     case 3:

  1901.                     {

  1902.                         float* in0 = (float*) hybridIn[0];

  1903.                         const float* in1 = (const float*) hybridIn[1];

  1904.                         for (int i = 0; i < (int) (18 * granule.maxb); ++i, ++in0)

  1905.                             *in0 = (*in0 + *in1++);

  1906.                     }

  1907.                     break;

  1908. 

  1909.                     case 1:

  1910.                     {

  1911.                         float* in0 = (float*) hybridIn[0];

  1912.                         const float* in1 = (const float*) hybridIn[1];

  1913.                         for (int i = 0; i < (int) (18 * granule.maxb); ++i)

  1914.                             *in0++ = *in1++;

  1915.                     }

  1916.                     break;

  1917.                 }

  1918.             }

  1919. 

  1920.             for (int ch = 0; ch < numChans; ++ch)

  1921.             {

  1922.                 const Layer3SideInfo::Info& granule = sideinfo.ch[ch].gr[gr];

  1923.                 granule.doAntialias (hybridIn[ch]);

  1924.                 layer3Hybrid (hybridIn[ch], hybridOut[ch], ch, granule);

  1925.             }

  1926. 

  1927.             for (int ss = 0; ss < 18; ++ss)

  1928.             {

  1929.                 if (single >= 0)

  1930.                     synthesise (hybridOut[0][ss], 0, pcm0, samplesDone);

  1931.                 else

  1932.                     synthesiseStereo (hybridOut[0][ss], hybridOut[1][ss], pcm0, pcm1, samplesDone);

  1933.             }

  1934.         }

  1935.     }

  1936. 

  1937.     int decodeLayer3SideInfo() noexcept

  1938.     {

  1939.         const int numChannels = frame.numChannels;

  1940.         const int sampleRate = frame.sampleRateIndex;

  1941.         const int single = (numChannels == 1) ? 0 : frame.single;

  1942.         const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;

  1943.         const int granules = frame.lsf ? 1 : 2;

  1944. 

  1945.         if (frame.lsf != 0)

  1946.             getLayer3SideInfo2 (numChannels, msStereo, sampleRate, single);

  1947.         else

  1948.             getLayer3SideInfo1 (numChannels, msStereo, sampleRate, single);

  1949. 

  1950.         int databits = 0;

  1951.         for (int gr = 0; gr < granules; ++gr)

  1952.             for (int ch = 0; ch < numChannels; ++ch)

  1953.                 databits += sideinfo.ch[ch].gr[gr].part2_3Length;

  1954. 

  1955.         return databits - 8 * sideinfo.mainDataStart;

  1956.     }

  1957. 

  1958.     void layer1Step1 (SideInfoLayer1& si) noexcept

  1959.     {

  1960.         zerostruct (si);

  1961.         int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;

  1962. 

  1963.         if (frame.numChannels == 2)

  1964.         {

  1965.             for (i = 0; i < jsbound; ++i)

  1966.             {

  1967.                 si.allocation[i][0] = getLeq8Bits (4);

  1968.                 si.allocation[i][1] = getLeq8Bits (4);

  1969.             }

  1970. 

  1971.             for (i = jsbound; i < 32; ++i)

  1972.                 si.allocation[i][0] = si.allocation[i][1] = getLeq8Bits (4);

  1973. 

  1974.             for (i = 0; i < 32; ++i)

  1975.             {

  1976.                 si.scaleFactor[i][0] = si.allocation[i][0] ? getLeq8Bits (6) : 0;

  1977.                 si.scaleFactor[i][1] = si.allocation[i][1] ? getLeq8Bits (6) : 0;

  1978.             }

  1979.         }

  1980.         else

  1981.         {

  1982.             for (i = 0; i < 32; ++i)

  1983.                 si.allocation[i][0] = getLeq8Bits (4);

  1984. 

  1985.             for (i = 0; i < 32; ++i)

  1986.                 si.scaleFactor[i][0] = si.allocation[i][0] ? getLeq8Bits (6) : 0;

  1987.         }

  1988.     }

  1989. 

  1990.     void layer1Step2 (SideInfoLayer1& si, float fraction[2][32]) noexcept

  1991.     {

  1992.         if (frame.numChannels == 2)

  1993.         {

  1994.             int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;

  1995. 

  1996.             for (i = 0; i < jsbound; ++i)

  1997.             {

  1998.                 const uint8 n0 = si.allocation[i][0];

  1999.                 const uint8 n1 = si.allocation[i][1];

  2000.                 fraction[0][i] = n0 > 0 ? (float) (((-1 << n0) + getLeq16Bits (n0 + 1) + 1) * constants.muls[n0 + 1][si.scaleFactor[i][0]]) : 0;

  2001.                 fraction[1][i] = n1 > 0 ? (float) (((-1 << n1) + getLeq16Bits (n1 + 1) + 1) * constants.muls[n1 + 1][si.scaleFactor[i][1]]) : 0;

  2002.             }

  2003. 

  2004.             for (i = jsbound; i < 32; ++i)

  2005.             {

  2006.                 const uint8 n = si.allocation[i][0];

  2007. 

  2008.                 if (n > 0)

  2009.                 {

  2010.                     const uint32 w = ((-1 << n) + getLeq16Bits (n + 1) + 1);

  2011.                     fraction[0][i] = (float) (w * constants.muls[n + 1][si.scaleFactor[i][0]]);

  2012.                     fraction[1][i] = (float) (w * constants.muls[n + 1][si.scaleFactor[i][1]]);

  2013.                 }

  2014.                 else

  2015.                     fraction[0][i] = fraction[1][i] = 0;

  2016.             }

  2017.         }

  2018.         else

  2019.         {

  2020.             for (int i = 0; i < 32; ++i)

  2021.             {

  2022.                 const uint8 n = si.allocation[i][0];

  2023.                 const uint8 j = si.scaleFactor[i][0];

  2024. 

  2025.                 if (n > 0)

  2026.                     fraction[0][i] = (float) (((-1 << n) + getLeq16Bits (n + 1) + 1) * constants.muls[n + 1][j]);

  2027.                 else

  2028.                     fraction[0][i] = 0;

  2029.             }

  2030.         }

  2031.     }

  2032. 

  2033.     void layer2Step1 (SideInfoLayer2& si) noexcept

  2034.     {

  2035.         zerostruct (si);

  2036.         const int sblimit = frame.layer2SubBandLimit;

  2037.         const int jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : frame.layer2SubBandLimit;

  2038.         const AllocationTable* allocTable = frame.allocationTable;

  2039.         uint8 scfsi[32][2];

  2040.         int i;

  2041. 

  2042.         if (frame.numChannels == 2)

  2043.         {

  2044.             for (i = 0; i < jsbound; ++i)

  2045.             {

  2046.                 const int16 step = allocTable->bits;

  2047.                 allocTable += (1 << step);

  2048.                 si.allocation[i][0] = getLeq8Bits (step);

  2049.                 si.allocation[i][1] = getLeq8Bits (step);

  2050.             }

  2051. 

  2052.             for (i = jsbound; i < sblimit; ++i)

  2053.             {

  2054.                 const int16 step = allocTable->bits;

  2055.                 const uint8 b0 = getLeq8Bits (step);

  2056.                 allocTable += (1 << step);

  2057.                 si.allocation[i][0] = b0;

  2058.                 si.allocation[i][1] = b0;

  2059.             }

  2060. 

  2061.             for (i = 0; i < sblimit; ++i)

  2062.             {

  2063.                 scfsi[i][0] = si.allocation[i][0] ? getLeq8Bits (2) : 0;

  2064.                 scfsi[i][1] = si.allocation[i][1] ? getLeq8Bits (2) : 0;

  2065.             }

  2066.         }

  2067.         else

  2068.         {

  2069.             for (i = 0; i < sblimit; ++i)

  2070.             {

  2071.                 const int16 step = allocTable->bits;

  2072.                 allocTable += (1 << step);

  2073.                 si.allocation[i][0] = getLeq8Bits (step);

  2074.             }

  2075. 

  2076.             for (i = 0; i < sblimit; ++i)

  2077.                 scfsi[i][0] = si.allocation[i][0] ? getLeq8Bits (2) : 0;

  2078.         }

  2079. 

  2080.         for (i = 0; i < sblimit; ++i)

  2081.         {

  2082.             for (int ch = 0; ch < frame.numChannels; ++ch)

  2083.             {

  2084.                 uint8 s0 = 0, s1 = 0, s2 = 0;

  2085. 

  2086.                 if (si.allocation[i][ch])

  2087.                 {

  2088.                     switch (scfsi[i][ch])

  2089.                     {

  2090.                         case 0:

  2091.                             s0 = getLeq8Bits (6);

  2092.                             s1 = getLeq8Bits (6);

  2093.                             s2 = getLeq8Bits (6);

  2094.                             break;

  2095.                         case 1:

  2096.                             s1 = s0 = getLeq8Bits (6);

  2097.                             s2 = getLeq8Bits (6);

  2098.                             break;

  2099.                         case 2:

  2100.                             s2 = s1 = s0 = getLeq8Bits (6);

  2101.                             break;

  2102.                         case 3:

  2103.                             s0 = getLeq8Bits (6);

  2104.                             s2 = s1 = getLeq8Bits (6);

  2105.                             break;

  2106.                         default:

  2107.                             break;

  2108.                     }

  2109.                 }

  2110. 

  2111.                 si.scaleFactor[i][ch][0] = s0;

  2112.                 si.scaleFactor[i][ch][1] = s1;

  2113.                 si.scaleFactor[i][ch][2] = s2;

  2114.             }

  2115.         }

  2116.     }

  2117. 

  2118.     void layer2Step2 (SideInfoLayer2& si, const int gr, float fraction[2][4][32]) noexcept

  2119.     {

  2120.         const AllocationTable* allocTable = frame.allocationTable;

  2121.         const int jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : frame.layer2SubBandLimit;

  2122.         int i;

  2123. 

  2124.         for (i = 0; i < jsbound; ++i)

  2125.         {

  2126.             const int16 step = allocTable->bits;

  2127. 

  2128.             for (int ch = 0; ch < frame.numChannels; ++ch)

  2129.             {

  2130.                 const uint8 ba = si.allocation[i][ch];

  2131.                 if (ba != 0)

  2132.                 {

  2133.                     const uint8 x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);

  2134.                     const AllocationTable* const alloc2 = allocTable + ba;

  2135.                     const int16 k = jmin ((int16) 16, alloc2->bits);

  2136.                     const int16 d1 = alloc2->d;

  2137. 

  2138.                     if (d1 < 0)

  2139.                     {

  2140.                         const double cm = constants.muls[k][x1];

  2141.                         fraction[ch][0][i] = (float) ((getBits (k) + d1) * cm);

  2142.                         fraction[ch][1][i] = (float) ((getBits (k) + d1) * cm);

  2143.                         fraction[ch][2][i] = (float) ((getBits (k) + d1) * cm);

  2144.                     }

  2145.                     else

  2146.                     {

  2147.                         const uint8* const tab = constants.getGroupTable (d1, getBits (k));

  2148.                         fraction[ch][0][i] = (float) constants.muls[tab[0]][x1];

  2149.                         fraction[ch][1][i] = (float) constants.muls[tab[1]][x1];

  2150.                         fraction[ch][2][i] = (float) constants.muls[tab[2]][x1];

  2151.                     }

  2152.                 }

  2153.                 else

  2154.                 {

  2155.                     fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;

  2156.                 }

  2157.             }

  2158. 

  2159.             allocTable += (1 << step);

  2160.         }

  2161. 

  2162.         for (i = jsbound; i < frame.layer2SubBandLimit; ++i)

  2163.         {

  2164.             const int16 step = allocTable->bits;

  2165.             const uint8 ba = si.allocation[i][0];

  2166. 

  2167.             if (ba != 0)

  2168.             {

  2169.                 const AllocationTable* const alloc2 = allocTable + ba;

  2170.                 int16 k = alloc2->bits;

  2171.                 int16 d1 = alloc2->d;

  2172.                 k = (k <= 16) ? k : 16;

  2173. 

  2174.                 if (d1 < 0)

  2175.                 {

  2176.                     const int v0 = getBits (k);

  2177.                     const int v1 = getBits (k);

  2178.                     const int v2 = getBits (k);

  2179. 

  2180.                     for (int ch = 0; ch < frame.numChannels; ++ch)

  2181.                     {

  2182.                         const uint8 x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);

  2183.                         const double cm = constants.muls[k][x1];

  2184.                         fraction[ch][0][i] = (float) ((v0 + d1) * cm);

  2185.                         fraction[ch][1][i] = (float) ((v1 + d1) * cm);

  2186.                         fraction[ch][2][i] = (float) ((v2 + d1) * cm);

  2187.                     }

  2188.                 }

  2189.                 else

  2190.                 {

  2191.                     const uint8* const tab = constants.getGroupTable (d1, getBits (k));

  2192.                     const uint8 k0 = tab[0];

  2193.                     const uint8 k1 = tab[1];

  2194.                     const uint8 k2 = tab[2];

  2195. 

  2196.                     for (int ch = 0; ch < frame.numChannels; ++ch)

  2197.                     {

  2198.                         const uint8 x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);

  2199.                         fraction[ch][0][i] = (float) constants.muls[k0][x1];

  2200.                         fraction[ch][1][i] = (float) constants.muls[k1][x1];

  2201.                         fraction[ch][2][i] = (float) constants.muls[k2][x1];

  2202.                     }

  2203.                 }

  2204.             }

  2205.             else

  2206.             {

  2207.                 fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] = 0;

  2208.                 fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0;

  2209.             }

  2210.             allocTable += (1 << step);

  2211.         }

  2212. 

  2213.         for (int ch = 0; ch < frame.numChannels; ++ch)

  2214.             for (i = frame.layer2SubBandLimit; i < 32; ++i)

  2215.                 fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;

  2216.     }

  2217. 

  2218.     void getLayer3SideInfo1 (const int stereo, const bool msStereo, const int sampleRate, const int single) noexcept

  2219.     {

  2220.         const int powdiff = (single == 3) ? 4 : 0;

  2221.         sideinfo.mainDataStart = getBits (9);

  2222.         sideinfo.privateBits = getBitsFast (stereo == 1 ? 5 : 3);

  2223. 

  2224.         for (int ch = 0; ch < stereo; ++ch)

  2225.         {

  2226.             sideinfo.ch[ch].gr[0].scfsi = -1;

  2227.             sideinfo.ch[ch].gr[1].scfsi = getBitsFast (4);

  2228.         }

  2229. 

  2230.         for (int gr = 0; gr < 2; ++gr)

  2231.         {

  2232.             for (int ch = 0; ch < stereo; ++ch)

  2233.             {

  2234.                 Layer3SideInfo::Info& granule = sideinfo.ch[ch].gr[gr];

  2235. 

  2236.                 granule.part2_3Length = getBits (12);

  2237.                 granule.bigValues = jmin (288, (int) getBitsFast (9));

  2238. 

  2239.                 const int qss = getBitsFast (8);

  2240.                 granule.pow2gain = constants.gainpow2 + 256 - qss + powdiff;

  2241. 

  2242.                 if (msStereo)

  2243.                     granule.pow2gain += 2;

  2244. 

  2245.                 granule.scaleFactorCompression = getBitsFast (4);

  2246. 

  2247.                 if (getOneBit())

  2248.                 {

  2249.                     granule.blockType = getBitsFast (2);

  2250.                     granule.mixedBlockFlag = getOneBit();

  2251.                     granule.tableSelect[0] = getBitsFast (5);

  2252.                     granule.tableSelect[1] = getBitsFast (5);

  2253.                     granule.tableSelect[2] = 0;

  2254. 

  2255.                     for (int i = 0; i < 3; ++i)

  2256.                     {

  2257.                         const int sbg = (getBitsFast (3) << 3);

  2258.                         granule.fullGain[i] = granule.pow2gain + sbg;

  2259.                     }

  2260. 

  2261.                     if (granule.blockType == 0)

  2262.                     {

  2263.                     }

  2264. 

  2265.                     granule.region1Start = 36 >> 1;

  2266.                     granule.region2Start = 576 >> 1;

  2267.                 }

  2268.                 else

  2269.                 {

  2270.                     for (int i = 0; i < 3; ++i)

  2271.                         granule.tableSelect[i] = getBitsFast (5);

  2272. 

  2273.                     const int r0c = getBitsFast (4);

  2274.                     const int r1c = getBitsFast (3);

  2275.                     const int region0index = jmin (22, r0c + 1);

  2276.                     const int region1index = jmin (22, r0c + 1 + r1c + 1);

  2277. 

  2278.                     granule.region1Start = bandInfo[sampleRate].longIndex[region0index] >> 1;

  2279.                     granule.region2Start = bandInfo[sampleRate].longIndex[region1index] >> 1;

  2280.                     granule.blockType = 0;

  2281.                     granule.mixedBlockFlag = 0;

  2282.                 }

  2283. 

  2284.                 granule.preflag = getOneBit();

  2285.                 granule.scaleFactorScale = getOneBit();

  2286.                 granule.count1TableSelect = getOneBit();

  2287.             }

  2288.         }

  2289.     }

  2290. 

  2291.     void getLayer3SideInfo2 (const int stereo, const bool msStereo, const int sampleRate, const int single) noexcept

  2292.     {

  2293.         const int powdiff = (single == 3) ? 4 : 0;

  2294.         sideinfo.mainDataStart = getBits (8);

  2295.         sideinfo.privateBits = stereo == 1 ? getOneBit() : getBitsFast (2);

  2296. 

  2297.         for (int ch = 0; ch < stereo; ++ch)

  2298.         {

  2299.             Layer3SideInfo::Info& granule = sideinfo.ch[ch].gr[0];

  2300. 

  2301.             granule.part2_3Length = getBits (12);

  2302.             granule.bigValues = jmin (288, (int) getBitsFast (9));

  2303. 

  2304.             const uint32 qss = getBitsFast (8);

  2305.             granule.pow2gain = constants.gainpow2 + 256 - qss + powdiff;

  2306. 

  2307.             if (msStereo)

  2308.                 granule.pow2gain += 2;

  2309. 

  2310.             granule.scaleFactorCompression = getBits (9);

  2311. 

  2312.             if (getOneBit())

  2313.             {

  2314.                 granule.blockType = getBitsFast (2);

  2315.                 granule.mixedBlockFlag = getOneBit();

  2316.                 granule.tableSelect[0] = getBitsFast (5);

  2317.                 granule.tableSelect[1] = getBitsFast (5);

  2318.                 granule.tableSelect[2] = 0;

  2319. 

  2320.                 for (int i = 0; i < 3; ++i)

  2321.                 {

  2322.                     const uint32 sbg = (getBitsFast (3) << 3);

  2323.                     granule.fullGain[i] = granule.pow2gain + sbg;

  2324.                 }

  2325. 

  2326.                 if (granule.blockType == 0)

  2327.                 {}

  2328. 

  2329.                 if (granule.blockType == 2)

  2330.                     granule.region1Start = sampleRate == 8 ? 36 : (36 >> 1);

  2331.                 else

  2332.                     granule.region1Start = sampleRate == 8 ? (108 >> 1) : (54 >> 1);

  2333. 

  2334.                 granule.region2Start = 576 >> 1;

  2335.             }

  2336.             else

  2337.             {

  2338.                 for (int i = 0; i < 3; ++i)

  2339.                     granule.tableSelect[i] = getBitsFast (5);

  2340. 

  2341.                 const int r0c = getBitsFast (4);

  2342.                 const int r1c = getBitsFast (3);

  2343.                 const int region0index = jmin (22, r0c + 1);

  2344.                 const int region1index = jmin (22, r0c + 1 + r1c + 1);

  2345. 

  2346.                 granule.region1Start = bandInfo[sampleRate].longIndex[region0index] >> 1;

  2347.                 granule.region2Start = bandInfo[sampleRate].longIndex[region1index] >> 1;

  2348.                 granule.blockType = 0;

  2349.                 granule.mixedBlockFlag = 0;

  2350.             }

  2351.             granule.scaleFactorScale = getOneBit();

  2352.             granule.count1TableSelect = getOneBit();

  2353.         }

  2354.     }

  2355. 

  2356.     int getLayer3ScaleFactors1 (int* scf, const Layer3SideInfo::Info& granule) noexcept

  2357.     {

  2358.         static const uint8 lengths[2][16] =

  2359.         {

  2360.             { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },

  2361.             { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 }

  2362.         };

  2363. 

  2364.         int numBits;

  2365.         const int num0 = lengths[0][granule.scaleFactorCompression];

  2366.         const int num1 = lengths[1][granule.scaleFactorCompression];

  2367. 

  2368.         if (granule.blockType == 2)

  2369.         {

  2370.             int i = 18;

  2371.             numBits = (num0 + num1) * 18;

  2372. 

  2373.             if (granule.mixedBlockFlag)

  2374.             {

  2375.                 for (int j = 8; --j >= 0;)  *scf++ = getBitsFast (num0);

  2376.                 numBits -= num0;

  2377.                 i = 9;

  2378.             }

  2379. 

  2380.             for (; --i >= 0;)       *scf++ = getBitsFast (num0);

  2381.             for (i = 18; --i >= 0;) *scf++ = getBitsFast (num1);

  2382. 

  2383.             *scf++ = 0;

  2384.             *scf++ = 0;

  2385.             *scf++ = 0;

  2386.         }

  2387.         else

  2388.         {

  2389.             const int scfsi = granule.scfsi;

  2390. 

  2391.             if (scfsi < 0)

  2392.             {

  2393.                 for (int i = 11; --i >= 0;)   *scf++ = getBitsFast (num0);

  2394.                 for (int j = 10; --j >= 0;)   *scf++ = getBitsFast (num1);

  2395.                 numBits = (num0 + num1) * 10 + num0;

  2396.             }

  2397.             else

  2398.             {

  2399.                 numBits = 0;

  2400.                 if ((scfsi & 8) == 0)

  2401.                 {

  2402.                     for (int i = 6; --i >= 0;)  *scf++ = getBitsFast (num0);

  2403.                     numBits += num0 * 6;

  2404.                 }

  2405.                 else

  2406.                     scf += 6;

  2407. 

  2408.                 if ((scfsi & 4) == 0)

  2409.                 {

  2410.                     for (int i = 5; --i >= 0;)  *scf++ = getBitsFast (num0);

  2411.                     numBits += num0 * 5;

  2412.                 }

  2413.                 else

  2414.                     scf += 5;

  2415. 

  2416.                 if ((scfsi & 2) == 0)

  2417.                 {

  2418.                     for (int i = 5; --i >= 0;)  *scf++ = getBitsFast (num1);

  2419.                     numBits += num1 * 5;

  2420.                 }

  2421.                 else

  2422.                     scf += 5;

  2423. 

  2424.                 if ((scfsi & 1) == 0)

  2425.                 {

  2426.                     for (int i = 5; --i >= 0;)  *scf++ = getBitsFast (num1);

  2427.                     numBits += num1 * 5;

  2428.                 }

  2429.                 else

  2430.                     scf += 5;

  2431.             }

  2432. 

  2433.             *scf = 0;

  2434.         }

  2435. 

  2436.         return numBits;

  2437.     }

  2438. 

  2439.     int getLayer3ScaleFactors2 (int* scf, Layer3SideInfo::Info& granule, const bool iStereo) noexcept

  2440.     {

  2441.         static const uint8 scaleTable[3][6][4] =

  2442.         {

  2443.             { { 6, 5, 5, 5 }, { 6, 5, 7, 3 },  { 11, 10, 0, 0 }, { 7, 7, 7, 0 },    { 6, 6, 6, 3 },  { 8, 8, 5, 0 } },

  2444.             { { 9, 9, 9, 9 }, { 9, 9, 12, 6 }, { 18, 18, 0, 0 }, { 12, 12, 12, 0 }, { 12, 9, 9, 6 }, { 15, 12, 9, 0 } },

  2445.             { { 6, 9, 9, 9 }, { 6, 9, 12, 6 }, { 15, 18, 0, 0 }, { 6, 15, 12, 0 },  { 6, 12, 9, 6 }, { 6, 18, 9, 0 } }

  2446.         };

  2447. 

  2448.         uint32 len = iStereo ? constants.iLength2 [granule.scaleFactorCompression >> 1]

  2449.                              : constants.nLength2 [granule.scaleFactorCompression];

  2450. 

  2451.         granule.preflag = (len >> 15) & 1;

  2452. 

  2453.         int n = 0;

  2454.         if (granule.blockType == 2)

  2455.         {

  2456.             ++n;

  2457.             if (granule.mixedBlockFlag)

  2458.                 ++n;

  2459.         }

  2460. 

  2461.         const uint8* const data = scaleTable[n][(len >> 12) & 7];

  2462.         int i, numBits = 0;

  2463. 

  2464.         for (i = 0; i < 4; ++i)

  2465.         {

  2466.             int num = len & 7;

  2467.             len >>= 3;

  2468. 

  2469.             if (num)

  2470.             {

  2471.                 for (int j = 0; j < (int) (data[i]); ++j)

  2472.                     *scf++ = getBitsFast (num);

  2473. 

  2474.                 numBits += data[i] * num;

  2475.             }

  2476.             else

  2477.             {

  2478.                 for (int j = 0; j < (int) (data[i]); ++j)

  2479.                     *scf++ = 0;

  2480.             }

  2481.         }

  2482. 

  2483.         n = (n << 1) + 1;

  2484.         for (i = 0; i < n; ++i)

  2485.             *scf++ = 0;

  2486. 

  2487.         return numBits;

  2488.     }

  2489. 

  2490.     bool layer3DequantizeSample (float xr[32][18], int* scf, Layer3SideInfo::Info& granule, int sampleRate, int part2bits) noexcept

  2491.     {

  2492.         const int shift = 1 + granule.scaleFactorScale;

  2493.         float* xrpnt = (float*) xr;

  2494.         int i, part2remain = granule.part2_3Length - part2bits;

  2495. 

  2496.         zeromem (xrpnt, sizeof (float) * (&xr[32][0] - xrpnt));

  2497. 

  2498.         const int bv = granule.bigValues;

  2499.         const int region1 = granule.region1Start;

  2500.         const int region2 = granule.region2Start;

  2501.         int l3 = ((576 >> 1) - bv) >> 1;

  2502.         int l[3];

  2503. 

  2504.         if (bv <= region1)

  2505.         {

  2506.             l[0] = bv;

  2507.             l[1] = 0;

  2508.             l[2] = 0;

  2509.         }

  2510.         else

  2511.         {

  2512.             l[0] = region1;

  2513.             if (bv <= region2)

  2514.             {

  2515.                 l[1] = bv - l[0];

  2516.                 l[2] = 0;

  2517.             }

  2518.             else

  2519.             {

  2520.                 l[1] = region2 - l[0];

  2521.                 l[2] = bv - region2;

  2522.             }

  2523.         }

  2524. 

  2525.         for (i = 0; i < 3; ++i)

  2526.             if (l[i] < 0)

  2527.                 l[i] = 0;

  2528. 

  2529.         if (granule.blockType == 2)

  2530.         {

  2531.             int max[4];

  2532.             int step = 0, lwin = 0, cb = 0, mc = 0;

  2533.             float v = 0;

  2534.             int* map;

  2535.             int* mapEnd;

  2536. 

  2537.             if (granule.mixedBlockFlag)

  2538.             {

  2539.                 max[3] = -1;

  2540.                 max[0] = max[1] = max[2] = 2;

  2541.                 map = constants.map [sampleRate][0];

  2542.                 mapEnd = constants.mapEnd [sampleRate][0];

  2543.             }

  2544.             else

  2545.             {

  2546.                 max[0] = max[1] = max[2] = max[3] = -1;

  2547.                 map = constants.map [sampleRate][1];

  2548.                 mapEnd = constants.mapEnd [sampleRate][1];

  2549.             }

  2550. 

  2551.             for (i = 0; i < 2; ++i)

  2552.             {

  2553.                 const newhuff* h = huffmanTables1 + granule.tableSelect[i];

  2554. 

  2555.                 for (int lp = l[i]; lp != 0; --lp, --mc)

  2556.                 {

  2557.                     int x, y;

  2558.                     if (mc == 0)

  2559.                     {

  2560.                         mc = *map++;

  2561.                         xrpnt = ((float*) xr) + (*map++);

  2562.                         lwin = *map++;

  2563.                         cb = *map++;

  2564. 

  2565.                         if (lwin == 3)

  2566.                         {

  2567.                             v = granule.pow2gain[ (*scf++) << shift];

  2568.                             step = 1;

  2569.                         }

  2570.                         else

  2571.                         {

  2572.                             v = granule.fullGain[lwin][ (*scf++) << shift];

  2573.                             step = 3;

  2574.                         }

  2575.                     }

  2576. 

  2577.                     const int16* val = h->table;

  2578. 

  2579.                     while ((y = *val++) < 0)

  2580.                     {

  2581.                         if (getOneBit())

  2582.                             val -= y;

  2583. 

  2584.                         --part2remain;

  2585.                     }

  2586. 

  2587.                     x = y >> 4;

  2588.                     y &= 15;

  2589. 

  2590.                     if (x == 15)

  2591.                     {

  2592.                         max[lwin] = cb;

  2593.                         part2remain -= h->linbits + 1;

  2594.                         x += getBits ((int) h->linbits);

  2595.                         *xrpnt = constants.ispow[x] * (getOneBit() ? -v : v);

  2596.                     }

  2597.                     else if (x)

  2598.                     {

  2599.                         max[lwin] = cb;

  2600.                         *xrpnt = constants.ispow[x] * (getOneBit() ? -v : v);

  2601.                         --part2remain;

  2602.                     }

  2603.                     else

  2604.                         *xrpnt = 0;

  2605. 

  2606.                     xrpnt += step;

  2607. 

  2608.                     if (y == 15)

  2609.                     {

  2610.                         max[lwin] = cb;

  2611.                         part2remain -= h->linbits + 1;

  2612.                         y += getBits ((int) h->linbits);

  2613.                         *xrpnt = constants.ispow[y] * (getOneBit() ? -v : v);

  2614.                     }

  2615.                     else if (y)

  2616.                     {

  2617.                         max[lwin] = cb;

  2618.                         *xrpnt = constants.ispow[y] * (getOneBit() ? -v : v);

  2619.                         --part2remain;

  2620.                     }

  2621.                     else

  2622.                         *xrpnt = 0;

  2623. 

  2624.                     xrpnt += step;

  2625.                 }

  2626.             }

  2627. 

  2628.             for (; l3 && (part2remain > 0); --l3)

  2629.             {

  2630.                 const newhuff* h = huffmanTables2 + granule.count1TableSelect;

  2631.                 const int16* val = h->table;

  2632.                 int16 a;

  2633. 

  2634.                 while ((a = *val++) < 0)

  2635.                 {

  2636.                     if (part2remain <= 0)

  2637.                     {

  2638.                         a = 0;

  2639.                         break;

  2640.                     }

  2641. 

  2642.                     --part2remain;

  2643.                     if (getOneBit())

  2644.                         val -= a;

  2645.                 }

  2646. 

  2647.                 for (i = 0; i < 4; ++i)

  2648.                 {

  2649.                     if ((i & 1) == 0)

  2650.                     {

  2651.                         if (mc == 0)

  2652.                         {

  2653.                             mc = *map++;

  2654.                             xrpnt = ((float*) xr) + (*map++);

  2655.                             lwin = *map++;

  2656.                             cb = *map++;

  2657. 

  2658.                             if (lwin == 3)

  2659.                             {

  2660.                                 v = granule.pow2gain[ (*scf++) << shift];

  2661.                                 step = 1;

  2662.                             }

  2663.                             else

  2664.                             {

  2665.                                 v = granule.fullGain[lwin][ (*scf++) << shift];

  2666.                                 step = 3;

  2667.                             }

  2668.                         }

  2669. 

  2670.                         --mc;

  2671.                     }

  2672. 

  2673.                     if ((a & (8 >> i)))

  2674.                     {

  2675.                         max[lwin] = cb;

  2676.                         if (part2remain == 0)

  2677.                             break;

  2678. 

  2679.                         --part2remain;

  2680.                         *xrpnt = getOneBit() ? -v : v;

  2681.                     }

  2682.                     else

  2683.                         *xrpnt = 0;

  2684. 

  2685.                     xrpnt += step;

  2686.                 }

  2687.             }

  2688. 

  2689.             while (map < mapEnd)

  2690.             {

  2691.                 if (mc == 0)

  2692.                 {

  2693.                     mc = *map++;

  2694.                     xrpnt = ((float*) xr) + *map++;

  2695.                     step = (*map++ == 3) ? 1 : 3;

  2696.                     ++map;

  2697.                 }

  2698. 

  2699.                 --mc;

  2700.                 *xrpnt = 0;  xrpnt += step;

  2701.                 *xrpnt = 0;  xrpnt += step;

  2702.             }

  2703. 

  2704.             granule.maxBand[0] = max[0] + 1;

  2705.             granule.maxBand[1] = max[1] + 1;

  2706.             granule.maxBand[2] = max[2] + 1;

  2707.             granule.maxBandl   = max[3] + 1;

  2708. 

  2709.             const int rmax = jmax (max[0], max[1], max[3]) + 1;

  2710.             granule.maxb = rmax ? constants.shortLimit[sampleRate][rmax]

  2711.                                 : constants.longLimit[sampleRate][max[3] + 1];

  2712.         }

  2713.         else

  2714.         {

  2715.             static const int pretab1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 };

  2716.             static const int pretab2[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

  2717. 

  2718.             const int* pretab = (const int*) (granule.preflag ? pretab1 : pretab2);

  2719.             int i, max = -1, cb = 0, mc = 0;

  2720.             int* map = constants.map [sampleRate][2];

  2721.             float v = 0;

  2722. 

  2723.             for (i = 0; i < 3; ++i)

  2724.             {

  2725.                 const newhuff* h = huffmanTables1 + granule.tableSelect[i];

  2726. 

  2727.                 for (int lp = l[i]; lp != 0; --lp, --mc)

  2728.                 {

  2729.                     if (mc == 0)

  2730.                     {

  2731.                         mc = *map++;

  2732.                         v = granule.pow2gain [((*scf++) + (*pretab++)) << shift];

  2733.                         cb = *map++;

  2734.                     }

  2735. 

  2736.                     const int16* val = h->table;

  2737.                     int y;

  2738. 

  2739.                     while ((y = *val++) < 0)

  2740.                     {

  2741.                         if (getOneBit()) val -= y;

  2742.                         --part2remain;

  2743.                     }

  2744. 

  2745.                     int x = y >> 4;

  2746.                     y &= 15;

  2747. 

  2748.                     if (x == 15)

  2749.                     {

  2750.                         max = cb;

  2751.                         part2remain -= h->linbits + 1;

  2752.                         x += getBits ((int) h->linbits);

  2753.                         *xrpnt++ = constants.ispow[x] * (getOneBit() ? -v : v);

  2754.                     }

  2755.                     else if (x)

  2756.                     {

  2757.                         max = cb;

  2758.                         *xrpnt++ = constants.ispow[x] * (getOneBit() ? -v : v);

  2759.                         --part2remain;

  2760.                     }

  2761.                     else

  2762.                         *xrpnt++ = 0;

  2763. 

  2764.                     if (y == 15)

  2765.                     {

  2766.                         max = cb;

  2767.                         part2remain -= h->linbits + 1;

  2768.                         y += getBits ((int) h->linbits);

  2769.                         *xrpnt++ = constants.ispow[y] * (getOneBit() ? -v : v);

  2770.                     }

  2771.                     else if (y)

  2772.                     {

  2773.                         max = cb;

  2774.                         *xrpnt++ = constants.ispow[y] * (getOneBit() ? -v : v);

  2775.                         --part2remain;

  2776.                     }

  2777.                     else

  2778.                         *xrpnt++ = 0;

  2779.                 }

  2780.             }

  2781. 

  2782.             for (; l3 && part2remain > 0; --l3)

  2783.             {

  2784.                 const newhuff* h = huffmanTables2 + granule.count1TableSelect;

  2785.                 const int16* values = h->table;

  2786.                 int16 a;

  2787. 

  2788.                 while ((a = *values++) < 0)

  2789.                 {

  2790.                     if (part2remain <= 0)

  2791.                     {

  2792.                         a = 0;

  2793.                         break;

  2794.                     }

  2795. 

  2796.                     --part2remain;

  2797.                     if (getOneBit())

  2798.                         values -= a;

  2799.                 }

  2800. 

  2801.                 for (i = 0; i < 4; ++i)

  2802.                 {

  2803.                     if ((i & 1) == 0)

  2804.                     {

  2805.                         if (mc == 0)

  2806.                         {

  2807.                             mc = *map++;

  2808.                             cb = *map++;

  2809.                             v = granule.pow2gain [((*scf++) + (*pretab++)) << shift];

  2810.                         }

  2811.                         --mc;

  2812.                     }

  2813. 

  2814.                     if ((a & (0x8 >> i)))

  2815.                     {

  2816.                         max = cb;

  2817. 

  2818.                         if (part2remain <= 0)

  2819.                             break;

  2820. 

  2821.                         --part2remain;

  2822.                         *xrpnt++ = getOneBit() ? -v : v;

  2823.                     }

  2824.                     else

  2825.                         *xrpnt++ = 0;

  2826.                 }

  2827.             }

  2828. 

  2829.             zeromem (xrpnt, sizeof (float) * (&xr[32][0] - xrpnt));

  2830. 

  2831.             granule.maxBandl = max + 1;

  2832.             granule.maxb = constants.longLimit[sampleRate][granule.maxBandl];

  2833.         }

  2834. 

  2835.         while (part2remain > 16)

  2836.         {

  2837.             getBits (16);

  2838.             part2remain -= 16;

  2839.         }

  2840. 

  2841.         if (part2remain > 0)

  2842.             getBits (part2remain);

  2843.         else if (part2remain < 0)

  2844.             return true;

  2845. 

  2846.         return false;

  2847.     }

  2848. 

  2849.     void layer3Hybrid (float fsIn[32][18], float tsOut[18][32], int ch, const Layer3SideInfo::Info& granule) noexcept

  2850.     {

  2851.         float* ts = (float*) tsOut;

  2852.         float* rawout1, *rawout2;

  2853.         int sb = 0;

  2854. 

  2855.         {

  2856.             int b = hybridBlockIndex[ch];

  2857.             rawout1 = hybridBlock[b][ch];

  2858.             b = 1 - b;

  2859.             rawout2 = hybridBlock[b][ch];

  2860.             hybridBlockIndex[ch] = b;

  2861.         }

  2862. 

  2863.         if (granule.mixedBlockFlag)

  2864.         {

  2865.             sb = 2;

  2866.             DCT::dct36 (fsIn[0], rawout1, rawout2, constants.win[0], ts);

  2867.             DCT::dct36 (fsIn[1], rawout1 + 18, rawout2 + 18, constants.win1[0], ts + 1);

  2868.             rawout1 += 36;

  2869.             rawout2 += 36;

  2870.             ts += 2;

  2871.         }

  2872. 

  2873.         int bt = granule.blockType;

  2874.         if (bt == 2)

  2875.         {

  2876.             for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)

  2877.             {

  2878.                 DCT::dct12 (fsIn[sb], rawout1, rawout2, constants.win[2], ts);

  2879.                 DCT::dct12 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[2], ts + 1);

  2880.             }

  2881.         }

  2882.         else

  2883.         {

  2884.             for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)

  2885.             {

  2886.                 DCT::dct36 (fsIn[sb], rawout1, rawout2, constants.win[bt], ts);

  2887.                 DCT::dct36 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[bt], ts + 1);

  2888.             }

  2889.         }

  2890. 

  2891.         for (; sb < 32; ++sb, ++ts)

  2892.         {

  2893.             for (int i = 0; i < 18; ++i)

  2894.             {

  2895.                 ts[i * 32] = *rawout1++;

  2896.                 *rawout2++ = 0;

  2897.             }

  2898.         }

  2899.     }

  2900. 

  2901.     void synthesiseStereo (const float* bandPtr0, const float* bandPtr1, float* out0, float* out1, int& samplesDone) noexcept

  2902.     {

  2903.         int dummy = samplesDone;

  2904.         synthesise (bandPtr0, 0, out0, dummy);

  2905.         synthesise (bandPtr1, 1, out1, samplesDone);

  2906.     }

  2907. 

  2908.     void synthesise (const float* bandPtr, const int channel, float* out, int& samplesDone)

  2909.     {

  2910.         out += samplesDone;

  2911.         const int bo = channel == 0 ? ((synthBo - 1) & 15) : synthBo;

  2912.         float (*buf)[0x110] = synthBuffers[channel];

  2913.         float* b0;

  2914.         int j, bo1 = bo;

  2915. 

  2916.         if (bo & 1)

  2917.         {

  2918.             b0 = buf[0];

  2919.             DCT::dct64 (buf[1] + ((bo + 1) & 15), buf[0] + bo, bandPtr);

  2920.         }

  2921.         else

  2922.         {

  2923.             ++bo1;

  2924.             b0 = buf[1];

  2925.             DCT::dct64 (buf[0] + bo, buf[1] + bo1, bandPtr);

  2926.         }

  2927. 

  2928.         synthBo = bo;

  2929.         const float* window = constants.decodeWin + 16 - bo1;

  2930. 

  2931.         for (j = 16; j != 0; --j, b0 += 16, window += 32)

  2932.         {

  2933.             float sum = window[0] * b0[0];  sum -= window[1] * b0[1];

  2934.             sum += window[2]  * b0[2];   sum -= window[3]  * b0[3];

  2935.             sum += window[4]  * b0[4];   sum -= window[5]  * b0[5];

  2936.             sum += window[6]  * b0[6];   sum -= window[7]  * b0[7];

  2937.             sum += window[8]  * b0[8];   sum -= window[9]  * b0[9];

  2938.             sum += window[10] * b0[10];  sum -= window[11] * b0[11];

  2939.             sum += window[12] * b0[12];  sum -= window[13] * b0[13];

  2940.             sum += window[14] * b0[14];  sum -= window[15] * b0[15];

  2941.             *out++ = sum;

  2942.         }

  2943. 

  2944.         {

  2945.             float sum = window[0] * b0[0];   sum += window[2] * b0[2];

  2946.             sum += window[4]  * b0[4];   sum += window[6]  * b0[6];

  2947.             sum += window[8]  * b0[8];   sum += window[10] * b0[10];

  2948.             sum += window[12] * b0[12];  sum += window[14] * b0[14];

  2949.             *out++ = sum;

  2950.             b0 -= 16; window -= 32;

  2951.             window += bo1 << 1;

  2952.         }

  2953. 

  2954.         for (j = 15; j != 0; --j, b0 -= 16, window -= 32)

  2955.         {

  2956.             float sum = -window[-1] * b0[0];  sum -= window[-2] * b0[1];

  2957.             sum -= window[-3]  * b0[2];   sum -= window[-4]  * b0[3];

  2958.             sum -= window[-5]  * b0[4];   sum -= window[-6]  * b0[5];

  2959.             sum -= window[-7]  * b0[6];   sum -= window[-8]  * b0[7];

  2960.             sum -= window[-9]  * b0[8];   sum -= window[-10] * b0[9];

  2961.             sum -= window[-11] * b0[10];  sum -= window[-12] * b0[11];

  2962.             sum -= window[-13] * b0[12];  sum -= window[-14] * b0[13];

  2963.             sum -= window[-15] * b0[14];  sum -= window[0]   * b0[15];

  2964.             *out++ = sum;

  2965.         }

  2966. 

  2967.         samplesDone += 32;

  2968.     }

  2969. 

  2970.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Stream);

  2971. };

  2972. 

  2973. //==============================================================================

  2974. static const char* const mp3FormatName = "MP3 file";

  2975. static const char* const mp3Extensions[] = { ".mp3", nullptr };

  2976. 

  2977. //==============================================================================

  2978. class MP3Reader : public AudioFormatReader

  2979. {

  2980. public:

  2981.     MP3Reader (InputStream* const in)

  2982.         : AudioFormatReader (in, TRANS (mp3FormatName)),

  2983.           stream (*in), currentPosition (0),

  2984.           decodedStart (0), decodedEnd (0)

  2985.     {

  2986.         skipID3();

  2987.         const int64 streamPos = stream.stream.getPosition();

  2988. 

  2989.         if (readNextBlock())

  2990.         {

  2991.             bitsPerSample = 32;

  2992.             usesFloatingPointData = true;

  2993.             sampleRate = stream.frame.getFrequency();

  2994.             numChannels = stream.frame.numChannels;

  2995.             lengthInSamples = findLength (streamPos);

  2996.         }

  2997.     }

  2998. 

  2999.     //==============================================================================

  3000.     bool readSamples (int** destSamples, int numDestChannels, int startOffsetInDestBuffer,

  3001.                       int64 startSampleInFile, int numSamples)

  3002.     {

  3003.         jassert (destSamples != nullptr);

  3004. 

  3005.         if (currentPosition != startSampleInFile)

  3006.         {

  3007.             if (! stream.seek (startSampleInFile / 1152 - 1))

  3008.             {

  3009.                 currentPosition = -1;

  3010.                 createEmptyDecodedData();

  3011.             }

  3012.             else

  3013.             {

  3014.                 decodedStart = decodedEnd = 0;

  3015.                 const int64 streamPos = stream.currentFrameIndex * 1152;

  3016.                 int toSkip = startSampleInFile - streamPos;

  3017.                 jassert (toSkip >= 0);

  3018. 

  3019.                 while (toSkip > 0)

  3020.                 {

  3021.                     if (! readNextBlock())

  3022.                     {

  3023.                         createEmptyDecodedData();

  3024.                         break;

  3025.                     }

  3026. 

  3027.                     const int numReady = decodedEnd - decodedStart;

  3028. 

  3029.                     if (numReady > toSkip)

  3030.                     {

  3031.                         decodedStart += toSkip;

  3032.                         break;

  3033.                     }

  3034. 

  3035.                     toSkip -= numReady;

  3036.                 }

  3037. 

  3038.                 currentPosition = startSampleInFile;

  3039.             }

  3040.         }

  3041. 

  3042.         while (numSamples > 0)

  3043.         {

  3044.             if (decodedEnd <= decodedStart && ! readNextBlock())

  3045.             {

  3046.                 for (int i = 2; --i >= 0;)

  3047.                     if (destSamples[i] != nullptr)

  3048.                         zeromem (destSamples[i] + startOffsetInDestBuffer, sizeof (float) * numSamples);

  3049. 

  3050.                 return false;

  3051.             }

  3052. 

  3053.             const int numToCopy = jmin (decodedEnd - decodedStart, numSamples);

  3054.             float* const* const dst = reinterpret_cast <float**> (destSamples);

  3055.             memcpy (dst[0] + startOffsetInDestBuffer, decoded0 + decodedStart, sizeof (float) * numToCopy);

  3056. 

  3057.             if (dst[1] != nullptr)

  3058.                 memcpy (dst[1] + startOffsetInDestBuffer, (numChannels < 2 ? decoded0 : decoded1) + decodedStart, sizeof (float) * numToCopy);

  3059. 

  3060.             startOffsetInDestBuffer += numToCopy;

  3061.             decodedStart += numToCopy;

  3062.             currentPosition += numToCopy;

  3063.             numSamples -= numToCopy;

  3064.         }

  3065. 

  3066.         return true;

  3067.     }

  3068. 

  3069. private:

  3070.     MP3Stream stream;

  3071.     int64 currentPosition;

  3072.     enum { decodedDataSize = 1152 };

  3073.     float decoded0 [decodedDataSize], decoded1 [decodedDataSize];

  3074.     int decodedStart, decodedEnd;

  3075. 

  3076.     void createEmptyDecodedData() noexcept

  3077.     {

  3078.         zeromem (decoded0, sizeof (decoded0));

  3079.         zeromem (decoded1, sizeof (decoded1));

  3080.         decodedStart = 0;

  3081.         decodedEnd = decodedDataSize;

  3082.     }

  3083. 

  3084.     bool readNextBlock()

  3085.     {

  3086.         for (int attempts = 10; --attempts >= 0;)

  3087.         {

  3088.             int samplesDone = 0;

  3089.             const int result = stream.decodeNextBlock (decoded0, decoded1, samplesDone);

  3090. 

  3091.             if (result > 0 && stream.stream.isExhausted())

  3092.             {

  3093.                 createEmptyDecodedData();

  3094.                 return true;

  3095.             }

  3096.             else if (result <= 0)

  3097.             {

  3098.                 decodedStart = 0;

  3099.                 decodedEnd = samplesDone;

  3100.                 return result == 0;

  3101.             }

  3102.         }

  3103. 

  3104.         return false;

  3105.     }

  3106. 

  3107.     void skipID3()

  3108.     {

  3109.         const int64 originalPosition = stream.stream.getPosition();

  3110.         const uint32 firstWord = stream.stream.readInt();

  3111. 

  3112.         if ((firstWord & 0xffffff) == 0x334449)

  3113.         {

  3114.             uint8 buffer[6];

  3115. 

  3116.             if (stream.stream.read (buffer, 6) == 6

  3117.                  && buffer[0] != 0xff

  3118.                  && ((buffer[2] | buffer[3] | buffer[4] | buffer[5]) & 0x80) == 0)

  3119.             {

  3120.                 const int length = (((uint32) buffer[2]) << 21)

  3121.                                  | (((uint32) buffer[3]) << 14)

  3122.                                  | (((uint32) buffer[4]) << 7)

  3123.                                  |  ((uint32) buffer[5]);

  3124. 

  3125.                 stream.stream.skipNextBytes (length);

  3126.                 return;

  3127.             }

  3128.         }

  3129. 

  3130.         stream.stream.setPosition (originalPosition);

  3131.     }

  3132. 

  3133.     int64 findLength (int64 streamStartPos)

  3134.     {

  3135.         int64 numFrames = stream.numFrames;

  3136. 

  3137.         if (numFrames <= 0)

  3138.         {

  3139.             const int64 streamSize = stream.stream.getTotalLength();

  3140. 

  3141.             if (streamSize > 0)

  3142.                 numFrames = (streamSize - streamStartPos) / (stream.frame.frameSize);

  3143.         }

  3144. 

  3145.         return numFrames * 1152;

  3146.     }

  3147. 

  3148.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Reader);

  3149. };

  3150. 

  3151. }

  3152. 

  3153. //==============================================================================

  3154. MP3AudioFormat::MP3AudioFormat()

  3155.     : AudioFormat (MP3Decoder::mp3FormatName, StringArray (MP3Decoder::mp3Extensions))

  3156. {}

  3157. 

  3158. MP3AudioFormat::~MP3AudioFormat() {}

  3159. 

  3160. Array<int> MP3AudioFormat::getPossibleSampleRates() { return Array<int>(); }

  3161. Array<int> MP3AudioFormat::getPossibleBitDepths()   { return Array<int>(); }

  3162. bool MP3AudioFormat::canDoStereo()                  { return true; }

  3163. bool MP3AudioFormat::canDoMono()                    { return true; }

  3164. bool MP3AudioFormat::isCompressed()                 { return true; }

  3165. StringArray MP3AudioFormat::getQualityOptions()     { return StringArray(); }

  3166. 

  3167. AudioFormatReader* MP3AudioFormat::createReaderFor (InputStream* sourceStream, const bool deleteStreamIfOpeningFails)

  3168. {

  3169.     ScopedPointer<MP3Decoder::MP3Reader> r (new MP3Decoder::MP3Reader (sourceStream));

  3170. 

  3171.     if (r->lengthInSamples > 0)

  3172.         return r.release();

  3173. 

  3174.     if (! deleteStreamIfOpeningFails)

  3175.         r->input = nullptr;

  3176. 

  3177.     return nullptr;

  3178. }

  3179. 

  3180. AudioFormatWriter* MP3AudioFormat::createWriterFor (OutputStream*, double /*sampleRateToUse*/,

  3181.                                                     unsigned int /*numberOfChannels*/, int /*bitsPerSample*/,

  3182.                                                     const StringPairArray& /*metadataValues*/, int /*qualityOptionIndex*/)

  3183. {

  3184.     return nullptr;

  3185. }

  3186. 

  3187. END_JUCE_NAMESPACE

  3188. #endif