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.
12908 Commits
9 Branches
2.5GB
Tree: c91514f57f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c91514f57f'
${ noResults }
JUCE/modules/juce_audio_formats/codecs/juce_MP3AudioFormat.cpp

3171 lines
130KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE 7 technical preview.

  5.    Copyright (c) 2022 - Raw Material Software Limited

  6. 

  7.    You may use this code under the terms of the GPL v3

  8.    (see www.gnu.org/licenses).

  9. 

  10.    For the technical preview this file cannot be licensed commercially.

  11. 

  12.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  13.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  14.    DISCLAIMED.

  15. 

  16.   ==============================================================================

  17. */

  18. 

  19. namespace juce

  20. {

  21. 

  22. /*

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

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

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

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

  27. 

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

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

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

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

  32. */

  33. #if JUCE_USE_MP3AUDIOFORMAT

  34. 

  35. namespace MP3Decoder

  36. {

  37. 

  38. struct AllocationTable

  39. {

  40.     int16 bits, d;

  41. };

  42. 

  43. constexpr AllocationTable allocTable0[] =

  44. {

  45.     {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},

  46.     {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},

  47.     {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},

  48.     {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},

  49.     {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},

  50.     {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},

  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.     {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},

  57.     {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},

  58.     {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},

  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.     {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}

  63. };

  64. 

  65. constexpr AllocationTable allocTable1[] =

  66. {

  67.     {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},

  68.     {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},

  69.     {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},

  70.     {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},

  71.     {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},

  72.     {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},

  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.     {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},

  79.     {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},

  80.     {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},

  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.     {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},

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

  86. };

  87. 

  88. constexpr AllocationTable allocTable2[] =

  89. {

  90.     {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},

  91.     {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},

  92.     {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},

  93.     {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},

  94.     {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}

  95. };

  96. 

  97. constexpr AllocationTable allocTable3[] =

  98. {

  99.     {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},

  100.     {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},

  101.     {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},

  102.     {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},

  103.     {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},

  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. };

  107. 

  108. constexpr AllocationTable allocTable4[] =

  109. {

  110.     {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},

  111.     {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},

  112.     {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},

  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.     {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},

  115.     {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},

  116.     {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},

  117.     {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},

  118.     {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},

  119.     {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},

  120.     {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},

  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}

  123. };

  124. 

  125. struct BandInfoStruct

  126. {

  127.     int16 longIndex[23];

  128.     int16 longDiff[22];

  129.     int16 shortIndex[14];

  130.     int16 shortDiff[13];

  131. };

  132. 

  133. constexpr BandInfoStruct bandInfo[9] =

  134. {

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

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

  137.     {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},

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

  139. 

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

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

  142.     {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},

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

  144. 

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

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

  147.     {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},

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

  149. 

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

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

  152.     {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},

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

  154. 

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

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

  157.     {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},

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

  159. 

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

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

  162.     {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},

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

  164. 

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

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

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

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

  169. 

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

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

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

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

  174. 

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

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

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

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

  179. };

  180. 

  181. constexpr double decodeWindow[] =

  182. {

  183.     0.000000000, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000030518,

  184.    -0.000030518, -0.000030518, -0.000030518, -0.000045776, -0.000045776, -0.000061035, -0.000061035, -0.000076294,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  215.     1.144989014

  216. };

  217. 

  218. constexpr int16 huffmanTab0[] = { 0 };

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

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

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

  222. constexpr 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 };

  223. constexpr 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 };

  224. 

  225. constexpr int16 huffmanTab7[] =

  226. {

  227.     -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,

  228.     -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

  229. };

  230. 

  231. constexpr int16 huffmanTab8[] =

  232. {

  233.     -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,

  234.     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

  235. };

  236. 

  237. constexpr int16 huffmanTab9[] =

  238. {

  239.     -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,

  240.     -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

  241. };

  242. 

  243. constexpr int16 huffmanTab10[] =

  244. {

  245.     -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,

  246.     -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,

  247.     -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,

  248.     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

  249. };

  250. 

  251. constexpr int16 huffmanTab11[] =

  252. {

  253.     -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,

  254.     -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,

  255.     -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,

  256.     -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

  257. };

  258. 

  259. constexpr int16 huffmanTab12[] =

  260. {

  261.     -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,

  262.     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,

  263.     -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,

  264.     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

  265. };

  266. 

  267. constexpr int16 huffmanTab13[] =

  268. {

  269.     -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,

  270.     -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,

  271.     -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,

  272.     -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,

  273.     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,

  274.     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,

  275.     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,

  276.     -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,

  277.     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,

  278.     -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,

  279.     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,

  280.     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,

  281.     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,

  282.     -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,

  283.     -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,

  284.     -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

  285. };

  286. 

  287. constexpr int16 huffmanTab15[] =

  288. {

  289.     -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,

  290.     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,

  291.     -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,

  292.     -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,

  293.     -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,

  294.     -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,

  295.     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,

  296.     -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,

  297.     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,

  298.     -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,

  299.     -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,

  300.     -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,

  301.     -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,

  302.     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,

  303.     -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,

  304.     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

  305. };

  306. 

  307. constexpr int16 huffmanTab16[] =

  308. {

  309.     -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,

  310.     -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,

  311.     -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,

  312.     -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,

  313.     -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,

  314.     -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,

  315.     -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,

  316.     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,

  317.     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,

  318.     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,

  319.     -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,

  320.     -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,

  321.     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,

  322.     -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,

  323.     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,

  324.     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

  325. };

  326. 

  327. constexpr int16 huffmanTab24[] =

  328. {

  329.     -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,

  330.     -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,

  331.     -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,

  332.     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,

  333.     -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,

  334.     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,

  335.     -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,

  336.     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,

  337.     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,

  338.     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,

  339.     -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,

  340.     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,

  341.     -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,

  342.     -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,

  343.     -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

  344. };

  345. 

  346. struct BitsToTableMap

  347. {

  348.     uint32 bits;

  349.     const int16* table;

  350. };

  351. 

  352. constexpr BitsToTableMap huffmanTables1[] =

  353. {

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

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

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

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

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

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

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

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

  362. };

  363. 

  364. constexpr 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 };

  365. constexpr 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 };

  366. 

  367. constexpr BitsToTableMap huffmanTables2[] = { { 0, huffmanTabC0 }, { 0, huffmanTabC1 } };

  368. 

  369. //==============================================================================

  370. struct VBRTagData

  371. {

  372.     bool read (const uint8* data) noexcept

  373.     {

  374.         flags = 0;

  375. 

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

  377.         if (layer != 1)

  378.             return false;

  379. 

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

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

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

  383. 

  384.         static constexpr short bitRates[3][16] =

  385.         {

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

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

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

  389.         };

  390. 

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

  392. 

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

  394.         {

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

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

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

  398.         };

  399. 

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

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

  402.         else

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

  404. 

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

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

  407. 

  408.         if (! isVbrTag (data))

  409.             return false;

  410. 

  411.         data += 4;

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

  413.         data += 4;

  414. 

  415.         if (flags & 1)

  416.         {

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

  418.             data += 4;

  419.         }

  420. 

  421.         if (flags & 2)

  422.         {

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

  424.             data += 4;

  425.         }

  426. 

  427.         if (flags & 4)

  428.         {

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

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

  431. 

  432.             data += 100;

  433.         }

  434. 

  435.         vbrScale = -1;

  436. 

  437.         if (flags & 8)

  438.             vbrScale = (int) ByteOrder::bigEndianInt (data);

  439. 

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

  441.         return true;

  442.     }

  443. 

  444.     uint8 toc[100];

  445.     int sampleRate, vbrScale, headersize;

  446.     unsigned int flags, frames, bytes;

  447. 

  448. private:

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

  450.     {

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

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

  453.     }

  454. };

  455. 

  456. //==============================================================================

  457. struct MP3Frame

  458. {

  459.     MP3Frame()

  460.     {

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

  462.         single = -1;

  463.     }

  464. 

  465.     void selectLayer2Table()

  466.     {

  467.         static constexpr int translate[3][2][16] =

  468.         {

  469.             { { 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 } },

  470.             { { 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 } },

  471.             { { 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 } }

  472.         };

  473. 

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

  475.         static constexpr int8 limits[] = { 27, 30, 8, 12, 30 };

  476. 

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

  478.         layer2SubBandLimit = limits[index];

  479.         allocationTable = tables[index];

  480.     }

  481. 

  482.     int getFrequency() const noexcept

  483.     {

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

  485.         return frequencies[sampleRateIndex];

  486.     }

  487. 

  488.     enum class ParseSuccessful { no, yes };

  489. 

  490.     ParseSuccessful decodeHeader (const uint32 header)

  491.     {

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

  493. 

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

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

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

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

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

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

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

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

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

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

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

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

  506.         //emphasis          = header & 3;

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

  508. 

  509.         static constexpr int frameSizes[2][3][16] =

  510.         {

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

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

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

  514. 

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

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

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

  518.         };

  519. 

  520.         if (bitrateIndex == 0)

  521.         {

  522.             jassertfalse; // This means the file is using "free format". Apparently very few decoders

  523.                           // support this mode, and this one certainly doesn't handle it correctly!

  524.             frameSize = 0;

  525.             return ParseSuccessful::no;

  526.         }

  527. 

  528.         switch (layer)

  529.         {

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

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

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

  533.             default: break;

  534.         }

  535. 

  536.         return ParseSuccessful::yes;

  537.     }

  538. 

  539.     int layer, frameSize, numChannels, single;

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

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

  542.     bool crc16FollowsHeader;

  543.     int bitrateIndex, sampleRateIndex, padding;

  544.     int mode, modeExt, layer2SubBandLimit;

  545.     enum { downSampleLimit = 32 };

  546.     const AllocationTable* allocationTable;

  547. };

  548. 

  549. //==============================================================================

  550. struct Constants

  551. {

  552.     Constants()

  553.     {

  554.         cosTables[0] = cos64; cosTables[1] = cos32; cosTables[2] = cos16; cosTables[3] = cos8; cosTables[4] = cos4;

  555.         initDecodeTables();

  556.         initLayer2Tables();

  557.         initLayer3Tables();

  558.     }

  559. 

  560.     const uint8* getGroupTable (const int16 d1, const uint32 index) const noexcept

  561.     {

  562.         switch (d1)

  563.         {

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

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

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

  567.             default:  break;

  568.         }

  569. 

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

  571.         return dummy;

  572.     }

  573. 

  574.     float muls[27][64];

  575.     float nToThe4Over3[8207];

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

  577.     float win[4][36];

  578.     float win1[4][36];

  579.     float powToGains[256 + 118 + 4];

  580.     int longLimit[9][23];

  581.     int shortLimit[9][14];

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

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

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

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

  586.     uint32 nLength2[512];

  587.     uint32 iLength2[256];

  588.     float decodeWin[512 + 32];

  589.     float* cosTables[5];

  590. 

  591. private:

  592.     int mapbuf0[9][152];

  593.     int mapbuf1[9][156];

  594.     int mapbuf2[9][44];

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

  596.     uint8 group3tab[32 * 3];

  597.     uint8 group5tab[128 * 3];

  598.     uint8 group9tab[1024 * 3];

  599. 

  600.     void initDecodeTables()

  601.     {

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

  603.         float* table = decodeWin;

  604. 

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

  606.         {

  607.             int kr = 0x10 >> i;

  608.             int divv = 0x40 >> i;

  609.             float* costab = cosTables[i];

  610. 

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

  612.                 costab[k] = (float) (1.0 / (2.0 * std::cos (MathConstants<double>::pi * (k * 2 + 1) / divv)));

  613.         }

  614. 

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

  616.         {

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

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

  619.             if (i % 32 == 31)

  620.                 table -= 1023;

  621.             if (i % 64 == 63)

  622.                 scaleval = -scaleval;

  623.         }

  624. 

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

  626.         {

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

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

  629. 

  630.             if (i % 32 == 31) table -= 1023;

  631.             if (i % 64 == 63) scaleval = -scaleval;

  632.         }

  633.     }

  634. 

  635.     void initLayer2Tables()

  636.     {

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

  638.         {

  639.             { 1, 0, 2 },

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

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

  642.         };

  643. 

  644.         static constexpr int tableLengths[] = { 3, 5, 9 };

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

  646. 

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

  648.         {

  649.             uint8* table = tables[i];

  650.             const int len = tableLengths[i];

  651. 

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

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

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

  655.                     {

  656.                         *table++ = base[i][l];

  657.                         *table++ = base[i][k];

  658.                         *table++ = base[i][j];

  659.                     }

  660.         }

  661. 

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

  663.         {

  664.             static constexpr double multipliers[] =

  665.             {

  666.                 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,

  667.                 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,

  668.                 -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

  669.             };

  670. 

  671.             float* table = muls[k];

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

  673.                 *table++ = (float) (multipliers[k] * std::pow (2.0, j / 3.0));

  674.             *table++ = 0;

  675.         }

  676.     }

  677. 

  678.     void initLayer3Tables()

  679.     {

  680.         int i, j;

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

  682.             powToGains[i + 256] = (float) std::pow (2.0, -0.25 * (i + 210));

  683. 

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

  685.             nToThe4Over3[i] = (float) std::pow ((double) i, 4.0 / 3.0);

  686. 

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

  688.         {

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

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

  691.             antiAliasingCs[i] = (float) (1.0 / sq);

  692.             antiAliasingCa[i] = (float) (Ci[i] / sq);

  693.         }

  694. 

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

  696.         {

  697.             win[0][i]      = win[1][i]      = (float) (0.5 * std::sin (MathConstants<double>::pi / 72.0 * (2 * i + 1))        / std::cos (MathConstants<double>::pi * (2 * i + 19)        / 72.0));

  698.             win[0][i + 18] = win[3][i + 18] = (float) (0.5 * std::sin (MathConstants<double>::pi / 72.0 * (2 * (i + 18) + 1)) / std::cos (MathConstants<double>::pi * (2 * (i + 18) + 19) / 72.0));

  699.         }

  700. 

  701.         const double piOver72 = MathConstants<double>::pi / 72.0;

  702. 

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

  704.         {

  705.             win[1][i + 18] = (float) (0.5 / std::cos (piOver72 * (2 * (i + 18) + 19)));

  706.             win[3][i + 12] = (float) (0.5 / std::cos (piOver72 * (2 * (i + 12) + 19)));

  707.             win[1][i + 24] = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 13)) / std::cos (piOver72 * (2 * (i + 24) + 19)));

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

  709.             win[3][i + 6]  = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 1)) / std::cos (piOver72 * (2 * (i + 6) + 19)));

  710.         }

  711. 

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

  713.             win[2][i] = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 1)) / std::cos (MathConstants<double>::pi * (2 * i + 7) / 24.0));

  714. 

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

  716.         {

  717.             static constexpr int len[4] = { 36, 36, 12, 36 };

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

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

  720.         }

  721. 

  722.         const double sqrt2 = 1.41421356237309504880168872420969808;

  723. 

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

  725.         {

  726.             const double t = std::tan (i * MathConstants<double>::pi / 12.0);

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

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

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

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

  731. 

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

  733.             {

  734.                 double p1 = 1.0, p2 = 1.0;

  735. 

  736.                 if (i > 0)

  737.                 {

  738.                     const double base = std::pow (2.0, -0.25 * (j + 1));

  739. 

  740.                     if (i & 1)

  741.                         p1 = std::pow (base, (i + 1) * 0.5);

  742.                     else

  743.                         p2 = std::pow (base, i * 0.5);

  744.                 }

  745. 

  746.                 pow1_1[j][i] = (float) p1;

  747.                 pow2_1[j][i] = (float) p2;

  748.                 pow1_2[j][i] = (float) (sqrt2 * p1);

  749.                 pow2_2[j][i] = (float) (sqrt2 * p2);

  750.             }

  751.         }

  752. 

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

  754.         {

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

  756.             int cb;

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

  758.             const int16* bdf = bi.longDiff;

  759. 

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

  761.             {

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

  763.                 *mp++ = i;

  764.                 *mp++ = 3;

  765.                 *mp++ = cb;

  766.             }

  767.             bdf = bi.shortDiff + 3;

  768. 

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

  770.             {

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

  772. 

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

  774.                 {

  775.                     *mp++ = l;

  776.                     *mp++ = i + lwin;

  777.                     *mp++ = lwin;

  778.                     *mp++ = cb;

  779.                 }

  780.                 i += 6 * l;

  781.             }

  782. 

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

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

  785.             bdf = bi.shortDiff;

  786. 

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

  788.             {

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

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

  791.                 {

  792.                     *mp++ = l;

  793.                     *mp++ = i + lwin;

  794.                     *mp++ = lwin;

  795.                     *mp++ = cb;

  796.                 }

  797.                 i += 6 * l;

  798.             }

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

  800. 

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

  802.             bdf = bi.longDiff;

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

  804.             {

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

  806.                 *mp++ = cb;

  807.             }

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

  809. 

  810.         }

  811. 

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

  813.         {

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

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

  816.         }

  817. 

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

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

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

  821.                 {

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

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

  824.                 }

  825. 

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

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

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

  829.                 {

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

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

  832.                 }

  833. 

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

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

  836.             {

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

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

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

  840.             }

  841. 

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

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

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

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

  846.                     {

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

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

  849.                     }

  850. 

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

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

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

  854.                 {

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

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

  857.                 }

  858.     }

  859. };

  860. 

  861. static const Constants constants;

  862. 

  863. 

  864. //==============================================================================

  865. struct Layer3SideInfo

  866. {

  867.     struct Info

  868.     {

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

  870.         {

  871.             float* xr1 = xr[1];

  872.             int sb;

  873. 

  874.             if (blockType == 2)

  875.             {

  876.                 if (mixedBlockFlag == 0)

  877.                     return;

  878. 

  879.                 sb = 1;

  880.             }

  881.             else

  882.                 sb = (int) maxb - 1;

  883. 

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

  885.             {

  886.                 auto* cs = constants.antiAliasingCs;

  887.                 auto* ca = constants.antiAliasingCa;

  888.                 auto* xr2 = xr1;

  889. 

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

  891.                 {

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

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

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

  895.                 }

  896.             }

  897.         }

  898. 

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

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

  901.         {

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

  903.             auto& bi = bandInfo[sampleRate];

  904.             const float* tabl1, *tabl2;

  905. 

  906.             if (lsf != 0)

  907.             {

  908.                 auto p = scaleFactorCompression & 1;

  909. 

  910.                 if (msStereo)

  911.                 {

  912.                     tabl1 = constants.pow1_2[p];

  913.                     tabl2 = constants.pow2_2[p];

  914.                 }

  915.                 else

  916.                 {

  917.                     tabl1 = constants.pow1_1[p];

  918.                     tabl2 = constants.pow2_1[p];

  919.                 }

  920.             }

  921.             else

  922.             {

  923.                 if (msStereo)

  924.                 {

  925.                     tabl1 = constants.tan1_2;

  926.                     tabl2 = constants.tan2_2;

  927.                 }

  928.                 else

  929.                 {

  930.                     tabl1 = constants.tan1_1;

  931.                     tabl2 = constants.tan2_1;

  932.                 }

  933.             }

  934. 

  935.             if (blockType == 2)

  936.             {

  937.                 bool doL = mixedBlockFlag != 0;

  938. 

  939.                 for (uint32 lwin = 0; lwin < 3; ++lwin)

  940.                 {

  941.                     uint32 sfb = maxBand[lwin];

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

  943. 

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

  945.                     {

  946.                         auto p = scaleFactors[sfb * 3 + lwin - mixedBlockFlag];

  947. 

  948.                         if (p != 7)

  949.                         {

  950.                             auto t1 = tabl1[p];

  951.                             auto t2 = tabl2[p];

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

  953.                             auto index = (uint32) sb + lwin;

  954. 

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

  956.                             {

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

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

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

  960.                             }

  961.                         }

  962.                     }

  963. 

  964.                     auto p = scaleFactors[11 * 3 + lwin - mixedBlockFlag];

  965. 

  966.                     if (p != 7)

  967.                     {

  968.                         auto t1 = tabl1[p];

  969.                         auto t2 = tabl2[p];

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

  971.                         auto index = (uint32) sb + lwin;

  972. 

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

  974.                         {

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

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

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

  978.                         }

  979.                     }

  980.                 }

  981. 

  982.                 if (doL)

  983.                 {

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

  985. 

  986.                     for (uint32 sfb = maxBandl; sfb < 8; ++sfb)

  987.                     {

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

  989.                         auto p = scaleFactors[sfb];

  990. 

  991.                         if (p != 7)

  992.                         {

  993.                             auto t1 = tabl1[p];

  994.                             auto t2 = tabl2[p];

  995. 

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

  997.                             {

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

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

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

  1001.                             }

  1002.                         }

  1003.                         else

  1004.                             index += sb;

  1005.                     }

  1006.                 }

  1007.             }

  1008.             else

  1009.             {

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

  1011. 

  1012.                 for (uint32 sfb = maxBandl; sfb < 21; ++sfb)

  1013.                 {

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

  1015.                     auto p = scaleFactors[sfb];

  1016. 

  1017.                     if (p != 7)

  1018.                     {

  1019.                         auto t1 = tabl1[p];

  1020.                         auto t2 = tabl2[p];

  1021. 

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

  1023.                         {

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

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

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

  1027.                         }

  1028.                     }

  1029.                     else

  1030.                         index += sb;

  1031.                 }

  1032. 

  1033.                 auto p = scaleFactors[20];

  1034. 

  1035.                 if (p != 7)

  1036.                 {

  1037.                     auto t1 = tabl1[p], t2 = tabl2[p];

  1038. 

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

  1040.                     {

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

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

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

  1044.                     }

  1045.                 }

  1046.             }

  1047.         }

  1048. 

  1049.         int scfsi;

  1050.         uint32 part2_3Length, bigValues;

  1051.         uint32 scaleFactorCompression, blockType, mixedBlockFlag;

  1052.         uint32 tableSelect[3];

  1053.         uint32 maxBand[3];

  1054.         uint32 maxBandl, maxb, region1Start, region2Start;

  1055.         uint32 preflag, scaleFactorScale, count1TableSelect;

  1056.         const float* fullGain[3];

  1057.         const float* pow2gain;

  1058.     };

  1059. 

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

  1061.     InfoPair ch[2];

  1062. 

  1063.     uint32 mainDataStart, privateBits;

  1064. };

  1065. 

  1066. //==============================================================================

  1067. namespace DCT

  1068. {

  1069.     enum { subBandLimit = 32 };

  1070.     static constexpr float cos6_1  = 0.866025388f;

  1071.     static constexpr float cos6_2  = 0.5f;

  1072.     static constexpr float cos9[]  = { 1.0f, 0.98480773f, 0.939692616f, 0.866025388f, 0.766044438f, 0.642787635f, 0.5f, 0.342020154f, 0.173648179f };

  1073.     static constexpr float cos36[] = { 0.501909912f, 0.517638087f, 0.551688969f, 0.610387266f, 0.707106769f, 0.871723413f, 1.18310082f, 1.93185163f, 5.73685646f };

  1074.     static constexpr float cos12[] = { 0.517638087f, 0.707106769f, 1.93185163f };

  1075. 

  1076.     inline void dct36_0 (int v, float* ts, float* out1, float* out2, const float* wintab, float sum0, float sum1) noexcept

  1077.     {

  1078.         auto tmp = sum0 + sum1;

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

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

  1081.         sum0 -= sum1;

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

  1083.         ts[subBandLimit * (9 + v)] = out1[9 + v] + sum0 * wintab[9 + v];

  1084.     }

  1085. 

  1086.     inline void dct36_12 (int v1, int v2, float* ts, float* out1, float* out2, const float* wintab,

  1087.                           float tmp1a, float tmp1b, float tmp2a, float tmp2b) noexcept

  1088.     {

  1089.         dct36_0 (v1, ts, out1, out2, wintab, tmp1a + tmp2a, (tmp1b + tmp2b) * cos36[v1]);

  1090.         dct36_0 (v2, ts, out1, out2, wintab, tmp2a - tmp1a, (tmp2b - tmp1b) * cos36[v2]);

  1091.     }

  1092. 

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

  1094.     {

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

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

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

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

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

  1100. 

  1101.         auto ta33 = in[6]  * cos9[3];

  1102.         auto ta66 = in[12] * cos9[6];

  1103.         auto tb33 = in[7]  * cos9[3];

  1104.         auto tb66 = in[13] * cos9[6];

  1105. 

  1106.         dct36_12 (0, 8, ts, out1, out2, wintab,

  1107.                   in[2] * cos9[1] + ta33 + in[10] * cos9[5] + in[14] * cos9[7],

  1108.                   in[3] * cos9[1] + tb33 + in[11] * cos9[5] + in[15] * cos9[7],

  1109.                   in[0] + in[4] * cos9[2] + in[8] * cos9[4] + ta66 + in[16] * cos9[8],

  1110.                   in[1] + in[5] * cos9[2] + in[9] * cos9[4] + tb66 + in[17] * cos9[8]);

  1111. 

  1112.         dct36_12 (1, 7, ts, out1, out2, wintab,

  1113.                   (in[2] - in[10] - in[14]) * cos9[3],

  1114.                   (in[3] - in[11] - in[15]) * cos9[3],

  1115.                   (in[4] - in[8] - in[16]) * cos9[6] - in[12] + in[0],

  1116.                   (in[5] - in[9] - in[17]) * cos9[6] - in[13] + in[1]);

  1117. 

  1118.         dct36_12 (2, 6, ts, out1, out2, wintab,

  1119.                   in[2] * cos9[5] - ta33 - in[10] * cos9[7] + in[14] * cos9[1],

  1120.                   in[3] * cos9[5] - tb33 - in[11] * cos9[7] + in[15] * cos9[1],

  1121.                   in[0] - in[4] * cos9[8] - in[8] * cos9[2] + ta66 + in[16] * cos9[4],

  1122.                   in[1] - in[5] * cos9[8] - in[9] * cos9[2] + tb66 + in[17] * cos9[4]);

  1123. 

  1124.         dct36_12 (3, 5, ts, out1, out2, wintab,

  1125.                   in[2] * cos9[7] - ta33 + in[10] * cos9[1] - in[14] * cos9[5],

  1126.                   in[3] * cos9[7] - tb33 + in[11] * cos9[1] - in[15] * cos9[5],

  1127.                   in[0] - in[4] * cos9[4] + in[8] * cos9[8] + ta66 - in[16] * cos9[2],

  1128.                   in[1] - in[5] * cos9[4] + in[9] * cos9[8] + tb66 - in[17] * cos9[2]);

  1129. 

  1130.         dct36_0 (4, ts, out1, out2, wintab,

  1131.                  in[0] - in[4] + in[8] - in[12] + in[16],

  1132.                  (in[1] - in[5] + in[9] - in[13] + in[17]) * cos36[4]);

  1133.     }

  1134. 

  1135.     struct DCT12Inputs

  1136.     {

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

  1138. 

  1139.         inline DCT12Inputs (const float* in) noexcept

  1140.         {

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

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

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

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

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

  1146.             in5 += in3; in3 += in1;

  1147.             in2 *= cos6_1;

  1148.             in3 *= cos6_1;

  1149.         }

  1150. 

  1151.         inline void process() noexcept

  1152.         {

  1153.             in0 += in4 * cos6_2;

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

  1155.             in1 += in5 * cos6_2;

  1156.             in5 = (in1 + in3) * cos12[0];

  1157.             in1 = (in1 - in3) * cos12[2];

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

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

  1160.         }

  1161.     };

  1162. 

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

  1164.     {

  1165.         {

  1166.             ts[0] = out1[0];

  1167.             ts[subBandLimit * 1] = out1[1];

  1168.             ts[subBandLimit * 2] = out1[2];

  1169.             ts[subBandLimit * 3] = out1[3];

  1170.             ts[subBandLimit * 4] = out1[4];

  1171.             ts[subBandLimit * 5] = out1[5];

  1172. 

  1173.             DCT12Inputs inputs (in);

  1174. 

  1175.             {

  1176.                 auto tmp1 = (inputs.in0 - inputs.in4);

  1177.                 auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];

  1178.                 auto tmp0 = tmp1 + tmp2;

  1179.                 tmp1 -= tmp2;

  1180. 

  1181.                 ts[16 * subBandLimit] = out1[16] + tmp0 * wi[10];

  1182.                 ts[13 * subBandLimit] = out1[13] + tmp0 * wi[7];

  1183.                 ts[7  * subBandLimit] = out1[7]  + tmp1 * wi[1];

  1184.                 ts[10 * subBandLimit] = out1[10] + tmp1 * wi[4];

  1185.             }

  1186. 

  1187.             inputs.process();

  1188. 

  1189.             ts[17 * subBandLimit] = out1[17] + inputs.in2 * wi[11];

  1190.             ts[12 * subBandLimit] = out1[12] + inputs.in2 * wi[6];

  1191.             ts[14 * subBandLimit] = out1[14] + inputs.in3 * wi[8];

  1192.             ts[15 * subBandLimit] = out1[15] + inputs.in3 * wi[9];

  1193. 

  1194.             ts[6  * subBandLimit] = out1[6]  + inputs.in0 * wi[0];

  1195.             ts[11 * subBandLimit] = out1[11] + inputs.in0 * wi[5];

  1196.             ts[8  * subBandLimit] = out1[8]  + inputs.in4 * wi[2];

  1197.             ts[9  * subBandLimit] = out1[9]  + inputs.in4 * wi[3];

  1198.         }

  1199. 

  1200.         {

  1201.             DCT12Inputs inputs (++in);

  1202.             auto tmp1 = (inputs.in0 - inputs.in4);

  1203.             auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];

  1204.             auto tmp0 = tmp1 + tmp2;

  1205.             tmp1 -= tmp2;

  1206.             out2[4] = tmp0 * wi[10];

  1207.             out2[1] = tmp0 * wi[7];

  1208.             ts[13 * subBandLimit] += tmp1 * wi[1];

  1209.             ts[16 * subBandLimit] += tmp1 * wi[4];

  1210. 

  1211.             inputs.process();

  1212. 

  1213.             out2[5] = inputs.in2 * wi[11];

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

  1215.             out2[2] = inputs.in3 * wi[8];

  1216.             out2[3] = inputs.in3 * wi[9];

  1217.             ts[12 * subBandLimit] += inputs.in0 * wi[0];

  1218.             ts[17 * subBandLimit] += inputs.in0 * wi[5];

  1219.             ts[14 * subBandLimit] += inputs.in4 * wi[2];

  1220.             ts[15 * subBandLimit] += inputs.in4 * wi[5 - 2];

  1221.         }

  1222. 

  1223.         {

  1224.             DCT12Inputs inputs (++in);

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

  1226. 

  1227.             auto tmp1 = (inputs.in0 - inputs.in4);

  1228.             auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];

  1229.             auto tmp0 = tmp1 + tmp2;

  1230.             tmp1 -= tmp2;

  1231. 

  1232.             out2[10] = tmp0 * wi[10];

  1233.             out2[7]  = tmp0 * wi[7];

  1234.             out2[1] += tmp1 * wi[1];

  1235.             out2[4] += tmp1 * wi[4];

  1236. 

  1237.             inputs.process();

  1238. 

  1239.             out2[11] = inputs.in2 * wi[11];

  1240.             out2[6]  = inputs.in2 * wi[6];

  1241.             out2[8]  = inputs.in3 * wi[8];

  1242.             out2[9]  = inputs.in3 * wi[9];

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

  1244.             out2[5] += inputs.in0 * wi[5];

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

  1246.             out2[3] += inputs.in4 * wi[3];

  1247.         }

  1248.     }

  1249. 

  1250.     static void dct64 (float* out0, float* out1, const float* samples) noexcept

  1251.     {

  1252.         float b1[32], b2[32];

  1253. 

  1254.         {

  1255.             auto* costab = constants.cosTables[0];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1272.         }

  1273. 

  1274.         {

  1275.             auto* costab = constants.cosTables[1];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1292.         }

  1293. 

  1294.         {

  1295.             auto* costab = constants.cosTables[2];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1312.         }

  1313. 

  1314.         {

  1315.             auto cos0 = constants.cosTables[3][0];

  1316.             auto cos1 = constants.cosTables[3][1];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1333.         }

  1334. 

  1335.         {

  1336.             auto cos0 = constants.cosTables[4][0];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1357.         }

  1358. 

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

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

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

  1362. 

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

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

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

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

  1367. 

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

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

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

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

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

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

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

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

  1376.     }

  1377. }

  1378. 

  1379. //==============================================================================

  1380. struct MP3Stream

  1381. {

  1382.     MP3Stream (InputStream& source)  : stream (source, 8192)

  1383.     {

  1384.         reset();

  1385.     }

  1386. 

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

  1388.     {

  1389.         if (! headerParsed)

  1390.         {

  1391.             auto nextFrameOffset = scanForNextFrameHeader (false);

  1392. 

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

  1394.             {

  1395.                 needToSyncBitStream = false;

  1396.                 readVBRHeader();

  1397. 

  1398.                 if (vbrHeaderFound)

  1399.                     return 1;

  1400.             }

  1401. 

  1402.             if (nextFrameOffset < 0)

  1403.                 return -1;

  1404. 

  1405.             if (nextFrameOffset > 0)

  1406.             {

  1407.                 wasFreeFormat = false;

  1408.                 needToSyncBitStream = true;

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

  1410. 

  1411.                 if (size > 2880)

  1412.                 {

  1413.                     size = 0;

  1414.                     bufferPointer = bufferSpace[bufferSpaceIndex] + 512;

  1415.                 }

  1416. 

  1417.                 auto toSkip = (size + nextFrameOffset) - 2880;

  1418. 

  1419.                 if (toSkip > 0)

  1420.                 {

  1421.                     stream.skipNextBytes (toSkip);

  1422.                     nextFrameOffset -= toSkip;

  1423.                 }

  1424. 

  1425.                 stream.read (bufferPointer, nextFrameOffset);

  1426.                 lastFrameSize += nextFrameOffset;

  1427.             }

  1428. 

  1429.             const auto successful = frame.decodeHeader ((uint32) stream.readIntBigEndian());

  1430. 

  1431.             if (successful == MP3Frame::ParseSuccessful::no)

  1432.                 return -1;

  1433. 

  1434.             headerParsed = true;

  1435.             frameSize = frame.frameSize;

  1436.             isFreeFormat = (frameSize == 0);

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

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

  1439. 

  1440.             if (frame.crc16FollowsHeader)

  1441.                 sideInfoSize += 2;

  1442. 

  1443.             bufferSpaceIndex = 1 - bufferSpaceIndex;

  1444.             bufferPointer = bufferSpace[bufferSpaceIndex] + 512;

  1445.             bitIndex = 0;

  1446. 

  1447.             if (lastFrameSize < 0)

  1448.                 return 1;

  1449.         }

  1450. 

  1451.         if (! sideParsed)

  1452.         {

  1453.             if (frame.layer == 3)

  1454.             {

  1455.                 stream.read (bufferPointer, sideInfoSize);

  1456. 

  1457.                 if (frame.crc16FollowsHeader)

  1458.                     getBits (16);

  1459. 

  1460.                 auto bits = jmax (0, decodeLayer3SideInfo());

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

  1462. 

  1463.                 if (! isFreeFormat)

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

  1465.             }

  1466.             else

  1467.             {

  1468.                 dataSize = frame.frameSize;

  1469.                 sideInfoSize = 0;

  1470.             }

  1471. 

  1472.             sideParsed = true;

  1473.         }

  1474. 

  1475.         int result = 1;

  1476. 

  1477.         if (! dataParsed)

  1478.         {

  1479.             stream.read (bufferPointer, dataSize);

  1480. 

  1481.             if (out0 != nullptr)

  1482.             {

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

  1484.                     getBits (16);

  1485. 

  1486.                 switch (frame.layer)

  1487.                 {

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

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

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

  1491.                     default: break;

  1492.                 }

  1493.             }

  1494. 

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

  1496.             dataParsed = true;

  1497.             result = 0;

  1498.         }

  1499. 

  1500.         if (isFreeFormat)

  1501.         {

  1502.             if (wasFreeFormat)

  1503.             {

  1504.                 frameSize = lastFrameSizeNoPadding + frame.padding;

  1505.             }

  1506.             else

  1507.             {

  1508.                 auto nextFrameOffset = scanForNextFrameHeader (true);

  1509. 

  1510.                 wasFreeFormat = isFreeFormat;

  1511. 

  1512.                 if (nextFrameOffset < 0)

  1513.                 {

  1514.                     lastFrameSize = frameSize;

  1515.                     return result;

  1516.                 }

  1517. 

  1518.                 frameSize = nextFrameOffset + sideInfoSize + dataSize;

  1519.                 lastFrameSizeNoPadding = frameSize - frame.padding;

  1520.             }

  1521.         }

  1522. 

  1523.         if (result == 0)

  1524.             return result;

  1525. 

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

  1527. 

  1528.         if (bytes > 0)

  1529.         {

  1530.             auto toSkip = bytes - 512;

  1531. 

  1532.             if (toSkip > 0)

  1533.             {

  1534.                 stream.skipNextBytes (toSkip);

  1535.                 bytes -= toSkip;

  1536.                 frameSize -= toSkip;

  1537.             }

  1538. 

  1539.             stream.read (bufferPointer, bytes);

  1540.             bufferPointer += bytes;

  1541.         }

  1542. 

  1543.         lastFrameSize = frameSize;

  1544.         wasFreeFormat = isFreeFormat;

  1545.         frameSize = 0;

  1546.         headerParsed = sideParsed = dataParsed = false;

  1547.         return result;

  1548.     }

  1549. 

  1550.     bool seek (int frameIndex)

  1551.     {

  1552.         frameIndex = jmax (0, frameIndex);

  1553. 

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

  1555.         {

  1556.             int dummy = 0;

  1557.             auto result = decodeNextBlock (nullptr, nullptr, dummy);

  1558. 

  1559.             if (result < 0)

  1560.                 return false;

  1561. 

  1562.             if (result > 0)

  1563.                 break;

  1564.         }

  1565. 

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

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

  1568. 

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

  1570.         currentFrameIndex = frameIndex;

  1571.         reset();

  1572.         return true;

  1573.     }

  1574. 

  1575.     MP3Frame frame;

  1576.     VBRTagData vbrTagData;

  1577.     BufferedInputStream stream;

  1578.     int numFrames = 0, currentFrameIndex = 0;

  1579.     bool vbrHeaderFound = false;

  1580. 

  1581. private:

  1582.     bool headerParsed, sideParsed, dataParsed, needToSyncBitStream;

  1583.     bool isFreeFormat, wasFreeFormat;

  1584.     int sideInfoSize, dataSize;

  1585.     int frameSize, lastFrameSize, lastFrameSizeNoPadding;

  1586.     int bufferSpaceIndex;

  1587.     Layer3SideInfo sideinfo;

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

  1589.     uint8* bufferPointer;

  1590.     int bitIndex, synthBo;

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

  1592.     int hybridBlockIndex[2];

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

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

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

  1596. 

  1597.     void reset() noexcept

  1598.     {

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

  1600.         lastFrameSize = -1;

  1601.         needToSyncBitStream = true;

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

  1603.         lastFrameSizeNoPadding = bufferSpaceIndex = 0;

  1604.         bufferPointer = bufferSpace[bufferSpaceIndex] + 512;

  1605.         synthBo = 1;

  1606. 

  1607.         zerostruct (sideinfo);

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

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

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

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

  1612.     }

  1613. 

  1614.     enum { storedStartPosInterval = 4 };

  1615.     Array<int64> frameStreamPositions;

  1616. 

  1617.     struct SideInfoLayer1

  1618.     {

  1619.         uint8 allocation[32][2];

  1620.         uint8 scaleFactor[32][2];

  1621.     };

  1622. 

  1623.     struct SideInfoLayer2

  1624.     {

  1625.         uint8 allocation[32][2];

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

  1627.     };

  1628. 

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

  1630.     {

  1631.         auto newLayer = (int) (4 - ((header >> 17) & 3));

  1632. 

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

  1634.                 && newLayer != 4

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

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

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

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

  1639.     }

  1640. 

  1641.     bool rollBackBufferPointer (int backstep) noexcept

  1642.     {

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

  1644.             return false;

  1645. 

  1646.         auto* oldBuffer = bufferSpace[1 - bufferSpaceIndex] + 512;

  1647.         bufferPointer -= backstep;

  1648. 

  1649.         if (backstep != 0)

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

  1651. 

  1652.         bitIndex = 0;

  1653.         return true;

  1654.     }

  1655. 

  1656.     uint32 getBits (int numBits) noexcept

  1657.     {

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

  1659.             return 0;

  1660. 

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

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

  1663.         bitIndex += numBits;

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

  1665.         bitIndex &= 7;

  1666.         return result;

  1667.     }

  1668. 

  1669.     uint32 getOneBit() noexcept

  1670.     {

  1671.         auto result = (uint8) (*bufferPointer << bitIndex);

  1672.         ++bitIndex;

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

  1674.         bitIndex &= 7;

  1675.         return (uint32) (result >> 7);

  1676.     }

  1677. 

  1678.     uint32 getBitsUnchecked (int numBits) noexcept

  1679.     {

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

  1681.         bitIndex += numBits;

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

  1683.         bitIndex &= 7;

  1684.         return result;

  1685.     }

  1686. 

  1687.     inline uint8  getBitsUint8  (int numBits) noexcept  { return (uint8)  getBitsUnchecked (numBits); }

  1688.     inline uint16 getBitsUint16 (int numBits) noexcept  { return (uint16) getBitsUnchecked (numBits); }

  1689. 

  1690.     int scanForNextFrameHeader (bool checkTypeAgainstLastFrame) noexcept

  1691.     {

  1692.         auto oldPos = stream.getPosition();

  1693.         int offset = -3;

  1694.         uint32 header = 0;

  1695. 

  1696.         for (;;)

  1697.         {

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

  1699.             {

  1700.                 offset = -1;

  1701.                 break;

  1702.             }

  1703. 

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

  1705. 

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

  1707.             {

  1708.                 if (! checkTypeAgainstLastFrame)

  1709.                     break;

  1710. 

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

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

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

  1714.                 const uint32 mode            = (header >> 6) & 3;

  1715.                 const uint32 numChannels     = (mode == 3) ? 1 : 2;

  1716. 

  1717.                 if (numChannels == (uint32) frame.numChannels && lsf == (uint32) frame.lsf

  1718.                       && mpeg25 == frame.mpeg25 && sampleRateIndex == (uint32) frame.sampleRateIndex)

  1719.                     break;

  1720.             }

  1721. 

  1722.             ++offset;

  1723.         }

  1724. 

  1725.         if (offset >= 0)

  1726.         {

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

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

  1729. 

  1730.             ++currentFrameIndex;

  1731.         }

  1732. 

  1733.         stream.setPosition (oldPos);

  1734.         return offset;

  1735.     }

  1736. 

  1737.     void readVBRHeader()

  1738.     {

  1739.         auto oldPos = stream.getPosition();

  1740.         uint8 xing[194];

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

  1742. 

  1743.         vbrHeaderFound = vbrTagData.read (xing);

  1744. 

  1745.         if (vbrHeaderFound)

  1746.         {

  1747.             numFrames = (int) vbrTagData.frames;

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

  1749.         }

  1750. 

  1751.         stream.setPosition (oldPos);

  1752.     }

  1753. 

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

  1755.     {

  1756.         float fraction[2][32];

  1757.         SideInfoLayer1 si;

  1758.         layer1Step1 (si);

  1759.         auto single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;

  1760. 

  1761.         if (single >= 0)

  1762.         {

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

  1764.             {

  1765.                 layer1Step2 (si, fraction);

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

  1767.             }

  1768.         }

  1769.         else

  1770.         {

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

  1772.             {

  1773.                 layer1Step2 (si, fraction);

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

  1775.             }

  1776.         }

  1777.     }

  1778. 

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

  1780.     {

  1781.         float fraction[2][4][32];

  1782.         frame.selectLayer2Table();

  1783.         SideInfoLayer2 si;

  1784.         layer2Step1 (si);

  1785.         auto single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;

  1786. 

  1787.         if (single >= 0)

  1788.         {

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

  1790.             {

  1791.                 layer2Step2 (si, i >> 2, fraction);

  1792. 

  1793.                 for (int j = 0; j < 3; ++j)

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

  1795.             }

  1796.         }

  1797.         else

  1798.         {

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

  1800.             {

  1801.                 layer2Step2 (si, i >> 2, fraction);

  1802. 

  1803.                 for (int j = 0; j < 3; ++j)

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

  1805.             }

  1806.         }

  1807.     }

  1808. 

  1809.     void decodeLayer3Frame (float* pcm0, float* pcm1, int& samplesDone) noexcept

  1810.     {

  1811.         if (! rollBackBufferPointer ((int) sideinfo.mainDataStart))

  1812.             return;

  1813. 

  1814.         const int single = frame.numChannels == 1 ? 0 : frame.single;

  1815.         const int numChans = (frame.numChannels == 1 || single >= 0) ? 1 : 2;

  1816.         const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;

  1817.         const bool iStereo  = (frame.mode == 1) && (frame.modeExt & 1) != 0;

  1818.         const int granules = frame.lsf ? 1 : 2;

  1819.         int scaleFactors[2][39];

  1820. 

  1821.         for (int gr = 0; gr < granules; ++gr)

  1822.         {

  1823.             {

  1824.                 auto& granule = sideinfo.ch[0].gr[gr];

  1825.                 auto part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[0], granule, 0)

  1826.                                            : getLayer3ScaleFactors1 (scaleFactors[0], granule);

  1827. 

  1828.                 if (layer3DequantizeSample (hybridIn[0], scaleFactors[0], granule, frame.sampleRateIndex, part2bits))

  1829.                     return;

  1830.             }

  1831. 

  1832.             if (frame.numChannels == 2)

  1833.             {

  1834.                 auto& granule = sideinfo.ch[1].gr[gr];

  1835.                 auto part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[1], granule, iStereo)

  1836.                                            : getLayer3ScaleFactors1 (scaleFactors[1], granule);

  1837. 

  1838.                 if (layer3DequantizeSample (hybridIn[1], scaleFactors[1], granule, frame.sampleRateIndex, part2bits))

  1839.                     return;

  1840. 

  1841.                 if (msStereo)

  1842.                 {

  1843.                     for (int i = 0; i < 32 * 18; ++i)

  1844.                     {

  1845.                         auto tmp0 = ((const float*) hybridIn[0])[i];

  1846.                         auto tmp1 = ((const float*) hybridIn[1])[i];

  1847.                         ((float*) hybridIn[1])[i] = tmp0 - tmp1;

  1848.                         ((float*) hybridIn[0])[i] = tmp0 + tmp1;

  1849.                     }

  1850.                 }

  1851. 

  1852.                 if (iStereo)

  1853.                     granule.doIStereo (hybridIn, scaleFactors[1], frame.sampleRateIndex, msStereo, frame.lsf);

  1854. 

  1855.                 if (msStereo || iStereo || single == 3)

  1856.                 {

  1857.                     if (granule.maxb > sideinfo.ch[0].gr[gr].maxb)

  1858.                         sideinfo.ch[0].gr[gr].maxb = granule.maxb;

  1859.                     else

  1860.                         granule.maxb = sideinfo.ch[0].gr[gr].maxb;

  1861.                 }

  1862. 

  1863.                 switch (single)

  1864.                 {

  1865.                     case 3:

  1866.                     {

  1867.                         auto* in0 = (float*) hybridIn[0];

  1868.                         auto* in1 = (const float*) hybridIn[1];

  1869. 

  1870.                         for (int i = 0; i < (int) (18 * granule.maxb); ++i, ++in0)

  1871.                             *in0 = (*in0 + *in1++);

  1872.                     }

  1873.                     break;

  1874. 

  1875.                     case 1:

  1876.                     {

  1877.                         auto* in0 = (float*) hybridIn[0];

  1878.                         auto* in1 = (const float*) hybridIn[1];

  1879. 

  1880.                         for (int i = 0; i < (int) (18 * granule.maxb); ++i)

  1881.                             *in0++ = *in1++;

  1882.                     }

  1883.                     break;

  1884. 

  1885.                     default:

  1886.                         break;

  1887.                 }

  1888.             }

  1889. 

  1890.             for (int ch = 0; ch < numChans; ++ch)

  1891.             {

  1892.                 auto& granule = sideinfo.ch[ch].gr[gr];

  1893.                 granule.doAntialias (hybridIn[ch]);

  1894.                 layer3Hybrid (hybridIn[ch], hybridOut[ch], ch, granule);

  1895.             }

  1896. 

  1897.             for (int ss = 0; ss < 18; ++ss)

  1898.             {

  1899.                 if (single >= 0)

  1900.                     synthesise (hybridOut[0][ss], 0, pcm0, samplesDone);

  1901.                 else

  1902.                     synthesiseStereo (hybridOut[0][ss], hybridOut[1][ss], pcm0, pcm1, samplesDone);

  1903.             }

  1904.         }

  1905.     }

  1906. 

  1907.     int decodeLayer3SideInfo() noexcept

  1908.     {

  1909.         const int numChannels = frame.numChannels;

  1910.         const int sampleRate = frame.sampleRateIndex;

  1911.         const int single = (numChannels == 1) ? 0 : frame.single;

  1912.         const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;

  1913.         const int granules = frame.lsf ? 1 : 2;

  1914. 

  1915.         if (frame.lsf == 0)

  1916.             getLayer3SideInfo1 (numChannels, msStereo, sampleRate, single);

  1917.         else

  1918.             getLayer3SideInfo2 (numChannels, msStereo, sampleRate, single);

  1919. 

  1920.         int databits = 0;

  1921. 

  1922.         for (int gr = 0; gr < granules; ++gr)

  1923.             for (int ch = 0; ch < numChannels; ++ch)

  1924.                 databits += (int) sideinfo.ch[ch].gr[gr].part2_3Length;

  1925. 

  1926.         return databits - 8 * (int) sideinfo.mainDataStart;

  1927.     }

  1928. 

  1929.     void layer1Step1 (SideInfoLayer1& si) noexcept

  1930.     {

  1931.         zerostruct (si);

  1932.         int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;

  1933. 

  1934.         if (frame.numChannels == 2)

  1935.         {

  1936.             for (i = 0; i < jsbound; ++i)

  1937.             {

  1938.                 si.allocation[i][0] = getBitsUint8 (4);

  1939.                 si.allocation[i][1] = getBitsUint8 (4);

  1940.             }

  1941. 

  1942.             for (i = jsbound; i < 32; ++i)

  1943.                 si.allocation[i][0] = si.allocation[i][1] = getBitsUint8 (4);

  1944. 

  1945.             for (i = 0; i < 32; ++i)

  1946.             {

  1947.                 si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;

  1948.                 si.scaleFactor[i][1] = si.allocation[i][1] ? getBitsUint8 (6) : 0;

  1949.             }

  1950.         }

  1951.         else

  1952.         {

  1953.             for (i = 0; i < 32; ++i)

  1954.                 si.allocation[i][0] = getBitsUint8 (4);

  1955. 

  1956.             for (i = 0; i < 32; ++i)

  1957.                 si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;

  1958.         }

  1959.     }

  1960. 

  1961.     void layer1Step2 (SideInfoLayer1& si, float fraction[2][32]) noexcept

  1962.     {

  1963.         if (frame.numChannels == 2)

  1964.         {

  1965.             int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;

  1966. 

  1967.             for (i = 0; i < jsbound; ++i)

  1968.             {

  1969.                 const uint8 n0 = si.allocation[i][0];

  1970.                 const uint8 n1 = si.allocation[i][1];

  1971.                 fraction[0][i] = n0 > 0 ? ((float) (-(1 << n0) + getBitsUint16 (n0 + 1) + 1) * constants.muls[n0 + 1][si.scaleFactor[i][0]]) : 0.0f;

  1972.                 fraction[1][i] = n1 > 0 ? ((float) (-(1 << n1) + getBitsUint16 (n1 + 1) + 1) * constants.muls[n1 + 1][si.scaleFactor[i][1]]) : 0.0f;

  1973.             }

  1974. 

  1975.             for (i = jsbound; i < 32; ++i)

  1976.             {

  1977.                 const uint8 n = si.allocation[i][0];

  1978. 

  1979.                 if (n > 0)

  1980.                 {

  1981.                     const uint32 w = ((uint32) -(1 << n) + getBitsUint16 (n + 1) + 1);

  1982.                     fraction[0][i] = ((float) w * constants.muls[n + 1][si.scaleFactor[i][0]]);

  1983.                     fraction[1][i] = ((float) w * constants.muls[n + 1][si.scaleFactor[i][1]]);

  1984.                 }

  1985.                 else

  1986.                     fraction[0][i] = fraction[1][i] = 0;

  1987.             }

  1988.         }

  1989.         else

  1990.         {

  1991.             for (int i = 0; i < 32; ++i)

  1992.             {

  1993.                 const uint8 n = si.allocation[i][0];

  1994.                 const uint8 j = si.scaleFactor[i][0];

  1995. 

  1996.                 if (n > 0)

  1997.                     fraction[0][i] = ((float) (-(1 << n) + getBitsUint16 (n + 1) + 1) * constants.muls[n + 1][j]);

  1998.                 else

  1999.                     fraction[0][i] = 0;

  2000.             }

  2001.         }

  2002.     }

  2003. 

  2004.     void layer2Step1 (SideInfoLayer2& si) noexcept

  2005.     {

  2006.         zerostruct (si);

  2007.         const auto sblimit = frame.layer2SubBandLimit;

  2008.         const auto jsbound = (frame.mode == 1 ? jmin ((frame.modeExt << 2) + 4, sblimit) : sblimit);

  2009.         auto* allocTable = frame.allocationTable;

  2010.         uint8 scfsi[32][2];

  2011. 

  2012.         if (frame.numChannels == 2)

  2013.         {

  2014.             for (int i = 0; i < jsbound; ++i)

  2015.             {

  2016.                 auto step = allocTable->bits;

  2017.                 allocTable += (static_cast<intptr_t> (1) << step);

  2018.                 si.allocation[i][0] = getBitsUint8 (step);

  2019.                 si.allocation[i][1] = getBitsUint8 (step);

  2020.             }

  2021. 

  2022.             for (int i = jsbound; i < sblimit; ++i)

  2023.             {

  2024.                 auto step = allocTable->bits;

  2025.                 auto b0 = getBitsUint8 (step);

  2026.                 allocTable += (static_cast<intptr_t> (1) << step);

  2027.                 si.allocation[i][0] = b0;

  2028.                 si.allocation[i][1] = b0;

  2029.             }

  2030. 

  2031.             for (int i = 0; i < sblimit; ++i)

  2032.             {

  2033.                 scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;

  2034.                 scfsi[i][1] = si.allocation[i][1] ? getBitsUint8 (2) : 0;

  2035.             }

  2036.         }

  2037.         else

  2038.         {

  2039.             for (int i = 0; i < sblimit; ++i)

  2040.             {

  2041.                 const int16 step = allocTable->bits;

  2042.                 allocTable += (static_cast<intptr_t> (1) << step);

  2043.                 si.allocation[i][0] = getBitsUint8 (step);

  2044.             }

  2045. 

  2046.             for (int i = 0; i < sblimit; ++i)

  2047.                 scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;

  2048.         }

  2049. 

  2050.         for (int i = 0; i < sblimit; ++i)

  2051.         {

  2052.             for (int ch = 0; ch < frame.numChannels; ++ch)

  2053.             {

  2054.                 uint8 s0 = 0, s1 = 0, s2 = 0;

  2055. 

  2056.                 if (si.allocation[i][ch])

  2057.                 {

  2058.                     switch (scfsi[i][ch])

  2059.                     {

  2060.                         case 0:

  2061.                             s0 = getBitsUint8 (6);

  2062.                             s1 = getBitsUint8 (6);

  2063.                             s2 = getBitsUint8 (6);

  2064.                             break;

  2065.                         case 1:

  2066.                             s1 = s0 = getBitsUint8 (6);

  2067.                             s2 = getBitsUint8 (6);

  2068.                             break;

  2069.                         case 2:

  2070.                             s2 = s1 = s0 = getBitsUint8 (6);

  2071.                             break;

  2072.                         case 3:

  2073.                             s0 = getBitsUint8 (6);

  2074.                             s2 = s1 = getBitsUint8 (6);

  2075.                             break;

  2076.                         default:

  2077.                             break;

  2078.                     }

  2079.                 }

  2080. 

  2081.                 si.scaleFactor[i][ch][0] = s0;

  2082.                 si.scaleFactor[i][ch][1] = s1;

  2083.                 si.scaleFactor[i][ch][2] = s2;

  2084.             }

  2085.         }

  2086.     }

  2087. 

  2088.     void layer2Step2 (SideInfoLayer2& si, const int gr, float fraction[2][4][32]) noexcept

  2089.     {

  2090.         auto* allocTable = frame.allocationTable;

  2091.         auto sblimit = frame.layer2SubBandLimit;

  2092.         const auto jsbound = (frame.mode == 1 ? jmin ((frame.modeExt << 2) + 4, sblimit) : sblimit);

  2093. 

  2094.         for (int i = 0; i < jsbound; ++i)

  2095.         {

  2096.             auto step = allocTable->bits;

  2097. 

  2098.             for (int ch = 0; ch < frame.numChannels; ++ch)

  2099.             {

  2100.                 if (auto ba = si.allocation[i][ch])

  2101.                 {

  2102.                     auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);

  2103.                     auto* alloc2 = allocTable + ba;

  2104.                     auto k = jmin ((int16) 16, alloc2->bits);

  2105.                     auto d1 = alloc2->d;

  2106. 

  2107.                     if (d1 < 0)

  2108.                     {

  2109.                         const double cm = constants.muls[k][x1];

  2110.                         fraction[ch][0][i] = (float) (((int) getBits (k) + d1) * cm);

  2111.                         fraction[ch][1][i] = (float) (((int) getBits (k) + d1) * cm);

  2112.                         fraction[ch][2][i] = (float) (((int) getBits (k) + d1) * cm);

  2113.                     }

  2114.                     else

  2115.                     {

  2116.                         auto* tab = constants.getGroupTable (d1, getBits (k));

  2117.                         fraction[ch][0][i] = (float) constants.muls[tab[0]][x1];

  2118.                         fraction[ch][1][i] = (float) constants.muls[tab[1]][x1];

  2119.                         fraction[ch][2][i] = (float) constants.muls[tab[2]][x1];

  2120.                     }

  2121.                 }

  2122.                 else

  2123.                 {

  2124.                     fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;

  2125.                 }

  2126.             }

  2127. 

  2128.             allocTable += (static_cast<intptr_t> (1) << step);

  2129.         }

  2130. 

  2131.         for (int i = jsbound; i < frame.layer2SubBandLimit; ++i)

  2132.         {

  2133.             auto step = allocTable->bits;

  2134.             auto ba = si.allocation[i][0];

  2135. 

  2136.             if (ba != 0)

  2137.             {

  2138.                 auto* alloc2 = allocTable + ba;

  2139.                 int16 k = alloc2->bits;

  2140.                 int16 d1 = alloc2->d;

  2141.                 k = (k <= 16) ? k : 16;

  2142. 

  2143.                 if (d1 < 0)

  2144.                 {

  2145.                     auto v0 = (int) getBits (k);

  2146.                     auto v1 = (int) getBits (k);

  2147.                     auto v2 = (int) getBits (k);

  2148. 

  2149.                     for (int ch = 0; ch < frame.numChannels; ++ch)

  2150.                     {

  2151.                         auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);

  2152.                         const double cm = constants.muls[k][x1];

  2153.                         fraction[ch][0][i] = (float) ((v0 + d1) * cm);

  2154.                         fraction[ch][1][i] = (float) ((v1 + d1) * cm);

  2155.                         fraction[ch][2][i] = (float) ((v2 + d1) * cm);

  2156.                     }

  2157.                 }

  2158.                 else

  2159.                 {

  2160.                     auto* tab = constants.getGroupTable (d1, getBits (k));

  2161.                     auto k0 = tab[0];

  2162.                     auto k1 = tab[1];

  2163.                     auto k2 = tab[2];

  2164. 

  2165.                     for (int ch = 0; ch < frame.numChannels; ++ch)

  2166.                     {

  2167.                         auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);

  2168.                         fraction[ch][0][i] = (float) constants.muls[k0][x1];

  2169.                         fraction[ch][1][i] = (float) constants.muls[k1][x1];

  2170.                         fraction[ch][2][i] = (float) constants.muls[k2][x1];

  2171.                     }

  2172.                 }

  2173.             }

  2174.             else

  2175.             {

  2176.                 fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] = 0;

  2177.                 fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0;

  2178.             }

  2179. 

  2180.             allocTable += (static_cast<intptr_t> (1) << step);

  2181.         }

  2182. 

  2183.         for (int ch = 0; ch < frame.numChannels; ++ch)

  2184.             for (int i = frame.layer2SubBandLimit; i < 32; ++i)

  2185.                 fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;

  2186.     }

  2187. 

  2188.     void getLayer3SideInfo1 (const int stereo, const bool msStereo, const int sampleRate, const int single) noexcept

  2189.     {

  2190.         const int powdiff = (single == 3) ? 4 : 0;

  2191.         sideinfo.mainDataStart = getBits (9);

  2192.         sideinfo.privateBits = getBitsUnchecked (stereo == 1 ? 5 : 3);

  2193. 

  2194.         for (int ch = 0; ch < stereo; ++ch)

  2195.         {

  2196.             sideinfo.ch[ch].gr[0].scfsi = -1;

  2197.             sideinfo.ch[ch].gr[1].scfsi = (int) getBitsUnchecked (4);

  2198.         }

  2199. 

  2200.         for (int gr = 0; gr < 2; ++gr)

  2201.         {

  2202.             for (int ch = 0; ch < stereo; ++ch)

  2203.             {

  2204.                 auto& granule = sideinfo.ch[ch].gr[gr];

  2205. 

  2206.                 granule.part2_3Length = getBits (12);

  2207.                 granule.bigValues = jmin (288u, getBitsUnchecked (9));

  2208. 

  2209.                 const int qss = (int) getBitsUnchecked (8);

  2210.                 granule.pow2gain = constants.powToGains + 256 - qss + powdiff;

  2211. 

  2212.                 if (msStereo)

  2213.                     granule.pow2gain += 2;

  2214. 

  2215.                 granule.scaleFactorCompression = getBitsUnchecked (4);

  2216. 

  2217.                 if (getOneBit())

  2218.                 {

  2219.                     granule.blockType = getBitsUnchecked (2);

  2220.                     granule.mixedBlockFlag = getOneBit();

  2221.                     granule.tableSelect[0] = getBitsUnchecked (5);

  2222.                     granule.tableSelect[1] = getBitsUnchecked (5);

  2223.                     granule.tableSelect[2] = 0;

  2224. 

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

  2226.                     {

  2227.                         const uint32 sbg = (getBitsUnchecked (3) << 3);

  2228.                         granule.fullGain[i] = granule.pow2gain + sbg;

  2229.                     }

  2230. 

  2231.                     granule.region1Start = 36 >> 1;

  2232.                     granule.region2Start = 576 >> 1;

  2233.                 }

  2234.                 else

  2235.                 {

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

  2237.                         granule.tableSelect[i] = getBitsUnchecked (5);

  2238. 

  2239.                     const int r0c = (int) getBitsUnchecked (4);

  2240.                     const int r1c = (int) getBitsUnchecked (3);

  2241.                     const int region0index = jmin (22, r0c + 1);

  2242.                     const int region1index = jmin (22, r0c + 1 + r1c + 1);

  2243. 

  2244.                     granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);

  2245.                     granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);

  2246.                     granule.blockType = 0;

  2247.                     granule.mixedBlockFlag = 0;

  2248.                 }

  2249. 

  2250.                 granule.preflag = getOneBit();

  2251.                 granule.scaleFactorScale = getOneBit();

  2252.                 granule.count1TableSelect = getOneBit();

  2253.             }

  2254.         }

  2255.     }

  2256. 

  2257.     void getLayer3SideInfo2 (const int stereo, const bool msStereo, const int sampleRate, const int single) noexcept

  2258.     {

  2259.         const int powdiff = (single == 3) ? 4 : 0;

  2260.         sideinfo.mainDataStart = getBits (8);

  2261.         sideinfo.privateBits = stereo == 1 ? getOneBit() : getBitsUnchecked (2);

  2262. 

  2263.         for (int ch = 0; ch < stereo; ++ch)

  2264.         {

  2265.             auto& granule = sideinfo.ch[ch].gr[0];

  2266. 

  2267.             granule.part2_3Length = getBits (12);

  2268.             granule.bigValues = jmin (288u, getBitsUnchecked (9));

  2269. 

  2270.             const uint32 qss = getBitsUnchecked (8);

  2271.             granule.pow2gain = constants.powToGains + 256 - qss + powdiff;

  2272. 

  2273.             if (msStereo)

  2274.                 granule.pow2gain += 2;

  2275. 

  2276.             granule.scaleFactorCompression = getBits (9);

  2277. 

  2278.             if (getOneBit())

  2279.             {

  2280.                 granule.blockType = getBitsUnchecked (2);

  2281.                 granule.mixedBlockFlag = getOneBit();

  2282.                 granule.tableSelect[0] = getBitsUnchecked (5);

  2283.                 granule.tableSelect[1] = getBitsUnchecked (5);

  2284.                 granule.tableSelect[2] = 0;

  2285. 

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

  2287.                 {

  2288.                     const uint32 sbg = (getBitsUnchecked (3) << 3);

  2289.                     granule.fullGain[i] = granule.pow2gain + sbg;

  2290.                 }

  2291. 

  2292.                 if (granule.blockType == 0)

  2293.                 {}

  2294. 

  2295.                 if (granule.blockType == 2)

  2296.                     granule.region1Start = sampleRate == 8 ? 36 : (36 >> 1);

  2297.                 else

  2298.                     granule.region1Start = sampleRate == 8 ? (108 >> 1) : (54 >> 1);

  2299. 

  2300.                 granule.region2Start = 576 >> 1;

  2301.             }

  2302.             else

  2303.             {

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

  2305.                     granule.tableSelect[i] = getBitsUnchecked (5);

  2306. 

  2307.                 const int r0c = (int) getBitsUnchecked (4);

  2308.                 const int r1c = (int) getBitsUnchecked (3);

  2309.                 const int region0index = jmin (22, r0c + 1);

  2310.                 const int region1index = jmin (22, r0c + 1 + r1c + 1);

  2311. 

  2312.                 granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);

  2313.                 granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);

  2314.                 granule.blockType = 0;

  2315.                 granule.mixedBlockFlag = 0;

  2316.             }

  2317.             granule.scaleFactorScale = getOneBit();

  2318.             granule.count1TableSelect = getOneBit();

  2319.         }

  2320.     }

  2321. 

  2322.     int getLayer3ScaleFactors1 (int* scf, const Layer3SideInfo::Info& granule) noexcept

  2323.     {

  2324.         static const uint8 lengths[2][16] =

  2325.         {

  2326.             { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },

  2327.             { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 }

  2328.         };

  2329. 

  2330.         int numBits;

  2331.         const int num0 = lengths[0][granule.scaleFactorCompression];

  2332.         const int num1 = lengths[1][granule.scaleFactorCompression];

  2333. 

  2334.         if (granule.blockType == 2)

  2335.         {

  2336.             int i = 18;

  2337.             numBits = (num0 + num1) * 18;

  2338. 

  2339.             if (granule.mixedBlockFlag)

  2340.             {

  2341.                 for (int j = 8; --j >= 0;)  *scf++ = (int) getBitsUnchecked (num0);

  2342.                 numBits -= num0;

  2343.                 i = 9;

  2344.             }

  2345. 

  2346.             for (; --i >= 0;)       *scf++ = (int) getBitsUnchecked (num0);

  2347.             for (i = 18; --i >= 0;) *scf++ = (int) getBitsUnchecked (num1);

  2348. 

  2349.             *scf++ = 0;

  2350.             *scf++ = 0;

  2351.             *scf++ = 0;

  2352.         }

  2353.         else

  2354.         {

  2355.             const int scfsi = granule.scfsi;

  2356. 

  2357.             if (scfsi < 0)

  2358.             {

  2359.                 for (int i = 11; --i >= 0;)   *scf++ = (int) getBitsUnchecked (num0);

  2360.                 for (int j = 10; --j >= 0;)   *scf++ = (int) getBitsUnchecked (num1);

  2361.                 numBits = (num0 + num1) * 10 + num0;

  2362.             }

  2363.             else

  2364.             {

  2365.                 numBits = 0;

  2366.                 if ((scfsi & 8) == 0)

  2367.                 {

  2368.                     for (int i = 6; --i >= 0;)  *scf++ = (int) getBitsUnchecked (num0);

  2369.                     numBits += num0 * 6;

  2370.                 }

  2371.                 else

  2372.                     scf += 6;

  2373. 

  2374.                 if ((scfsi & 4) == 0)

  2375.                 {

  2376.                     for (int i = 5; --i >= 0;)  *scf++ = (int) getBitsUnchecked (num0);

  2377.                     numBits += num0 * 5;

  2378.                 }

  2379.                 else

  2380.                     scf += 5;

  2381. 

  2382.                 if ((scfsi & 2) == 0)

  2383.                 {

  2384.                     for (int i = 5; --i >= 0;)  *scf++ = (int) getBitsUnchecked (num1);

  2385.                     numBits += num1 * 5;

  2386.                 }

  2387.                 else

  2388.                     scf += 5;

  2389. 

  2390.                 if ((scfsi & 1) == 0)

  2391.                 {

  2392.                     for (int i = 5; --i >= 0;)  *scf++ = (int) getBitsUnchecked (num1);

  2393.                     numBits += num1 * 5;

  2394.                 }

  2395.                 else

  2396.                     scf += 5;

  2397.             }

  2398. 

  2399.             *scf = 0;

  2400.         }

  2401. 

  2402.         return numBits;

  2403.     }

  2404. 

  2405.     JUCE_BEGIN_IGNORE_WARNINGS_MSVC (6385)

  2406.     int getLayer3ScaleFactors2 (int* scf, Layer3SideInfo::Info& granule, const bool iStereo) noexcept

  2407.     {

  2408.         static const uint8 scaleTable[3][6][4] =

  2409.         {

  2410.             { { 6, 5, 5, 5 }, { 6, 5, 7, 3 },  { 11, 10, 0, 0 }, { 7, 7, 7, 0 },    { 6, 6, 6, 3 },  { 8, 8, 5, 0 } },

  2411.             { { 9, 9, 9, 9 }, { 9, 9, 12, 6 }, { 18, 18, 0, 0 }, { 12, 12, 12, 0 }, { 12, 9, 9, 6 }, { 15, 12, 9, 0 } },

  2412.             { { 6, 9, 9, 9 }, { 6, 9, 12, 6 }, { 15, 18, 0, 0 }, { 6, 15, 12, 0 },  { 6, 12, 9, 6 }, { 6, 18, 9, 0 } }

  2413.         };

  2414. 

  2415.         uint32 len = iStereo ? constants.iLength2[granule.scaleFactorCompression >> 1]

  2416.                              : constants.nLength2[granule.scaleFactorCompression];

  2417. 

  2418.         granule.preflag = (len >> 15) & 1;

  2419. 

  2420.         int n = 0;

  2421.         if (granule.blockType == 2)

  2422.         {

  2423.             ++n;

  2424.             if (granule.mixedBlockFlag)

  2425.                 ++n;

  2426.         }

  2427. 

  2428.         const uint8* const data = scaleTable[n][(len >> 12) & 7];

  2429.         int numBits = 0;

  2430. 

  2431.         for (int i = 0; i < 4; ++i)

  2432.         {

  2433.             int num = len & 7;

  2434.             len >>= 3;

  2435. 

  2436.             if (num)

  2437.             {

  2438.                 for (int j = 0; j < (int) (data[i]); ++j)

  2439.                     *scf++ = (int) getBitsUnchecked (num);

  2440. 

  2441.                 numBits += data[i] * num;

  2442.             }

  2443.             else

  2444.             {

  2445.                 for (int j = 0; j < (int) (data[i]); ++j)

  2446.                     *scf++ = 0;

  2447.             }

  2448.         }

  2449. 

  2450.         n = (n << 1) + 1;

  2451. 

  2452.         for (int i = 0; i < n; ++i)

  2453.             *scf++ = 0;

  2454. 

  2455.         return numBits;

  2456.     }

  2457.     JUCE_END_IGNORE_WARNINGS_MSVC

  2458. 

  2459.     bool layer3DequantizeSample (float xr[32][18], int* scf, Layer3SideInfo::Info& granule, int sampleRate, int part2bits) noexcept

  2460.     {

  2461.         const uint32 shift = 1 + granule.scaleFactorScale;

  2462.         auto* xrpnt = (float*) xr;

  2463.         auto part2remain = (int) granule.part2_3Length - part2bits;

  2464. 

  2465.         zeromem (xrpnt, (size_t) (&xr[32][0] - xrpnt) * sizeof (float));

  2466. 

  2467.         auto bv = (int) granule.bigValues;

  2468.         auto region1 = (int) granule.region1Start;

  2469.         auto region2 = (int) granule.region2Start;

  2470.         int l3 = ((576 >> 1) - bv) >> 1;

  2471.         int l[3];

  2472. 

  2473.         if (bv <= region1)

  2474.         {

  2475.             l[0] = bv;

  2476.             l[1] = 0;

  2477.             l[2] = 0;

  2478.         }

  2479.         else

  2480.         {

  2481.             l[0] = region1;

  2482.             if (bv <= region2)

  2483.             {

  2484.                 l[1] = bv - l[0];

  2485.                 l[2] = 0;

  2486.             }

  2487.             else

  2488.             {

  2489.                 l[1] = region2 - l[0];

  2490.                 l[2] = bv - region2;

  2491.             }

  2492.         }

  2493. 

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

  2495.             if (l[i] < 0)

  2496.                 l[i] = 0;

  2497. 

  2498.         if (granule.blockType == 2)

  2499.         {

  2500.             int max[4];

  2501.             int step = 0, lwin = 0, cb = 0, mc = 0;

  2502.             float v = 0;

  2503.             int* map;

  2504.             int* mapEnd;

  2505. 

  2506.             if (granule.mixedBlockFlag)

  2507.             {

  2508.                 max[3] = -1;

  2509.                 max[0] = max[1] = max[2] = 2;

  2510.                 map    = constants.map   [sampleRate][0];

  2511.                 mapEnd = constants.mapEnd[sampleRate][0];

  2512.             }

  2513.             else

  2514.             {

  2515.                 max[0] = max[1] = max[2] = max[3] = -1;

  2516.                 map    = constants.map   [sampleRate][1];

  2517.                 mapEnd = constants.mapEnd[sampleRate][1];

  2518.             }

  2519. 

  2520.             for (int i = 0; i < 2; ++i)

  2521.             {

  2522.                 auto* h = huffmanTables1 + granule.tableSelect[i];

  2523. 

  2524.                 for (int lp = l[i]; lp != 0; --lp, --mc)

  2525.                 {

  2526.                     int x, y;

  2527.                     if (mc == 0)

  2528.                     {

  2529.                         mc = *map++;

  2530.                         xrpnt = ((float*) xr) + (*map++);

  2531.                         lwin = *map++;

  2532.                         cb = *map++;

  2533. 

  2534.                         if (lwin == 3)

  2535.                         {

  2536.                             v = granule.pow2gain[ (*scf++) << shift];

  2537.                             step = 1;

  2538.                         }

  2539.                         else

  2540.                         {

  2541.                             v = granule.fullGain[lwin][ (*scf++) << shift];

  2542.                             step = 3;

  2543.                         }

  2544.                     }

  2545. 

  2546.                     auto* val = h->table;

  2547. 

  2548.                     while ((y = *val++) < 0)

  2549.                     {

  2550.                         if (getOneBit())

  2551.                             val -= y;

  2552. 

  2553.                         --part2remain;

  2554.                     }

  2555. 

  2556.                     x = y >> 4;

  2557.                     y &= 15;

  2558. 

  2559.                     if (x == 15)

  2560.                     {

  2561.                         max[lwin] = cb;

  2562.                         part2remain -= (int) (h->bits + 1);

  2563.                         x += (int) getBits ((int) h->bits);

  2564.                         *xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);

  2565.                     }

  2566.                     else if (x)

  2567.                     {

  2568.                         max[lwin] = cb;

  2569.                         *xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);

  2570.                         --part2remain;

  2571.                     }

  2572.                     else

  2573.                         *xrpnt = 0;

  2574. 

  2575.                     xrpnt += step;

  2576. 

  2577.                     if (y == 15)

  2578.                     {

  2579.                         max[lwin] = cb;

  2580.                         part2remain -= (int) (h->bits + 1);

  2581.                         y += (int) getBits ((int) h->bits);

  2582.                         *xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);

  2583.                     }

  2584.                     else if (y)

  2585.                     {

  2586.                         max[lwin] = cb;

  2587.                         *xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);

  2588.                         --part2remain;

  2589.                     }

  2590.                     else

  2591.                         *xrpnt = 0;

  2592. 

  2593.                     xrpnt += step;

  2594.                 }

  2595.             }

  2596. 

  2597.             for (; l3 && (part2remain > 0); --l3)

  2598.             {

  2599.                 auto* h = huffmanTables2 + granule.count1TableSelect;

  2600.                 auto* val = h->table;

  2601.                 int16 a;

  2602. 

  2603.                 while ((a = *val++) < 0)

  2604.                 {

  2605.                     if (part2remain <= 0)

  2606.                     {

  2607.                         a = 0;

  2608.                         break;

  2609.                     }

  2610. 

  2611.                     --part2remain;

  2612. 

  2613.                     if (getOneBit())

  2614.                         val -= a;

  2615.                 }

  2616. 

  2617.                 for (int i = 0; i < 4; ++i)

  2618.                 {

  2619.                     if ((i & 1) == 0)

  2620.                     {

  2621.                         if (mc == 0)

  2622.                         {

  2623.                             mc = *map++;

  2624.                             xrpnt = ((float*) xr) + (*map++);

  2625.                             lwin = *map++;

  2626.                             cb = *map++;

  2627. 

  2628.                             if (lwin == 3)

  2629.                             {

  2630.                                 v = granule.pow2gain[ (*scf++) << shift];

  2631.                                 step = 1;

  2632.                             }

  2633.                             else

  2634.                             {

  2635.                                 v = granule.fullGain[lwin][ (*scf++) << shift];

  2636.                                 step = 3;

  2637.                             }

  2638.                         }

  2639. 

  2640.                         --mc;

  2641.                     }

  2642. 

  2643.                     if ((a & (8 >> i)))

  2644.                     {

  2645.                         max[lwin] = cb;

  2646. 

  2647.                         if (part2remain == 0)

  2648.                             break;

  2649. 

  2650.                         --part2remain;

  2651.                         *xrpnt = getOneBit() ? -v : v;

  2652.                     }

  2653.                     else

  2654.                         *xrpnt = 0;

  2655. 

  2656.                     xrpnt += step;

  2657.                 }

  2658.             }

  2659. 

  2660.             while (map < mapEnd)

  2661.             {

  2662.                 if (mc == 0)

  2663.                 {

  2664.                     mc = *map++;

  2665.                     xrpnt = ((float*) xr) + *map++;

  2666.                     step = (*map++ == 3) ? 1 : 3;

  2667.                     ++map;

  2668.                 }

  2669. 

  2670.                 --mc;

  2671.                 *xrpnt = 0;  xrpnt += step;

  2672.                 *xrpnt = 0;  xrpnt += step;

  2673.             }

  2674. 

  2675.             granule.maxBand[0] = (uint32) (max[0] + 1);

  2676.             granule.maxBand[1] = (uint32) (max[1] + 1);

  2677.             granule.maxBand[2] = (uint32) (max[2] + 1);

  2678.             granule.maxBandl   = (uint32) (max[3] + 1);

  2679. 

  2680.             const int rmax = jmax (max[0], max[1], max[3]) + 1;

  2681.             granule.maxb = rmax ? (uint32) constants.shortLimit[sampleRate][rmax]

  2682.                                 : (uint32) constants.longLimit[sampleRate][max[3] + 1];

  2683.         }

  2684.         else

  2685.         {

  2686.             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 };

  2687.             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 };

  2688. 

  2689.             auto* pretab = (const int*) (granule.preflag ? pretab1 : pretab2);

  2690.             int max = -1, cb = 0, mc = 0;

  2691.             auto* map = constants.map[sampleRate][2];

  2692.             float v = 0;

  2693. 

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

  2695.             {

  2696.                 auto* h = huffmanTables1 + granule.tableSelect[i];

  2697. 

  2698.                 for (int lp = l[i]; lp != 0; --lp, --mc)

  2699.                 {

  2700.                     if (mc == 0)

  2701.                     {

  2702.                         mc = *map++;

  2703.                         v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];

  2704.                         cb = *map++;

  2705.                     }

  2706. 

  2707.                     auto* val = h->table;

  2708.                     int y;

  2709. 

  2710.                     while ((y = *val++) < 0)

  2711.                     {

  2712.                         if (getOneBit()) val -= y;

  2713.                         --part2remain;

  2714.                     }

  2715. 

  2716.                     int x = y >> 4;

  2717.                     y &= 15;

  2718. 

  2719.                     if (x == 15)

  2720.                     {

  2721.                         max = cb;

  2722.                         part2remain -= (int) (h->bits + 1);

  2723.                         x += (int) getBits ((int) h->bits);

  2724.                         *xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);

  2725.                     }

  2726.                     else if (x)

  2727.                     {

  2728.                         max = cb;

  2729.                         *xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);

  2730.                         --part2remain;

  2731.                     }

  2732.                     else

  2733.                         *xrpnt++ = 0;

  2734. 

  2735.                     if (y == 15)

  2736.                     {

  2737.                         max = cb;

  2738.                         part2remain -= (int) (h->bits + 1);

  2739.                         y += (int) getBits ((int) h->bits);

  2740.                         *xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);

  2741.                     }

  2742.                     else if (y)

  2743.                     {

  2744.                         max = cb;

  2745.                         *xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);

  2746.                         --part2remain;

  2747.                     }

  2748.                     else

  2749.                         *xrpnt++ = 0;

  2750.                 }

  2751.             }

  2752. 

  2753.             for (; l3 && part2remain > 0; --l3)

  2754.             {

  2755.                 auto* h = huffmanTables2 + granule.count1TableSelect;

  2756.                 auto* values = h->table;

  2757.                 int16 a;

  2758. 

  2759.                 while ((a = *values++) < 0)

  2760.                 {

  2761.                     if (part2remain <= 0)

  2762.                     {

  2763.                         a = 0;

  2764.                         break;

  2765.                     }

  2766. 

  2767.                     --part2remain;

  2768. 

  2769.                     if (getOneBit())

  2770.                         values -= a;

  2771.                 }

  2772. 

  2773.                 for (int i = 0; i < 4; ++i)

  2774.                 {

  2775.                     if ((i & 1) == 0)

  2776.                     {

  2777.                         if (mc == 0)

  2778.                         {

  2779.                             mc = *map++;

  2780.                             cb = *map++;

  2781.                             v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];

  2782.                         }

  2783.                         --mc;

  2784.                     }

  2785. 

  2786.                     if ((a & (0x8 >> i)))

  2787.                     {

  2788.                         max = cb;

  2789. 

  2790.                         if (part2remain <= 0)

  2791.                             break;

  2792. 

  2793.                         --part2remain;

  2794.                         *xrpnt++ = getOneBit() ? -v : v;

  2795.                     }

  2796.                     else

  2797.                         *xrpnt++ = 0;

  2798.                 }

  2799.             }

  2800. 

  2801.             zeromem (xrpnt, (size_t) (&xr[32][0] - xrpnt) * sizeof (float));

  2802. 

  2803.             granule.maxBandl = (uint32) (max + 1);

  2804.             granule.maxb = (uint32) constants.longLimit[sampleRate][granule.maxBandl];

  2805.         }

  2806. 

  2807.         while (part2remain > 16)

  2808.         {

  2809.             getBits (16);

  2810.             part2remain -= 16;

  2811.         }

  2812. 

  2813.         if (part2remain > 0)

  2814.             getBits (part2remain);

  2815.         else if (part2remain < 0)

  2816.             return true;

  2817. 

  2818.         return false;

  2819.     }

  2820. 

  2821.     void layer3Hybrid (float fsIn[32][18], float tsOut[18][32], int ch, const Layer3SideInfo::Info& granule) noexcept

  2822.     {

  2823.         auto* ts = (float*) tsOut;

  2824.         float* rawout1, *rawout2;

  2825.         int sb = 0;

  2826. 

  2827.         {

  2828.             int b = hybridBlockIndex[ch];

  2829.             rawout1 = hybridBlock[b][ch];

  2830.             b = 1 - b;

  2831.             rawout2 = hybridBlock[b][ch];

  2832.             hybridBlockIndex[ch] = b;

  2833.         }

  2834. 

  2835.         if (granule.mixedBlockFlag)

  2836.         {

  2837.             sb = 2;

  2838.             DCT::dct36 (fsIn[0], rawout1, rawout2, constants.win[0], ts);

  2839.             DCT::dct36 (fsIn[1], rawout1 + 18, rawout2 + 18, constants.win1[0], ts + 1);

  2840.             rawout1 += 36;

  2841.             rawout2 += 36;

  2842.             ts += 2;

  2843.         }

  2844. 

  2845.         auto bt = granule.blockType;

  2846. 

  2847.         if (bt == 2)

  2848.         {

  2849.             for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)

  2850.             {

  2851.                 DCT::dct12 (fsIn[sb], rawout1, rawout2, constants.win[2], ts);

  2852.                 DCT::dct12 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[2], ts + 1);

  2853.             }

  2854.         }

  2855.         else

  2856.         {

  2857.             for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)

  2858.             {

  2859.                 DCT::dct36 (fsIn[sb], rawout1, rawout2, constants.win[bt], ts);

  2860.                 DCT::dct36 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[bt], ts + 1);

  2861.             }

  2862.         }

  2863. 

  2864.         for (; sb < 32; ++sb, ++ts)

  2865.         {

  2866.             for (int i = 0; i < 18; ++i)

  2867.             {

  2868.                 ts[i * 32] = *rawout1++;

  2869.                 *rawout2++ = 0;

  2870.             }

  2871.         }

  2872.     }

  2873. 

  2874.     void synthesiseStereo (const float* bandPtr0, const float* bandPtr1, float* out0, float* out1, int& samplesDone) noexcept

  2875.     {

  2876.         auto dummy = samplesDone;

  2877.         synthesise (bandPtr0, 0, out0, dummy);

  2878.         synthesise (bandPtr1, 1, out1, samplesDone);

  2879.     }

  2880. 

  2881.     void synthesise (const float* bandPtr, int channel, float* out, int& samplesDone)

  2882.     {

  2883.         out += samplesDone;

  2884.         const int bo = channel == 0 ? ((synthBo - 1) & 15) : synthBo;

  2885.         float (*buf)[0x110] = synthBuffers[channel];

  2886.         float* b0;

  2887.         auto bo1 = bo;

  2888. 

  2889.         if (bo & 1)

  2890.         {

  2891.             b0 = buf[0];

  2892.             DCT::dct64 (buf[1] + ((bo + 1) & 15), buf[0] + bo, bandPtr);

  2893.         }

  2894.         else

  2895.         {

  2896.             ++bo1;

  2897.             b0 = buf[1];

  2898.             DCT::dct64 (buf[0] + bo, buf[1] + bo1, bandPtr);

  2899.         }

  2900. 

  2901.         synthBo = bo;

  2902.         const float* window = constants.decodeWin + 16 - bo1;

  2903. 

  2904.         for (int j = 16; j != 0; --j, b0 += 16, window += 32)

  2905.         {

  2906.             auto sum = window[0] * b0[0];  sum -= window[1] * b0[1];

  2907.             sum += window[2]  * b0[2];   sum -= window[3]  * b0[3];

  2908.             sum += window[4]  * b0[4];   sum -= window[5]  * b0[5];

  2909.             sum += window[6]  * b0[6];   sum -= window[7]  * b0[7];

  2910.             sum += window[8]  * b0[8];   sum -= window[9]  * b0[9];

  2911.             sum += window[10] * b0[10];  sum -= window[11] * b0[11];

  2912.             sum += window[12] * b0[12];  sum -= window[13] * b0[13];

  2913.             sum += window[14] * b0[14];  sum -= window[15] * b0[15];

  2914.             *out++ = sum;

  2915.         }

  2916. 

  2917.         {

  2918.             auto sum = window[0] * b0[0];   sum += window[2] * b0[2];

  2919.             sum += window[4]  * b0[4];   sum += window[6]  * b0[6];

  2920.             sum += window[8]  * b0[8];   sum += window[10] * b0[10];

  2921.             sum += window[12] * b0[12];  sum += window[14] * b0[14];

  2922.             *out++ = sum;

  2923.             b0 -= 16; window -= 32;

  2924.             window += (ptrdiff_t) bo1 << 1;

  2925.         }

  2926. 

  2927.         for (int j = 15; j != 0; --j, b0 -= 16, window -= 32)

  2928.         {

  2929.             auto sum = -window[-1] * b0[0];  sum -= window[-2] * b0[1];

  2930.             sum -= window[-3]  * b0[2];   sum -= window[-4]  * b0[3];

  2931.             sum -= window[-5]  * b0[4];   sum -= window[-6]  * b0[5];

  2932.             sum -= window[-7]  * b0[6];   sum -= window[-8]  * b0[7];

  2933.             sum -= window[-9]  * b0[8];   sum -= window[-10] * b0[9];

  2934.             sum -= window[-11] * b0[10];  sum -= window[-12] * b0[11];

  2935.             sum -= window[-13] * b0[12];  sum -= window[-14] * b0[13];

  2936.             sum -= window[-15] * b0[14];  sum -= window[0]   * b0[15];

  2937.             *out++ = sum;

  2938.         }

  2939. 

  2940.         samplesDone += 32;

  2941.     }

  2942. 

  2943.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Stream)

  2944. };

  2945. 

  2946. //==============================================================================

  2947. static const char* const mp3FormatName = "MP3 file";

  2948. 

  2949. //==============================================================================

  2950. class MP3Reader : public AudioFormatReader

  2951. {

  2952. public:

  2953.     MP3Reader (InputStream* const in)

  2954.         : AudioFormatReader (in, mp3FormatName),

  2955.           stream (*in), currentPosition (0),

  2956.           decodedStart (0), decodedEnd (0)

  2957.     {

  2958.         skipID3();

  2959.         const int64 streamPos = stream.stream.getPosition();

  2960. 

  2961.         if (readNextBlock())

  2962.         {

  2963.             bitsPerSample = 32;

  2964.             usesFloatingPointData = true;

  2965.             sampleRate = stream.frame.getFrequency();

  2966.             numChannels = (unsigned int) stream.frame.numChannels;

  2967.             lengthInSamples = findLength (streamPos);

  2968.         }

  2969.     }

  2970. 

  2971.     bool readSamples (int** destSamples, int numDestChannels, int startOffsetInDestBuffer,

  2972.                       int64 startSampleInFile, int numSamples) override

  2973.     {

  2974.         if (destSamples == nullptr)

  2975.         {

  2976.             jassertfalse;

  2977.             return false;

  2978.         }

  2979. 

  2980.         if (currentPosition != startSampleInFile)

  2981.         {

  2982.             if (! stream.seek ((int) (startSampleInFile / 1152 - 1)))

  2983.             {

  2984.                 currentPosition = -1;

  2985.                 createEmptyDecodedData();

  2986.             }

  2987.             else

  2988.             {

  2989.                 decodedStart = decodedEnd = 0;

  2990.                 const int64 streamPos = stream.currentFrameIndex * 1152;

  2991.                 int toSkip = (int) (startSampleInFile - streamPos);

  2992.                 jassert (toSkip >= 0);

  2993. 

  2994.                 while (toSkip > 0)

  2995.                 {

  2996.                     if (! readNextBlock())

  2997.                     {

  2998.                         createEmptyDecodedData();

  2999.                         break;

  3000.                     }

  3001. 

  3002.                     const int numReady = decodedEnd - decodedStart;

  3003. 

  3004.                     if (numReady > toSkip)

  3005.                     {

  3006.                         decodedStart += toSkip;

  3007.                         break;

  3008.                     }

  3009. 

  3010.                     toSkip -= numReady;

  3011.                 }

  3012. 

  3013.                 currentPosition = startSampleInFile;

  3014.             }

  3015.         }

  3016. 

  3017.         while (numSamples > 0)

  3018.         {

  3019.             if (decodedEnd <= decodedStart && ! readNextBlock())

  3020.             {

  3021.                 for (int i = numDestChannels; --i >= 0;)

  3022.                     if (destSamples[i] != nullptr)

  3023.                         zeromem (destSamples[i] + startOffsetInDestBuffer, (size_t) numSamples * sizeof (float));

  3024. 

  3025.                 return false;

  3026.             }

  3027. 

  3028.             const int numToCopy = jmin (decodedEnd - decodedStart, numSamples);

  3029.             float* const* const dst = reinterpret_cast<float**> (destSamples);

  3030.             memcpy (dst[0] + startOffsetInDestBuffer, decoded0 + decodedStart, (size_t) numToCopy * sizeof (float));

  3031. 

  3032.             if (numDestChannels > 1 && dst[1] != nullptr)

  3033.                 memcpy (dst[1] + startOffsetInDestBuffer, (numChannels < 2 ? decoded0 : decoded1) + decodedStart, (size_t) numToCopy * sizeof (float));

  3034. 

  3035.             startOffsetInDestBuffer += numToCopy;

  3036.             decodedStart += numToCopy;

  3037.             currentPosition += numToCopy;

  3038.             numSamples -= numToCopy;

  3039.         }

  3040. 

  3041.         return true;

  3042.     }

  3043. 

  3044. private:

  3045.     MP3Stream stream;

  3046.     int64 currentPosition;

  3047.     enum { decodedDataSize = 1152 };

  3048.     float decoded0[decodedDataSize], decoded1[decodedDataSize];

  3049.     int decodedStart, decodedEnd;

  3050. 

  3051.     void createEmptyDecodedData() noexcept

  3052.     {

  3053.         zeromem (decoded0, sizeof (decoded0));

  3054.         zeromem (decoded1, sizeof (decoded1));

  3055.         decodedStart = 0;

  3056.         decodedEnd = decodedDataSize;

  3057.     }

  3058. 

  3059.     bool readNextBlock()

  3060.     {

  3061.         for (int attempts = 10; --attempts >= 0;)

  3062.         {

  3063.             int samplesDone = 0;

  3064.             const int result = stream.decodeNextBlock (decoded0, decoded1, samplesDone);

  3065. 

  3066.             if (result > 0 && stream.stream.isExhausted())

  3067.             {

  3068.                 createEmptyDecodedData();

  3069.                 return true;

  3070.             }

  3071. 

  3072.             if (result <= 0)

  3073.             {

  3074.                 decodedStart = 0;

  3075.                 decodedEnd = samplesDone;

  3076.                 return result == 0;

  3077.             }

  3078.         }

  3079. 

  3080.         return false;

  3081.     }

  3082. 

  3083.     void skipID3()

  3084.     {

  3085.         const int64 originalPosition = stream.stream.getPosition();

  3086.         const uint32 firstWord = (uint32) stream.stream.readInt();

  3087. 

  3088.         if ((firstWord & 0xffffff) == 0x334449)

  3089.         {

  3090.             uint8 buffer[6];

  3091. 

  3092.             if (stream.stream.read (buffer, 6) == 6

  3093.                  && buffer[0] != 0xff

  3094.                  && ((buffer[2] | buffer[3] | buffer[4] | buffer[5]) & 0x80) == 0)

  3095.             {

  3096.                 const uint32 length = (((uint32) buffer[2]) << 21)

  3097.                                     | (((uint32) buffer[3]) << 14)

  3098.                                     | (((uint32) buffer[4]) << 7)

  3099.                                     |  ((uint32) buffer[5]);

  3100. 

  3101.                 stream.stream.skipNextBytes (length);

  3102.                 return;

  3103.             }

  3104.         }

  3105. 

  3106.         stream.stream.setPosition (originalPosition);

  3107.     }

  3108. 

  3109.     int64 findLength (int64 streamStartPos)

  3110.     {

  3111.         int64 numFrames = stream.numFrames;

  3112. 

  3113.         if (numFrames <= 0)

  3114.         {

  3115.             const int64 streamSize = stream.stream.getTotalLength();

  3116. 

  3117.             if (streamSize > 0)

  3118.             {

  3119.                 const int bytesPerFrame = stream.frame.frameSize + 4;

  3120. 

  3121.                 if (bytesPerFrame == 417 || bytesPerFrame == 418)

  3122.                     numFrames = roundToInt ((double) (streamSize - streamStartPos) / 417.95918); // more accurate for 128k

  3123.                 else

  3124.                     numFrames = (streamSize - streamStartPos) / bytesPerFrame;

  3125.             }

  3126.         }

  3127. 

  3128.         return numFrames * 1152;

  3129.     }

  3130. 

  3131.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Reader)

  3132. };

  3133. 

  3134. }

  3135. 

  3136. //==============================================================================

  3137. MP3AudioFormat::MP3AudioFormat()  : AudioFormat (MP3Decoder::mp3FormatName, ".mp3") {}

  3138. MP3AudioFormat::~MP3AudioFormat() {}

  3139. 

  3140. Array<int> MP3AudioFormat::getPossibleSampleRates() { return {}; }

  3141. Array<int> MP3AudioFormat::getPossibleBitDepths()   { return {}; }

  3142. bool MP3AudioFormat::canDoStereo()                  { return true; }

  3143. bool MP3AudioFormat::canDoMono()                    { return true; }

  3144. bool MP3AudioFormat::isCompressed()                 { return true; }

  3145. StringArray MP3AudioFormat::getQualityOptions()     { return {}; }

  3146. 

  3147. AudioFormatReader* MP3AudioFormat::createReaderFor (InputStream* sourceStream, const bool deleteStreamIfOpeningFails)

  3148. {

  3149.     std::unique_ptr<MP3Decoder::MP3Reader> r (new MP3Decoder::MP3Reader (sourceStream));

  3150. 

  3151.     if (r->lengthInSamples > 0)

  3152.         return r.release();

  3153. 

  3154.     if (! deleteStreamIfOpeningFails)

  3155.         r->input = nullptr;

  3156. 

  3157.     return nullptr;

  3158. }

  3159. 

  3160. AudioFormatWriter* MP3AudioFormat::createWriterFor (OutputStream*, double /*sampleRateToUse*/,

  3161.                                                     unsigned int /*numberOfChannels*/, int /*bitsPerSample*/,

  3162.                                                     const StringPairArray& /*metadataValues*/, int /*qualityOptionIndex*/)

  3163. {

  3164.     jassertfalse; // not yet implemented!

  3165.     return nullptr;

  3166. }

  3167. 

  3168. #endif

  3169. 

  3170. } // namespace juce