2018-06-17 20:34:53 +08:00
|
|
|
/*
|
|
|
|
|
==============================================================================
|
|
|
|
|
|
|
|
|
|
This file is part of the JUCE library.
|
|
|
|
|
Copyright (c) 2017 - ROLI Ltd.
|
|
|
|
|
|
|
|
|
|
JUCE is an open source library subject to commercial or open-source
|
|
|
|
|
licensing.
|
|
|
|
|
|
|
|
|
|
By using JUCE, you agree to the terms of both the JUCE 5 End-User License
|
|
|
|
|
Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
|
|
|
|
|
27th April 2017).
|
|
|
|
|
|
|
|
|
|
End User License Agreement: www.juce.com/juce-5-licence
|
|
|
|
|
Privacy Policy: www.juce.com/juce-5-privacy-policy
|
|
|
|
|
|
|
|
|
|
Or: You may also use this code under the terms of the GPL v3 (see
|
|
|
|
|
www.gnu.org/licenses).
|
|
|
|
|
|
|
|
|
|
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
|
|
|
|
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
|
|
|
|
DISCLAIMED.
|
|
|
|
|
|
|
|
|
|
==============================================================================
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
namespace juce
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
IMPORTANT DISCLAIMER: By choosing to enable the JUCE_USE_MP3AUDIOFORMAT flag and
|
|
|
|
|
to compile this MP3 code into your software, you do so AT YOUR OWN RISK! By doing so,
|
|
|
|
|
you are agreeing that ROLI Ltd. is in no way responsible for any patent, copyright,
|
|
|
|
|
or other legal issues that you may suffer as a result.
|
|
|
|
|
|
|
|
|
|
The code in juce_MP3AudioFormat.cpp is NOT guaranteed to be free from infringements of 3rd-party
|
|
|
|
|
intellectual property. If you wish to use it, please seek your own independent advice about the
|
|
|
|
|
legality of doing so. If you are not willing to accept full responsibility for the consequences
|
|
|
|
|
of using this code, then do not enable the JUCE_USE_MP3AUDIOFORMAT setting.
|
|
|
|
|
*/
|
|
|
|
|
#if JUCE_USE_MP3AUDIOFORMAT
|
|
|
|
|
|
|
|
|
|
namespace MP3Decoder
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
struct AllocationTable { int16 bits, d; };
|
|
|
|
|
|
|
|
|
|
const struct AllocationTable allocTable0[] =
|
|
|
|
|
{
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const struct AllocationTable allocTable1[] =
|
|
|
|
|
{
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const struct AllocationTable allocTable2[] =
|
|
|
|
|
{
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const struct AllocationTable allocTable3[] =
|
|
|
|
|
{
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const struct AllocationTable allocTable4[] =
|
|
|
|
|
{
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{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},
|
|
|
|
|
{2, 0}, {5, 3}, {7, 5}, {10, 9}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct BandInfoStruct
|
|
|
|
|
{
|
|
|
|
|
int16 longIndex[23];
|
|
|
|
|
int16 longDiff[22];
|
|
|
|
|
int16 shortIndex[14];
|
|
|
|
|
int16 shortDiff[13];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const BandInfoStruct bandInfo[9] =
|
|
|
|
|
{
|
|
|
|
|
{ {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576},
|
|
|
|
|
{4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158},
|
|
|
|
|
{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},
|
|
|
|
|
{4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56} },
|
|
|
|
|
|
|
|
|
|
{ {0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576},
|
|
|
|
|
{4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192},
|
|
|
|
|
{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},
|
|
|
|
|
{4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66} },
|
|
|
|
|
|
|
|
|
|
{ {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576},
|
|
|
|
|
{4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26},
|
|
|
|
|
{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},
|
|
|
|
|
{4, 4, 4, 4, 6, 8, 12, 16, 20, 26, 34, 42, 12} },
|
|
|
|
|
|
|
|
|
|
{ {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
|
|
|
|
|
{6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },
|
|
|
|
|
{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},
|
|
|
|
|
{4, 4, 4, 6, 6, 8, 10, 14, 18, 26, 32, 42, 18 } },
|
|
|
|
|
|
|
|
|
|
{ {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576},
|
|
|
|
|
{6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36 },
|
|
|
|
|
{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},
|
|
|
|
|
{4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 32, 44, 12 } },
|
|
|
|
|
|
|
|
|
|
{ {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
|
|
|
|
|
{6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },
|
|
|
|
|
{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},
|
|
|
|
|
{4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18 } },
|
|
|
|
|
|
|
|
|
|
{ {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
|
|
|
|
|
{6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54},
|
|
|
|
|
{0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},
|
|
|
|
|
{4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18} },
|
|
|
|
|
|
|
|
|
|
{ {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
|
|
|
|
|
{6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54},
|
|
|
|
|
{0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},
|
|
|
|
|
{4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18} },
|
|
|
|
|
|
|
|
|
|
{ {0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576},
|
|
|
|
|
{12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2},
|
|
|
|
|
{0, 24, 48, 72, 108, 156, 216, 288, 372, 480, 486, 492, 498, 576},
|
|
|
|
|
{8, 8, 8, 12, 16, 20, 24, 28, 36, 2, 2, 2, 26} }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const double decodeWindow[] =
|
|
|
|
|
{
|
|
|
|
|
0.000000000, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000030518,
|
|
|
|
|
-0.000030518, -0.000030518, -0.000030518, -0.000045776, -0.000045776, -0.000061035, -0.000061035, -0.000076294,
|
|
|
|
|
-0.000076294, -0.000091553, -0.000106812, -0.000106812, -0.000122070, -0.000137329, -0.000152588, -0.000167847,
|
|
|
|
|
-0.000198364, -0.000213623, -0.000244141, -0.000259399, -0.000289917, -0.000320435, -0.000366211, -0.000396729,
|
|
|
|
|
-0.000442505, -0.000473022, -0.000534058, -0.000579834, -0.000625610, -0.000686646, -0.000747681, -0.000808716,
|
|
|
|
|
-0.000885010, -0.000961304, -0.001037598, -0.001113892, -0.001205444, -0.001296997, -0.001388550, -0.001480103,
|
|
|
|
|
-0.001586914, -0.001693726, -0.001785278, -0.001907349, -0.002014160, -0.002120972, -0.002243042, -0.002349854,
|
|
|
|
|
-0.002456665, -0.002578735, -0.002685547, -0.002792358, -0.002899170, -0.002990723, -0.003082275, -0.003173828,
|
|
|
|
|
-0.003250122, -0.003326416, -0.003387451, -0.003433228, -0.003463745, -0.003479004, -0.003479004, -0.003463745,
|
|
|
|
|
-0.003417969, -0.003372192, -0.003280640, -0.003173828, -0.003051758, -0.002883911, -0.002700806, -0.002487183,
|
|
|
|
|
-0.002227783, -0.001937866, -0.001617432, -0.001266479, -0.000869751, -0.000442505, 0.000030518, 0.000549316,
|
|
|
|
|
0.001098633, 0.001693726, 0.002334595, 0.003005981, 0.003723145, 0.004486084, 0.005294800, 0.006118774,
|
|
|
|
|
0.007003784, 0.007919312, 0.008865356, 0.009841919, 0.010848999, 0.011886597, 0.012939453, 0.014022827,
|
|
|
|
|
0.015121460, 0.016235352, 0.017349243, 0.018463135, 0.019577026, 0.020690918, 0.021789551, 0.022857666,
|
|
|
|
|
0.023910522, 0.024932861, 0.025909424, 0.026840210, 0.027725220, 0.028533936, 0.029281616, 0.029937744,
|
|
|
|
|
0.030532837, 0.031005859, 0.031387329, 0.031661987, 0.031814575, 0.031845093, 0.031738281, 0.031478882,
|
|
|
|
|
0.031082153, 0.030517578, 0.029785156, 0.028884888, 0.027801514, 0.026535034, 0.025085449, 0.023422241,
|
|
|
|
|
0.021575928, 0.019531250, 0.017257690, 0.014801025, 0.012115479, 0.009231567, 0.006134033, 0.002822876,
|
|
|
|
|
-0.000686646, -0.004394531, -0.008316040, -0.012420654, -0.016708374, -0.021179199, -0.025817871, -0.030609131,
|
|
|
|
|
-0.035552979, -0.040634155, -0.045837402, -0.051132202, -0.056533813, -0.061996460, -0.067520142, -0.073059082,
|
|
|
|
|
-0.078628540, -0.084182739, -0.089706421, -0.095169067, -0.100540161, -0.105819702, -0.110946655, -0.115921021,
|
|
|
|
|
-0.120697021, -0.125259399, -0.129562378, -0.133590698, -0.137298584, -0.140670776, -0.143676758, -0.146255493,
|
|
|
|
|
-0.148422241, -0.150115967, -0.151306152, -0.151962280, -0.152069092, -0.151596069, -0.150497437, -0.148773193,
|
|
|
|
|
-0.146362305, -0.143264771, -0.139450073, -0.134887695, -0.129577637, -0.123474121, -0.116577148, -0.108856201,
|
|
|
|
|
-0.100311279, -0.090927124, -0.080688477, -0.069595337, -0.057617187, -0.044784546, -0.031082153, -0.016510010,
|
|
|
|
|
-0.001068115, 0.015228271, 0.032379150, 0.050354004, 0.069168091, 0.088775635, 0.109161377, 0.130310059,
|
|
|
|
|
0.152206421, 0.174789429, 0.198059082, 0.221984863, 0.246505737, 0.271591187, 0.297210693, 0.323318481,
|
|
|
|
|
0.349868774, 0.376800537, 0.404083252, 0.431655884, 0.459472656, 0.487472534, 0.515609741, 0.543823242,
|
|
|
|
|
0.572036743, 0.600219727, 0.628295898, 0.656219482, 0.683914185, 0.711318970, 0.738372803, 0.765029907,
|
|
|
|
|
0.791213989, 0.816864014, 0.841949463, 0.866363525, 0.890090942, 0.913055420, 0.935195923, 0.956481934,
|
|
|
|
|
0.976852417, 0.996246338, 1.014617920, 1.031936646, 1.048156738, 1.063217163, 1.077117920, 1.089782715,
|
|
|
|
|
1.101211548, 1.111373901, 1.120223999, 1.127746582, 1.133926392, 1.138763428, 1.142211914, 1.144287109,
|
|
|
|
|
1.144989014
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab0[] = { 0 };
|
|
|
|
|
const int16 huffmanTab1[] = { -5,-3,-1,17,1,16,0 };
|
|
|
|
|
const int16 huffmanTab2[] = { -15,-11,-9,-5,-3,-1,34,2,18,-1,33,32,17,-1,1,16,0 };
|
|
|
|
|
const int16 huffmanTab3[] = { -13,-11,-9,-5,-3,-1,34,2,18,-1,33,32,16,17,-1,1,0 };
|
|
|
|
|
const int16 huffmanTab5[] = { -29,-25,-23,-15,-7,-5,-3,-1,51,35,50,49,-3,-1,19,3,-1,48,34,-3,-1,18,33,-1,2,32,17,-1,1,16,0 };
|
|
|
|
|
const int16 huffmanTab6[] = { -25,-19,-13,-9,-5,-3,-1,51,3,35,-1,50,48,-1,19,49,-3,-1,34,2,18,-3,-1,33,32,1,-1,17,-1,16,0 };
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab7[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
-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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab8[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab9[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
-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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab10[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab11[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab12[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab13[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab15[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab16[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTab24[] =
|
|
|
|
|
{
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
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,
|
|
|
|
|
-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,
|
|
|
|
|
-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,
|
|
|
|
|
-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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct BitsToTableMap
|
|
|
|
|
{
|
|
|
|
|
uint32 bits;
|
|
|
|
|
const int16* table;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const BitsToTableMap huffmanTables1[] =
|
|
|
|
|
{
|
|
|
|
|
{ 0, huffmanTab0 }, { 0, huffmanTab1 }, { 0, huffmanTab2 }, { 0, huffmanTab3 },
|
|
|
|
|
{ 0, huffmanTab0 }, { 0, huffmanTab5 }, { 0, huffmanTab6 }, { 0, huffmanTab7 },
|
|
|
|
|
{ 0, huffmanTab8 }, { 0, huffmanTab9 }, { 0, huffmanTab10 }, { 0, huffmanTab11 },
|
|
|
|
|
{ 0, huffmanTab12 }, { 0, huffmanTab13 }, { 0, huffmanTab0 }, { 0, huffmanTab15 },
|
|
|
|
|
{ 1, huffmanTab16 }, { 2, huffmanTab16 }, { 3, huffmanTab16 }, { 4, huffmanTab16 },
|
|
|
|
|
{ 6, huffmanTab16 }, { 8, huffmanTab16 }, { 10, huffmanTab16 }, { 13, huffmanTab16 },
|
|
|
|
|
{ 4, huffmanTab24 }, { 5, huffmanTab24 }, { 6, huffmanTab24 }, { 7, huffmanTab24 },
|
|
|
|
|
{ 8, huffmanTab24 }, { 9, huffmanTab24 }, { 11, huffmanTab24 }, { 13, huffmanTab24 }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int16 huffmanTabC0[] = { -29,-21,-13,-7,-3,-1,11,15,-1,13,14,-3,-1,7,5,9,-3,-1,6,3,-1,10,12,-3,-1,2,1,-1,4,8,0 };
|
|
|
|
|
const int16 huffmanTabC1[] = { -15,-7,-3,-1,15,14,-1,13,12,-3,-1,11,10,-1,9,8,-7,-3,-1,7,6,-1,5,4,-3,-1,3,2,-1,1,0 };
|
|
|
|
|
|
|
|
|
|
const BitsToTableMap huffmanTables2[] = { { 0, huffmanTabC0 }, { 0, huffmanTabC1 } };
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
|
|
|
struct VBRTagData
|
|
|
|
|
{
|
|
|
|
|
bool read (const uint8* data) noexcept
|
|
|
|
|
{
|
|
|
|
|
flags = 0;
|
|
|
|
|
|
|
|
|
|
const int layer = (data[1] >> 1) & 3;
|
|
|
|
|
if (layer != 1)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
const int type = (data[1] >> 3) & 1;
|
|
|
|
|
const int sampleRateIndex = (data[2] >> 2) & 3;
|
|
|
|
|
const int mode = (data[3] >> 6) & 3;
|
|
|
|
|
|
|
|
|
|
static const short bitRates[3][16] =
|
|
|
|
|
{
|
|
|
|
|
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1 }, // MPEG2
|
|
|
|
|
{ 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1 }, // MPEG1
|
|
|
|
|
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, -1, -1, -1, -1, -1, -1, -1 }, // MPEG 2.5
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int bitrate = bitRates[type][((data[2] >> 4) & 15)];
|
|
|
|
|
|
|
|
|
|
const int sampleRates[3][4] =
|
|
|
|
|
{
|
|
|
|
|
{ 22050, 24000, 16000, -1 }, // MPEG2
|
|
|
|
|
{ 44100, 48000, 32000, -1 }, // MPEG1
|
|
|
|
|
{ 11025, 12000, 8000, -1 }, // MPEG2.5
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if ((data[1] >> 4) == 0xe)
|
|
|
|
|
sampleRate = sampleRates[2][sampleRateIndex];
|
|
|
|
|
else
|
|
|
|
|
sampleRate = sampleRates[type][sampleRateIndex];
|
|
|
|
|
|
|
|
|
|
data += type != 0 ? (mode != 3 ? (32 + 4) : (17 + 4))
|
|
|
|
|
: (mode != 3 ? (17 + 4) : (9 + 4));
|
|
|
|
|
|
|
|
|
|
if (! isVbrTag (data))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
data += 4;
|
|
|
|
|
flags = ByteOrder::bigEndianInt (data);
|
|
|
|
|
data += 4;
|
|
|
|
|
|
|
|
|
|
if (flags & 1)
|
|
|
|
|
{
|
|
|
|
|
frames = ByteOrder::bigEndianInt (data);
|
|
|
|
|
data += 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (flags & 2)
|
|
|
|
|
{
|
|
|
|
|
bytes = ByteOrder::bigEndianInt (data);
|
|
|
|
|
data += 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (flags & 4)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 100; ++i)
|
|
|
|
|
toc[i] = data[i];
|
|
|
|
|
|
|
|
|
|
data += 100;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vbrScale = -1;
|
|
|
|
|
|
|
|
|
|
if (flags & 8)
|
|
|
|
|
vbrScale = (int) ByteOrder::bigEndianInt (data);
|
|
|
|
|
|
|
|
|
|
headersize = ((type + 1) * 72000 * bitrate) / sampleRate;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8 toc[100];
|
|
|
|
|
int sampleRate, vbrScale, headersize;
|
|
|
|
|
unsigned int flags, frames, bytes;
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
static bool isVbrTag (const uint8* d) noexcept
|
|
|
|
|
{
|
|
|
|
|
return (d[0] == 'X' && d[1] == 'i' && d[2] == 'n' && d[3] == 'g')
|
|
|
|
|
|| (d[0] == 'I' && d[1] == 'n' && d[2] == 'f' && d[3] == 'o');
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
|
|
|
struct MP3Frame
|
|
|
|
|
{
|
|
|
|
|
MP3Frame()
|
|
|
|
|
{
|
|
|
|
|
zeromem (this, sizeof (MP3Frame));
|
|
|
|
|
single = -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void selectLayer2Table()
|
|
|
|
|
{
|
|
|
|
|
static const int translate[3][2][16] =
|
|
|
|
|
{
|
|
|
|
|
{ { 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 } },
|
|
|
|
|
{ { 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 } },
|
|
|
|
|
{ { 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 } }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const AllocationTable* const tables[] = { allocTable0, allocTable1, allocTable2, allocTable3, allocTable4 };
|
|
|
|
|
static const int8 limits[] = { 27, 30, 8, 12, 30 };
|
|
|
|
|
|
|
|
|
|
const int index = lsf ? 4 : translate[sampleRateIndex][2 - numChannels][bitrateIndex];
|
|
|
|
|
layer2SubBandLimit = limits[index];
|
|
|
|
|
allocationTable = tables[index];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int getFrequency() const noexcept
|
|
|
|
|
{
|
|
|
|
|
const int frequencies[] = { 44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000 };
|
|
|
|
|
return frequencies[sampleRateIndex];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void decodeHeader (const uint32 header)
|
|
|
|
|
{
|
|
|
|
|
jassert (((header >> 10) & 3) != 3);
|
|
|
|
|
|
|
|
|
|
mpeg25 = (header & (1 << 20)) == 0;
|
|
|
|
|
lsf = mpeg25 ? 1 : ((header & (1 << 19)) ? 0 : 1);
|
|
|
|
|
layer = 4 - ((header >> 17) & 3);
|
|
|
|
|
sampleRateIndex = mpeg25 ? (6 + ((header >> 10) & 3)) : ((int) ((header >> 10) & 3) + (lsf * 3));
|
|
|
|
|
crc16FollowsHeader = ((header >> 16) & 1) == 0;
|
|
|
|
|
bitrateIndex = (header >> 12) & 15;
|
|
|
|
|
padding = (header >> 9) & 1;
|
|
|
|
|
mode = (header >> 6) & 3;
|
|
|
|
|
modeExt = (header >> 4) & 3;
|
|
|
|
|
//extension = (header >> 8) & 1;
|
|
|
|
|
//copyright = (header >> 3) & 1;
|
|
|
|
|
//original = (header >> 2) & 1;
|
|
|
|
|
//emphasis = header & 3;
|
|
|
|
|
numChannels = (mode == 3) ? 1 : 2;
|
|
|
|
|
|
|
|
|
|
static const int frameSizes[2][3][16] =
|
|
|
|
|
{
|
|
|
|
|
{ { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },
|
|
|
|
|
{ 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 },
|
|
|
|
|
{ 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 } },
|
|
|
|
|
|
|
|
|
|
{ { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 },
|
|
|
|
|
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 },
|
|
|
|
|
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 } }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (bitrateIndex == 0)
|
|
|
|
|
{
|
|
|
|
|
jassertfalse; // This means the file is using "free format". Apparently very few decoders
|
|
|
|
|
// support this mode, and this one certainly doesn't handle it correctly!
|
|
|
|
|
frameSize = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
switch (layer)
|
|
|
|
|
{
|
|
|
|
|
case 1: frameSize = (((frameSizes[lsf][0][bitrateIndex] * 12000) / getFrequency() + padding) * 4) - 4; break;
|
|
|
|
|
case 2: frameSize = (frameSizes[lsf][1][bitrateIndex] * 144000) / getFrequency() + (padding - 4); break;
|
|
|
|
|
case 3: frameSize = (bitrateIndex == 0) ? 0 : ((frameSizes[lsf][2][bitrateIndex] * 144000) / (getFrequency() << lsf) + (padding - 4)); break;
|
|
|
|
|
default: break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int layer, frameSize, numChannels, single;
|
|
|
|
|
int lsf; // 0 = mpeg-1, 1 = mpeg-2/LSF
|
|
|
|
|
bool mpeg25; // true = mpeg-2.5, false = mpeg-1/2
|
|
|
|
|
bool crc16FollowsHeader;
|
|
|
|
|
int bitrateIndex, sampleRateIndex, padding;
|
|
|
|
|
int mode, modeExt, layer2SubBandLimit;
|
|
|
|
|
enum { downSampleLimit = 32 };
|
|
|
|
|
const AllocationTable* allocationTable;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
|
|
|
struct Constants
|
|
|
|
|
{
|
|
|
|
|
Constants()
|
|
|
|
|
{
|
|
|
|
|
cosTables[0] = cos64; cosTables[1] = cos32; cosTables[2] = cos16; cosTables[3] = cos8; cosTables[4] = cos4;
|
|
|
|
|
initDecodeTables();
|
|
|
|
|
initLayer2Tables();
|
|
|
|
|
initLayer3Tables();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const uint8* getGroupTable (const int16 d1, const uint32 index) const noexcept
|
|
|
|
|
{
|
|
|
|
|
switch (d1)
|
|
|
|
|
{
|
|
|
|
|
case 3: return &group3tab[3 * jmin (index, 3u * 3u * 3u)];
|
|
|
|
|
case 5: return &group5tab[3 * jmin (index, 5u * 5u * 5u)];
|
|
|
|
|
case 9: return &group9tab[3 * jmin (index, 9u * 9u * 9u)];
|
|
|
|
|
default: break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const uint8 dummy[] = { 0, 0, 0 };
|
|
|
|
|
return dummy;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
float muls[27][64];
|
|
|
|
|
float nToThe4Over3[8207];
|
|
|
|
|
float antiAliasingCa[8], antiAliasingCs[8];
|
|
|
|
|
float win[4][36];
|
|
|
|
|
float win1[4][36];
|
|
|
|
|
float powToGains[256 + 118 + 4];
|
|
|
|
|
int longLimit[9][23];
|
|
|
|
|
int shortLimit[9][14];
|
|
|
|
|
float tan1_1[16], tan2_1[16], tan1_2[16], tan2_2[16];
|
|
|
|
|
float pow1_1[2][16], pow2_1[2][16], pow1_2[2][16], pow2_2[2][16];
|
|
|
|
|
int* map[9][3];
|
|
|
|
|
int* mapEnd[9][3];
|
|
|
|
|
uint32 nLength2[512];
|
|
|
|
|
uint32 iLength2[256];
|
|
|
|
|
float decodeWin[512 + 32];
|
|
|
|
|
float* cosTables[5];
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
int mapbuf0[9][152];
|
|
|
|
|
int mapbuf1[9][156];
|
|
|
|
|
int mapbuf2[9][44];
|
|
|
|
|
float cos64[16], cos32[8], cos16[4], cos8[2], cos4[1];
|
|
|
|
|
uint8 group3tab[32 * 3];
|
|
|
|
|
uint8 group5tab[128 * 3];
|
|
|
|
|
uint8 group9tab[1024 * 3];
|
|
|
|
|
|
|
|
|
|
void initDecodeTables()
|
|
|
|
|
{
|
|
|
|
|
int i, j, scaleval = -1;
|
|
|
|
|
float* table = decodeWin;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 5; ++i)
|
|
|
|
|
{
|
|
|
|
|
int kr = 0x10 >> i;
|
|
|
|
|
int divv = 0x40 >> i;
|
|
|
|
|
float* costab = cosTables[i];
|
|
|
|
|
|
|
|
|
|
for (int k = 0; k < kr; ++k)
|
|
|
|
|
costab[k] = (float) (1.0 / (2.0 * std::cos (MathConstants<double>::pi * (k * 2 + 1) / divv)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0, j = 0; i < 256; ++i, ++j, table += 32)
|
|
|
|
|
{
|
|
|
|
|
if (table < decodeWin + 512 + 16)
|
|
|
|
|
table[16] = table[0] = (float) (decodeWindow[j] * scaleval);
|
|
|
|
|
if (i % 32 == 31)
|
|
|
|
|
table -= 1023;
|
|
|
|
|
if (i % 64 == 63)
|
|
|
|
|
scaleval = -scaleval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (; i < 512; ++i, --j, table += 32)
|
|
|
|
|
{
|
|
|
|
|
if (table < decodeWin + 512 + 16)
|
|
|
|
|
table[16] = table[0] = (float) (decodeWindow[j] * scaleval);
|
|
|
|
|
|
|
|
|
|
if (i % 32 == 31) table -= 1023;
|
|
|
|
|
if (i % 64 == 63) scaleval = -scaleval;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void initLayer2Tables()
|
|
|
|
|
{
|
|
|
|
|
static const uint8 base[3][9] =
|
|
|
|
|
{
|
|
|
|
|
{ 1, 0, 2 },
|
|
|
|
|
{ 17, 18, 0, 19, 20 },
|
|
|
|
|
{ 21, 1, 22, 23, 0, 24, 25, 2, 26 }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const int tableLengths[] = { 3, 5, 9 };
|
|
|
|
|
static uint8* tables[] = { group3tab, group5tab, group9tab };
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
|
|
|
{
|
|
|
|
|
uint8* table = tables[i];
|
|
|
|
|
const int len = tableLengths[i];
|
|
|
|
|
|
|
|
|
|
for (int j = 0; j < len; ++j)
|
|
|
|
|
for (int k = 0; k < len; ++k)
|
|
|
|
|
for (int l = 0; l < len; ++l)
|
|
|
|
|
{
|
|
|
|
|
*table++ = base[i][l];
|
|
|
|
|
*table++ = base[i][k];
|
|
|
|
|
*table++ = base[i][j];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int k = 0; k < 27; ++k)
|
|
|
|
|
{
|
|
|
|
|
static const double multipliers[] =
|
|
|
|
|
{
|
|
|
|
|
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,
|
|
|
|
|
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,
|
|
|
|
|
-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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
float* table = muls[k];
|
|
|
|
|
for (int j = 3, i = 0; i < 63; ++i, --j)
|
|
|
|
|
*table++ = (float) (multipliers[k] * std::pow (2.0, j / 3.0));
|
|
|
|
|
*table++ = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void initLayer3Tables()
|
|
|
|
|
{
|
|
|
|
|
int i, j;
|
|
|
|
|
for (i = -256; i < 118 + 4; ++i)
|
|
|
|
|
powToGains[i + 256] = (float) std::pow (2.0, -0.25 * (i + 210));
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 8207; ++i)
|
|
|
|
|
nToThe4Over3[i] = (float) std::pow ((double) i, 4.0 / 3.0);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 8; ++i)
|
|
|
|
|
{
|
|
|
|
|
static double Ci[] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 };
|
|
|
|
|
const double sq = sqrt (1.0 + Ci[i] * Ci[i]);
|
|
|
|
|
antiAliasingCs[i] = (float) (1.0 / sq);
|
|
|
|
|
antiAliasingCa[i] = (float) (Ci[i] / sq);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 18; ++i)
|
|
|
|
|
{
|
|
|
|
|
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));
|
|
|
|
|
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));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const double piOver72 = MathConstants<double>::pi / 72.0;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 6; ++i)
|
|
|
|
|
{
|
|
|
|
|
win[1][i + 18] = (float) (0.5 / std::cos (piOver72 * (2 * (i + 18) + 19)));
|
|
|
|
|
win[3][i + 12] = (float) (0.5 / std::cos (piOver72 * (2 * (i + 12) + 19)));
|
|
|
|
|
win[1][i + 24] = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 13)) / std::cos (piOver72 * (2 * (i + 24) + 19)));
|
|
|
|
|
win[1][i + 30] = win[3][i] = 0;
|
|
|
|
|
win[3][i + 6] = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 1)) / std::cos (piOver72 * (2 * (i + 6) + 19)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 12; ++i)
|
|
|
|
|
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));
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < 4; ++j)
|
|
|
|
|
{
|
|
|
|
|
static const int len[4] = { 36, 36, 12, 36 };
|
|
|
|
|
for (i = 0; i < len[j]; i += 2) win1[j][i] = win[j][i];
|
|
|
|
|
for (i = 1; i < len[j]; i += 2) win1[j][i] = -win[j][i];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const double sqrt2 = 1.41421356237309504880168872420969808;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 16; ++i)
|
|
|
|
|
{
|
|
|
|
|
const double t = std::tan (i * MathConstants<double>::pi / 12.0);
|
|
|
|
|
tan1_1[i] = (float) (t / (1.0 + t));
|
|
|
|
|
tan2_1[i] = (float) (1.0 / (1.0 + t));
|
|
|
|
|
tan1_2[i] = (float) (sqrt2 * t / (1.0 + t));
|
|
|
|
|
tan2_2[i] = (float) (sqrt2 / (1.0 + t));
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < 2; ++j)
|
|
|
|
|
{
|
|
|
|
|
double p1 = 1.0, p2 = 1.0;
|
|
|
|
|
|
|
|
|
|
if (i > 0)
|
|
|
|
|
{
|
|
|
|
|
const double base = std::pow (2.0, -0.25 * (j + 1));
|
|
|
|
|
|
|
|
|
|
if (i & 1)
|
|
|
|
|
p1 = std::pow (base, (i + 1) * 0.5);
|
|
|
|
|
else
|
|
|
|
|
p2 = std::pow (base, i * 0.5);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pow1_1[j][i] = (float) p1;
|
|
|
|
|
pow2_1[j][i] = (float) p2;
|
|
|
|
|
pow1_2[j][i] = (float) (sqrt2 * p1);
|
|
|
|
|
pow2_2[j][i] = (float) (sqrt2 * p2);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < 9; ++j)
|
|
|
|
|
{
|
|
|
|
|
const BandInfoStruct& bi = bandInfo[j];
|
|
|
|
|
int cb;
|
|
|
|
|
int* mp = map[j][0] = mapbuf0[j];
|
|
|
|
|
const int16* bdf = bi.longDiff;
|
|
|
|
|
|
|
|
|
|
for (i = 0, cb = 0; cb < 8; ++cb, i += *bdf++)
|
|
|
|
|
{
|
|
|
|
|
*mp++ = (*bdf) >> 1;
|
|
|
|
|
*mp++ = i;
|
|
|
|
|
*mp++ = 3;
|
|
|
|
|
*mp++ = cb;
|
|
|
|
|
}
|
|
|
|
|
bdf = bi.shortDiff + 3;
|
|
|
|
|
|
|
|
|
|
for (cb = 3; cb < 13; ++cb)
|
|
|
|
|
{
|
|
|
|
|
const int l = (*bdf++) >> 1;
|
|
|
|
|
|
|
|
|
|
for (int lwin = 0; lwin < 3; ++lwin)
|
|
|
|
|
{
|
|
|
|
|
*mp++ = l;
|
|
|
|
|
*mp++ = i + lwin;
|
|
|
|
|
*mp++ = lwin;
|
|
|
|
|
*mp++ = cb;
|
|
|
|
|
}
|
|
|
|
|
i += 6 * l;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mapEnd[j][0] = mp;
|
|
|
|
|
mp = map[j][1] = mapbuf1[j];
|
|
|
|
|
bdf = bi.shortDiff;
|
|
|
|
|
|
|
|
|
|
for (i = 0, cb = 0; cb < 13; ++cb)
|
|
|
|
|
{
|
|
|
|
|
const int l = (*bdf++) >> 1;
|
|
|
|
|
for (int lwin = 0; lwin < 3; ++lwin)
|
|
|
|
|
{
|
|
|
|
|
*mp++ = l;
|
|
|
|
|
*mp++ = i + lwin;
|
|
|
|
|
*mp++ = lwin;
|
|
|
|
|
*mp++ = cb;
|
|
|
|
|
}
|
|
|
|
|
i += 6 * l;
|
|
|
|
|
}
|
|
|
|
|
mapEnd[j][1] = mp;
|
|
|
|
|
|
|
|
|
|
mp = map[j][2] = mapbuf2[j];
|
|
|
|
|
bdf = bi.longDiff;
|
|
|
|
|
for (cb = 0; cb < 22; ++cb)
|
|
|
|
|
{
|
|
|
|
|
*mp++ = (*bdf++) >> 1;
|
|
|
|
|
*mp++ = cb;
|
|
|
|
|
}
|
|
|
|
|
mapEnd[j][2] = mp;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < 9; ++j)
|
|
|
|
|
{
|
|
|
|
|
for (i = 0; i < 23; ++i) longLimit[j][i] = jmin (32, (bandInfo[j].longIndex[i] - 1 + 8) / 18 + 1);
|
|
|
|
|
for (i = 0; i < 14; ++i) shortLimit[j][i] = jmin (32, (bandInfo[j].shortIndex[i] - 1) / 18 + 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 5; ++i)
|
|
|
|
|
for (j = 0; j < 6; ++j)
|
|
|
|
|
for (int k = 0; k < 6; ++k)
|
|
|
|
|
{
|
|
|
|
|
const int n = k + j * 6 + i * 36;
|
|
|
|
|
iLength2[n] = (unsigned int) (i | (j << 3) | (k << 6) | (3 << 12));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 4; ++i)
|
|
|
|
|
for (j = 0; j < 4; ++j)
|
|
|
|
|
for (int k = 0; k < 4; ++k)
|
|
|
|
|
{
|
|
|
|
|
const int n = k + j * 4 + i * 16;
|
|
|
|
|
iLength2[n + 180] = (unsigned int) (i | (j << 3) | (k << 6) | (4 << 12));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 4; ++i)
|
|
|
|
|
for (j = 0; j < 3; ++j)
|
|
|
|
|
{
|
|
|
|
|
const int n = j + i * 3;
|
|
|
|
|
iLength2[n + 244] = (unsigned int) (i | (j << 3) | (5 << 12));
|
|
|
|
|
nLength2[n + 500] = (unsigned int) (i | (j << 3) | (2 << 12) | (1 << 15));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 5; ++i)
|
|
|
|
|
for (j = 0; j < 5; ++j)
|
|
|
|
|
for (int k = 0; k < 4; ++k)
|
|
|
|
|
for (int l = 0; l < 4; ++l)
|
|
|
|
|
{
|
|
|
|
|
const int n = l + k * 4 + j * 16 + i * 80;
|
|
|
|
|
nLength2[n] = (unsigned int) (i | (j << 3) | (k << 6) | (l << 9) | (0 << 12));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 5; ++i)
|
|
|
|
|
for (j = 0; j < 5; ++j)
|
|
|
|
|
for (int k = 0; k < 4; ++k)
|
|
|
|
|
{
|
|
|
|
|
const int n = k + j * 4 + i * 20;
|
|
|
|
|
nLength2[n + 400] = (unsigned int) (i | (j << 3) | (k << 6) | (1 << 12));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const Constants constants;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
|
|
|
struct Layer3SideInfo
|
|
|
|
|
{
|
|
|
|
|
struct Info
|
|
|
|
|
{
|
|
|
|
|
void doAntialias (float xr[32][18]) const noexcept
|
|
|
|
|
{
|
|
|
|
|
float* xr1 = xr[1];
|
|
|
|
|
int sb;
|
|
|
|
|
|
|
|
|
|
if (blockType == 2)
|
|
|
|
|
{
|
|
|
|
|
if (mixedBlockFlag == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
sb = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
sb = (int) maxb - 1;
|
|
|
|
|
|
|
|
|
|
for (; sb != 0; --sb, xr1 += 10)
|
|
|
|
|
{
|
|
|
|
|
auto* cs = constants.antiAliasingCs;
|
|
|
|
|
auto* ca = constants.antiAliasingCa;
|
|
|
|
|
auto* xr2 = xr1;
|
|
|
|
|
|
|
|
|
|
for (int ss = 7; ss >= 0; --ss)
|
|
|
|
|
{
|
|
|
|
|
const float bu = *--xr2, bd = *xr1;
|
|
|
|
|
*xr2 = (bu * *cs) - (bd * *ca);
|
|
|
|
|
*xr1++ = (bd * *cs++) + (bu * *ca++);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void doIStereo (float xrBuffer[2][32][18], const int* scaleFactors,
|
|
|
|
|
int sampleRate, bool msStereo, int lsf) const noexcept
|
|
|
|
|
{
|
|
|
|
|
float (*xr) [32 * 18] = (float (*) [32 * 18]) xrBuffer;
|
|
|
|
|
auto& bi = bandInfo[sampleRate];
|
|
|
|
|
const float* tabl1, *tabl2;
|
|
|
|
|
|
|
|
|
|
if (lsf != 0)
|
|
|
|
|
{
|
|
|
|
|
auto p = scaleFactorCompression & 1;
|
|
|
|
|
|
|
|
|
|
if (msStereo)
|
|
|
|
|
{
|
|
|
|
|
tabl1 = constants.pow1_2[p];
|
|
|
|
|
tabl2 = constants.pow2_2[p];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
tabl1 = constants.pow1_1[p];
|
|
|
|
|
tabl2 = constants.pow2_1[p];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (msStereo)
|
|
|
|
|
{
|
|
|
|
|
tabl1 = constants.tan1_2;
|
|
|
|
|
tabl2 = constants.tan2_2;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
tabl1 = constants.tan1_1;
|
|
|
|
|
tabl2 = constants.tan2_1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (blockType == 2)
|
|
|
|
|
{
|
|
|
|
|
bool doL = mixedBlockFlag != 0;
|
|
|
|
|
|
|
|
|
|
for (uint32 lwin = 0; lwin < 3; ++lwin)
|
|
|
|
|
{
|
|
|
|
|
uint32 sfb = maxBand[lwin];
|
|
|
|
|
doL = doL && (sfb <= 3);
|
|
|
|
|
|
|
|
|
|
for (; sfb < 12; ++sfb)
|
|
|
|
|
{
|
|
|
|
|
auto p = scaleFactors[sfb * 3 + lwin - mixedBlockFlag];
|
|
|
|
|
|
|
|
|
|
if (p != 7)
|
|
|
|
|
{
|
|
|
|
|
auto t1 = tabl1[p];
|
|
|
|
|
auto t2 = tabl2[p];
|
|
|
|
|
int sb = bi.shortDiff[sfb];
|
|
|
|
|
auto index = (uint32) sb + lwin;
|
|
|
|
|
|
|
|
|
|
for (; sb > 0; --sb, index += 3)
|
|
|
|
|
{
|
|
|
|
|
float v = xr[0][index];
|
|
|
|
|
xr[0][index] = v * t1;
|
|
|
|
|
xr[1][index] = v * t2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto p = scaleFactors[11 * 3 + lwin - mixedBlockFlag];
|
|
|
|
|
|
|
|
|
|
if (p != 7)
|
|
|
|
|
{
|
|
|
|
|
auto t1 = tabl1[p];
|
|
|
|
|
auto t2 = tabl2[p];
|
|
|
|
|
int sb = bi.shortDiff[12];
|
|
|
|
|
auto index = (uint32) sb + lwin;
|
|
|
|
|
|
|
|
|
|
for (; sb > 0; --sb, index += 3)
|
|
|
|
|
{
|
|
|
|
|
float v = xr[0][index];
|
|
|
|
|
xr[0][index] = v * t1;
|
|
|
|
|
xr[1][index] = v * t2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (doL)
|
|
|
|
|
{
|
|
|
|
|
int index = bi.longIndex[maxBandl];
|
|
|
|
|
|
|
|
|
|
for (uint32 sfb = maxBandl; sfb < 8; ++sfb)
|
|
|
|
|
{
|
|
|
|
|
int sb = bi.longDiff[sfb];
|
|
|
|
|
auto p = scaleFactors[sfb];
|
|
|
|
|
|
|
|
|
|
if (p != 7)
|
|
|
|
|
{
|
|
|
|
|
auto t1 = tabl1[p];
|
|
|
|
|
auto t2 = tabl2[p];
|
|
|
|
|
|
|
|
|
|
for (; sb > 0; --sb, ++index)
|
|
|
|
|
{
|
|
|
|
|
float v = xr[0][index];
|
|
|
|
|
xr[0][index] = v * t1;
|
|
|
|
|
xr[1][index] = v * t2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
index += sb;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int index = bi.longIndex[maxBandl];
|
|
|
|
|
|
|
|
|
|
for (uint32 sfb = maxBandl; sfb < 21; ++sfb)
|
|
|
|
|
{
|
|
|
|
|
int sb = bi.longDiff[sfb];
|
|
|
|
|
auto p = scaleFactors[sfb];
|
|
|
|
|
|
|
|
|
|
if (p != 7)
|
|
|
|
|
{
|
|
|
|
|
auto t1 = tabl1[p];
|
|
|
|
|
auto t2 = tabl2[p];
|
|
|
|
|
|
|
|
|
|
for (; sb > 0; --sb, ++index)
|
|
|
|
|
{
|
|
|
|
|
const float v = xr[0][index];
|
|
|
|
|
xr[0][index] = v * t1;
|
|
|
|
|
xr[1][index] = v * t2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
index += sb;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto p = scaleFactors[20];
|
|
|
|
|
|
|
|
|
|
if (p != 7)
|
|
|
|
|
{
|
|
|
|
|
auto t1 = tabl1[p], t2 = tabl2[p];
|
|
|
|
|
|
|
|
|
|
for (int sb = bi.longDiff[21]; sb > 0; --sb, ++index)
|
|
|
|
|
{
|
|
|
|
|
const float v = xr[0][index];
|
|
|
|
|
xr[0][index] = v * t1;
|
|
|
|
|
xr[1][index] = v * t2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int scfsi;
|
|
|
|
|
uint32 part2_3Length, bigValues;
|
|
|
|
|
uint32 scaleFactorCompression, blockType, mixedBlockFlag;
|
|
|
|
|
uint32 tableSelect[3];
|
|
|
|
|
uint32 maxBand[3];
|
|
|
|
|
uint32 maxBandl, maxb, region1Start, region2Start;
|
|
|
|
|
uint32 preflag, scaleFactorScale, count1TableSelect;
|
|
|
|
|
const float* fullGain[3];
|
|
|
|
|
const float* pow2gain;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct InfoPair { Info gr[2]; };
|
|
|
|
|
InfoPair ch[2];
|
|
|
|
|
|
|
|
|
|
uint32 mainDataStart, privateBits;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
|
|
|
namespace DCT
|
|
|
|
|
{
|
|
|
|
|
enum { subBandLimit = 32 };
|
|
|
|
|
static const float cos6_1 = 0.866025388f;
|
|
|
|
|
static const float cos6_2 = 0.5f;
|
|
|
|
|
static const float cos9[] = { 1.0f, 0.98480773f, 0.939692616f, 0.866025388f, 0.766044438f, 0.642787635f, 0.5f, 0.342020154f, 0.173648179f };
|
|
|
|
|
static const float cos36[] = { 0.501909912f, 0.517638087f, 0.551688969f, 0.610387266f, 0.707106769f, 0.871723413f, 1.18310082f, 1.93185163f, 5.73685646f };
|
|
|
|
|
static const float cos12[] = { 0.517638087f, 0.707106769f, 1.93185163f };
|
|
|
|
|
|
|
|
|
|
inline void dct36_0 (int v, float* ts, float* out1, float* out2, const float* wintab, float sum0, float sum1) noexcept
|
|
|
|
|
{
|
|
|
|
|
auto tmp = sum0 + sum1;
|
|
|
|
|
out2[9 + v] = tmp * wintab[27 + v];
|
|
|
|
|
out2[8 - v] = tmp * wintab[26 - v];
|
|
|
|
|
sum0 -= sum1;
|
|
|
|
|
ts[subBandLimit * (8 - v)] = out1[8 - v] + sum0 * wintab[8 - v];
|
|
|
|
|
ts[subBandLimit * (9 + v)] = out1[9 + v] + sum0 * wintab[9 + v];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline void dct36_12 (int v1, int v2, float* ts, float* out1, float* out2, const float* wintab,
|
|
|
|
|
float tmp1a, float tmp1b, float tmp2a, float tmp2b) noexcept
|
|
|
|
|
{
|
|
|
|
|
dct36_0 (v1, ts, out1, out2, wintab, tmp1a + tmp2a, (tmp1b + tmp2b) * cos36[v1]);
|
|
|
|
|
dct36_0 (v2, ts, out1, out2, wintab, tmp2a - tmp1a, (tmp2b - tmp1b) * cos36[v2]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void dct36 (float* in, float* out1, float* out2, const float* wintab, float* ts) noexcept
|
|
|
|
|
{
|
|
|
|
|
in[17] += in[16]; in[16] += in[15]; in[15] += in[14]; in[14] += in[13]; in[13] += in[12];
|
|
|
|
|
in[12] += in[11]; in[11] += in[10]; in[10] += in[9]; in[9] += in[8]; in[8] += in[7];
|
|
|
|
|
in[7] += in[6]; in[6] += in[5]; in[5] += in[4]; in[4] += in[3]; in[3] += in[2];
|
|
|
|
|
in[2] += in[1]; in[1] += in[0]; in[17] += in[15]; in[15] += in[13]; in[13] += in[11];
|
|
|
|
|
in[11] += in[9]; in[9] += in[7]; in[7] += in[5]; in[5] += in[3]; in[3] += in[1];
|
|
|
|
|
|
|
|
|
|
auto ta33 = in[6] * cos9[3];
|
|
|
|
|
auto ta66 = in[12] * cos9[6];
|
|
|
|
|
auto tb33 = in[7] * cos9[3];
|
|
|
|
|
auto tb66 = in[13] * cos9[6];
|
|
|
|
|
|
|
|
|
|
dct36_12 (0, 8, ts, out1, out2, wintab,
|
|
|
|
|
in[2] * cos9[1] + ta33 + in[10] * cos9[5] + in[14] * cos9[7],
|
|
|
|
|
in[3] * cos9[1] + tb33 + in[11] * cos9[5] + in[15] * cos9[7],
|
|
|
|
|
in[0] + in[4] * cos9[2] + in[8] * cos9[4] + ta66 + in[16] * cos9[8],
|
|
|
|
|
in[1] + in[5] * cos9[2] + in[9] * cos9[4] + tb66 + in[17] * cos9[8]);
|
|
|
|
|
|
|
|
|
|
dct36_12 (1, 7, ts, out1, out2, wintab,
|
|
|
|
|
(in[2] - in[10] - in[14]) * cos9[3],
|
|
|
|
|
(in[3] - in[11] - in[15]) * cos9[3],
|
|
|
|
|
(in[4] - in[8] - in[16]) * cos9[6] - in[12] + in[0],
|
|
|
|
|
(in[5] - in[9] - in[17]) * cos9[6] - in[13] + in[1]);
|
|
|
|
|
|
|
|
|
|
dct36_12 (2, 6, ts, out1, out2, wintab,
|
|
|
|
|
in[2] * cos9[5] - ta33 - in[10] * cos9[7] + in[14] * cos9[1],
|
|
|
|
|
in[3] * cos9[5] - tb33 - in[11] * cos9[7] + in[15] * cos9[1],
|
|
|
|
|
in[0] - in[4] * cos9[8] - in[8] * cos9[2] + ta66 + in[16] * cos9[4],
|
|
|
|
|
in[1] - in[5] * cos9[8] - in[9] * cos9[2] + tb66 + in[17] * cos9[4]);
|
|
|
|
|
|
|
|
|
|
dct36_12 (3, 5, ts, out1, out2, wintab,
|
|
|
|
|
in[2] * cos9[7] - ta33 + in[10] * cos9[1] - in[14] * cos9[5],
|
|
|
|
|
in[3] * cos9[7] - tb33 + in[11] * cos9[1] - in[15] * cos9[5],
|
|
|
|
|
in[0] - in[4] * cos9[4] + in[8] * cos9[8] + ta66 - in[16] * cos9[2],
|
|
|
|
|
in[1] - in[5] * cos9[4] + in[9] * cos9[8] + tb66 - in[17] * cos9[2]);
|
|
|
|
|
|
|
|
|
|
dct36_0 (4, ts, out1, out2, wintab,
|
|
|
|
|
in[0] - in[4] + in[8] - in[12] + in[16],
|
|
|
|
|
(in[1] - in[5] + in[9] - in[13] + in[17]) * cos36[4]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct DCT12Inputs
|
|
|
|
|
{
|
|
|
|
|
float in0, in1, in2, in3, in4, in5;
|
|
|
|
|
|
|
|
|
|
inline DCT12Inputs (const float* in) noexcept
|
|
|
|
|
{
|
|
|
|
|
in5 = in[5 * 3] + (in4 = in[4 * 3]);
|
|
|
|
|
in4 += (in3 = in[3 * 3]);
|
|
|
|
|
in3 += (in2 = in[2 * 3]);
|
|
|
|
|
in2 += (in1 = in[1 * 3]);
|
|
|
|
|
in1 += (in0 = in[0 * 3]);
|
|
|
|
|
in5 += in3; in3 += in1;
|
|
|
|
|
in2 *= cos6_1;
|
|
|
|
|
in3 *= cos6_1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline void process() noexcept
|
|
|
|
|
{
|
|
|
|
|
in0 += in4 * cos6_2;
|
|
|
|
|
in4 = in0 + in2; in0 -= in2;
|
|
|
|
|
in1 += in5 * cos6_2;
|
|
|
|
|
in5 = (in1 + in3) * cos12[0];
|
|
|
|
|
in1 = (in1 - in3) * cos12[2];
|
|
|
|
|
in3 = in4 + in5; in4 -= in5;
|
|
|
|
|
in2 = in0 + in1; in0 -= in1;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void dct12 (const float* in, float* out1, float* out2, const float* wi, float* ts) noexcept
|
|
|
|
|
{
|
|
|
|
|
{
|
|
|
|
|
ts[0] = out1[0];
|
|
|
|
|
ts[subBandLimit * 1] = out1[1];
|
|
|
|
|
ts[subBandLimit * 2] = out1[2];
|
|
|
|
|
ts[subBandLimit * 3] = out1[3];
|
|
|
|
|
ts[subBandLimit * 4] = out1[4];
|
|
|
|
|
ts[subBandLimit * 5] = out1[5];
|
|
|
|
|
|
|
|
|
|
DCT12Inputs inputs (in);
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
auto tmp1 = (inputs.in0 - inputs.in4);
|
|
|
|
|
auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];
|
|
|
|
|
auto tmp0 = tmp1 + tmp2;
|
|
|
|
|
tmp1 -= tmp2;
|
|
|
|
|
|
|
|
|
|
ts[16 * subBandLimit] = out1[16] + tmp0 * wi[10];
|
|
|
|
|
ts[13 * subBandLimit] = out1[13] + tmp0 * wi[7];
|
|
|
|
|
ts[7 * subBandLimit] = out1[7] + tmp1 * wi[1];
|
|
|
|
|
ts[10 * subBandLimit] = out1[10] + tmp1 * wi[4];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inputs.process();
|
|
|
|
|
|
|
|
|
|
ts[17 * subBandLimit] = out1[17] + inputs.in2 * wi[11];
|
|
|
|
|
ts[12 * subBandLimit] = out1[12] + inputs.in2 * wi[6];
|
|
|
|
|
ts[14 * subBandLimit] = out1[14] + inputs.in3 * wi[8];
|
|
|
|
|
ts[15 * subBandLimit] = out1[15] + inputs.in3 * wi[9];
|
|
|
|
|
|
|
|
|
|
ts[6 * subBandLimit] = out1[6] + inputs.in0 * wi[0];
|
|
|
|
|
ts[11 * subBandLimit] = out1[11] + inputs.in0 * wi[5];
|
|
|
|
|
ts[8 * subBandLimit] = out1[8] + inputs.in4 * wi[2];
|
|
|
|
|
ts[9 * subBandLimit] = out1[9] + inputs.in4 * wi[3];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
DCT12Inputs inputs (++in);
|
|
|
|
|
auto tmp1 = (inputs.in0 - inputs.in4);
|
|
|
|
|
auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];
|
|
|
|
|
auto tmp0 = tmp1 + tmp2;
|
|
|
|
|
tmp1 -= tmp2;
|
|
|
|
|
out2[4] = tmp0 * wi[10];
|
|
|
|
|
out2[1] = tmp0 * wi[7];
|
|
|
|
|
ts[13 * subBandLimit] += tmp1 * wi[1];
|
|
|
|
|
ts[16 * subBandLimit] += tmp1 * wi[4];
|
|
|
|
|
|
|
|
|
|
inputs.process();
|
|
|
|
|
|
|
|
|
|
out2[5] = inputs.in2 * wi[11];
|
|
|
|
|
out2[0] = inputs.in2 * wi[6];
|
|
|
|
|
out2[2] = inputs.in3 * wi[8];
|
|
|
|
|
out2[3] = inputs.in3 * wi[9];
|
|
|
|
|
ts[12 * subBandLimit] += inputs.in0 * wi[0];
|
|
|
|
|
ts[17 * subBandLimit] += inputs.in0 * wi[5];
|
|
|
|
|
ts[14 * subBandLimit] += inputs.in4 * wi[2];
|
|
|
|
|
ts[15 * subBandLimit] += inputs.in4 * wi[5 - 2];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
DCT12Inputs inputs (++in);
|
|
|
|
|
out2[12] = out2[13] = out2[14] = out2[15] = out2[16] = out2[17] = 0;
|
|
|
|
|
|
|
|
|
|
auto tmp1 = (inputs.in0 - inputs.in4);
|
|
|
|
|
auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];
|
|
|
|
|
auto tmp0 = tmp1 + tmp2;
|
|
|
|
|
tmp1 -= tmp2;
|
|
|
|
|
|
|
|
|
|
out2[10] = tmp0 * wi[10];
|
|
|
|
|
out2[7] = tmp0 * wi[7];
|
|
|
|
|
out2[1] += tmp1 * wi[1];
|
|
|
|
|
out2[4] += tmp1 * wi[4];
|
|
|
|
|
|
|
|
|
|
inputs.process();
|
|
|
|
|
|
|
|
|
|
out2[11] = inputs.in2 * wi[11];
|
|
|
|
|
out2[6] = inputs.in2 * wi[6];
|
|
|
|
|
out2[8] = inputs.in3 * wi[8];
|
|
|
|
|
out2[9] = inputs.in3 * wi[9];
|
|
|
|
|
out2[0] += inputs.in0 * wi[0];
|
|
|
|
|
out2[5] += inputs.in0 * wi[5];
|
|
|
|
|
out2[2] += inputs.in4 * wi[2];
|
|
|
|
|
out2[3] += inputs.in4 * wi[3];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void dct64 (float* out0, float* out1, const float* samples) noexcept
|
|
|
|
|
{
|
|
|
|
|
float b1[32], b2[32];
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
auto* costab = constants.cosTables[0];
|
|
|
|
|
b1[0x00] = samples[0x00] + samples[0x1F]; b1[0x1F] = (samples[0x00] - samples[0x1F]) * costab[0x0];
|
|
|
|
|
b1[0x01] = samples[0x01] + samples[0x1E]; b1[0x1E] = (samples[0x01] - samples[0x1E]) * costab[0x1];
|
|
|
|
|
b1[0x02] = samples[0x02] + samples[0x1D]; b1[0x1D] = (samples[0x02] - samples[0x1D]) * costab[0x2];
|
|
|
|
|
b1[0x03] = samples[0x03] + samples[0x1C]; b1[0x1C] = (samples[0x03] - samples[0x1C]) * costab[0x3];
|
|
|
|
|
b1[0x04] = samples[0x04] + samples[0x1B]; b1[0x1B] = (samples[0x04] - samples[0x1B]) * costab[0x4];
|
|
|
|
|
b1[0x05] = samples[0x05] + samples[0x1A]; b1[0x1A] = (samples[0x05] - samples[0x1A]) * costab[0x5];
|
|
|
|
|
b1[0x06] = samples[0x06] + samples[0x19]; b1[0x19] = (samples[0x06] - samples[0x19]) * costab[0x6];
|
|
|
|
|
b1[0x07] = samples[0x07] + samples[0x18]; b1[0x18] = (samples[0x07] - samples[0x18]) * costab[0x7];
|
|
|
|
|
b1[0x08] = samples[0x08] + samples[0x17]; b1[0x17] = (samples[0x08] - samples[0x17]) * costab[0x8];
|
|
|
|
|
b1[0x09] = samples[0x09] + samples[0x16]; b1[0x16] = (samples[0x09] - samples[0x16]) * costab[0x9];
|
|
|
|
|
b1[0x0A] = samples[0x0A] + samples[0x15]; b1[0x15] = (samples[0x0A] - samples[0x15]) * costab[0xA];
|
|
|
|
|
b1[0x0B] = samples[0x0B] + samples[0x14]; b1[0x14] = (samples[0x0B] - samples[0x14]) * costab[0xB];
|
|
|
|
|
b1[0x0C] = samples[0x0C] + samples[0x13]; b1[0x13] = (samples[0x0C] - samples[0x13]) * costab[0xC];
|
|
|
|
|
b1[0x0D] = samples[0x0D] + samples[0x12]; b1[0x12] = (samples[0x0D] - samples[0x12]) * costab[0xD];
|
|
|
|
|
b1[0x0E] = samples[0x0E] + samples[0x11]; b1[0x11] = (samples[0x0E] - samples[0x11]) * costab[0xE];
|
|
|
|
|
b1[0x0F] = samples[0x0F] + samples[0x10]; b1[0x10] = (samples[0x0F] - samples[0x10]) * costab[0xF];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
auto* costab = constants.cosTables[1];
|
|
|
|
|
b2[0x00] = b1[0x00] + b1[0x0F]; b2[0x0F] = (b1[0x00] - b1[0x0F]) * costab[0];
|
|
|
|
|
b2[0x01] = b1[0x01] + b1[0x0E]; b2[0x0E] = (b1[0x01] - b1[0x0E]) * costab[1];
|
|
|
|
|
b2[0x02] = b1[0x02] + b1[0x0D]; b2[0x0D] = (b1[0x02] - b1[0x0D]) * costab[2];
|
|
|
|
|
b2[0x03] = b1[0x03] + b1[0x0C]; b2[0x0C] = (b1[0x03] - b1[0x0C]) * costab[3];
|
|
|
|
|
b2[0x04] = b1[0x04] + b1[0x0B]; b2[0x0B] = (b1[0x04] - b1[0x0B]) * costab[4];
|
|
|
|
|
b2[0x05] = b1[0x05] + b1[0x0A]; b2[0x0A] = (b1[0x05] - b1[0x0A]) * costab[5];
|
|
|
|
|
b2[0x06] = b1[0x06] + b1[0x09]; b2[0x09] = (b1[0x06] - b1[0x09]) * costab[6];
|
|
|
|
|
b2[0x07] = b1[0x07] + b1[0x08]; b2[0x08] = (b1[0x07] - b1[0x08]) * costab[7];
|
|
|
|
|
b2[0x10] = b1[0x10] + b1[0x1F]; b2[0x1F] = (b1[0x1F] - b1[0x10]) * costab[0];
|
|
|
|
|
b2[0x11] = b1[0x11] + b1[0x1E]; b2[0x1E] = (b1[0x1E] - b1[0x11]) * costab[1];
|
|
|
|
|
b2[0x12] = b1[0x12] + b1[0x1D]; b2[0x1D] = (b1[0x1D] - b1[0x12]) * costab[2];
|
|
|
|
|
b2[0x13] = b1[0x13] + b1[0x1C]; b2[0x1C] = (b1[0x1C] - b1[0x13]) * costab[3];
|
|
|
|
|
b2[0x14] = b1[0x14] + b1[0x1B]; b2[0x1B] = (b1[0x1B] - b1[0x14]) * costab[4];
|
|
|
|
|
b2[0x15] = b1[0x15] + b1[0x1A]; b2[0x1A] = (b1[0x1A] - b1[0x15]) * costab[5];
|
|
|
|
|
b2[0x16] = b1[0x16] + b1[0x19]; b2[0x19] = (b1[0x19] - b1[0x16]) * costab[6];
|
|
|
|
|
b2[0x17] = b1[0x17] + b1[0x18]; b2[0x18] = (b1[0x18] - b1[0x17]) * costab[7];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
auto* costab = constants.cosTables[2];
|
|
|
|
|
b1[0x00] = b2[0x00] + b2[0x07]; b1[0x07] = (b2[0x00] - b2[0x07]) * costab[0];
|
|
|
|
|
b1[0x01] = b2[0x01] + b2[0x06]; b1[0x06] = (b2[0x01] - b2[0x06]) * costab[1];
|
|
|
|
|
b1[0x02] = b2[0x02] + b2[0x05]; b1[0x05] = (b2[0x02] - b2[0x05]) * costab[2];
|
|
|
|
|
b1[0x03] = b2[0x03] + b2[0x04]; b1[0x04] = (b2[0x03] - b2[0x04]) * costab[3];
|
|
|
|
|
b1[0x08] = b2[0x08] + b2[0x0F]; b1[0x0F] = (b2[0x0F] - b2[0x08]) * costab[0];
|
|
|
|
|
b1[0x09] = b2[0x09] + b2[0x0E]; b1[0x0E] = (b2[0x0E] - b2[0x09]) * costab[1];
|
|
|
|
|
b1[0x0A] = b2[0x0A] + b2[0x0D]; b1[0x0D] = (b2[0x0D] - b2[0x0A]) * costab[2];
|
|
|
|
|
b1[0x0B] = b2[0x0B] + b2[0x0C]; b1[0x0C] = (b2[0x0C] - b2[0x0B]) * costab[3];
|
|
|
|
|
b1[0x10] = b2[0x10] + b2[0x17]; b1[0x17] = (b2[0x10] - b2[0x17]) * costab[0];
|
|
|
|
|
b1[0x11] = b2[0x11] + b2[0x16]; b1[0x16] = (b2[0x11] - b2[0x16]) * costab[1];
|
|
|
|
|
b1[0x12] = b2[0x12] + b2[0x15]; b1[0x15] = (b2[0x12] - b2[0x15]) * costab[2];
|
|
|
|
|
b1[0x13] = b2[0x13] + b2[0x14]; b1[0x14] = (b2[0x13] - b2[0x14]) * costab[3];
|
|
|
|
|
b1[0x18] = b2[0x18] + b2[0x1F]; b1[0x1F] = (b2[0x1F] - b2[0x18]) * costab[0];
|
|
|
|
|
b1[0x19] = b2[0x19] + b2[0x1E]; b1[0x1E] = (b2[0x1E] - b2[0x19]) * costab[1];
|
|
|
|
|
b1[0x1A] = b2[0x1A] + b2[0x1D]; b1[0x1D] = (b2[0x1D] - b2[0x1A]) * costab[2];
|
|
|
|
|
b1[0x1B] = b2[0x1B] + b2[0x1C]; b1[0x1C] = (b2[0x1C] - b2[0x1B]) * costab[3];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
auto cos0 = constants.cosTables[3][0];
|
|
|
|
|
auto cos1 = constants.cosTables[3][1];
|
|
|
|
|
b2[0x00] = b1[0x00] + b1[0x03]; b2[0x03] = (b1[0x00] - b1[0x03]) * cos0;
|
|
|
|
|
b2[0x01] = b1[0x01] + b1[0x02]; b2[0x02] = (b1[0x01] - b1[0x02]) * cos1;
|
|
|
|
|
b2[0x04] = b1[0x04] + b1[0x07]; b2[0x07] = (b1[0x07] - b1[0x04]) * cos0;
|
|
|
|
|
b2[0x05] = b1[0x05] + b1[0x06]; b2[0x06] = (b1[0x06] - b1[0x05]) * cos1;
|
|
|
|
|
b2[0x08] = b1[0x08] + b1[0x0B]; b2[0x0B] = (b1[0x08] - b1[0x0B]) * cos0;
|
|
|
|
|
b2[0x09] = b1[0x09] + b1[0x0A]; b2[0x0A] = (b1[0x09] - b1[0x0A]) * cos1;
|
|
|
|
|
b2[0x0C] = b1[0x0C] + b1[0x0F]; b2[0x0F] = (b1[0x0F] - b1[0x0C]) * cos0;
|
|
|
|
|
b2[0x0D] = b1[0x0D] + b1[0x0E]; b2[0x0E] = (b1[0x0E] - b1[0x0D]) * cos1;
|
|
|
|
|
b2[0x10] = b1[0x10] + b1[0x13]; b2[0x13] = (b1[0x10] - b1[0x13]) * cos0;
|
|
|
|
|
b2[0x11] = b1[0x11] + b1[0x12]; b2[0x12] = (b1[0x11] - b1[0x12]) * cos1;
|
|
|
|
|
b2[0x14] = b1[0x14] + b1[0x17]; b2[0x17] = (b1[0x17] - b1[0x14]) * cos0;
|
|
|
|
|
b2[0x15] = b1[0x15] + b1[0x16]; b2[0x16] = (b1[0x16] - b1[0x15]) * cos1;
|
|
|
|
|
b2[0x18] = b1[0x18] + b1[0x1B]; b2[0x1B] = (b1[0x18] - b1[0x1B]) * cos0;
|
|
|
|
|
b2[0x19] = b1[0x19] + b1[0x1A]; b2[0x1A] = (b1[0x19] - b1[0x1A]) * cos1;
|
|
|
|
|
b2[0x1C] = b1[0x1C] + b1[0x1F]; b2[0x1F] = (b1[0x1F] - b1[0x1C]) * cos0;
|
|
|
|
|
b2[0x1D] = b1[0x1D] + b1[0x1E]; b2[0x1E] = (b1[0x1E] - b1[0x1D]) * cos1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
auto cos0 = constants.cosTables[4][0];
|
|
|
|
|
b1[0x00] = b2[0x00] + b2[0x01]; b1[0x01] = (b2[0x00] - b2[0x01]) * cos0;
|
|
|
|
|
b1[0x02] = b2[0x02] + b2[0x03]; b1[0x03] = (b2[0x03] - b2[0x02]) * cos0; b1[0x02] += b1[0x03];
|
|
|
|
|
b1[0x04] = b2[0x04] + b2[0x05]; b1[0x05] = (b2[0x04] - b2[0x05]) * cos0;
|
|
|
|
|
b1[0x06] = b2[0x06] + b2[0x07]; b1[0x07] = (b2[0x07] - b2[0x06]) * cos0;
|
|
|
|
|
b1[0x06] += b1[0x07]; b1[0x04] += b1[0x06]; b1[0x06] += b1[0x05]; b1[0x05] += b1[0x07];
|
|
|
|
|
b1[0x08] = b2[0x08] + b2[0x09]; b1[0x09] = (b2[0x08] - b2[0x09]) * cos0;
|
|
|
|
|
b1[0x0A] = b2[0x0A] + b2[0x0B]; b1[0x0B] = (b2[0x0B] - b2[0x0A]) * cos0; b1[0x0A] += b1[0x0B];
|
|
|
|
|
b1[0x0C] = b2[0x0C] + b2[0x0D]; b1[0x0D] = (b2[0x0C] - b2[0x0D]) * cos0;
|
|
|
|
|
b1[0x0E] = b2[0x0E] + b2[0x0F]; b1[0x0F] = (b2[0x0F] - b2[0x0E]) * cos0;
|
|
|
|
|
b1[0x0E] += b1[0x0F]; b1[0x0C] += b1[0x0E]; b1[0x0E] += b1[0x0D]; b1[0x0D] += b1[0x0F];
|
|
|
|
|
b1[0x10] = b2[0x10] + b2[0x11]; b1[0x11] = (b2[0x10] - b2[0x11]) * cos0;
|
|
|
|
|
b1[0x12] = b2[0x12] + b2[0x13]; b1[0x13] = (b2[0x13] - b2[0x12]) * cos0; b1[0x12] += b1[0x13];
|
|
|
|
|
b1[0x14] = b2[0x14] + b2[0x15]; b1[0x15] = (b2[0x14] - b2[0x15]) * cos0;
|
|
|
|
|
b1[0x16] = b2[0x16] + b2[0x17]; b1[0x17] = (b2[0x17] - b2[0x16]) * cos0;
|
|
|
|
|
b1[0x16] += b1[0x17]; b1[0x14] += b1[0x16]; b1[0x16] += b1[0x15]; b1[0x15] += b1[0x17];
|
|
|
|
|
b1[0x18] = b2[0x18] + b2[0x19]; b1[0x19] = (b2[0x18] - b2[0x19]) * cos0;
|
|
|
|
|
b1[0x1A] = b2[0x1A] + b2[0x1B]; b1[0x1B] = (b2[0x1B] - b2[0x1A]) * cos0; b1[0x1A] += b1[0x1B];
|
|
|
|
|
b1[0x1C] = b2[0x1C] + b2[0x1D]; b1[0x1D] = (b2[0x1C] - b2[0x1D]) * cos0;
|
|
|
|
|
b1[0x1E] = b2[0x1E] + b2[0x1F]; b1[0x1F] = (b2[0x1F] - b2[0x1E]) * cos0;
|
|
|
|
|
b1[0x1E] += b1[0x1F]; b1[0x1C] += b1[0x1E]; b1[0x1E] += b1[0x1D]; b1[0x1D] += b1[0x1F];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out0[0x10 * 16] = b1[0x00]; out0[0x10 * 12] = b1[0x04]; out0[0x10 * 8] = b1[0x02]; out0[0x10 * 4] = b1[0x06];
|
|
|
|
|
out0[0] = b1[0x01]; out1[0] = b1[0x01]; out1[0x10 * 4] = b1[0x05]; out1[0x10 * 8] = b1[0x03];
|
|
|
|
|
out1[0x10 * 12] = b1[0x07];
|
|
|
|
|
|
|
|
|
|
b1[0x08] += b1[0x0C]; out0[0x10 * 14] = b1[0x08]; b1[0x0C] += b1[0x0a]; out0[0x10 * 10] = b1[0x0C];
|
|
|
|
|
b1[0x0A] += b1[0x0E]; out0[0x10 * 6] = b1[0x0A]; b1[0x0E] += b1[0x09]; out0[0x10 * 2] = b1[0x0E];
|
|
|
|
|
b1[0x09] += b1[0x0D]; out1[0x10 * 2] = b1[0x09]; b1[0x0D] += b1[0x0B]; out1[0x10 * 6] = b1[0x0D];
|
|
|
|
|
b1[0x0B] += b1[0x0F]; out1[0x10 * 10] = b1[0x0B]; out1[0x10 * 14] = b1[0x0F];
|
|
|
|
|
|
|
|
|
|
b1[0x18] += b1[0x1C]; out0[0x10 * 15] = b1[0x10] + b1[0x18]; out0[0x10 * 13] = b1[0x18] + b1[0x14];
|
|
|
|
|
b1[0x1C] += b1[0x1a]; out0[0x10 * 11] = b1[0x14] + b1[0x1C]; out0[0x10 * 9] = b1[0x1C] + b1[0x12];
|
|
|
|
|
b1[0x1A] += b1[0x1E]; out0[0x10 * 7] = b1[0x12] + b1[0x1A]; out0[0x10 * 5] = b1[0x1A] + b1[0x16];
|
|
|
|
|
b1[0x1E] += b1[0x19]; out0[0x10 * 3] = b1[0x16] + b1[0x1E]; out0[0x10 * 1] = b1[0x1E] + b1[0x11];
|
|
|
|
|
b1[0x19] += b1[0x1D]; out1[0x10 * 1] = b1[0x11] + b1[0x19]; out1[0x10 * 3] = b1[0x19] + b1[0x15];
|
|
|
|
|
b1[0x1D] += b1[0x1B]; out1[0x10 * 5] = b1[0x15] + b1[0x1D]; out1[0x10 * 7] = b1[0x1D] + b1[0x13];
|
|
|
|
|
b1[0x1B] += b1[0x1F]; out1[0x10 * 9] = b1[0x13] + b1[0x1B]; out1[0x10 * 11] = b1[0x1B] + b1[0x17];
|
|
|
|
|
out1[0x10 * 13] = b1[0x17] + b1[0x1F]; out1[0x10 * 15] = b1[0x1F];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
|
|
|
struct MP3Stream
|
|
|
|
|
{
|
|
|
|
|
MP3Stream (InputStream& source) : stream (source, 8192)
|
|
|
|
|
{
|
|
|
|
|
reset();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int decodeNextBlock (float* out0, float* out1, int& done)
|
|
|
|
|
{
|
|
|
|
|
if (! headerParsed)
|
|
|
|
|
{
|
|
|
|
|
auto nextFrameOffset = scanForNextFrameHeader (false);
|
|
|
|
|
|
|
|
|
|
if (lastFrameSize == -1 || needToSyncBitStream)
|
|
|
|
|
{
|
|
|
|
|
needToSyncBitStream = false;
|
|
|
|
|
readVBRHeader();
|
|
|
|
|
|
|
|
|
|
if (vbrHeaderFound)
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (nextFrameOffset < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
if (nextFrameOffset > 0)
|
|
|
|
|
{
|
|
|
|
|
wasFreeFormat = false;
|
|
|
|
|
needToSyncBitStream = true;
|
|
|
|
|
auto size = (int) (bufferPointer - (bufferSpace[bufferSpaceIndex] + 512));
|
|
|
|
|
|
|
|
|
|
if (size > 2880)
|
|
|
|
|
{
|
|
|
|
|
size = 0;
|
|
|
|
|
bufferPointer = bufferSpace[bufferSpaceIndex] + 512;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto toSkip = (size + nextFrameOffset) - 2880;
|
|
|
|
|
|
|
|
|
|
if (toSkip > 0)
|
|
|
|
|
{
|
|
|
|
|
stream.skipNextBytes (toSkip);
|
|
|
|
|
nextFrameOffset -= toSkip;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
stream.read (bufferPointer, nextFrameOffset);
|
|
|
|
|
lastFrameSize += nextFrameOffset;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
frame.decodeHeader ((uint32) stream.readIntBigEndian());
|
|
|
|
|
headerParsed = true;
|
|
|
|
|
frameSize = frame.frameSize;
|
|
|
|
|
isFreeFormat = (frameSize == 0);
|
|
|
|
|
sideInfoSize = frame.lsf != 0 ? ((frame.numChannels == 1) ? 9 : 17)
|
|
|
|
|
: ((frame.numChannels == 1) ? 17 : 32);
|
|
|
|
|
|
|
|
|
|
if (frame.crc16FollowsHeader)
|
|
|
|
|
sideInfoSize += 2;
|
|
|
|
|
|
|
|
|
|
bufferSpaceIndex = 1 - bufferSpaceIndex;
|
|
|
|
|
bufferPointer = bufferSpace[bufferSpaceIndex] + 512;
|
|
|
|
|
bitIndex = 0;
|
|
|
|
|
|
|
|
|
|
if (lastFrameSize < 0)
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (! sideParsed)
|
|
|
|
|
{
|
|
|
|
|
if (frame.layer == 3)
|
|
|
|
|
{
|
|
|
|
|
stream.read (bufferPointer, sideInfoSize);
|
|
|
|
|
|
|
|
|
|
if (frame.crc16FollowsHeader)
|
|
|
|
|
getBits (16);
|
|
|
|
|
|
|
|
|
|
auto bits = jmax (0, decodeLayer3SideInfo());
|
|
|
|
|
dataSize = (bits + 7) / 8;
|
|
|
|
|
|
|
|
|
|
if (! isFreeFormat)
|
|
|
|
|
dataSize = jmin (dataSize, frame.frameSize - sideInfoSize);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
dataSize = frame.frameSize;
|
|
|
|
|
sideInfoSize = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sideParsed = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int result = 1;
|
|
|
|
|
|
|
|
|
|
if (! dataParsed)
|
|
|
|
|
{
|
|
|
|
|
stream.read (bufferPointer, dataSize);
|
|
|
|
|
|
|
|
|
|
if (out0 != nullptr)
|
|
|
|
|
{
|
|
|
|
|
if (frame.layer < 3 && frame.crc16FollowsHeader)
|
|
|
|
|
getBits (16);
|
|
|
|
|
|
|
|
|
|
switch (frame.layer)
|
|
|
|
|
{
|
|
|
|
|
case 1: decodeLayer1Frame (out0, out1, done); break;
|
|
|
|
|
case 2: decodeLayer2Frame (out0, out1, done); break;
|
|
|
|
|
case 3: decodeLayer3Frame (out0, out1, done); break;
|
|
|
|
|
default: break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bufferPointer = bufferSpace[bufferSpaceIndex] + 512 + sideInfoSize + dataSize;
|
|
|
|
|
dataParsed = true;
|
|
|
|
|
result = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isFreeFormat)
|
|
|
|
|
{
|
|
|
|
|
if (wasFreeFormat)
|
|
|
|
|
{
|
|
|
|
|
frameSize = lastFrameSizeNoPadding + frame.padding;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
auto nextFrameOffset = scanForNextFrameHeader (true);
|
|
|
|
|
|
|
|
|
|
wasFreeFormat = isFreeFormat;
|
|
|
|
|
|
|
|
|
|
if (nextFrameOffset < 0)
|
|
|
|
|
{
|
|
|
|
|
lastFrameSize = frameSize;
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
frameSize = nextFrameOffset + sideInfoSize + dataSize;
|
|
|
|
|
lastFrameSizeNoPadding = frameSize - frame.padding;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (result == 0)
|
|
|
|
|
return result;
|
|
|
|
|
|
|
|
|
|
int bytes = frameSize - (sideInfoSize + dataSize);
|
|
|
|
|
|
|
|
|
|
if (bytes > 0)
|
|
|
|
|
{
|
|
|
|
|
auto toSkip = bytes - 512;
|
|
|
|
|
|
|
|
|
|
if (toSkip > 0)
|
|
|
|
|
{
|
|
|
|
|
stream.skipNextBytes (toSkip);
|
|
|
|
|
bytes -= toSkip;
|
|
|
|
|
frameSize -= toSkip;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
stream.read (bufferPointer, bytes);
|
|
|
|
|
bufferPointer += bytes;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
lastFrameSize = frameSize;
|
|
|
|
|
wasFreeFormat = isFreeFormat;
|
|
|
|
|
frameSize = 0;
|
|
|
|
|
headerParsed = sideParsed = dataParsed = false;
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool seek (int frameIndex)
|
|
|
|
|
{
|
|
|
|
|
frameIndex = jmax (0, frameIndex);
|
|
|
|
|
|
|
|
|
|
while (frameIndex >= frameStreamPositions.size() * storedStartPosInterval)
|
|
|
|
|
{
|
|
|
|
|
int dummy = 0;
|
|
|
|
|
auto result = decodeNextBlock (nullptr, nullptr, dummy);
|
|
|
|
|
|
|
|
|
|
if (result < 0)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
if (result > 0)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
frameIndex = jmin (frameIndex & ~(storedStartPosInterval - 1),
|
|
|
|
|
frameStreamPositions.size() * storedStartPosInterval - 1);
|
|
|
|
|
stream.setPosition (frameStreamPositions.getUnchecked (frameIndex / storedStartPosInterval));
|
|
|
|
|
currentFrameIndex = frameIndex;
|
|
|
|
|
reset();
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MP3Frame frame;
|
|
|
|
|
VBRTagData vbrTagData;
|
|
|
|
|
BufferedInputStream stream;
|
|
|
|
|
int numFrames = 0, currentFrameIndex = 0;
|
|
|
|
|
bool vbrHeaderFound = false;
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
bool headerParsed, sideParsed, dataParsed, needToSyncBitStream;
|
|
|
|
|
bool isFreeFormat, wasFreeFormat;
|
|
|
|
|
int sideInfoSize, dataSize;
|
|
|
|
|
int frameSize, lastFrameSize, lastFrameSizeNoPadding;
|
|
|
|
|
int bufferSpaceIndex;
|
|
|
|
|
Layer3SideInfo sideinfo;
|
|
|
|
|
uint8 bufferSpace[2][2880 + 1024];
|
|
|
|
|
uint8* bufferPointer;
|
|
|
|
|
int bitIndex, synthBo;
|
|
|
|
|
float hybridBlock[2][2][32 * 18];
|
|
|
|
|
int hybridBlockIndex[2];
|
|
|
|
|
float synthBuffers[2][2][0x110];
|
|
|
|
|
float hybridIn[2][32][18];
|
|
|
|
|
float hybridOut[2][18][32];
|
|
|
|
|
|
|
|
|
|
void reset() noexcept
|
|
|
|
|
{
|
|
|
|
|
headerParsed = sideParsed = dataParsed = isFreeFormat = wasFreeFormat = false;
|
|
|
|
|
lastFrameSize = -1;
|
|
|
|
|
needToSyncBitStream = true;
|
|
|
|
|
frameSize = sideInfoSize = dataSize = bitIndex = 0;
|
|
|
|
|
lastFrameSizeNoPadding = bufferSpaceIndex = 0;
|
|
|
|
|
bufferPointer = bufferSpace[bufferSpaceIndex] + 512;
|
|
|
|
|
synthBo = 1;
|
|
|
|
|
|
|
|
|
|
zerostruct (sideinfo);
|
|
|
|
|
zeromem (bufferSpace, sizeof (bufferSpace));
|
|
|
|
|
zeromem (hybridBlock, sizeof (hybridBlock));
|
|
|
|
|
zeromem (hybridBlockIndex, sizeof (hybridBlockIndex));
|
|
|
|
|
zeromem (synthBuffers, sizeof (synthBuffers));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
enum { storedStartPosInterval = 4 };
|
|
|
|
|
Array<int64> frameStreamPositions;
|
|
|
|
|
|
|
|
|
|
struct SideInfoLayer1
|
|
|
|
|
{
|
|
|
|
|
uint8 allocation[32][2];
|
|
|
|
|
uint8 scaleFactor[32][2];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct SideInfoLayer2
|
|
|
|
|
{
|
|
|
|
|
uint8 allocation[32][2];
|
|
|
|
|
uint8 scaleFactor[32][2][3];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static bool isValidHeader (uint32 header, int oldLayer) noexcept
|
|
|
|
|
{
|
|
|
|
|
int newLayer = 4 - ((header >> 17) & 3);
|
|
|
|
|
|
|
|
|
|
return (header & 0xffe00000) == 0xffe00000
|
|
|
|
|
&& newLayer != 4
|
|
|
|
|
&& (oldLayer <= 0 || newLayer == oldLayer)
|
|
|
|
|
&& ((header >> 12) & 15) != 15
|
|
|
|
|
&& ((header >> 10) & 3) != 3
|
|
|
|
|
&& (header & 3) != 2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool rollBackBufferPointer (int backstep) noexcept
|
|
|
|
|
{
|
|
|
|
|
if (lastFrameSize < 0 && backstep > 0)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
auto* oldBuffer = bufferSpace[1 - bufferSpaceIndex] + 512;
|
|
|
|
|
bufferPointer -= backstep;
|
|
|
|
|
|
|
|
|
|
if (backstep != 0)
|
|
|
|
|
memcpy (bufferPointer, oldBuffer + lastFrameSize - backstep, (size_t) backstep);
|
|
|
|
|
|
|
|
|
|
bitIndex = 0;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32 getBits (int numBits) noexcept
|
|
|
|
|
{
|
|
|
|
|
if (numBits <= 0 || bufferPointer == nullptr)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
const uint32 result = ((((((bufferPointer[0] << 8) | bufferPointer[1]) << 8)
|
|
|
|
|
| bufferPointer[2]) << bitIndex) & 0xffffff) >> (24 - numBits);
|
|
|
|
|
bitIndex += numBits;
|
|
|
|
|
bufferPointer += (bitIndex >> 3);
|
|
|
|
|
bitIndex &= 7;
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32 getOneBit() noexcept
|
|
|
|
|
{
|
|
|
|
|
auto result = (uint8) (*bufferPointer << bitIndex);
|
|
|
|
|
++bitIndex;
|
|
|
|
|
bufferPointer += (bitIndex >> 3);
|
|
|
|
|
bitIndex &= 7;
|
|
|
|
|
return result >> 7;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32 getBitsUnchecked (int numBits) noexcept
|
|
|
|
|
{
|
|
|
|
|
const uint32 result = ((((bufferPointer[0] << 8) | bufferPointer[1]) << bitIndex) & 0xffff) >> (16 - numBits);
|
|
|
|
|
bitIndex += numBits;
|
|
|
|
|
bufferPointer += (bitIndex >> 3);
|
|
|
|
|
bitIndex &= 7;
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline uint8 getBitsUint8 (int numBits) noexcept { return (uint8) getBitsUnchecked (numBits); }
|
|
|
|
|
inline uint16 getBitsUint16 (int numBits) noexcept { return (uint16) getBitsUnchecked (numBits); }
|
|
|
|
|
|
|
|
|
|
int scanForNextFrameHeader (bool checkTypeAgainstLastFrame) noexcept
|
|
|
|
|
{
|
|
|
|
|
auto oldPos = stream.getPosition();
|
|
|
|
|
int offset = -3;
|
|
|
|
|
uint32 header = 0;
|
|
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
|
{
|
|
|
|
|
if (stream.isExhausted() || stream.getPosition() > oldPos + 32768)
|
|
|
|
|
{
|
|
|
|
|
offset = -1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
header = (header << 8) | (uint8) stream.readByte();
|
|
|
|
|
|
|
|
|
|
if (offset >= 0 && isValidHeader (header, frame.layer))
|
|
|
|
|
{
|
|
|
|
|
if (! checkTypeAgainstLastFrame)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
const bool mpeg25 = (header & (1 << 20)) == 0;
|
|
|
|
|
const uint32 lsf = mpeg25 ? 1 : ((header & (1 << 19)) ? 0 : 1);
|
|
|
|
|
const uint32 sampleRateIndex = mpeg25 ? (6 + ((header >> 10) & 3)) : (((header >> 10) & 3) + (lsf * 3));
|
|
|
|
|
const uint32 mode = (header >> 6) & 3;
|
|
|
|
|
const uint32 numChannels = (mode == 3) ? 1 : 2;
|
|
|
|
|
|
|
|
|
|
if (numChannels == (uint32) frame.numChannels && lsf == (uint32) frame.lsf
|
|
|
|
|
&& mpeg25 == frame.mpeg25 && sampleRateIndex == (uint32) frame.sampleRateIndex)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
++offset;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (offset >= 0)
|
|
|
|
|
{
|
|
|
|
|
if ((currentFrameIndex & (storedStartPosInterval - 1)) == 0)
|
|
|
|
|
frameStreamPositions.set (currentFrameIndex / storedStartPosInterval, oldPos + offset);
|
|
|
|
|
|
|
|
|
|
++currentFrameIndex;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
stream.setPosition (oldPos);
|
|
|
|
|
return offset;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void readVBRHeader()
|
|
|
|
|
{
|
|
|
|
|
auto oldPos = stream.getPosition();
|
|
|
|
|
uint8 xing[194];
|
|
|
|
|
stream.read (xing, sizeof (xing));
|
|
|
|
|
|
|
|
|
|
vbrHeaderFound = vbrTagData.read (xing);
|
|
|
|
|
|
|
|
|
|
if (vbrHeaderFound)
|
|
|
|
|
{
|
|
|
|
|
numFrames = (int) vbrTagData.frames;
|
|
|
|
|
oldPos += jmax (vbrTagData.headersize, 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
stream.setPosition (oldPos);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void decodeLayer1Frame (float* pcm0, float* pcm1, int& samplesDone) noexcept
|
|
|
|
|
{
|
|
|
|
|
float fraction[2][32];
|
|
|
|
|
SideInfoLayer1 si;
|
|
|
|
|
layer1Step1 (si);
|
|
|
|
|
auto single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;
|
|
|
|
|
|
|
|
|
|
if (single >= 0)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 12; ++i)
|
|
|
|
|
{
|
|
|
|
|
layer1Step2 (si, fraction);
|
|
|
|
|
synthesise (fraction[single], 0, pcm0, samplesDone);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 12; ++i)
|
|
|
|
|
{
|
|
|
|
|
layer1Step2 (si, fraction);
|
|
|
|
|
synthesiseStereo (fraction[0], fraction[1], pcm0, pcm1, samplesDone);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void decodeLayer2Frame (float* pcm0, float* pcm1, int& samplesDone)
|
|
|
|
|
{
|
|
|
|
|
float fraction[2][4][32];
|
|
|
|
|
frame.selectLayer2Table();
|
|
|
|
|
SideInfoLayer2 si;
|
|
|
|
|
layer2Step1 (si);
|
|
|
|
|
auto single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;
|
|
|
|
|
|
|
|
|
|
if (single >= 0)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 12; ++i)
|
|
|
|
|
{
|
|
|
|
|
layer2Step2 (si, i >> 2, fraction);
|
|
|
|
|
|
|
|
|
|
for (int j = 0; j < 3; ++j)
|
|
|
|
|
synthesise (fraction[single][j], 0, pcm0, samplesDone);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 12; ++i)
|
|
|
|
|
{
|
|
|
|
|
layer2Step2 (si, i >> 2, fraction);
|
|
|
|
|
|
|
|
|
|
for (int j = 0; j < 3; ++j)
|
|
|
|
|
synthesiseStereo (fraction[0][j], fraction[1][j], pcm0, pcm1, samplesDone);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void decodeLayer3Frame (float* pcm0, float* pcm1, int& samplesDone) noexcept
|
|
|
|
|
{
|
|
|
|
|
if (! rollBackBufferPointer ((int) sideinfo.mainDataStart))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
const int single = frame.numChannels == 1 ? 0 : frame.single;
|
|
|
|
|
const int numChans = (frame.numChannels == 1 || single >= 0) ? 1 : 2;
|
|
|
|
|
const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;
|
|
|
|
|
const bool iStereo = (frame.mode == 1) && (frame.modeExt & 1) != 0;
|
|
|
|
|
const int granules = frame.lsf ? 1 : 2;
|
|
|
|
|
int scaleFactors[2][39];
|
|
|
|
|
|
|
|
|
|
for (int gr = 0; gr < granules; ++gr)
|
|
|
|
|
{
|
|
|
|
|
{
|
|
|
|
|
auto& granule = sideinfo.ch[0].gr[gr];
|
|
|
|
|
auto part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[0], granule, 0)
|
|
|
|
|
: getLayer3ScaleFactors1 (scaleFactors[0], granule);
|
|
|
|
|
|
|
|
|
|
if (layer3DequantizeSample (hybridIn[0], scaleFactors[0], granule, frame.sampleRateIndex, part2bits))
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (frame.numChannels == 2)
|
|
|
|
|
{
|
|
|
|
|
auto& granule = sideinfo.ch[1].gr[gr];
|
|
|
|
|
auto part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[1], granule, iStereo)
|
|
|
|
|
: getLayer3ScaleFactors1 (scaleFactors[1], granule);
|
|
|
|
|
|
|
|
|
|
if (layer3DequantizeSample (hybridIn[1], scaleFactors[1], granule, frame.sampleRateIndex, part2bits))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (msStereo)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 32 * 18; ++i)
|
|
|
|
|
{
|
|
|
|
|
auto tmp0 = ((const float*) hybridIn[0])[i];
|
|
|
|
|
auto tmp1 = ((const float*) hybridIn[1])[i];
|
|
|
|
|
((float*) hybridIn[1])[i] = tmp0 - tmp1;
|
|
|
|
|
((float*) hybridIn[0])[i] = tmp0 + tmp1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (iStereo)
|
|
|
|
|
granule.doIStereo (hybridIn, scaleFactors[1], frame.sampleRateIndex, msStereo, frame.lsf);
|
|
|
|
|
|
|
|
|
|
if (msStereo || iStereo || single == 3)
|
|
|
|
|
{
|
|
|
|
|
if (granule.maxb > sideinfo.ch[0].gr[gr].maxb)
|
|
|
|
|
sideinfo.ch[0].gr[gr].maxb = granule.maxb;
|
|
|
|
|
else
|
|
|
|
|
granule.maxb = sideinfo.ch[0].gr[gr].maxb;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (single)
|
|
|
|
|
{
|
|
|
|
|
case 3:
|
|
|
|
|
{
|
|
|
|
|
auto* in0 = (float*) hybridIn[0];
|
|
|
|
|
auto* in1 = (const float*) hybridIn[1];
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < (int) (18 * granule.maxb); ++i, ++in0)
|
|
|
|
|
*in0 = (*in0 + *in1++);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
|
{
|
|
|
|
|
auto* in0 = (float*) hybridIn[0];
|
|
|
|
|
auto* in1 = (const float*) hybridIn[1];
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < (int) (18 * granule.maxb); ++i)
|
|
|
|
|
*in0++ = *in1++;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int ch = 0; ch < numChans; ++ch)
|
|
|
|
|
{
|
|
|
|
|
auto& granule = sideinfo.ch[ch].gr[gr];
|
|
|
|
|
granule.doAntialias (hybridIn[ch]);
|
|
|
|
|
layer3Hybrid (hybridIn[ch], hybridOut[ch], ch, granule);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int ss = 0; ss < 18; ++ss)
|
|
|
|
|
{
|
|
|
|
|
if (single >= 0)
|
|
|
|
|
synthesise (hybridOut[0][ss], 0, pcm0, samplesDone);
|
|
|
|
|
else
|
|
|
|
|
synthesiseStereo (hybridOut[0][ss], hybridOut[1][ss], pcm0, pcm1, samplesDone);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int decodeLayer3SideInfo() noexcept
|
|
|
|
|
{
|
|
|
|
|
const int numChannels = frame.numChannels;
|
|
|
|
|
const int sampleRate = frame.sampleRateIndex;
|
|
|
|
|
const int single = (numChannels == 1) ? 0 : frame.single;
|
|
|
|
|
const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;
|
|
|
|
|
const int granules = frame.lsf ? 1 : 2;
|
|
|
|
|
|
|
|
|
|
if (frame.lsf == 0)
|
|
|
|
|
getLayer3SideInfo1 (numChannels, msStereo, sampleRate, single);
|
|
|
|
|
else
|
|
|
|
|
getLayer3SideInfo2 (numChannels, msStereo, sampleRate, single);
|
|
|
|
|
|
|
|
|
|
int databits = 0;
|
|
|
|
|
for (int gr = 0; gr < granules; ++gr)
|
|
|
|
|
for (int ch = 0; ch < numChannels; ++ch)
|
|
|
|
|
databits += sideinfo.ch[ch].gr[gr].part2_3Length;
|
|
|
|
|
|
|
|
|
|
return databits - 8 * (int) sideinfo.mainDataStart;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void layer1Step1 (SideInfoLayer1& si) noexcept
|
|
|
|
|
{
|
|
|
|
|
zerostruct (si);
|
|
|
|
|
int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;
|
|
|
|
|
|
|
|
|
|
if (frame.numChannels == 2)
|
|
|
|
|
{
|
|
|
|
|
for (i = 0; i < jsbound; ++i)
|
|
|
|
|
{
|
|
|
|
|
si.allocation[i][0] = getBitsUint8 (4);
|
|
|
|
|
si.allocation[i][1] = getBitsUint8 (4);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = jsbound; i < 32; ++i)
|
|
|
|
|
si.allocation[i][0] = si.allocation[i][1] = getBitsUint8 (4);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 32; ++i)
|
|
|
|
|
{
|
|
|
|
|
si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;
|
|
|
|
|
si.scaleFactor[i][1] = si.allocation[i][1] ? getBitsUint8 (6) : 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (i = 0; i < 32; ++i)
|
|
|
|
|
si.allocation[i][0] = getBitsUint8 (4);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 32; ++i)
|
|
|
|
|
si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void layer1Step2 (SideInfoLayer1& si, float fraction[2][32]) noexcept
|
|
|
|
|
{
|
|
|
|
|
if (frame.numChannels == 2)
|
|
|
|
|
{
|
|
|
|
|
int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < jsbound; ++i)
|
|
|
|
|
{
|
|
|
|
|
const uint8 n0 = si.allocation[i][0];
|
|
|
|
|
const uint8 n1 = si.allocation[i][1];
|
2019-06-23 03:41:38 +08:00
|
|
|
fraction[0][i] = n0 > 0 ? (float) ((-(1 << n0) + getBitsUint16 (n0 + 1) + 1) * constants.muls[n0 + 1][si.scaleFactor[i][0]]) : 0;
|
|
|
|
|
fraction[1][i] = n1 > 0 ? (float) ((-(1 << n1) + getBitsUint16 (n1 + 1) + 1) * constants.muls[n1 + 1][si.scaleFactor[i][1]]) : 0;
|
2018-06-17 20:34:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = jsbound; i < 32; ++i)
|
|
|
|
|
{
|
|
|
|
|
const uint8 n = si.allocation[i][0];
|
|
|
|
|
|
|
|
|
|
if (n > 0)
|
|
|
|
|
{
|
2019-06-23 03:41:38 +08:00
|
|
|
const uint32 w = ((uint32) -(1 << n) + getBitsUint16 (n + 1) + 1);
|
2018-06-17 20:34:53 +08:00
|
|
|
fraction[0][i] = (float) (w * constants.muls[n + 1][si.scaleFactor[i][0]]);
|
|
|
|
|
fraction[1][i] = (float) (w * constants.muls[n + 1][si.scaleFactor[i][1]]);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
fraction[0][i] = fraction[1][i] = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 32; ++i)
|
|
|
|
|
{
|
|
|
|
|
const uint8 n = si.allocation[i][0];
|
|
|
|
|
const uint8 j = si.scaleFactor[i][0];
|
|
|
|
|
|
|
|
|
|
if (n > 0)
|
2019-06-23 03:41:38 +08:00
|
|
|
fraction[0][i] = (float) ((-(1 << n) + getBitsUint16 (n + 1) + 1) * constants.muls[n + 1][j]);
|
2018-06-17 20:34:53 +08:00
|
|
|
else
|
|
|
|
|
fraction[0][i] = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void layer2Step1 (SideInfoLayer2& si) noexcept
|
|
|
|
|
{
|
|
|
|
|
zerostruct (si);
|
|
|
|
|
const int sblimit = frame.layer2SubBandLimit;
|
|
|
|
|
const int jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : frame.layer2SubBandLimit;
|
|
|
|
|
auto* allocTable = frame.allocationTable;
|
|
|
|
|
uint8 scfsi[32][2];
|
|
|
|
|
|
|
|
|
|
if (frame.numChannels == 2)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < jsbound; ++i)
|
|
|
|
|
{
|
|
|
|
|
auto step = allocTable->bits;
|
|
|
|
|
allocTable += (static_cast<intptr_t> (1) << step);
|
|
|
|
|
si.allocation[i][0] = getBitsUint8 (step);
|
|
|
|
|
si.allocation[i][1] = getBitsUint8 (step);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = jsbound; i < sblimit; ++i)
|
|
|
|
|
{
|
|
|
|
|
auto step = allocTable->bits;
|
|
|
|
|
auto b0 = getBitsUint8 (step);
|
|
|
|
|
allocTable += (static_cast<intptr_t> (1) << step);
|
|
|
|
|
si.allocation[i][0] = b0;
|
|
|
|
|
si.allocation[i][1] = b0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < sblimit; ++i)
|
|
|
|
|
{
|
|
|
|
|
scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;
|
|
|
|
|
scfsi[i][1] = si.allocation[i][1] ? getBitsUint8 (2) : 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < sblimit; ++i)
|
|
|
|
|
{
|
|
|
|
|
const int16 step = allocTable->bits;
|
|
|
|
|
allocTable += (static_cast<intptr_t> (1) << step);
|
|
|
|
|
si.allocation[i][0] = getBitsUint8 (step);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < sblimit; ++i)
|
|
|
|
|
scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < sblimit; ++i)
|
|
|
|
|
{
|
|
|
|
|
for (int ch = 0; ch < frame.numChannels; ++ch)
|
|
|
|
|
{
|
|
|
|
|
uint8 s0 = 0, s1 = 0, s2 = 0;
|
|
|
|
|
|
|
|
|
|
if (si.allocation[i][ch])
|
|
|
|
|
{
|
|
|
|
|
switch (scfsi[i][ch])
|
|
|
|
|
{
|
|
|
|
|
case 0:
|
|
|
|
|
s0 = getBitsUint8 (6);
|
|
|
|
|
s1 = getBitsUint8 (6);
|
|
|
|
|
s2 = getBitsUint8 (6);
|
|
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
s1 = s0 = getBitsUint8 (6);
|
|
|
|
|
s2 = getBitsUint8 (6);
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
s2 = s1 = s0 = getBitsUint8 (6);
|
|
|
|
|
break;
|
|
|
|
|
case 3:
|
|
|
|
|
s0 = getBitsUint8 (6);
|
|
|
|
|
s2 = s1 = getBitsUint8 (6);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
si.scaleFactor[i][ch][0] = s0;
|
|
|
|
|
si.scaleFactor[i][ch][1] = s1;
|
|
|
|
|
si.scaleFactor[i][ch][2] = s2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void layer2Step2 (SideInfoLayer2& si, const int gr, float fraction[2][4][32]) noexcept
|
|
|
|
|
{
|
|
|
|
|
auto* allocTable = frame.allocationTable;
|
|
|
|
|
const int jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : frame.layer2SubBandLimit;
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < jsbound; ++i)
|
|
|
|
|
{
|
|
|
|
|
auto step = allocTable->bits;
|
|
|
|
|
|
|
|
|
|
for (int ch = 0; ch < frame.numChannels; ++ch)
|
|
|
|
|
{
|
|
|
|
|
if (auto ba = si.allocation[i][ch])
|
|
|
|
|
{
|
|
|
|
|
auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
|
|
|
|
|
auto* alloc2 = allocTable + ba;
|
|
|
|
|
auto k = jmin ((int16) 16, alloc2->bits);
|
|
|
|
|
auto d1 = alloc2->d;
|
|
|
|
|
|
|
|
|
|
if (d1 < 0)
|
|
|
|
|
{
|
|
|
|
|
const double cm = constants.muls[k][x1];
|
|
|
|
|
fraction[ch][0][i] = (float) (((int) getBits (k) + d1) * cm);
|
|
|
|
|
fraction[ch][1][i] = (float) (((int) getBits (k) + d1) * cm);
|
|
|
|
|
fraction[ch][2][i] = (float) (((int) getBits (k) + d1) * cm);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
auto* tab = constants.getGroupTable (d1, getBits (k));
|
|
|
|
|
fraction[ch][0][i] = (float) constants.muls[tab[0]][x1];
|
|
|
|
|
fraction[ch][1][i] = (float) constants.muls[tab[1]][x1];
|
|
|
|
|
fraction[ch][2][i] = (float) constants.muls[tab[2]][x1];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
allocTable += (static_cast<intptr_t> (1) << step);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = jsbound; i < frame.layer2SubBandLimit; ++i)
|
|
|
|
|
{
|
|
|
|
|
auto step = allocTable->bits;
|
|
|
|
|
auto ba = si.allocation[i][0];
|
|
|
|
|
|
|
|
|
|
if (ba != 0)
|
|
|
|
|
{
|
|
|
|
|
auto* alloc2 = allocTable + ba;
|
|
|
|
|
int16 k = alloc2->bits;
|
|
|
|
|
int16 d1 = alloc2->d;
|
|
|
|
|
k = (k <= 16) ? k : 16;
|
|
|
|
|
|
|
|
|
|
if (d1 < 0)
|
|
|
|
|
{
|
|
|
|
|
auto v0 = (int) getBits (k);
|
|
|
|
|
auto v1 = (int) getBits (k);
|
|
|
|
|
auto v2 = (int) getBits (k);
|
|
|
|
|
|
|
|
|
|
for (int ch = 0; ch < frame.numChannels; ++ch)
|
|
|
|
|
{
|
|
|
|
|
auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
|
|
|
|
|
const double cm = constants.muls[k][x1];
|
|
|
|
|
fraction[ch][0][i] = (float) ((v0 + d1) * cm);
|
|
|
|
|
fraction[ch][1][i] = (float) ((v1 + d1) * cm);
|
|
|
|
|
fraction[ch][2][i] = (float) ((v2 + d1) * cm);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
auto* tab = constants.getGroupTable (d1, getBits (k));
|
|
|
|
|
auto k0 = tab[0];
|
|
|
|
|
auto k1 = tab[1];
|
|
|
|
|
auto k2 = tab[2];
|
|
|
|
|
|
|
|
|
|
for (int ch = 0; ch < frame.numChannels; ++ch)
|
|
|
|
|
{
|
|
|
|
|
auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
|
|
|
|
|
fraction[ch][0][i] = (float) constants.muls[k0][x1];
|
|
|
|
|
fraction[ch][1][i] = (float) constants.muls[k1][x1];
|
|
|
|
|
fraction[ch][2][i] = (float) constants.muls[k2][x1];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] = 0;
|
|
|
|
|
fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
allocTable += (static_cast<intptr_t> (1) << step);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int ch = 0; ch < frame.numChannels; ++ch)
|
|
|
|
|
for (int i = frame.layer2SubBandLimit; i < 32; ++i)
|
|
|
|
|
fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void getLayer3SideInfo1 (const int stereo, const bool msStereo, const int sampleRate, const int single) noexcept
|
|
|
|
|
{
|
|
|
|
|
const int powdiff = (single == 3) ? 4 : 0;
|
|
|
|
|
sideinfo.mainDataStart = getBits (9);
|
|
|
|
|
sideinfo.privateBits = getBitsUnchecked (stereo == 1 ? 5 : 3);
|
|
|
|
|
|
|
|
|
|
for (int ch = 0; ch < stereo; ++ch)
|
|
|
|
|
{
|
|
|
|
|
sideinfo.ch[ch].gr[0].scfsi = -1;
|
|
|
|
|
sideinfo.ch[ch].gr[1].scfsi = (int) getBitsUnchecked (4);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int gr = 0; gr < 2; ++gr)
|
|
|
|
|
{
|
|
|
|
|
for (int ch = 0; ch < stereo; ++ch)
|
|
|
|
|
{
|
|
|
|
|
auto& granule = sideinfo.ch[ch].gr[gr];
|
|
|
|
|
|
|
|
|
|
granule.part2_3Length = getBits (12);
|
|
|
|
|
granule.bigValues = jmin (288u, getBitsUnchecked (9));
|
|
|
|
|
|
|
|
|
|
const int qss = (int) getBitsUnchecked (8);
|
|
|
|
|
granule.pow2gain = constants.powToGains + 256 - qss + powdiff;
|
|
|
|
|
|
|
|
|
|
if (msStereo)
|
|
|
|
|
granule.pow2gain += 2;
|
|
|
|
|
|
|
|
|
|
granule.scaleFactorCompression = getBitsUnchecked (4);
|
|
|
|
|
|
|
|
|
|
if (getOneBit())
|
|
|
|
|
{
|
|
|
|
|
granule.blockType = getBitsUnchecked (2);
|
|
|
|
|
granule.mixedBlockFlag = getOneBit();
|
|
|
|
|
granule.tableSelect[0] = getBitsUnchecked (5);
|
|
|
|
|
granule.tableSelect[1] = getBitsUnchecked (5);
|
|
|
|
|
granule.tableSelect[2] = 0;
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
|
|
|
{
|
|
|
|
|
const uint32 sbg = (getBitsUnchecked (3) << 3);
|
|
|
|
|
granule.fullGain[i] = granule.pow2gain + sbg;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
granule.region1Start = 36 >> 1;
|
|
|
|
|
granule.region2Start = 576 >> 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
|
|
|
granule.tableSelect[i] = getBitsUnchecked (5);
|
|
|
|
|
|
|
|
|
|
const int r0c = (int) getBitsUnchecked (4);
|
|
|
|
|
const int r1c = (int) getBitsUnchecked (3);
|
|
|
|
|
const int region0index = jmin (22, r0c + 1);
|
|
|
|
|
const int region1index = jmin (22, r0c + 1 + r1c + 1);
|
|
|
|
|
|
|
|
|
|
granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);
|
|
|
|
|
granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);
|
|
|
|
|
granule.blockType = 0;
|
|
|
|
|
granule.mixedBlockFlag = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
granule.preflag = getOneBit();
|
|
|
|
|
granule.scaleFactorScale = getOneBit();
|
|
|
|
|
granule.count1TableSelect = getOneBit();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void getLayer3SideInfo2 (const int stereo, const bool msStereo, const int sampleRate, const int single) noexcept
|
|
|
|
|
{
|
|
|
|
|
const int powdiff = (single == 3) ? 4 : 0;
|
|
|
|
|
sideinfo.mainDataStart = getBits (8);
|
|
|
|
|
sideinfo.privateBits = stereo == 1 ? getOneBit() : getBitsUnchecked (2);
|
|
|
|
|
|
|
|
|
|
for (int ch = 0; ch < stereo; ++ch)
|
|
|
|
|
{
|
|
|
|
|
auto& granule = sideinfo.ch[ch].gr[0];
|
|
|
|
|
|
|
|
|
|
granule.part2_3Length = getBits (12);
|
|
|
|
|
granule.bigValues = jmin (288u, getBitsUnchecked (9));
|
|
|
|
|
|
|
|
|
|
const uint32 qss = getBitsUnchecked (8);
|
|
|
|
|
granule.pow2gain = constants.powToGains + 256 - qss + powdiff;
|
|
|
|
|
|
|
|
|
|
if (msStereo)
|
|
|
|
|
granule.pow2gain += 2;
|
|
|
|
|
|
|
|
|
|
granule.scaleFactorCompression = getBits (9);
|
|
|
|
|
|
|
|
|
|
if (getOneBit())
|
|
|
|
|
{
|
|
|
|
|
granule.blockType = getBitsUnchecked (2);
|
|
|
|
|
granule.mixedBlockFlag = getOneBit();
|
|
|
|
|
granule.tableSelect[0] = getBitsUnchecked (5);
|
|
|
|
|
granule.tableSelect[1] = getBitsUnchecked (5);
|
|
|
|
|
granule.tableSelect[2] = 0;
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
|
|
|
{
|
|
|
|
|
const uint32 sbg = (getBitsUnchecked (3) << 3);
|
|
|
|
|
granule.fullGain[i] = granule.pow2gain + sbg;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (granule.blockType == 0)
|
|
|
|
|
{}
|
|
|
|
|
|
|
|
|
|
if (granule.blockType == 2)
|
|
|
|
|
granule.region1Start = sampleRate == 8 ? 36 : (36 >> 1);
|
|
|
|
|
else
|
|
|
|
|
granule.region1Start = sampleRate == 8 ? (108 >> 1) : (54 >> 1);
|
|
|
|
|
|
|
|
|
|
granule.region2Start = 576 >> 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
|
|
|
granule.tableSelect[i] = getBitsUnchecked (5);
|
|
|
|
|
|
|
|
|
|
const int r0c = (int) getBitsUnchecked (4);
|
|
|
|
|
const int r1c = (int) getBitsUnchecked (3);
|
|
|
|
|
const int region0index = jmin (22, r0c + 1);
|
|
|
|
|
const int region1index = jmin (22, r0c + 1 + r1c + 1);
|
|
|
|
|
|
|
|
|
|
granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);
|
|
|
|
|
granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);
|
|
|
|
|
granule.blockType = 0;
|
|
|
|
|
granule.mixedBlockFlag = 0;
|
|
|
|
|
}
|
|
|
|
|
granule.scaleFactorScale = getOneBit();
|
|
|
|
|
granule.count1TableSelect = getOneBit();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int getLayer3ScaleFactors1 (int* scf, const Layer3SideInfo::Info& granule) noexcept
|
|
|
|
|
{
|
|
|
|
|
static const uint8 lengths[2][16] =
|
|
|
|
|
{
|
|
|
|
|
{ 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
|
|
|
|
|
{ 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int numBits;
|
|
|
|
|
const int num0 = lengths[0][granule.scaleFactorCompression];
|
|
|
|
|
const int num1 = lengths[1][granule.scaleFactorCompression];
|
|
|
|
|
|
|
|
|
|
if (granule.blockType == 2)
|
|
|
|
|
{
|
|
|
|
|
int i = 18;
|
|
|
|
|
numBits = (num0 + num1) * 18;
|
|
|
|
|
|
|
|
|
|
if (granule.mixedBlockFlag)
|
|
|
|
|
{
|
|
|
|
|
for (int j = 8; --j >= 0;) *scf++ = (int) getBitsUnchecked (num0);
|
|
|
|
|
numBits -= num0;
|
|
|
|
|
i = 9;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (; --i >= 0;) *scf++ = (int) getBitsUnchecked (num0);
|
|
|
|
|
for (i = 18; --i >= 0;) *scf++ = (int) getBitsUnchecked (num1);
|
|
|
|
|
|
|
|
|
|
*scf++ = 0;
|
|
|
|
|
*scf++ = 0;
|
|
|
|
|
*scf++ = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
const int scfsi = granule.scfsi;
|
|
|
|
|
|
|
|
|
|
if (scfsi < 0)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 11; --i >= 0;) *scf++ = (int) getBitsUnchecked (num0);
|
|
|
|
|
for (int j = 10; --j >= 0;) *scf++ = (int) getBitsUnchecked (num1);
|
|
|
|
|
numBits = (num0 + num1) * 10 + num0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
numBits = 0;
|
|
|
|
|
if ((scfsi & 8) == 0)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 6; --i >= 0;) *scf++ = (int) getBitsUnchecked (num0);
|
|
|
|
|
numBits += num0 * 6;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
scf += 6;
|
|
|
|
|
|
|
|
|
|
if ((scfsi & 4) == 0)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 5; --i >= 0;) *scf++ = (int) getBitsUnchecked (num0);
|
|
|
|
|
numBits += num0 * 5;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
scf += 5;
|
|
|
|
|
|
|
|
|
|
if ((scfsi & 2) == 0)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 5; --i >= 0;) *scf++ = (int) getBitsUnchecked (num1);
|
|
|
|
|
numBits += num1 * 5;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
scf += 5;
|
|
|
|
|
|
|
|
|
|
if ((scfsi & 1) == 0)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 5; --i >= 0;) *scf++ = (int) getBitsUnchecked (num1);
|
|
|
|
|
numBits += num1 * 5;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
scf += 5;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*scf = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return numBits;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int getLayer3ScaleFactors2 (int* scf, Layer3SideInfo::Info& granule, const bool iStereo) noexcept
|
|
|
|
|
{
|
|
|
|
|
static const uint8 scaleTable[3][6][4] =
|
|
|
|
|
{
|
|
|
|
|
{ { 6, 5, 5, 5 }, { 6, 5, 7, 3 }, { 11, 10, 0, 0 }, { 7, 7, 7, 0 }, { 6, 6, 6, 3 }, { 8, 8, 5, 0 } },
|
|
|
|
|
{ { 9, 9, 9, 9 }, { 9, 9, 12, 6 }, { 18, 18, 0, 0 }, { 12, 12, 12, 0 }, { 12, 9, 9, 6 }, { 15, 12, 9, 0 } },
|
|
|
|
|
{ { 6, 9, 9, 9 }, { 6, 9, 12, 6 }, { 15, 18, 0, 0 }, { 6, 15, 12, 0 }, { 6, 12, 9, 6 }, { 6, 18, 9, 0 } }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
uint32 len = iStereo ? constants.iLength2[granule.scaleFactorCompression >> 1]
|
|
|
|
|
: constants.nLength2[granule.scaleFactorCompression];
|
|
|
|
|
|
|
|
|
|
granule.preflag = (len >> 15) & 1;
|
|
|
|
|
|
|
|
|
|
int n = 0;
|
|
|
|
|
if (granule.blockType == 2)
|
|
|
|
|
{
|
|
|
|
|
++n;
|
|
|
|
|
if (granule.mixedBlockFlag)
|
|
|
|
|
++n;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const uint8* const data = scaleTable[n][(len >> 12) & 7];
|
|
|
|
|
int numBits = 0;
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
|
|
|
{
|
|
|
|
|
int num = len & 7;
|
|
|
|
|
len >>= 3;
|
|
|
|
|
|
|
|
|
|
if (num)
|
|
|
|
|
{
|
|
|
|
|
for (int j = 0; j < (int) (data[i]); ++j)
|
|
|
|
|
*scf++ = (int) getBitsUnchecked (num);
|
|
|
|
|
|
|
|
|
|
numBits += data[i] * num;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int j = 0; j < (int) (data[i]); ++j)
|
|
|
|
|
*scf++ = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
n = (n << 1) + 1;
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < n; ++i)
|
|
|
|
|
*scf++ = 0;
|
|
|
|
|
|
|
|
|
|
return numBits;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool layer3DequantizeSample (float xr[32][18], int* scf, Layer3SideInfo::Info& granule, int sampleRate, int part2bits) noexcept
|
|
|
|
|
{
|
|
|
|
|
const uint32 shift = 1 + granule.scaleFactorScale;
|
|
|
|
|
auto* xrpnt = (float*) xr;
|
|
|
|
|
auto part2remain = (int) granule.part2_3Length - part2bits;
|
|
|
|
|
|
|
|
|
|
zeromem (xrpnt, sizeof (float) * (size_t) (&xr[32][0] - xrpnt));
|
|
|
|
|
|
|
|
|
|
auto bv = (int) granule.bigValues;
|
|
|
|
|
auto region1 = (int) granule.region1Start;
|
|
|
|
|
auto region2 = (int) granule.region2Start;
|
|
|
|
|
int l3 = ((576 >> 1) - bv) >> 1;
|
|
|
|
|
int l[3];
|
|
|
|
|
|
|
|
|
|
if (bv <= region1)
|
|
|
|
|
{
|
|
|
|
|
l[0] = bv;
|
|
|
|
|
l[1] = 0;
|
|
|
|
|
l[2] = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
l[0] = region1;
|
|
|
|
|
if (bv <= region2)
|
|
|
|
|
{
|
|
|
|
|
l[1] = bv - l[0];
|
|
|
|
|
l[2] = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
l[1] = region2 - l[0];
|
|
|
|
|
l[2] = bv - region2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
|
|
|
if (l[i] < 0)
|
|
|
|
|
l[i] = 0;
|
|
|
|
|
|
|
|
|
|
if (granule.blockType == 2)
|
|
|
|
|
{
|
|
|
|
|
int max[4];
|
|
|
|
|
int step = 0, lwin = 0, cb = 0, mc = 0;
|
|
|
|
|
float v = 0;
|
|
|
|
|
int* map;
|
|
|
|
|
int* mapEnd;
|
|
|
|
|
|
|
|
|
|
if (granule.mixedBlockFlag)
|
|
|
|
|
{
|
|
|
|
|
max[3] = -1;
|
|
|
|
|
max[0] = max[1] = max[2] = 2;
|
|
|
|
|
map = constants.map [sampleRate][0];
|
|
|
|
|
mapEnd = constants.mapEnd[sampleRate][0];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
max[0] = max[1] = max[2] = max[3] = -1;
|
|
|
|
|
map = constants.map [sampleRate][1];
|
|
|
|
|
mapEnd = constants.mapEnd[sampleRate][1];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 2; ++i)
|
|
|
|
|
{
|
|
|
|
|
auto* h = huffmanTables1 + granule.tableSelect[i];
|
|
|
|
|
|
|
|
|
|
for (int lp = l[i]; lp != 0; --lp, --mc)
|
|
|
|
|
{
|
|
|
|
|
int x, y;
|
|
|
|
|
if (mc == 0)
|
|
|
|
|
{
|
|
|
|
|
mc = *map++;
|
|
|
|
|
xrpnt = ((float*) xr) + (*map++);
|
|
|
|
|
lwin = *map++;
|
|
|
|
|
cb = *map++;
|
|
|
|
|
|
|
|
|
|
if (lwin == 3)
|
|
|
|
|
{
|
|
|
|
|
v = granule.pow2gain[ (*scf++) << shift];
|
|
|
|
|
step = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
v = granule.fullGain[lwin][ (*scf++) << shift];
|
|
|
|
|
step = 3;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto* val = h->table;
|
|
|
|
|
|
|
|
|
|
while ((y = *val++) < 0)
|
|
|
|
|
{
|
|
|
|
|
if (getOneBit())
|
|
|
|
|
val -= y;
|
|
|
|
|
|
|
|
|
|
--part2remain;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
x = y >> 4;
|
|
|
|
|
y &= 15;
|
|
|
|
|
|
|
|
|
|
if (x == 15)
|
|
|
|
|
{
|
|
|
|
|
max[lwin] = cb;
|
|
|
|
|
part2remain -= h->bits + 1;
|
|
|
|
|
x += getBits ((int) h->bits);
|
|
|
|
|
*xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
|
|
|
|
|
}
|
|
|
|
|
else if (x)
|
|
|
|
|
{
|
|
|
|
|
max[lwin] = cb;
|
|
|
|
|
*xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
|
|
|
|
|
--part2remain;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*xrpnt = 0;
|
|
|
|
|
|
|
|
|
|
xrpnt += step;
|
|
|
|
|
|
|
|
|
|
if (y == 15)
|
|
|
|
|
{
|
|
|
|
|
max[lwin] = cb;
|
|
|
|
|
part2remain -= h->bits + 1;
|
|
|
|
|
y += getBits ((int) h->bits);
|
|
|
|
|
*xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
|
|
|
|
|
}
|
|
|
|
|
else if (y)
|
|
|
|
|
{
|
|
|
|
|
max[lwin] = cb;
|
|
|
|
|
*xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
|
|
|
|
|
--part2remain;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*xrpnt = 0;
|
|
|
|
|
|
|
|
|
|
xrpnt += step;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (; l3 && (part2remain > 0); --l3)
|
|
|
|
|
{
|
|
|
|
|
auto* h = huffmanTables2 + granule.count1TableSelect;
|
|
|
|
|
auto* val = h->table;
|
|
|
|
|
int16 a;
|
|
|
|
|
|
|
|
|
|
while ((a = *val++) < 0)
|
|
|
|
|
{
|
|
|
|
|
if (part2remain <= 0)
|
|
|
|
|
{
|
|
|
|
|
a = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
--part2remain;
|
|
|
|
|
|
|
|
|
|
if (getOneBit())
|
|
|
|
|
val -= a;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
|
|
|
{
|
|
|
|
|
if ((i & 1) == 0)
|
|
|
|
|
{
|
|
|
|
|
if (mc == 0)
|
|
|
|
|
{
|
|
|
|
|
mc = *map++;
|
|
|
|
|
xrpnt = ((float*) xr) + (*map++);
|
|
|
|
|
lwin = *map++;
|
|
|
|
|
cb = *map++;
|
|
|
|
|
|
|
|
|
|
if (lwin == 3)
|
|
|
|
|
{
|
|
|
|
|
v = granule.pow2gain[ (*scf++) << shift];
|
|
|
|
|
step = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
v = granule.fullGain[lwin][ (*scf++) << shift];
|
|
|
|
|
step = 3;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
--mc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((a & (8 >> i)))
|
|
|
|
|
{
|
|
|
|
|
max[lwin] = cb;
|
|
|
|
|
|
|
|
|
|
if (part2remain == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
--part2remain;
|
|
|
|
|
*xrpnt = getOneBit() ? -v : v;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*xrpnt = 0;
|
|
|
|
|
|
|
|
|
|
xrpnt += step;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (map < mapEnd)
|
|
|
|
|
{
|
|
|
|
|
if (mc == 0)
|
|
|
|
|
{
|
|
|
|
|
mc = *map++;
|
|
|
|
|
xrpnt = ((float*) xr) + *map++;
|
|
|
|
|
step = (*map++ == 3) ? 1 : 3;
|
|
|
|
|
++map;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
--mc;
|
|
|
|
|
*xrpnt = 0; xrpnt += step;
|
|
|
|
|
*xrpnt = 0; xrpnt += step;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
granule.maxBand[0] = (uint32) (max[0] + 1);
|
|
|
|
|
granule.maxBand[1] = (uint32) (max[1] + 1);
|
|
|
|
|
granule.maxBand[2] = (uint32) (max[2] + 1);
|
|
|
|
|
granule.maxBandl = (uint32) (max[3] + 1);
|
|
|
|
|
|
|
|
|
|
const int rmax = jmax (max[0], max[1], max[3]) + 1;
|
|
|
|
|
granule.maxb = rmax ? (uint32) constants.shortLimit[sampleRate][rmax]
|
|
|
|
|
: (uint32) constants.longLimit[sampleRate][max[3] + 1];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
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 };
|
|
|
|
|
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 };
|
|
|
|
|
|
|
|
|
|
auto* pretab = (const int*) (granule.preflag ? pretab1 : pretab2);
|
|
|
|
|
int max = -1, cb = 0, mc = 0;
|
|
|
|
|
auto* map = constants.map[sampleRate][2];
|
|
|
|
|
float v = 0;
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
|
|
|
{
|
|
|
|
|
auto* h = huffmanTables1 + granule.tableSelect[i];
|
|
|
|
|
|
|
|
|
|
for (int lp = l[i]; lp != 0; --lp, --mc)
|
|
|
|
|
{
|
|
|
|
|
if (mc == 0)
|
|
|
|
|
{
|
|
|
|
|
mc = *map++;
|
|
|
|
|
v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];
|
|
|
|
|
cb = *map++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto* val = h->table;
|
|
|
|
|
int y;
|
|
|
|
|
|
|
|
|
|
while ((y = *val++) < 0)
|
|
|
|
|
{
|
|
|
|
|
if (getOneBit()) val -= y;
|
|
|
|
|
--part2remain;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int x = y >> 4;
|
|
|
|
|
y &= 15;
|
|
|
|
|
|
|
|
|
|
if (x == 15)
|
|
|
|
|
{
|
|
|
|
|
max = cb;
|
|
|
|
|
part2remain -= h->bits + 1;
|
|
|
|
|
x += getBits ((int) h->bits);
|
|
|
|
|
*xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
|
|
|
|
|
}
|
|
|
|
|
else if (x)
|
|
|
|
|
{
|
|
|
|
|
max = cb;
|
|
|
|
|
*xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
|
|
|
|
|
--part2remain;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*xrpnt++ = 0;
|
|
|
|
|
|
|
|
|
|
if (y == 15)
|
|
|
|
|
{
|
|
|
|
|
max = cb;
|
|
|
|
|
part2remain -= h->bits + 1;
|
|
|
|
|
y += getBits ((int) h->bits);
|
|
|
|
|
*xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
|
|
|
|
|
}
|
|
|
|
|
else if (y)
|
|
|
|
|
{
|
|
|
|
|
max = cb;
|
|
|
|
|
*xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
|
|
|
|
|
--part2remain;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*xrpnt++ = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (; l3 && part2remain > 0; --l3)
|
|
|
|
|
{
|
|
|
|
|
auto* h = huffmanTables2 + granule.count1TableSelect;
|
|
|
|
|
auto* values = h->table;
|
|
|
|
|
int16 a;
|
|
|
|
|
|
|
|
|
|
while ((a = *values++) < 0)
|
|
|
|
|
{
|
|
|
|
|
if (part2remain <= 0)
|
|
|
|
|
{
|
|
|
|
|
a = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
--part2remain;
|
|
|
|
|
|
|
|
|
|
if (getOneBit())
|
|
|
|
|
values -= a;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
|
|
|
{
|
|
|
|
|
if ((i & 1) == 0)
|
|
|
|
|
{
|
|
|
|
|
if (mc == 0)
|
|
|
|
|
{
|
|
|
|
|
mc = *map++;
|
|
|
|
|
cb = *map++;
|
|
|
|
|
v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];
|
|
|
|
|
}
|
|
|
|
|
--mc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((a & (0x8 >> i)))
|
|
|
|
|
{
|
|
|
|
|
max = cb;
|
|
|
|
|
|
|
|
|
|
if (part2remain <= 0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
--part2remain;
|
|
|
|
|
*xrpnt++ = getOneBit() ? -v : v;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*xrpnt++ = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
zeromem (xrpnt, sizeof (float) * (size_t) (&xr[32][0] - xrpnt));
|
|
|
|
|
|
|
|
|
|
granule.maxBandl = (uint32) (max + 1);
|
|
|
|
|
granule.maxb = (uint32) constants.longLimit[sampleRate][granule.maxBandl];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (part2remain > 16)
|
|
|
|
|
{
|
|
|
|
|
getBits (16);
|
|
|
|
|
part2remain -= 16;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (part2remain > 0)
|
|
|
|
|
getBits (part2remain);
|
|
|
|
|
else if (part2remain < 0)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void layer3Hybrid (float fsIn[32][18], float tsOut[18][32], int ch, const Layer3SideInfo::Info& granule) noexcept
|
|
|
|
|
{
|
|
|
|
|
auto* ts = (float*) tsOut;
|
|
|
|
|
float* rawout1, *rawout2;
|
|
|
|
|
int sb = 0;
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
int b = hybridBlockIndex[ch];
|
|
|
|
|
rawout1 = hybridBlock[b][ch];
|
|
|
|
|
b = 1 - b;
|
|
|
|
|
rawout2 = hybridBlock[b][ch];
|
|
|
|
|
hybridBlockIndex[ch] = b;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (granule.mixedBlockFlag)
|
|
|
|
|
{
|
|
|
|
|
sb = 2;
|
|
|
|
|
DCT::dct36 (fsIn[0], rawout1, rawout2, constants.win[0], ts);
|
|
|
|
|
DCT::dct36 (fsIn[1], rawout1 + 18, rawout2 + 18, constants.win1[0], ts + 1);
|
|
|
|
|
rawout1 += 36;
|
|
|
|
|
rawout2 += 36;
|
|
|
|
|
ts += 2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto bt = granule.blockType;
|
|
|
|
|
|
|
|
|
|
if (bt == 2)
|
|
|
|
|
{
|
|
|
|
|
for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)
|
|
|
|
|
{
|
|
|
|
|
DCT::dct12 (fsIn[sb], rawout1, rawout2, constants.win[2], ts);
|
|
|
|
|
DCT::dct12 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[2], ts + 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)
|
|
|
|
|
{
|
|
|
|
|
DCT::dct36 (fsIn[sb], rawout1, rawout2, constants.win[bt], ts);
|
|
|
|
|
DCT::dct36 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[bt], ts + 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (; sb < 32; ++sb, ++ts)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 18; ++i)
|
|
|
|
|
{
|
|
|
|
|
ts[i * 32] = *rawout1++;
|
|
|
|
|
*rawout2++ = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void synthesiseStereo (const float* bandPtr0, const float* bandPtr1, float* out0, float* out1, int& samplesDone) noexcept
|
|
|
|
|
{
|
|
|
|
|
auto dummy = samplesDone;
|
|
|
|
|
synthesise (bandPtr0, 0, out0, dummy);
|
|
|
|
|
synthesise (bandPtr1, 1, out1, samplesDone);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void synthesise (const float* bandPtr, int channel, float* out, int& samplesDone)
|
|
|
|
|
{
|
|
|
|
|
out += samplesDone;
|
|
|
|
|
const int bo = channel == 0 ? ((synthBo - 1) & 15) : synthBo;
|
|
|
|
|
float (*buf)[0x110] = synthBuffers[channel];
|
|
|
|
|
float* b0;
|
|
|
|
|
auto bo1 = bo;
|
|
|
|
|
|
|
|
|
|
if (bo & 1)
|
|
|
|
|
{
|
|
|
|
|
b0 = buf[0];
|
|
|
|
|
DCT::dct64 (buf[1] + ((bo + 1) & 15), buf[0] + bo, bandPtr);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
++bo1;
|
|
|
|
|
b0 = buf[1];
|
|
|
|
|
DCT::dct64 (buf[0] + bo, buf[1] + bo1, bandPtr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
synthBo = bo;
|
|
|
|
|
const float* window = constants.decodeWin + 16 - bo1;
|
|
|
|
|
|
|
|
|
|
for (int j = 16; j != 0; --j, b0 += 16, window += 32)
|
|
|
|
|
{
|
|
|
|
|
auto sum = window[0] * b0[0]; sum -= window[1] * b0[1];
|
|
|
|
|
sum += window[2] * b0[2]; sum -= window[3] * b0[3];
|
|
|
|
|
sum += window[4] * b0[4]; sum -= window[5] * b0[5];
|
|
|
|
|
sum += window[6] * b0[6]; sum -= window[7] * b0[7];
|
|
|
|
|
sum += window[8] * b0[8]; sum -= window[9] * b0[9];
|
|
|
|
|
sum += window[10] * b0[10]; sum -= window[11] * b0[11];
|
|
|
|
|
sum += window[12] * b0[12]; sum -= window[13] * b0[13];
|
|
|
|
|
sum += window[14] * b0[14]; sum -= window[15] * b0[15];
|
|
|
|
|
*out++ = sum;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
auto sum = window[0] * b0[0]; sum += window[2] * b0[2];
|
|
|
|
|
sum += window[4] * b0[4]; sum += window[6] * b0[6];
|
|
|
|
|
sum += window[8] * b0[8]; sum += window[10] * b0[10];
|
|
|
|
|
sum += window[12] * b0[12]; sum += window[14] * b0[14];
|
|
|
|
|
*out++ = sum;
|
|
|
|
|
b0 -= 16; window -= 32;
|
|
|
|
|
window += bo1 << 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int j = 15; j != 0; --j, b0 -= 16, window -= 32)
|
|
|
|
|
{
|
|
|
|
|
auto sum = -window[-1] * b0[0]; sum -= window[-2] * b0[1];
|
|
|
|
|
sum -= window[-3] * b0[2]; sum -= window[-4] * b0[3];
|
|
|
|
|
sum -= window[-5] * b0[4]; sum -= window[-6] * b0[5];
|
|
|
|
|
sum -= window[-7] * b0[6]; sum -= window[-8] * b0[7];
|
|
|
|
|
sum -= window[-9] * b0[8]; sum -= window[-10] * b0[9];
|
|
|
|
|
sum -= window[-11] * b0[10]; sum -= window[-12] * b0[11];
|
|
|
|
|
sum -= window[-13] * b0[12]; sum -= window[-14] * b0[13];
|
|
|
|
|
sum -= window[-15] * b0[14]; sum -= window[0] * b0[15];
|
|
|
|
|
*out++ = sum;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
samplesDone += 32;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Stream)
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
|
|
|
static const char* const mp3FormatName = "MP3 file";
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
|
|
|
class MP3Reader : public AudioFormatReader
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
MP3Reader (InputStream* const in)
|
|
|
|
|
: AudioFormatReader (in, mp3FormatName),
|
|
|
|
|
stream (*in), currentPosition (0),
|
|
|
|
|
decodedStart (0), decodedEnd (0)
|
|
|
|
|
{
|
|
|
|
|
skipID3();
|
|
|
|
|
const int64 streamPos = stream.stream.getPosition();
|
|
|
|
|
|
|
|
|
|
if (readNextBlock())
|
|
|
|
|
{
|
|
|
|
|
bitsPerSample = 32;
|
|
|
|
|
usesFloatingPointData = true;
|
|
|
|
|
sampleRate = stream.frame.getFrequency();
|
|
|
|
|
numChannels = (unsigned int) stream.frame.numChannels;
|
|
|
|
|
lengthInSamples = findLength (streamPos);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool readSamples (int** destSamples, int numDestChannels, int startOffsetInDestBuffer,
|
|
|
|
|
int64 startSampleInFile, int numSamples) override
|
|
|
|
|
{
|
|
|
|
|
jassert (destSamples != nullptr);
|
|
|
|
|
|
|
|
|
|
if (currentPosition != startSampleInFile)
|
|
|
|
|
{
|
|
|
|
|
if (! stream.seek ((int) (startSampleInFile / 1152 - 1)))
|
|
|
|
|
{
|
|
|
|
|
currentPosition = -1;
|
|
|
|
|
createEmptyDecodedData();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
decodedStart = decodedEnd = 0;
|
|
|
|
|
const int64 streamPos = stream.currentFrameIndex * 1152;
|
|
|
|
|
int toSkip = (int) (startSampleInFile - streamPos);
|
|
|
|
|
jassert (toSkip >= 0);
|
|
|
|
|
|
|
|
|
|
while (toSkip > 0)
|
|
|
|
|
{
|
|
|
|
|
if (! readNextBlock())
|
|
|
|
|
{
|
|
|
|
|
createEmptyDecodedData();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const int numReady = decodedEnd - decodedStart;
|
|
|
|
|
|
|
|
|
|
if (numReady > toSkip)
|
|
|
|
|
{
|
|
|
|
|
decodedStart += toSkip;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
toSkip -= numReady;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
currentPosition = startSampleInFile;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (numSamples > 0)
|
|
|
|
|
{
|
|
|
|
|
if (decodedEnd <= decodedStart && ! readNextBlock())
|
|
|
|
|
{
|
|
|
|
|
for (int i = numDestChannels; --i >= 0;)
|
|
|
|
|
if (destSamples[i] != nullptr)
|
|
|
|
|
zeromem (destSamples[i] + startOffsetInDestBuffer, sizeof (float) * (size_t) numSamples);
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const int numToCopy = jmin (decodedEnd - decodedStart, numSamples);
|
|
|
|
|
float* const* const dst = reinterpret_cast<float**> (destSamples);
|
|
|
|
|
memcpy (dst[0] + startOffsetInDestBuffer, decoded0 + decodedStart, sizeof (float) * (size_t) numToCopy);
|
|
|
|
|
|
|
|
|
|
if (numDestChannels > 1 && dst[1] != nullptr)
|
|
|
|
|
memcpy (dst[1] + startOffsetInDestBuffer, (numChannels < 2 ? decoded0 : decoded1) + decodedStart, sizeof (float) * (size_t) numToCopy);
|
|
|
|
|
|
|
|
|
|
startOffsetInDestBuffer += numToCopy;
|
|
|
|
|
decodedStart += numToCopy;
|
|
|
|
|
currentPosition += numToCopy;
|
|
|
|
|
numSamples -= numToCopy;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
MP3Stream stream;
|
|
|
|
|
int64 currentPosition;
|
|
|
|
|
enum { decodedDataSize = 1152 };
|
|
|
|
|
float decoded0[decodedDataSize], decoded1[decodedDataSize];
|
|
|
|
|
int decodedStart, decodedEnd;
|
|
|
|
|
|
|
|
|
|
void createEmptyDecodedData() noexcept
|
|
|
|
|
{
|
|
|
|
|
zeromem (decoded0, sizeof (decoded0));
|
|
|
|
|
zeromem (decoded1, sizeof (decoded1));
|
|
|
|
|
decodedStart = 0;
|
|
|
|
|
decodedEnd = decodedDataSize;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool readNextBlock()
|
|
|
|
|
{
|
|
|
|
|
for (int attempts = 10; --attempts >= 0;)
|
|
|
|
|
{
|
|
|
|
|
int samplesDone = 0;
|
|
|
|
|
const int result = stream.decodeNextBlock (decoded0, decoded1, samplesDone);
|
|
|
|
|
|
|
|
|
|
if (result > 0 && stream.stream.isExhausted())
|
|
|
|
|
{
|
|
|
|
|
createEmptyDecodedData();
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (result <= 0)
|
|
|
|
|
{
|
|
|
|
|
decodedStart = 0;
|
|
|
|
|
decodedEnd = samplesDone;
|
|
|
|
|
return result == 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void skipID3()
|
|
|
|
|
{
|
|
|
|
|
const int64 originalPosition = stream.stream.getPosition();
|
|
|
|
|
const uint32 firstWord = (uint32) stream.stream.readInt();
|
|
|
|
|
|
|
|
|
|
if ((firstWord & 0xffffff) == 0x334449)
|
|
|
|
|
{
|
|
|
|
|
uint8 buffer[6];
|
|
|
|
|
|
|
|
|
|
if (stream.stream.read (buffer, 6) == 6
|
|
|
|
|
&& buffer[0] != 0xff
|
|
|
|
|
&& ((buffer[2] | buffer[3] | buffer[4] | buffer[5]) & 0x80) == 0)
|
|
|
|
|
{
|
|
|
|
|
const uint32 length = (((uint32) buffer[2]) << 21)
|
|
|
|
|
| (((uint32) buffer[3]) << 14)
|
|
|
|
|
| (((uint32) buffer[4]) << 7)
|
|
|
|
|
| ((uint32) buffer[5]);
|
|
|
|
|
|
|
|
|
|
stream.stream.skipNextBytes (length);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
stream.stream.setPosition (originalPosition);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int64 findLength (int64 streamStartPos)
|
|
|
|
|
{
|
|
|
|
|
int64 numFrames = stream.numFrames;
|
|
|
|
|
|
|
|
|
|
if (numFrames <= 0)
|
|
|
|
|
{
|
|
|
|
|
const int64 streamSize = stream.stream.getTotalLength();
|
|
|
|
|
|
|
|
|
|
if (streamSize > 0)
|
|
|
|
|
{
|
|
|
|
|
const int bytesPerFrame = stream.frame.frameSize + 4;
|
|
|
|
|
|
|
|
|
|
if (bytesPerFrame == 417 || bytesPerFrame == 418)
|
|
|
|
|
numFrames = roundToInt ((streamSize - streamStartPos) / 417.95918); // more accurate for 128k
|
|
|
|
|
else
|
|
|
|
|
numFrames = (streamSize - streamStartPos) / bytesPerFrame;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return numFrames * 1152;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Reader)
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
|
|
|
MP3AudioFormat::MP3AudioFormat() : AudioFormat (MP3Decoder::mp3FormatName, ".mp3") {}
|
|
|
|
|
MP3AudioFormat::~MP3AudioFormat() {}
|
|
|
|
|
|
|
|
|
|
Array<int> MP3AudioFormat::getPossibleSampleRates() { return {}; }
|
|
|
|
|
Array<int> MP3AudioFormat::getPossibleBitDepths() { return {}; }
|
|
|
|
|
bool MP3AudioFormat::canDoStereo() { return true; }
|
|
|
|
|
bool MP3AudioFormat::canDoMono() { return true; }
|
|
|
|
|
bool MP3AudioFormat::isCompressed() { return true; }
|
|
|
|
|
StringArray MP3AudioFormat::getQualityOptions() { return {}; }
|
|
|
|
|
|
|
|
|
|
AudioFormatReader* MP3AudioFormat::createReaderFor (InputStream* sourceStream, const bool deleteStreamIfOpeningFails)
|
|
|
|
|
{
|
|
|
|
|
std::unique_ptr<MP3Decoder::MP3Reader> r (new MP3Decoder::MP3Reader (sourceStream));
|
|
|
|
|
|
|
|
|
|
if (r->lengthInSamples > 0)
|
|
|
|
|
return r.release();
|
|
|
|
|
|
|
|
|
|
if (! deleteStreamIfOpeningFails)
|
|
|
|
|
r->input = nullptr;
|
|
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
AudioFormatWriter* MP3AudioFormat::createWriterFor (OutputStream*, double /*sampleRateToUse*/,
|
|
|
|
|
unsigned int /*numberOfChannels*/, int /*bitsPerSample*/,
|
|
|
|
|
const StringPairArray& /*metadataValues*/, int /*qualityOptionIndex*/)
|
|
|
|
|
{
|
|
|
|
|
jassertfalse; // not yet implemented!
|
|
|
|
|
return nullptr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
} // namespace juce
|
