2125 lines
72 KiB
C++
2125 lines
72 KiB
C++
#include "./aacframe.h"
|
|
#include "./aaccodebook.h"
|
|
|
|
#include "../adts/adtsframe.h"
|
|
|
|
#include "../mp4/mp4ids.h"
|
|
|
|
#include "../exceptions.h"
|
|
|
|
#include <c++utilities/io/bitreader.h>
|
|
|
|
#include <istream>
|
|
#include <limits>
|
|
|
|
using namespace std;
|
|
using namespace CppUtilities;
|
|
|
|
/*!
|
|
* \file aacframe.cpp
|
|
* \remarks The AAC parser is still WIP. It does not work yet and its API/ABI may change even in patch releases.
|
|
*/
|
|
|
|
namespace TagParser {
|
|
|
|
/// \cond
|
|
|
|
const std::uint8_t maxPredictionSfb[16] = { 33, 33, 38, 40, 40, 40, 41, 41, 37, 37, 37, 34, 64, 64, 64, 64 };
|
|
|
|
const uint8_t swb512WindowCount[] = { 0, 0, 0, 36, 36, 37, 31, 31, 0, 0, 0, 0 };
|
|
|
|
const std::uint8_t swb480WindowCount[] = { 0, 0, 0, 35, 35, 37, 30, 30, 0, 0, 0, 0 };
|
|
|
|
const std::uint8_t swb960WindowCount[] = { 40, 40, 45, 49, 49, 49, 46, 46, 42, 42, 42, 40 };
|
|
|
|
const std::uint8_t swb1024WindowCount[] = { 41, 41, 47, 49, 49, 51, 47, 47, 43, 43, 43, 40 };
|
|
|
|
const std::uint8_t swb128WindowCount[] = { 12, 12, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15 };
|
|
|
|
const std::uint16_t swbOffset1024_96[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 96, 108, 120, 132, 144, 156, 172,
|
|
188, 212, 240, 276, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024 };
|
|
|
|
const std::uint16_t swbOffset128_96[] = { 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128 };
|
|
|
|
const std::uint16_t swbOffset1024_64[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 100, 112, 124, 140, 156, 172, 192,
|
|
216, 240, 268, 304, 344, 384, 424, 464, 504, 544, 584, 624, 664, 704, 744, 784, 824, 864, 904, 944, 984, 1024 };
|
|
|
|
const std::uint16_t swbOffset128_64[] = { 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128 };
|
|
|
|
const std::uint16_t swbOffset1024_48[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72, 80, 88, 96, 108, 120, 132, 144, 160, 176, 196,
|
|
216, 240, 264, 292, 320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800, 832, 864, 896, 928, 1024 };
|
|
|
|
const std::uint16_t swbOffset512_48[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 68, 76, 84, 92, 100, 112, 124, 136, 148, 164,
|
|
184, 208, 236, 268, 300, 332, 364, 396, 428, 460, 512 };
|
|
|
|
const std::uint16_t swbOffset480_48[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 96, 108, 120, 132, 144, 156, 172,
|
|
188, 212, 240, 272, 304, 336, 368, 400, 432, 480 };
|
|
|
|
const std::uint16_t swbOffset128_48[] = { 0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128 };
|
|
|
|
const std::uint16_t swbOffset1024_32[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72, 80, 88, 96, 108, 120, 132, 144, 160, 176, 196,
|
|
216, 240, 264, 292, 320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800, 832, 864, 896, 928, 960, 992, 1024 };
|
|
|
|
const std::uint16_t swbOffset512_32[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 96, 108, 120, 132, 144, 160, 176,
|
|
192, 212, 236, 260, 288, 320, 352, 384, 416, 448, 480, 512 };
|
|
|
|
const std::uint16_t swbOffset480_32[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 72, 80, 88, 96, 104, 112, 124, 136, 148,
|
|
164, 180, 200, 224, 256, 288, 320, 352, 384, 416, 448, 480 };
|
|
|
|
const std::uint16_t swbOffset1024_24[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 124, 136, 148, 160,
|
|
172, 188, 204, 220, 240, 260, 284, 308, 336, 364, 396, 432, 468, 508, 552, 600, 652, 704, 768, 832, 896, 960, 1024 };
|
|
|
|
const std::uint16_t swbOffset512_24[]
|
|
= { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68, 80, 92, 104, 120, 140, 164, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480, 512 };
|
|
|
|
const std::uint16_t swbOffset480_24[]
|
|
= { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68, 80, 92, 104, 120, 140, 164, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480 };
|
|
|
|
const std::uint16_t swbOffset128_24[] = { 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128 };
|
|
|
|
const std::uint16_t swbOffset1024_16[] = { 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 100, 112, 124, 136, 148, 160, 172, 184, 196, 212, 228, 244,
|
|
260, 280, 300, 320, 344, 368, 396, 424, 456, 492, 532, 572, 616, 664, 716, 772, 832, 896, 960, 1024 };
|
|
|
|
const std::uint16_t swbOffset128_16[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128 };
|
|
|
|
const std::uint16_t swbOffset1024_8[] = { 0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 172, 188, 204, 220, 236, 252, 268, 288, 308,
|
|
328, 348, 372, 396, 420, 448, 476, 508, 544, 580, 620, 664, 712, 764, 820, 880, 944, 1024 };
|
|
|
|
const std::uint16_t swbOffset128_8[] = { 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128 };
|
|
|
|
static const std::uint16_t *const swbOffset1024Window[] = {
|
|
swbOffset1024_96, /* 96000 */
|
|
swbOffset1024_96, /* 88200 */
|
|
swbOffset1024_64, /* 64000 */
|
|
swbOffset1024_48, /* 48000 */
|
|
swbOffset1024_48, /* 44100 */
|
|
swbOffset1024_32, /* 32000 */
|
|
swbOffset1024_24, /* 24000 */
|
|
swbOffset1024_24, /* 22050 */
|
|
swbOffset1024_16, /* 16000 */
|
|
swbOffset1024_16, /* 12000 */
|
|
swbOffset1024_16, /* 11025 */
|
|
swbOffset1024_8, /* 8000 */
|
|
};
|
|
|
|
static const std::uint16_t *const swbOffset512Window[] = {
|
|
nullptr, /* 96000 */
|
|
nullptr, /* 88200 */
|
|
nullptr, /* 64000 */
|
|
swbOffset512_48, /* 48000 */
|
|
swbOffset512_48, /* 44100 */
|
|
swbOffset512_32, /* 32000 */
|
|
swbOffset512_24, /* 24000 */
|
|
swbOffset512_24, /* 22050 */
|
|
nullptr, /* 16000 */
|
|
nullptr, /* 12000 */
|
|
nullptr, /* 11025 */
|
|
nullptr, /* 8000 */
|
|
};
|
|
|
|
static const std::uint16_t *const swbOffset480Window[] = {
|
|
nullptr, /* 96000 */
|
|
nullptr, /* 88200 */
|
|
nullptr, /* 64000 */
|
|
swbOffset480_48, /* 48000 */
|
|
swbOffset480_48, /* 44100 */
|
|
swbOffset480_32, /* 32000 */
|
|
swbOffset480_24, /* 24000 */
|
|
swbOffset480_24, /* 22050 */
|
|
nullptr, /* 16000 */
|
|
nullptr, /* 12000 */
|
|
nullptr, /* 11025 */
|
|
nullptr, /* 8000 */
|
|
};
|
|
|
|
static const std::uint16_t *const swbOffset128Window[] = {
|
|
swbOffset128_96, /* 96000 */
|
|
swbOffset128_96, /* 88200 */
|
|
swbOffset128_64, /* 64000 */
|
|
swbOffset128_48, /* 48000 */
|
|
swbOffset128_48, /* 44100 */
|
|
swbOffset128_48, /* 32000 */
|
|
swbOffset128_24, /* 24000 */
|
|
swbOffset128_24, /* 22050 */
|
|
swbOffset128_16, /* 16000 */
|
|
swbOffset128_16, /* 12000 */
|
|
swbOffset128_16, /* 11025 */
|
|
swbOffset128_8 /* 8000 */
|
|
};
|
|
|
|
/*!
|
|
* \brief Constructs a new LTP info object.
|
|
*/
|
|
AacLtpInfo::AacLtpInfo()
|
|
: lastBand(0)
|
|
, dataPresent(0)
|
|
, lag(0)
|
|
, lagUpdate(0)
|
|
, coef(0)
|
|
, longUsed{ 0 }
|
|
, shortUsed{ 0 }
|
|
, shortLagPresent{ 0 }
|
|
, shortLag{ 0 }
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new predictor info object.
|
|
*/
|
|
AacPredictorInfo::AacPredictorInfo()
|
|
: maxSfb(0)
|
|
, reset(0)
|
|
, resetGroupNumber(0)
|
|
, predictionUsed{ 0 }
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new pulse info object.
|
|
*/
|
|
AacPulseInfo::AacPulseInfo()
|
|
: count(0)
|
|
, startSfb(0)
|
|
, offset{ 0 }
|
|
, amp{ 0 }
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new TNS info object.
|
|
*/
|
|
AacTnsInfo::AacTnsInfo()
|
|
: filt{ 0 }
|
|
, coefRes{ 0 }
|
|
, length{ { 0 } }
|
|
, order{ { 0 } }
|
|
, direction{ { 0 } }
|
|
, coefCompress{ { 0 } }
|
|
, coef{ { { 0 } } }
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new SSR info object.
|
|
*/
|
|
AacSsrInfo::AacSsrInfo()
|
|
: maxBand(0)
|
|
, adjustNum{ { 0 } }
|
|
, alevcode{ { { 0 } } }
|
|
, aloccode{ { { 0 } } }
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new DRC info object.
|
|
*/
|
|
AacDrcInfo::AacDrcInfo()
|
|
: present(0)
|
|
, bandCount(0)
|
|
, pceInstanceTag(0)
|
|
, excludedChannelsPresent(0)
|
|
, bandTop{ 0 }
|
|
, progRefLevel(0)
|
|
, dynamicRangeSign{ 0 }
|
|
, dynamicRangeControl{ 0 }
|
|
, excludeMask{ 0 }
|
|
, additionalExcludedChannels{ 0 }
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new PS info object.
|
|
*/
|
|
AacPsInfo::AacPsInfo()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new DRM-PS info object.
|
|
*/
|
|
AacDrmPsInfo::AacDrmPsInfo()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new SBR info object.
|
|
*/
|
|
AacSbrInfo::AacSbrInfo(std::uint8_t sbrElementType, std::uint16_t samplingFrequency, std::uint16_t frameLength, bool isDrm)
|
|
: aacElementId(sbrElementType)
|
|
, samplingFrequency(samplingFrequency)
|
|
,
|
|
|
|
maxAacLine(0)
|
|
,
|
|
|
|
rate(0)
|
|
, justSeeked(0)
|
|
, ret(0)
|
|
,
|
|
|
|
ampRes{ 0 }
|
|
,
|
|
|
|
k0(0)
|
|
, kx(0)
|
|
, m(0)
|
|
, nMaster(0)
|
|
, nHigh(0)
|
|
, nLow(0)
|
|
, nq(0)
|
|
, nl{ 0 }
|
|
, n{ 0 }
|
|
,
|
|
|
|
fMaster{ 0 }
|
|
, fTableRes{ { 0 } }
|
|
, fTableNoise{ 0 }
|
|
, fTableLim{ { 0 } }
|
|
, fGroup{ { 0 } }
|
|
, ng{ 0 }
|
|
,
|
|
|
|
tableMapKToG{ 0 }
|
|
,
|
|
|
|
absBordLead{ 0 }
|
|
, absBordTrail{ 0 }
|
|
, relLeadCount{ 0 }
|
|
, relTrailCount{ 0 }
|
|
,
|
|
|
|
le{ 0 }
|
|
, lePrev{ 0 }
|
|
, lq{ 0 }
|
|
,
|
|
|
|
te{ { 0 } }
|
|
, tq{ { 0 } }
|
|
, f{ { 0 } }
|
|
, fPrev{ 0 }
|
|
,
|
|
|
|
//*G_temp_prev{{0}},
|
|
//*Q_temp_prev{{0}},
|
|
//GQ_ringbuf_index{0},
|
|
|
|
e{ { { 0 } } }
|
|
, ePrev{ { 0 } }
|
|
,
|
|
//E_orig{{{0}}},
|
|
//E_curr{{{0}}},
|
|
q{ { { 0 } } }
|
|
,
|
|
//Q_div{{{0}}},
|
|
//Q_div2{{{0}}},
|
|
qPrev{ { 0 } }
|
|
,
|
|
|
|
la{ 0 }
|
|
, laPrev{ 0 }
|
|
,
|
|
|
|
bsInvfMode{ { 0 } }
|
|
, bsInvfModePrev{ { 0 } }
|
|
,
|
|
//bwArray{{0}},
|
|
//bwArray_prev{{0}},
|
|
|
|
noPatches(0)
|
|
, patchNoSubbands{ 0 }
|
|
, patchStartSubband{ 0 }
|
|
,
|
|
|
|
bsAddHarmonic{ { 0 } }
|
|
, bsAddHarmonicPrev{ { 0 } }
|
|
,
|
|
|
|
indexNoisePrev{ 0 }
|
|
, psiIsPrev{ 0 }
|
|
,
|
|
|
|
bsStartFreqPrev(numeric_limits<std::uint8_t>::max())
|
|
, bsStopFreqPrev(0)
|
|
, bsXoverBandPrev(0)
|
|
, bsFreqScalePrev(0)
|
|
, bsAlterScalePrev(0)
|
|
, bsNoiseBandsPrev(0)
|
|
,
|
|
|
|
prevEnvIsShort{ -1, -1 }
|
|
,
|
|
|
|
kxPrev(0)
|
|
, bsco(0)
|
|
, bscoPrev(0)
|
|
, mPrev(0)
|
|
, frameLength(frameLength)
|
|
,
|
|
|
|
reset(1)
|
|
, frame(0)
|
|
, headerCount(0)
|
|
,
|
|
|
|
idAac(0)
|
|
,
|
|
//qmfa_info *qmfa{0},
|
|
//qmfs_info *qmfs{0},
|
|
|
|
//qmf_t Xsbr{{{0}}},
|
|
|
|
isDrmSbr(isDrm)
|
|
,
|
|
//drm_ps_info *drm_ps;
|
|
|
|
timeSlotsRateCount(aacSbrRate * (frameLength == 960 ? aacNoTimeSlots960 : aacNoTimeSlots))
|
|
, timeSlotsCount(frameLength == 960 ? aacNoTimeSlots960 : aacNoTimeSlots)
|
|
, tHfGen(8)
|
|
, tHfAdj(2)
|
|
,
|
|
|
|
psUsed(0)
|
|
, psResetFlag(0)
|
|
,
|
|
|
|
bsHeaderFlag(0)
|
|
, bsCrcFlag(0)
|
|
, bsSbrCrcBits(0)
|
|
, bsProtocolVersion(0)
|
|
, bsAmpRes(1)
|
|
, bsStartFreq(5)
|
|
, bsStopFreq(0)
|
|
, bsXoverBand(0)
|
|
, bsFreqScale(2)
|
|
, bsAlterScale(1)
|
|
, bsNoiseBands(2)
|
|
, bsLimiterBands(2)
|
|
, bsLimiterGains(2)
|
|
, bsInterpolFreq(1)
|
|
, bsSmoothingMode(1)
|
|
, bsSamplerateMode(1)
|
|
, bsAddHarmonicFlag{ 0 }
|
|
, bsAddHarmonicFlagPrev{ 0 }
|
|
, bsExtendedData(0)
|
|
, bsExtensionId(0)
|
|
, bsExtensionData(0)
|
|
, bsCoupling(0)
|
|
, bsFrameClass{ 0 }
|
|
, bsRelBord{ { 0 } }
|
|
, bsRelBord0{ { 0 } }
|
|
, bsRelBord1{ { 0 } }
|
|
, bsPointer{ 0 }
|
|
, bsAbsBord0{ 0 }
|
|
, bsAbsBord1{ 0 }
|
|
, bsRelCount0{ 0 }
|
|
, bsRelCount1{ 0 }
|
|
, bsDfEnv{ { 0 } }
|
|
, bsDfNoise{ { 0 } }
|
|
{
|
|
throw NotImplementedException(); // TODO
|
|
/*
|
|
switch (sbrElementType) {
|
|
using namespace AacSyntaxElementTypes;
|
|
case ChannelPairElement:
|
|
|
|
break;
|
|
default:;
|
|
}
|
|
*/
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new program config object.
|
|
*/
|
|
AacProgramConfig::AacProgramConfig()
|
|
: elementInstanceTag(0)
|
|
, objectType(0)
|
|
, samplingFrequencyIndex(0)
|
|
, frontChannelElementCount(0)
|
|
, sideChannelElementCount(0)
|
|
, backChannelElementCount(0)
|
|
, lfeChannelElementCount(0)
|
|
, assocDataElementCount(0)
|
|
, validCcElementCount(0)
|
|
, monoMixdownPresent(0)
|
|
, monoMixdownElementNumber(0)
|
|
, stereoMixdownPresent(0)
|
|
, stereoMixdownElementNumber(0)
|
|
, matrixMixdownIdxPresent(0)
|
|
, pseudoSurroundEnable(0)
|
|
, matrixMixdownIdx(0)
|
|
, frontElementIsCpe{ 0 }
|
|
, frontElementTagSelect{ 0 }
|
|
, sideElementIsCpe{ 0 }
|
|
, sideElementTagSelect{ 0 }
|
|
, backElementIsCpe{ 0 }
|
|
, backElementTagSelect{ 0 }
|
|
, lfeElementTagSelect{ 0 }
|
|
, assocDataElementTagSelect{ 0 }
|
|
, ccElementIsIndSw{ 0 }
|
|
, validCcElementTagSelect{ 0 }
|
|
, channels(0)
|
|
, commentFieldBytes(0)
|
|
, commentFieldData{ 0 }
|
|
, frontChannelCount(0)
|
|
, sideChannelCount(0)
|
|
, backChannelCount(0)
|
|
, lfeChannelCount(0)
|
|
, sceChannel{ 0 }
|
|
, cpeChannel{ 0 }
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new ICS info object.
|
|
*/
|
|
AacIcsInfo::AacIcsInfo()
|
|
: maxSfb(0)
|
|
, swbCount(0)
|
|
, windowGroupCount(0)
|
|
, windowCount(0)
|
|
, windowSequence(0)
|
|
, windowGroupLengths{ 0 }
|
|
, windowShape(0)
|
|
, scaleFactorGrouping(0)
|
|
, sectionSfbOffset{ { 0 } }
|
|
, swbOffset{ 0 }
|
|
, maxSwbOffset(0)
|
|
, sectionCb{ { 0 } }
|
|
, sectionStart{ { 0 } }
|
|
, sectionEnd{ { 0 } }
|
|
, sfbCb{ { 0 } }
|
|
, sectionsPerGroup{ 0 }
|
|
, globalGain(0)
|
|
, scaleFactors{ { 0 } }
|
|
, midSideCodingMaskPresent(0)
|
|
, midSideCodingUsed{ { 0 } }
|
|
, noiseUsed(0)
|
|
, isUsed(0)
|
|
, pulseDataPresent(0)
|
|
, tnsDataPresent(0)
|
|
, gainControlPresent(0)
|
|
, predictorDataPresent(0)
|
|
, reorderedSpectralDataLength(0)
|
|
, longestCodewordLength(0)
|
|
, sfConcealment(0)
|
|
, revGlobalGain(0)
|
|
, rvlcSfLength(0)
|
|
, dpcmNoiseNrg(0)
|
|
, sfEscapesPresent(0)
|
|
, rvlcEscapesLength(0)
|
|
, dpcmNoiseLastPos(0)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
* \class TagParser::AacFrameElementParser
|
|
* \brief The AacFrameElementParser class parses AAC frame elements.
|
|
* \remarks
|
|
* - Only reads reads the basic syntax yet; does not reconstruct samples.
|
|
* - This class is not well tested yet.
|
|
*/
|
|
|
|
/*!
|
|
* \brief Parses "Long Term Prediction" info.
|
|
*/
|
|
void AacFrameElementParser::parseLtpInfo(const AacIcsInfo &ics, AacLtpInfo <p)
|
|
{
|
|
ltp.lag = 0;
|
|
if (m_mpeg4AudioObjectId == Mpeg4AudioObjectIds::ErAacLd) {
|
|
if ((ltp.lagUpdate = m_reader.readBit())) {
|
|
ltp.lag = m_reader.readBits<std::uint16_t>(10);
|
|
}
|
|
} else {
|
|
ltp.lag = m_reader.readBits<std::uint16_t>(11);
|
|
}
|
|
if (ltp.lag > (m_frameLength << 1)) {
|
|
throw InvalidDataException();
|
|
}
|
|
ltp.coef = m_reader.readBits<std::uint8_t>(3);
|
|
switch (ics.windowSequence) {
|
|
case AacIcsSequenceTypes::EightShortSequence:
|
|
for (std::uint8_t w = 0; w < ics.windowCount; ++w) {
|
|
if ((ltp.shortUsed[w] = m_reader.readBit())) {
|
|
if ((ltp.shortLagPresent[w] = m_reader.readBit())) {
|
|
ltp.shortLag[w] = m_reader.readBits<std::uint8_t>(4);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
ltp.lastBand = std::min<std::uint8_t>(ics.maxSfb, aacMaxLtpSfb);
|
|
for (std::uint8_t sfb = 0; sfb < ltp.lastBand; ++sfb) {
|
|
ltp.longUsed[sfb] = m_reader.readBit();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses "individual channel stream" info.
|
|
*/
|
|
void AacFrameElementParser::parseIcsInfo(AacIcsInfo &ics)
|
|
{
|
|
using namespace AacIcsSequenceTypes;
|
|
if (m_reader.readBit()) { // isc reserved bit (must be 0)
|
|
throw InvalidDataException();
|
|
}
|
|
ics.windowSequence = m_reader.readBits<std::uint8_t>(2);
|
|
ics.windowShape = m_reader.readBit();
|
|
if (m_mpeg4AudioObjectId == Mpeg4AudioObjectIds::ErAacLd && ics.windowSequence != OnlyLongSequence) {
|
|
throw InvalidDataException(); // no block switching in LD
|
|
}
|
|
if (ics.windowSequence == EightShortSequence) {
|
|
ics.maxSfb = m_reader.readBits<std::uint8_t>(4);
|
|
ics.scaleFactorGrouping = m_reader.readBits<std::uint8_t>(7);
|
|
} else {
|
|
ics.maxSfb = m_reader.readBits<std::uint8_t>(6);
|
|
}
|
|
calculateWindowGroupingInfo(ics);
|
|
if (ics.windowSequence != EightShortSequence) {
|
|
if ((ics.predictorDataPresent = m_reader.readBit())) {
|
|
switch (m_mpeg4AudioObjectId) {
|
|
case Mpeg4AudioObjectIds::AacMain:
|
|
// MPEG-2 style AAC predictor
|
|
if ((ics.predictor.reset = m_reader.readBit())) {
|
|
ics.predictor.resetGroupNumber = m_reader.readBits<std::uint8_t>(5);
|
|
ics.predictor.maxSfb = ics.maxSfb;
|
|
}
|
|
if (ics.predictor.maxSfb > maxPredictionSfb[m_mpeg4SamplingFrequencyIndex]) {
|
|
ics.predictor.maxSfb = maxPredictionSfb[m_mpeg4SamplingFrequencyIndex];
|
|
}
|
|
for (std::uint8_t sfb = 0; sfb < ics.predictor.maxSfb; ++sfb) {
|
|
ics.predictor.predictionUsed[sfb] = m_reader.readBit();
|
|
}
|
|
break;
|
|
default:
|
|
// "Long Term Prediction"
|
|
if (m_mpeg4AudioObjectId < Mpeg4AudioObjectIds::ErAacLc) {
|
|
if ((ics.ltp1.dataPresent = m_reader.readBit())) {
|
|
parseLtpInfo(ics, ics.ltp1);
|
|
}
|
|
if (m_commonWindow) {
|
|
if ((ics.ltp2.dataPresent = m_reader.readBit())) {
|
|
parseLtpInfo(ics, ics.ltp2);
|
|
}
|
|
}
|
|
}
|
|
if (!m_commonWindow && (m_mpeg4AudioObjectId >= Mpeg4AudioObjectIds::ErAacLc)) {
|
|
if ((ics.ltp1.dataPresent = m_reader.readBit())) {
|
|
parseLtpInfo(ics, ics.ltp1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses section data.
|
|
*/
|
|
void AacFrameElementParser::parseSectionData(AacIcsInfo &ics)
|
|
{
|
|
const std::uint8_t sectionBits = ics.windowSequence == AacIcsSequenceTypes::EightShortSequence ? 3 : 5;
|
|
const std::uint8_t sectionEscValue = static_cast<std::uint8_t>((1 << sectionBits) - 1);
|
|
for (std::uint8_t groupIndex = 0, sectionIndex = 0; groupIndex < ics.windowGroupCount; ++groupIndex, sectionIndex = 0) {
|
|
for (std::uint8_t i = 0, sectionLength, sectionLengthIncrease; i < ics.maxSfb; i += sectionLength, ++sectionIndex) {
|
|
ics.sectionCb[groupIndex][sectionIndex] = m_reader.readBits<std::uint8_t>(m_aacSectionDataResilienceFlag ? 5 : 4);
|
|
sectionLength = 0;
|
|
sectionLengthIncrease
|
|
= (!m_aacSectionDataResilienceFlag && (ics.sectionCb[groupIndex][sectionIndex] < 16 || ics.sectionCb[groupIndex][sectionIndex] > 32)
|
|
&& ics.sectionCb[groupIndex][sectionIndex] != 11)
|
|
? m_reader.readBits<std::uint8_t>(sectionBits)
|
|
: 1;
|
|
while (sectionLengthIncrease == sectionEscValue) {
|
|
sectionLength += sectionLengthIncrease;
|
|
sectionLengthIncrease = m_reader.readBits<std::uint8_t>(sectionBits);
|
|
}
|
|
sectionLength += sectionLengthIncrease;
|
|
ics.sectionStart[groupIndex][sectionIndex] = i;
|
|
ics.sectionEnd[groupIndex][sectionIndex] = i + sectionLength;
|
|
if (ics.windowSequence == AacIcsSequenceTypes::EightShortSequence) {
|
|
if (i + sectionLength > 8 * 15) {
|
|
throw InvalidDataException();
|
|
} else if (sectionIndex >= 8 * 15) {
|
|
throw InvalidDataException();
|
|
}
|
|
} else {
|
|
if (i + sectionLength > aacMaxSfb) {
|
|
throw InvalidDataException();
|
|
} else if (sectionIndex >= aacMaxSfb) {
|
|
throw InvalidDataException();
|
|
}
|
|
}
|
|
for (std::uint8_t sfb = i; sfb < i + sectionLength; ++sfb) {
|
|
ics.sfbCb[groupIndex][sfb] = ics.sectionCb[groupIndex][sectionIndex];
|
|
}
|
|
}
|
|
ics.sectionsPerGroup[groupIndex] = sectionIndex;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Decodes scale factor data (called by parseScaleFactorData()).
|
|
*/
|
|
void AacFrameElementParser::decodeScaleFactorData(AacIcsInfo &ics)
|
|
{
|
|
std::int16_t tmp;
|
|
std::uint8_t noisePcmFlag = 1;
|
|
std::int16_t scaleFactor = ics.globalGain;
|
|
std::int16_t isPosition = 0;
|
|
std::int16_t noiseEnergy = ics.globalGain - 90;
|
|
using namespace AacScaleFactorTypes;
|
|
for (std::uint8_t group = 0; group < ics.windowGroupCount; ++group) {
|
|
for (std::uint8_t sfb = 0; sfb < ics.maxSfb; ++sfb) {
|
|
switch (ics.sfbCb[group][sfb]) {
|
|
case ZeroHcb: // zero book
|
|
ics.scaleFactors[group][sfb] = 0;
|
|
break;
|
|
case IntensityHcb: // intensity books
|
|
case IntensityHcb2:
|
|
ics.scaleFactors[group][sfb] = static_cast<std::uint16_t>(isPosition += (parseHuffmanScaleFactor() - 60));
|
|
break;
|
|
case NoiseHcb: // noise books
|
|
if (noisePcmFlag) {
|
|
noisePcmFlag = 0;
|
|
tmp = m_reader.readBits<std::int16_t>(9);
|
|
} else {
|
|
tmp = parseHuffmanScaleFactor() - 60;
|
|
}
|
|
ics.scaleFactors[group][sfb] = static_cast<std::uint16_t>(noiseEnergy += tmp);
|
|
break;
|
|
default: // spectral books
|
|
scaleFactor += parseHuffmanScaleFactor() - 60;
|
|
if (scaleFactor < 0 || scaleFactor > 255) {
|
|
throw InvalidDataException();
|
|
} else {
|
|
ics.scaleFactors[group][sfb] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Decodes RVLC scale factor data.
|
|
*/
|
|
void AacFrameElementParser::decodeRvlcScaleFactorData(AacIcsInfo &ics)
|
|
{
|
|
if (ics.rvlcSfLength) {
|
|
m_reader.skipBits(ics.rvlcSfLength);
|
|
}
|
|
if (ics.sfEscapesPresent) {
|
|
m_reader.skipBits(ics.rvlcEscapesLength);
|
|
}
|
|
// TODO: decode RVLC scale factors and escapes
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses scale factor data.
|
|
*/
|
|
void AacFrameElementParser::parseScaleFactorData(AacIcsInfo &ics)
|
|
{
|
|
if (!m_aacScalefactorDataResilienceFlag) {
|
|
decodeScaleFactorData(ics);
|
|
} else {
|
|
decodeRvlcScaleFactorData(ics);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses pulse data.
|
|
*/
|
|
void AacFrameElementParser::parsePulseData(AacIcsInfo &ics)
|
|
{
|
|
AacPulseInfo &p = ics.pulse;
|
|
p.count = m_reader.readBits<std::uint8_t>(2);
|
|
p.startSfb = m_reader.readBits<std::uint8_t>(6);
|
|
if (p.startSfb > ics.swbCount) {
|
|
throw InvalidDataException();
|
|
}
|
|
for (std::uint8_t i = 0; i <= p.count; ++i) {
|
|
p.offset[i] = m_reader.readBits<std::uint8_t>(5);
|
|
p.amp[i] = m_reader.readBits<std::uint8_t>(4);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses TNS data.
|
|
*/
|
|
void AacFrameElementParser::parseTnsData(AacIcsInfo &ics)
|
|
{
|
|
std::uint8_t filtBits, lengthBits, orderBits, startCoefBits, coefBits;
|
|
if (ics.windowSequence == AacIcsSequenceTypes::EightShortSequence) {
|
|
filtBits = 1;
|
|
lengthBits = 4;
|
|
orderBits = 3;
|
|
} else {
|
|
filtBits = 2;
|
|
lengthBits = 6;
|
|
orderBits = 5;
|
|
}
|
|
for (std::uint8_t window = 0; window < ics.windowCount; ++window) {
|
|
if ((ics.tns.filt[window] = m_reader.readBits<std::uint8_t>(filtBits))) {
|
|
startCoefBits = (ics.tns.coefRes[window] = m_reader.readBit()) ? 4 : 3;
|
|
}
|
|
for (std::uint8_t filt = 0; filt < ics.tns.filt[window]; ++filt) {
|
|
ics.tns.length[window][filt] = m_reader.readBits<std::uint8_t>(lengthBits);
|
|
if ((ics.tns.order[window][filt] = m_reader.readBits<std::uint8_t>(orderBits))) {
|
|
ics.tns.direction[window][filt] = m_reader.readBit();
|
|
ics.tns.coefCompress[window][filt] = m_reader.readBit();
|
|
coefBits = startCoefBits - ics.tns.coefCompress[window][filt];
|
|
for (std::uint8_t i = 0; i < ics.tns.order[window][filt]; ++i) {
|
|
ics.tns.coef[window][filt][i] = m_reader.readBits<std::uint8_t>(coefBits);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses gain control data.
|
|
*/
|
|
void AacFrameElementParser::parseGainControlData(AacIcsInfo &ics)
|
|
{
|
|
AacSsrInfo &ssr = ics.ssr;
|
|
ssr.maxBand = m_reader.readBits<std::uint8_t>(2);
|
|
switch (ics.windowSequence) {
|
|
using namespace AacIcsSequenceTypes;
|
|
case OnlyLongSequence:
|
|
for (std::uint8_t bd = 1; bd <= ssr.maxBand; ++bd) {
|
|
for (std::uint8_t wd = 0; wd < 1; ++wd) {
|
|
ssr.adjustNum[bd][wd] = m_reader.readBits<std::uint8_t>(3);
|
|
for (std::uint8_t ad = 0; ad < ssr.adjustNum[bd][wd]; ++ad) {
|
|
ssr.alevcode[bd][wd][ad] = m_reader.readBits<std::uint8_t>(4);
|
|
ssr.aloccode[bd][wd][ad] = m_reader.readBits<std::uint8_t>(5);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case LongStartSequence:
|
|
for (std::uint8_t bd = 1; bd <= ssr.maxBand; ++bd) {
|
|
for (std::uint8_t wd = 0; wd < 2; ++wd) {
|
|
ssr.adjustNum[bd][wd] = m_reader.readBits<std::uint8_t>(3);
|
|
for (std::uint8_t ad = 0; ad < ssr.adjustNum[bd][wd]; ++ad) {
|
|
ssr.alevcode[bd][wd][ad] = m_reader.readBits<std::uint8_t>(4);
|
|
ssr.aloccode[bd][wd][ad] = m_reader.readBits<std::uint8_t>(wd ? 2 : 4);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case EightShortSequence:
|
|
for (std::uint8_t bd = 1; bd <= ssr.maxBand; ++bd) {
|
|
for (std::uint8_t wd = 0; wd < 8; ++wd) {
|
|
ssr.adjustNum[bd][wd] = m_reader.readBits<std::uint8_t>(3);
|
|
for (std::uint8_t ad = 0; ad < ssr.adjustNum[bd][wd]; ++ad) {
|
|
ssr.alevcode[bd][wd][ad] = m_reader.readBits<std::uint8_t>(4);
|
|
ssr.aloccode[bd][wd][ad] = m_reader.readBits<std::uint8_t>(2);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case LongStopSequence:
|
|
for (std::uint8_t bd = 1; bd <= ssr.maxBand; ++bd) {
|
|
for (std::uint8_t wd = 0; wd < 2; ++wd) {
|
|
ssr.adjustNum[bd][wd] = m_reader.readBits<std::uint8_t>(3);
|
|
for (std::uint8_t ad = 0; ad < ssr.adjustNum[bd][wd]; ++ad) {
|
|
ssr.alevcode[bd][wd][ad] = m_reader.readBits<std::uint8_t>(4);
|
|
ssr.aloccode[bd][wd][ad] = m_reader.readBits<std::uint8_t>(wd ? 5 : 4);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses spectral data.
|
|
*/
|
|
void AacFrameElementParser::parseSpectralData(AacIcsInfo &ics, std::int16_t *specData)
|
|
{
|
|
//byte groups = 0;
|
|
//uint16 nshort = m_frameLength / 8;
|
|
for (std::uint8_t group = 0; group < ics.windowGroupCount; ++group) {
|
|
//byte p = groups * nshort;
|
|
for (std::uint8_t section = 0; section < ics.sectionsPerGroup[group]; ++section) {
|
|
using namespace AacScaleFactorTypes;
|
|
std::uint8_t sectionCb = ics.sectionCb[group][section];
|
|
std::uint16_t increment = (sectionCb >= FirstPairHcb) ? 2 : 4;
|
|
switch (sectionCb) {
|
|
case ZeroHcb:
|
|
case NoiseHcb:
|
|
case IntensityHcb:
|
|
case IntensityHcb2:
|
|
//p += (ics.sectionSfbOffset[group][ics.sectionEnd[group][section]] - ics.sectionSfbOffset[group][ics.sectionStart[group][section]]);
|
|
break;
|
|
default:
|
|
for (std::uint16_t k = ics.sectionSfbOffset[group][ics.sectionStart[group][section]];
|
|
k < ics.sectionSfbOffset[group][ics.sectionEnd[group][section]]; k += increment) {
|
|
parseHuffmanSpectralData(sectionCb, specData);
|
|
//p += increment;
|
|
}
|
|
}
|
|
}
|
|
//groups += ics.windowGroupLengths[group];
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses "side info".
|
|
*/
|
|
void AacFrameElementParser::parseSideInfo(AacIcsInfo &ics, bool scaleFlag)
|
|
{
|
|
ics.globalGain = m_reader.readBits<std::uint8_t>(8);
|
|
if (!m_commonWindow && !scaleFlag) {
|
|
parseIcsInfo(ics);
|
|
}
|
|
parseSectionData(ics);
|
|
parseScaleFactorData(ics);
|
|
if (!scaleFlag) {
|
|
if ((ics.pulseDataPresent = m_reader.readBit())) {
|
|
parsePulseData(ics);
|
|
}
|
|
if ((ics.tnsDataPresent = m_reader.readBit())) {
|
|
parseTnsData(ics);
|
|
}
|
|
if ((ics.gainControlPresent = m_reader.readBit())) {
|
|
if (m_mpeg4AudioObjectId != Mpeg4AudioObjectIds::AacSsr) {
|
|
throw InvalidDataException();
|
|
} else {
|
|
parseGainControlData(ics);
|
|
}
|
|
}
|
|
}
|
|
if (m_aacScalefactorDataResilienceFlag) {
|
|
decodeRvlcScaleFactorData(ics);
|
|
}
|
|
}
|
|
|
|
std::uint8_t AacFrameElementParser::parseExcludedChannels()
|
|
{
|
|
for (std::uint8_t i = 0; i < 7; ++i) {
|
|
m_drc.excludeMask[i] = m_reader.readBit();
|
|
}
|
|
std::uint8_t size = 0;
|
|
for (; (m_drc.additionalExcludedChannels[size] = m_reader.readBit()); ++size) {
|
|
for (std::uint8_t i = 0; i < 7; ++i) {
|
|
m_drc.excludeMask[i] = m_reader.readBit();
|
|
}
|
|
}
|
|
return size + 1;
|
|
}
|
|
|
|
std::uint8_t AacFrameElementParser::parseDynamicRange()
|
|
{
|
|
std::uint8_t size = 1;
|
|
m_drc.bandCount = 1;
|
|
if (m_reader.readBit()) { // excluded channels present
|
|
m_drc.pceInstanceTag = m_reader.readBits<std::uint8_t>(4);
|
|
m_reader.skipBits(4); // skip reserved bits
|
|
++size;
|
|
}
|
|
if ((m_drc.excludedChannelsPresent = m_reader.readBit())) {
|
|
size += parseExcludedChannels();
|
|
}
|
|
if (m_reader.readBit()) { // has bands data
|
|
m_drc.bandCount += m_reader.readBits<std::uint8_t>(4);
|
|
m_reader.skipBits(4); // skip reserved bits
|
|
++size;
|
|
for (std::uint8_t i = 0; i < m_drc.bandCount; ++i, ++size) {
|
|
m_drc.bandTop[i] = m_reader.readBits<std::uint8_t>(8);
|
|
}
|
|
}
|
|
if (m_reader.readBit()) { // has prog ref level
|
|
m_drc.progRefLevel = m_reader.readBits<std::uint8_t>(7);
|
|
m_reader.skipBits(1); // skip reserved bit
|
|
++size;
|
|
}
|
|
for (std::uint8_t i = 0; i < m_drc.bandCount; ++i) {
|
|
m_drc.dynamicRangeSign[i] = m_reader.readBit();
|
|
m_drc.dynamicRangeControl[i] = m_reader.readBits<std::uint8_t>(7);
|
|
++size;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
std::int16_t AacFrameElementParser::sbrHuffmanDec(SbrHuffTab table)
|
|
{
|
|
std::uint8_t bit;
|
|
std::int16_t index = 0;
|
|
while (index >= 0) {
|
|
bit = m_reader.readBit();
|
|
index = table[index][bit];
|
|
}
|
|
return index + 64;
|
|
}
|
|
|
|
void AacFrameElementParser::parseSbrGrid(std::shared_ptr<AacSbrInfo> &sbr, std::uint8_t channel)
|
|
{
|
|
std::uint8_t tmp, bsEnvCount;
|
|
//byte bsRelCount0, bsRelCount1;
|
|
switch ((sbr->bsFrameClass[channel] = m_reader.readBits<std::uint8_t>(2))) {
|
|
using namespace BsFrameClasses;
|
|
case FixFix:
|
|
tmp = m_reader.readBits<std::uint8_t>(2);
|
|
sbr->absBordLead[channel] = 0;
|
|
sbr->absBordTrail[channel] = sbr->timeSlotsCount;
|
|
sbr->relLeadCount[channel] = (bsEnvCount = min<std::uint8_t>(static_cast<std::uint8_t>(1 << tmp), 5)) - 1;
|
|
sbr->relTrailCount[channel] = 0;
|
|
tmp = m_reader.readBit();
|
|
for (std::uint8_t env = 0; env < bsEnvCount; ++env) {
|
|
sbr->f[channel][env] = tmp;
|
|
}
|
|
break;
|
|
case FixVar:
|
|
sbr->absBordLead[channel] = 0;
|
|
sbr->absBordTrail[channel] = m_reader.readBits<std::uint8_t>(2) + sbr->timeSlotsCount;
|
|
sbr->relLeadCount[channel] = 0;
|
|
sbr->relTrailCount[channel] = bsEnvCount = m_reader.readBits<std::uint8_t>(2);
|
|
for (std::uint8_t rel = 0; rel < bsEnvCount; ++rel) {
|
|
sbr->bsRelBord[channel][rel] = 2 * m_reader.readBits<std::uint8_t>(2) + 2;
|
|
}
|
|
sbr->bsPointer[channel] = m_reader.readBits<std::uint8_t>(static_cast<std::uint8_t>(sbrLog2(static_cast<std::int8_t>(bsEnvCount + 2))));
|
|
for (std::uint8_t env = 0; env <= bsEnvCount; ++env) {
|
|
sbr->f[channel][bsEnvCount - env] = m_reader.readBit();
|
|
}
|
|
break;
|
|
case VarFix:
|
|
sbr->absBordLead[channel] = m_reader.readBits<std::uint8_t>(2);
|
|
sbr->absBordTrail[channel] = sbr->timeSlotsCount;
|
|
sbr->relLeadCount[channel] = bsEnvCount = m_reader.readBits<std::uint8_t>(2);
|
|
sbr->relTrailCount[channel] = 0;
|
|
for (std::uint8_t rel = 0; rel < bsEnvCount; ++rel) {
|
|
sbr->bsRelBord[channel][rel] = 2 * m_reader.readBits<std::uint8_t>(2) + 2;
|
|
}
|
|
sbr->bsPointer[channel] = m_reader.readBits<std::uint8_t>(static_cast<std::uint8_t>(sbrLog2(static_cast<std::int8_t>(bsEnvCount + 2))));
|
|
for (std::uint8_t env = 0; env < bsEnvCount; ++env) {
|
|
sbr->f[channel][env] = m_reader.readBit();
|
|
}
|
|
break;
|
|
case VarVar:
|
|
sbr->absBordLead[channel] = m_reader.readBits<std::uint8_t>(2);
|
|
sbr->absBordTrail[channel] = m_reader.readBits<std::uint8_t>(2) + sbr->timeSlotsCount;
|
|
//bsRelCount0 = m_reader.readBits<std::uint8_t>(2);
|
|
//bsRelCount1 = m_reader.readBits<std::uint8_t>(2);
|
|
m_reader.skipBits(4);
|
|
bsEnvCount = min<std::uint8_t>(5, sbr->bsRelCount0[channel] + sbr->bsRelCount1[channel] + 1);
|
|
for (std::uint8_t rel = 0; rel < sbr->bsRelCount0[channel]; ++rel) {
|
|
sbr->bsRelBord0[channel][rel] = 2 * m_reader.readBits<std::uint8_t>(2) + 2;
|
|
}
|
|
for (std::uint8_t rel = 0; rel < sbr->bsRelCount1[channel]; ++rel) {
|
|
sbr->bsRelBord1[channel][rel] = 2 * m_reader.readBits<std::uint8_t>(2) + 2;
|
|
}
|
|
sbr->bsPointer[channel] = m_reader.readBits<std::uint8_t>(
|
|
static_cast<std::uint8_t>(sbrLog2(static_cast<std::int8_t>(sbr->bsRelCount0[channel] + sbr->bsRelCount1[channel] + 2))));
|
|
for (std::uint8_t env = 0; env < bsEnvCount; ++env) {
|
|
sbr->f[channel][env] = m_reader.readBit();
|
|
}
|
|
sbr->relLeadCount[channel] = sbr->bsRelCount0[channel];
|
|
sbr->relTrailCount[channel] = sbr->bsRelCount1[channel];
|
|
break;
|
|
default:;
|
|
}
|
|
if ((sbr->le[channel] = min<std::uint8_t>(bsEnvCount, sbr->bsFrameClass[channel] == BsFrameClasses::VarVar ? 5 : 4)) <= 0) {
|
|
throw InvalidDataException();
|
|
}
|
|
sbr->lq[channel] = sbr->le[channel] > 1 ? 2 : 1;
|
|
// TODO: envelope time border vector, noise floor time border vector
|
|
}
|
|
|
|
void AacFrameElementParser::parseSbrDtdf(std::shared_ptr<AacSbrInfo> &sbr, std::uint8_t channel)
|
|
{
|
|
for (std::uint8_t i = 0; i < sbr->le[channel]; ++i) {
|
|
sbr->bsDfEnv[channel][i] = m_reader.readBit();
|
|
}
|
|
for (std::uint8_t i = 0; i < sbr->lq[channel]; ++i) {
|
|
sbr->bsDfNoise[channel][i] = m_reader.readBit();
|
|
}
|
|
}
|
|
|
|
void AacFrameElementParser::parseInvfMode(std::shared_ptr<AacSbrInfo> &sbr, std::uint8_t channel)
|
|
{
|
|
for (std::uint8_t i = 0; i < sbr->nq; ++i) {
|
|
sbr->bsInvfMode[channel][i] = m_reader.readBits<std::uint8_t>(2);
|
|
}
|
|
}
|
|
|
|
void AacFrameElementParser::parseSbrEnvelope(std::shared_ptr<AacSbrInfo> &sbr, std::uint8_t channel)
|
|
{
|
|
std::int8_t delta;
|
|
//SbrHuffTab tHuff;
|
|
SbrHuffTab fHuff;
|
|
if ((sbr->le[channel] == 1) && (sbr->bsFrameClass[channel] == BsFrameClasses::FixFix)) {
|
|
sbr->ampRes[channel] = 0;
|
|
} else {
|
|
sbr->ampRes[channel] = sbr->bsAmpRes;
|
|
}
|
|
if ((sbr->bsCoupling) && (channel == 1)) {
|
|
delta = 1;
|
|
if (sbr->ampRes[channel]) {
|
|
//tHuff = tHuffmanEnvBal30dB;
|
|
fHuff = fHuffmanEnvBal30dB;
|
|
} else {
|
|
//tHuff = tHuffmanEnvBal15dB;
|
|
fHuff = fHuffmanEnvBal15dB;
|
|
}
|
|
} else {
|
|
delta = 0;
|
|
if (sbr->ampRes[channel]) {
|
|
//tHuff = tHuffmanEnv30dB;
|
|
fHuff = fHuffmanEnv30dB;
|
|
} else {
|
|
//tHuff = tHuffmanEnv15dB;
|
|
fHuff = fHuffmanEnv15dB;
|
|
}
|
|
}
|
|
for (std::uint8_t env = 0; env < sbr->le[channel]; ++env) {
|
|
if (sbr->bsDfEnv[channel][env] == 0) {
|
|
if ((sbr->bsCoupling == 1) && (channel == 1)) {
|
|
if (sbr->ampRes[channel]) {
|
|
sbr->e[channel][0][env] = static_cast<std::int16_t>(m_reader.readBits<std::uint16_t>(5) << delta);
|
|
} else {
|
|
sbr->e[channel][0][env] = static_cast<std::int16_t>(m_reader.readBits<std::uint16_t>(6) << delta);
|
|
}
|
|
} else {
|
|
if (sbr->ampRes[channel]) {
|
|
sbr->e[channel][0][env] = static_cast<std::int16_t>(m_reader.readBits<std::uint16_t>(6) << delta);
|
|
} else {
|
|
sbr->e[channel][0][env] = static_cast<std::int16_t>(m_reader.readBits<std::uint16_t>(7) << delta);
|
|
}
|
|
}
|
|
for (std::uint8_t band = 1; band < sbr->n[sbr->f[channel][env]]; ++band) {
|
|
sbr->e[channel][band][env] = static_cast<std::int16_t>(sbrHuffmanDec(fHuff) << delta);
|
|
}
|
|
} else {
|
|
for (std::uint8_t band = 0; band < sbr->n[sbr->f[channel][env]]; ++band) {
|
|
sbr->e[channel][band][env] = static_cast<std::int16_t>(sbrHuffmanDec(fHuff) << delta);
|
|
}
|
|
}
|
|
}
|
|
// TODO: extract envelope data
|
|
}
|
|
|
|
void AacFrameElementParser::parseSbrNoise(std::shared_ptr<AacSbrInfo> &sbr, std::uint8_t channel)
|
|
{
|
|
std::int8_t delta;
|
|
//SbrHuffTab tHuff;
|
|
SbrHuffTab fHuff;
|
|
if ((sbr->bsCoupling == 1) && (channel == 1)) {
|
|
delta = 1;
|
|
//tHuff = tHuffmanNoiseBal30dB;
|
|
fHuff = fHuffmanEnvBal30dB;
|
|
} else {
|
|
delta = 1;
|
|
//tHuff = tHuffmanNoise30dB;
|
|
fHuff = fHuffmanEnv30dB;
|
|
}
|
|
for (std::uint8_t noise = 0; noise < sbr->lq[channel]; ++noise) {
|
|
if (sbr->bsDfNoise[channel][noise] == 0) {
|
|
if ((sbr->bsCoupling == 1) && (channel == 1)) {
|
|
sbr->q[channel][0][noise] = m_reader.readBits<std::uint8_t>(5) << delta;
|
|
} else {
|
|
sbr->q[channel][0][noise] = m_reader.readBits<std::uint8_t>(5) << delta;
|
|
}
|
|
for (std::uint8_t band = 1; band < sbr->nq; ++band) {
|
|
sbr->q[channel][band][noise] = sbrHuffmanDec(fHuff) << delta;
|
|
}
|
|
} else {
|
|
for (std::uint8_t band = 0; band < sbr->nq; ++band) {
|
|
sbr->q[channel][band][noise] = sbrHuffmanDec(fHuff) << delta;
|
|
}
|
|
}
|
|
}
|
|
// TODO: extract noise floor data
|
|
}
|
|
|
|
void AacFrameElementParser::parseSbrSinusoidalCoding(std::shared_ptr<AacSbrInfo> &sbr, std::uint8_t channel)
|
|
{
|
|
for (std::uint8_t i = 0; i < sbr->nHigh; ++i) {
|
|
sbr->bsAddHarmonic[channel][i] = m_reader.readBit();
|
|
}
|
|
}
|
|
|
|
std::uint16_t AacFrameElementParser::parseSbrExtension(std::shared_ptr<AacSbrInfo> &sbr, std::uint8_t extensionId, std::uint8_t)
|
|
{
|
|
std::uint8_t header;
|
|
std::uint16_t res;
|
|
switch (extensionId) {
|
|
using namespace AacSbrExtensionIds;
|
|
case Ps:
|
|
if (sbr->psResetFlag) {
|
|
sbr->ps->headerRead = 0;
|
|
}
|
|
res = parsePsData(sbr->ps, header);
|
|
if (sbr->psUsed == 0 && header == 1) {
|
|
sbr->psUsed = 1;
|
|
}
|
|
if (header == 1) {
|
|
sbr->psResetFlag = 0;
|
|
}
|
|
return res;
|
|
case DrmParametricStereo:
|
|
sbr->psUsed = 1;
|
|
return parseDrmPsData(sbr->drmPs);
|
|
default:
|
|
sbr->bsExtendedData = m_reader.readBits<std::uint8_t>(6);
|
|
return 6;
|
|
}
|
|
}
|
|
|
|
std::uint16_t AacFrameElementParser::parsePsData(std::shared_ptr<AacPsInfo> &ps, std::uint8_t &header)
|
|
{
|
|
if (m_reader.readBit()) {
|
|
header = 1;
|
|
ps->headerRead = 1;
|
|
ps->use34HybridBands = 0;
|
|
if ((ps->enableIID = m_reader.readBit())) {
|
|
ps->iidMode = m_reader.readBits<std::uint8_t>(3);
|
|
}
|
|
}
|
|
throw NotImplementedException(); // TODO
|
|
}
|
|
|
|
std::uint16_t AacFrameElementParser::parseDrmPsData(std::shared_ptr<AacDrmPsInfo> &drmPs)
|
|
{
|
|
VAR_UNUSED(drmPs)
|
|
throw NotImplementedException(); // TODO
|
|
}
|
|
|
|
void AacFrameElementParser::parseSbrSingleChannelElement(std::shared_ptr<AacSbrInfo> &sbr)
|
|
{
|
|
if (m_reader.readBit()) { // bs data extra
|
|
m_reader.skipBits(4); // skip bs reserved
|
|
}
|
|
if (sbr->isDrmSbr) {
|
|
m_reader.skipBits(1); // bs coupling
|
|
}
|
|
parseSbrGrid(sbr, 0);
|
|
parseSbrDtdf(sbr, 0);
|
|
parseInvfMode(sbr, 0);
|
|
parseSbrEnvelope(sbr, 0);
|
|
parseSbrNoise(sbr, 0);
|
|
// TODO: envelope noise dequantisation
|
|
if ((sbr->bsAddHarmonicFlag[0] = m_reader.readBit())) {
|
|
parseSbrSinusoidalCoding(sbr, 0);
|
|
}
|
|
if ((sbr->bsExtendedData = m_reader.readBit())) {
|
|
std::uint16_t cnt = m_reader.readBits<std::uint16_t>(4);
|
|
if (cnt == 0xF) {
|
|
cnt += m_reader.readBits<std::uint16_t>(8);
|
|
}
|
|
std::uint16_t bitsLeft = 8 * cnt;
|
|
while (bitsLeft > 7) {
|
|
sbr->bsExtensionId = m_reader.readBits<std::uint8_t>(2);
|
|
std::uint16_t tmpBitCount = 2 + parseSbrExtension(sbr, sbr->bsExtensionId, static_cast<std::uint8_t>(bitsLeft));
|
|
if (tmpBitCount > bitsLeft) {
|
|
throw InvalidDataException();
|
|
} else {
|
|
bitsLeft -= tmpBitCount;
|
|
}
|
|
}
|
|
if (bitsLeft) { // read remaining bits
|
|
m_reader.skipBits(bitsLeft);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AacFrameElementParser::parseSbrChannelPairElement(std::shared_ptr<AacSbrInfo> &sbr)
|
|
{
|
|
if (m_reader.readBit()) { // bs data extra
|
|
m_reader.skipBits(8); // skip bs reserved
|
|
}
|
|
if ((sbr->bsCoupling = m_reader.readBit())) {
|
|
parseSbrGrid(sbr, 0);
|
|
// copy data from left to right
|
|
sbr->bsFrameClass[1] = sbr->bsFrameClass[0];
|
|
sbr->le[1] = sbr->le[0];
|
|
sbr->lq[1] = sbr->lq[0];
|
|
sbr->bsPointer[1] = sbr->bsPointer[0];
|
|
for (std::uint8_t n = 0; n < sbr->le[0]; ++n) {
|
|
sbr->te[1][n] = sbr->te[0][n];
|
|
sbr->f[1][n] = sbr->f[0][n];
|
|
}
|
|
for (std::uint8_t n = 0; n < sbr->lq[0]; ++n) {
|
|
sbr->tq[1][n] = sbr->tq[0][n];
|
|
}
|
|
parseSbrDtdf(sbr, 0);
|
|
parseSbrDtdf(sbr, 1);
|
|
parseInvfMode(sbr, 0);
|
|
for (std::uint8_t n = 0; n < sbr->nq; ++n) {
|
|
sbr->bsInvfMode[1][n] = sbr->bsInvfMode[0][n];
|
|
}
|
|
parseSbrEnvelope(sbr, 0);
|
|
parseSbrNoise(sbr, 0);
|
|
parseSbrEnvelope(sbr, 1);
|
|
parseSbrNoise(sbr, 1);
|
|
} else {
|
|
parseSbrGrid(sbr, 0);
|
|
parseSbrGrid(sbr, 1);
|
|
parseSbrDtdf(sbr, 0);
|
|
parseSbrDtdf(sbr, 1);
|
|
parseInvfMode(sbr, 0);
|
|
parseInvfMode(sbr, 1);
|
|
parseSbrEnvelope(sbr, 0);
|
|
parseSbrEnvelope(sbr, 1);
|
|
parseSbrNoise(sbr, 0);
|
|
parseSbrNoise(sbr, 1);
|
|
}
|
|
if ((sbr->bsAddHarmonicFlag[0] = m_reader.readBit())) {
|
|
parseSbrSinusoidalCoding(sbr, 0);
|
|
}
|
|
if ((sbr->bsAddHarmonicFlag[1] = m_reader.readBit())) {
|
|
parseSbrSinusoidalCoding(sbr, 1);
|
|
}
|
|
// TODO: envelope noise dequantisation (for both channels)
|
|
if (sbr->bsCoupling) {
|
|
// TODO: unmap envelope noise
|
|
}
|
|
if ((sbr->bsExtendedData = m_reader.readBit())) {
|
|
std::uint16_t cnt = m_reader.readBits<std::uint16_t>(4);
|
|
if (cnt == 0xF) {
|
|
cnt += m_reader.readBits<std::uint16_t>(8);
|
|
}
|
|
std::uint16_t bitsLeft = 8 * cnt;
|
|
while (bitsLeft > 7) {
|
|
sbr->bsExtensionId = m_reader.readBits<std::uint8_t>(2);
|
|
std::uint16_t tmpBitCount = 2 + parseSbrExtension(sbr, sbr->bsExtensionId, static_cast<std::uint8_t>(bitsLeft));
|
|
if (tmpBitCount > bitsLeft) {
|
|
throw InvalidDataException();
|
|
} else {
|
|
bitsLeft -= tmpBitCount;
|
|
}
|
|
}
|
|
if (bitsLeft) { // read remaining bits
|
|
m_reader.skipBits(bitsLeft);
|
|
}
|
|
}
|
|
}
|
|
|
|
shared_ptr<AacSbrInfo> AacFrameElementParser::makeSbrInfo(std::uint8_t sbrElement, bool isDrm)
|
|
{
|
|
if (m_mpeg4ExtensionSamplingFrequencyIndex >= sizeof(mpeg4SamplingFrequencyTable)
|
|
&& m_mpeg4SamplingFrequencyIndex >= sizeof(mpeg4SamplingFrequencyTable)) {
|
|
throw InvalidDataException(); // sampling frequency index is invalid
|
|
}
|
|
return make_shared<AacSbrInfo>(m_elementId[sbrElement],
|
|
m_mpeg4ExtensionSamplingFrequencyIndex < sizeof(mpeg4SamplingFrequencyTable)
|
|
? mpeg4SamplingFrequencyTable[m_mpeg4ExtensionSamplingFrequencyIndex]
|
|
: mpeg4SamplingFrequencyTable[m_mpeg4SamplingFrequencyIndex] * 2,
|
|
m_frameLength, isDrm);
|
|
}
|
|
|
|
void AacFrameElementParser::parseSbrExtensionData(std::uint8_t sbrElement, std::uint16_t count, bool crcFlag)
|
|
{
|
|
VAR_UNUSED(count);
|
|
//uint16 alignBitCount = 0;
|
|
std::shared_ptr<AacSbrInfo> &sbr = m_sbrElements[sbrElement];
|
|
if (m_psResetFlag) {
|
|
sbr->psResetFlag = m_psResetFlag;
|
|
}
|
|
if (!sbr->isDrmSbr) {
|
|
if (crcFlag) {
|
|
sbr->bsSbrCrcBits = m_reader.readBits<std::uint16_t>(10);
|
|
}
|
|
}
|
|
//auto startFrequ = sbr->bsStartFreq;
|
|
//auto samplerateMode = sbr->bsSamplerateMode;
|
|
//auto stopFrequ = sbr->bsStopFreq;
|
|
//auto frequScale = sbr->bsFreqScale;
|
|
//auto alterScale = sbr->bsAlterScale;
|
|
//auto xoverBand = sbr->bsXoverBand;
|
|
if ((sbr->bsHeaderFlag = m_reader.readBit())) {
|
|
sbr->bsStartFreq = m_reader.readBits<std::uint8_t>(4);
|
|
sbr->bsStopFreq = m_reader.readBits<std::uint8_t>(4);
|
|
sbr->bsXoverBand = m_reader.readBits<std::uint8_t>(3);
|
|
m_reader.skipBits(2);
|
|
std::uint8_t bsExtraHeader1 = m_reader.readBit();
|
|
std::uint8_t bsExtraHeader2 = m_reader.readBit();
|
|
if (bsExtraHeader1) {
|
|
sbr->bsFreqScale = m_reader.readBits<std::uint8_t>(2);
|
|
sbr->bsAlterScale = m_reader.readBit();
|
|
sbr->bsNoiseBands = m_reader.readBits<std::uint8_t>(2);
|
|
} else {
|
|
sbr->bsFreqScale = 2;
|
|
sbr->bsAlterScale = 1;
|
|
sbr->bsNoiseBands = 2;
|
|
}
|
|
if (bsExtraHeader2) {
|
|
sbr->bsLimiterBands = m_reader.readBits<std::uint8_t>(2);
|
|
sbr->bsLimiterGains = m_reader.readBits<std::uint8_t>(2);
|
|
sbr->bsInterpolFreq = m_reader.readBit();
|
|
sbr->bsSmoothingMode = m_reader.readBit();
|
|
} else {
|
|
sbr->bsLimiterBands = 2;
|
|
sbr->bsLimiterGains = 2;
|
|
sbr->bsInterpolFreq = 1;
|
|
sbr->bsSmoothingMode = 1;
|
|
}
|
|
}
|
|
if (sbr->headerCount) {
|
|
if (sbr->reset || (sbr->bsHeaderFlag && sbr->justSeeked)) {
|
|
// TODO: calc SBR tables; restore old values on error
|
|
}
|
|
sbr->rate = sbr->bsSamplerateMode ? 2 : 1;
|
|
switch (sbr->aacElementId) {
|
|
using namespace AacSyntaxElementTypes;
|
|
case SingleChannelElement:
|
|
parseSbrSingleChannelElement(sbr);
|
|
break;
|
|
case ChannelPairElement:
|
|
parseSbrChannelPairElement(sbr);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::uint8_t AacFrameElementParser::parseHuffmanScaleFactor()
|
|
{
|
|
std::uint16_t offset = 0;
|
|
while (aacHcbSf[offset][1]) {
|
|
offset += aacHcbSf[offset][m_reader.readBit()];
|
|
if (offset > 240) {
|
|
throw InvalidDataException();
|
|
}
|
|
}
|
|
return aacHcbSf[offset][0];
|
|
}
|
|
|
|
void AacFrameElementParser::parseHuffmanSpectralData(std::uint8_t cb, std::int16_t *sp)
|
|
{
|
|
switch (cb) {
|
|
case 1:
|
|
case 2: // 2-step method for data quadruples
|
|
huffman2StepQuad(cb, sp);
|
|
break;
|
|
case 3: // binary search for data quadruples
|
|
huffmanBinaryQuadSign(cb, sp);
|
|
break;
|
|
case 4: // binary search for data paris
|
|
huffmanBinaryPair(cb, sp);
|
|
break;
|
|
case 5: // 2-step method for data pairs
|
|
huffman2StepPair(cb, sp);
|
|
break;
|
|
case 6: // 2-step method for data pairs
|
|
huffman2StepPair(cb, sp);
|
|
break;
|
|
case 7:
|
|
case 9: // binary search for data pairs
|
|
huffmanBinaryPairSign(cb, sp);
|
|
break;
|
|
case 8:
|
|
case 10: // 2-step method for data pairs
|
|
huffman2StepPairSign(cb, sp);
|
|
break;
|
|
case 11:
|
|
try {
|
|
huffman2StepPairSign(11, sp);
|
|
} catch (const InvalidDataException &) {
|
|
sp[0] = huffmanGetEscape(sp[0]);
|
|
sp[1] = huffmanGetEscape(sp[1]);
|
|
throw;
|
|
}
|
|
sp[0] = huffmanGetEscape(sp[0]);
|
|
sp[1] = huffmanGetEscape(sp[1]);
|
|
break;
|
|
case 12:
|
|
try {
|
|
huffman2StepPair(11, sp);
|
|
} catch (const InvalidDataException &) {
|
|
sp[0] = huffmanCodebook(0);
|
|
sp[1] = huffmanCodebook(1);
|
|
throw;
|
|
}
|
|
sp[0] = huffmanCodebook(0);
|
|
sp[1] = huffmanCodebook(1);
|
|
break;
|
|
case 16:
|
|
case 17:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 21:
|
|
case 22:
|
|
case 23:
|
|
case 24:
|
|
case 25:
|
|
case 26:
|
|
case 27:
|
|
case 28:
|
|
case 29:
|
|
case 30:
|
|
case 31:
|
|
try {
|
|
huffman2StepPairSign(11, sp);
|
|
} catch (const InvalidDataException &) {
|
|
sp[0] = huffmanGetEscape(sp[0]);
|
|
sp[1] = huffmanGetEscape(sp[1]);
|
|
vcb11CheckLav(cb, sp);
|
|
throw;
|
|
}
|
|
sp[0] = huffmanGetEscape(sp[0]);
|
|
sp[1] = huffmanGetEscape(sp[1]);
|
|
vcb11CheckLav(cb, sp);
|
|
break;
|
|
default:
|
|
throw InvalidDataException(); // non existend codebook number
|
|
}
|
|
}
|
|
|
|
void AacFrameElementParser::huffmanSignBits(std::int16_t *sp, std::uint8_t len)
|
|
{
|
|
for (std::int16_t *end = sp + len; sp < end; ++sp) {
|
|
if (*sp) {
|
|
if (m_reader.readBit()) {
|
|
*sp = -(*sp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AacFrameElementParser::huffman2StepQuad(std::uint8_t cb, std::int16_t *sp)
|
|
{
|
|
std::uint32_t cw = m_reader.showBits<std::uint32_t>(aacHcbN[cb]);
|
|
std::uint16_t offset = aacHcbTable[cb][cw].offset;
|
|
uint8_t extraBits = aacHcbTable[cb][cw].extraBits;
|
|
if (extraBits) {
|
|
m_reader.skipBits(aacHcbN[cb]);
|
|
offset += m_reader.showBits<std::uint16_t>(extraBits);
|
|
m_reader.skipBits(aacHcb2QuadTable[cb][offset].bits - aacHcbN[cb]);
|
|
} else {
|
|
m_reader.skipBits(aacHcb2QuadTable[cb][offset].bits);
|
|
}
|
|
if (offset > aacHcb2QuadTableSize[cb]) {
|
|
throw InvalidDataException();
|
|
}
|
|
sp[0] = aacHcb2QuadTable[cb][offset].x;
|
|
sp[1] = aacHcb2QuadTable[cb][offset].y;
|
|
sp[2] = aacHcb2QuadTable[cb][offset].v;
|
|
sp[3] = aacHcb2QuadTable[cb][offset].w;
|
|
}
|
|
|
|
void AacFrameElementParser::huffmanBinaryQuadSign(std::uint8_t cb, std::int16_t *sp)
|
|
{
|
|
try {
|
|
huffman2StepQuad(cb, sp);
|
|
} catch (const InvalidDataException &) {
|
|
huffmanSignBits(sp, 4);
|
|
throw;
|
|
}
|
|
huffmanSignBits(sp, 4);
|
|
}
|
|
|
|
void AacFrameElementParser::huffmanBinaryPair(std::uint8_t cb, std::int16_t *sp)
|
|
{
|
|
std::uint16_t offset = 0;
|
|
while (!aacHcbBinTable[cb][offset].isLeaf) {
|
|
offset += aacHcbBinTable[cb][offset].data[m_reader.readBit()];
|
|
}
|
|
if (offset > aacHcbBinTableSize[cb]) {
|
|
throw InvalidDataException();
|
|
}
|
|
sp[0] = aacHcbBinTable[cb][offset].data[0];
|
|
sp[1] = aacHcbBinTable[cb][offset].data[1];
|
|
}
|
|
|
|
void AacFrameElementParser::huffman2StepPair(std::uint8_t cb, std::int16_t *sp)
|
|
{
|
|
std::uint32_t cw = m_reader.showBits<std::uint32_t>(aacHcbN[cb]);
|
|
std::uint16_t offset = aacHcbTable[cb][cw].offset;
|
|
uint8_t extraBits = aacHcbTable[cb][cw].extraBits;
|
|
if (extraBits) {
|
|
m_reader.skipBits(aacHcbN[cb]);
|
|
offset += m_reader.showBits<std::uint16_t>(extraBits);
|
|
m_reader.skipBits(aacHcb2PairTable[cb][offset].bits - aacHcbN[cb]);
|
|
} else {
|
|
m_reader.skipBits(aacHcb2PairTable[cb][offset].bits);
|
|
}
|
|
if (offset > aacHcb2PairTableSize[cb]) {
|
|
throw InvalidDataException();
|
|
}
|
|
sp[0] = aacHcb2PairTable[cb][offset].x;
|
|
sp[1] = aacHcb2PairTable[cb][offset].y;
|
|
}
|
|
|
|
void AacFrameElementParser::huffmanBinaryPairSign(std::uint8_t cb, std::int16_t *sp)
|
|
{
|
|
try {
|
|
huffmanBinaryPair(cb, sp);
|
|
} catch (const InvalidDataException &) {
|
|
huffmanSignBits(sp, 2);
|
|
throw;
|
|
}
|
|
huffmanSignBits(sp, 2);
|
|
}
|
|
|
|
void AacFrameElementParser::huffman2StepPairSign(std::uint8_t cb, std::int16_t *sp)
|
|
{
|
|
try {
|
|
huffman2StepPair(cb, sp);
|
|
} catch (const InvalidDataException &) {
|
|
huffmanSignBits(sp, 2);
|
|
throw;
|
|
}
|
|
huffmanSignBits(sp, 2);
|
|
}
|
|
|
|
std::int16_t AacFrameElementParser::huffmanGetEscape(std::int16_t sp)
|
|
{
|
|
std::uint8_t neg;
|
|
if (sp < 0) {
|
|
if (sp != -16)
|
|
return sp;
|
|
neg = 1;
|
|
} else {
|
|
if (sp != 16)
|
|
return sp;
|
|
neg = 0;
|
|
}
|
|
std::uint8_t size;
|
|
for (size = 4; m_reader.readBit(); ++size) {
|
|
}
|
|
const std::int16_t off = m_reader.readBits<std::int16_t>(size);
|
|
return static_cast<std::int16_t>(neg ? -(off | (1 << size)) : (off | (1 << size)));
|
|
}
|
|
|
|
void AacFrameElementParser::vcb11CheckLav(std::uint8_t cb, std::int16_t *sp)
|
|
{
|
|
static const uint16_t vcb11LavTab[] = { 16, 31, 47, 63, 95, 127, 159, 191, 223, 255, 319, 383, 511, 767, 1023, 2047 };
|
|
std::uint16_t max = 0;
|
|
if (cb < 16 || cb > 31)
|
|
return;
|
|
max = vcb11LavTab[cb - 16];
|
|
if ((abs(sp[0]) > max) || (abs(sp[1]) > max)) {
|
|
sp[0] = 0;
|
|
sp[1] = 0;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Calculates "window grouping info".
|
|
*/
|
|
void AacFrameElementParser::calculateWindowGroupingInfo(AacIcsInfo &ics)
|
|
{
|
|
using namespace AacIcsSequenceTypes;
|
|
switch (ics.windowSequence) {
|
|
case OnlyLongSequence:
|
|
case LongStartSequence:
|
|
case LongStopSequence:
|
|
ics.windowCount = ics.windowGroupCount = ics.windowGroupLengths[0] = 1;
|
|
if (m_mpeg4AudioObjectId == Mpeg4AudioObjectIds::ErAacLd) {
|
|
if (m_frameLength == 512) {
|
|
ics.swbCount = swb512WindowCount[m_mpeg4SamplingFrequencyIndex];
|
|
} else { // if 480
|
|
ics.swbCount = swb480WindowCount[m_mpeg4SamplingFrequencyIndex];
|
|
}
|
|
} else {
|
|
if (m_frameLength == 1024) {
|
|
ics.swbCount = swb1024WindowCount[m_mpeg4SamplingFrequencyIndex];
|
|
} else {
|
|
ics.swbCount = swb960WindowCount[m_mpeg4SamplingFrequencyIndex];
|
|
}
|
|
}
|
|
if (ics.maxSfb > ics.swbCount) {
|
|
throw InvalidDataException();
|
|
}
|
|
if (m_mpeg4AudioObjectId == Mpeg4AudioObjectIds::ErAacLd) {
|
|
if (m_frameLength == 512) {
|
|
for (std::uint8_t i = 0; i <= ics.swbCount; ++i) {
|
|
ics.sectionSfbOffset[0][i] = swbOffset512Window[m_mpeg4SamplingFrequencyIndex][i];
|
|
ics.swbOffset[i] = swbOffset512Window[m_mpeg4SamplingFrequencyIndex][i];
|
|
}
|
|
} else {
|
|
for (std::uint8_t i = 0; i <= ics.swbCount; ++i) {
|
|
ics.sectionSfbOffset[0][i] = swbOffset480Window[m_mpeg4SamplingFrequencyIndex][i];
|
|
ics.swbOffset[i] = swbOffset480Window[m_mpeg4SamplingFrequencyIndex][i];
|
|
}
|
|
}
|
|
} else {
|
|
for (std::uint8_t i = 0; i <= ics.swbCount; ++i) {
|
|
ics.sectionSfbOffset[0][i] = swbOffset1024Window[m_mpeg4SamplingFrequencyIndex][i];
|
|
ics.swbOffset[i] = swbOffset1024Window[m_mpeg4SamplingFrequencyIndex][i];
|
|
}
|
|
}
|
|
ics.sectionSfbOffset[0][ics.swbCount] = ics.swbOffset[ics.swbCount] = ics.maxSwbOffset = m_frameLength;
|
|
break;
|
|
case EightShortSequence:
|
|
ics.windowCount = 8;
|
|
ics.windowGroupCount = ics.windowGroupLengths[0] = 1;
|
|
ics.swbCount = swb128WindowCount[m_mpeg4SamplingFrequencyIndex];
|
|
if (ics.maxSfb > ics.swbCount) {
|
|
throw InvalidDataException();
|
|
}
|
|
for (std::uint8_t i = 0; i < ics.swbCount; ++i) {
|
|
ics.swbOffset[i] = swbOffset128Window[m_mpeg4SamplingFrequencyIndex][i];
|
|
}
|
|
ics.swbOffset[ics.swbCount] = ics.maxSwbOffset = m_frameLength / 8;
|
|
for (std::uint8_t i = 0; i < ics.windowCount - 1; ++i) {
|
|
if (!(ics.scaleFactorGrouping & (1 << (6 - i)))) {
|
|
ics.windowGroupLengths[ics.windowGroupCount] = 1;
|
|
++ics.windowGroupCount;
|
|
} else {
|
|
++(ics.windowGroupLengths[ics.windowGroupCount - 1]);
|
|
}
|
|
}
|
|
for (std::uint8_t g = 0; g < ics.windowGroupCount; ++g) {
|
|
std::uint8_t sectionSfb = 0;
|
|
std::uint16_t offset = 0, width;
|
|
for (std::uint8_t i = 0; i < ics.swbCount; ++i) {
|
|
if (i + 1 == ics.swbCount) {
|
|
width = (m_frameLength / 8) - swbOffset128Window[m_mpeg4SamplingFrequencyIndex][i];
|
|
} else {
|
|
width = swbOffset128Window[m_mpeg4SamplingFrequencyIndex][i + 1] - swbOffset128Window[m_mpeg4SamplingFrequencyIndex][i];
|
|
}
|
|
width *= ics.windowGroupLengths[g];
|
|
ics.sectionSfbOffset[g][sectionSfb++] = offset;
|
|
offset += width;
|
|
}
|
|
ics.sectionSfbOffset[g][sectionSfb] = offset;
|
|
}
|
|
break;
|
|
default:
|
|
throw InvalidDataException();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses "individual channel stream" (basic audio unit).
|
|
*/
|
|
void AacFrameElementParser::parseIndividualChannelStream(AacIcsInfo &ics, std::int16_t *specData, bool scaleFlag)
|
|
{
|
|
parseSideInfo(ics, scaleFlag);
|
|
if (m_mpeg4AudioObjectId >= Mpeg4AudioObjectIds::ErAacLc) {
|
|
if (ics.tnsDataPresent) {
|
|
parseTnsData(ics);
|
|
}
|
|
}
|
|
if (m_mpeg4AudioObjectId == Mpeg4AudioObjectIds::ErParametric) { // DRM stuff?
|
|
// TODO: check CRC
|
|
throw NotImplementedException();
|
|
}
|
|
if (m_aacSpectralDataResilienceFlag) {
|
|
// TODO: parseReorderedSpectralData(ic);
|
|
throw NotImplementedException();
|
|
} else {
|
|
parseSpectralData(ics, specData);
|
|
}
|
|
if (ics.pulseDataPresent) {
|
|
if (ics.windowSequence == AacIcsSequenceTypes::EightShortSequence) {
|
|
throw InvalidDataException(); // pulse coding not allowed for short blocks
|
|
} else {
|
|
// TODO: reconstruct pulse coding
|
|
//decodePulseData(ic);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses "single channel element".
|
|
*/
|
|
void AacFrameElementParser::parseSingleChannelElement()
|
|
{
|
|
if (m_elementCount + 1 > aacMaxSyntaxElements) {
|
|
throw NotImplementedException(); // can not parse frame with more than aacMaxSyntaxElements syntax elements
|
|
}
|
|
// TODO: check whether limit of channels is exceeded
|
|
|
|
std::int16_t specData[1024] = { 0 };
|
|
m_elementId[m_elementCount] = AacSyntaxElementTypes::SingleChannelElement;
|
|
m_elementInstanceTag[m_elementCount] = m_reader.readBits<std::uint8_t>(4);
|
|
//m_channel = channel;
|
|
//m_pairedChannel = -1;
|
|
parseIndividualChannelStream(m_ics1, specData);
|
|
if (m_ics1.isUsed) {
|
|
throw InvalidDataException(); // IS not allowed in single channel
|
|
}
|
|
// check wheter next bitstream element is a fill element (for SBR decoding)
|
|
if (m_reader.showBits<std::uint8_t>(3) == AacSyntaxElementTypes::FillElement) {
|
|
parseFillElement(m_elementCount);
|
|
}
|
|
// TODO: reconstruct single channel element
|
|
// TODO: map output channels position to internal data channels
|
|
m_channelCount += m_elementChannelCount[m_elementCount];
|
|
++m_elementCount;
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses "channel pair element".
|
|
*/
|
|
void AacFrameElementParser::parseChannelPairElement()
|
|
{
|
|
if (m_elementCount + 2 > aacMaxSyntaxElements) {
|
|
throw NotImplementedException(); // can not parse frame with more than aacMaxSyntaxElements syntax elements
|
|
}
|
|
// TODO: check whether limit of channels is exceeded
|
|
m_elementId[m_elementCount] = AacSyntaxElementTypes::ChannelPairElement;
|
|
m_elementChannelCount[m_elementCount] = 2; // number of output channels in CPE is always 2
|
|
|
|
std::int16_t specData1[1024] = { 0 };
|
|
std::int16_t specData2[1024] = { 0 };
|
|
//m_channel = channels;
|
|
//m_pairedChannel = channels + 1;
|
|
m_elementInstanceTag[m_elementCount] = m_reader.readBits<std::uint8_t>(4);
|
|
if ((m_commonWindow = m_reader.readBit())) {
|
|
// both channels have common ics data
|
|
parseIcsInfo(m_ics1);
|
|
if ((m_ics1.midSideCodingMaskPresent = m_reader.readBits<std::uint8_t>(2) == 1)) { // ms mask present
|
|
for (std::uint8_t g = 0; g < m_ics1.windowGroupCount; ++g) {
|
|
for (std::uint8_t sfb = 0; sfb < m_ics1.maxSfb; ++sfb) {
|
|
m_ics1.midSideCodingUsed[g][sfb] = m_reader.readBit();
|
|
}
|
|
}
|
|
//m_reader.skipBits(m_ics1.windowGroupCount * m_ics1.maxSfb);
|
|
}
|
|
if (m_mpeg4AudioObjectId >= Mpeg4AudioObjectIds::ErAacLc && m_ics1.predictorDataPresent) {
|
|
if ((m_ics1.ltp1.dataPresent = m_reader.readBit())) {
|
|
parseLtpInfo(m_ics1, m_ics1.ltp1);
|
|
}
|
|
}
|
|
m_ics2 = m_ics1;
|
|
} else {
|
|
m_ics1.midSideCodingMaskPresent = false;
|
|
}
|
|
parseIndividualChannelStream(m_ics1, specData1);
|
|
if (m_commonWindow && m_mpeg4AudioObjectId >= Mpeg4AudioObjectIds::ErAacLc && m_ics1.predictorDataPresent) {
|
|
if ((m_ics1.ltp2.dataPresent = m_reader.readBit())) {
|
|
parseLtpInfo(m_ics1, m_ics1.ltp2);
|
|
}
|
|
}
|
|
parseIndividualChannelStream(m_ics2, specData2);
|
|
// check if next bitstream element is a fill element (for SBR decoding)
|
|
if (m_reader.showBits<std::uint8_t>(3) == AacSyntaxElementTypes::FillElement) {
|
|
parseFillElement(m_elementCount);
|
|
}
|
|
// TODO: reconstruct channel pair
|
|
// TODO: map output channels position to internal data channels
|
|
m_channelCount += 2;
|
|
++m_elementCount;
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses/skips "channel coupling element".
|
|
*/
|
|
void AacFrameElementParser::parseCouplingChannelElement()
|
|
{
|
|
m_reader.skipBits(4); // element instance tag
|
|
std::uint8_t swCceFlag = m_reader.readBit();
|
|
std::uint8_t coupledElementCount = m_reader.readBits<std::uint8_t>(3);
|
|
std::uint8_t gainElementLists = 0;
|
|
for (std::uint8_t c = 0; c < coupledElementCount; ++c) {
|
|
++gainElementLists;
|
|
std::uint8_t ccTargetIsCpe = m_reader.readBit();
|
|
//byte ccTargetTagSelect = m_reader.readBits<byte>(4);
|
|
m_reader.skipBits(4); // cc target tag select
|
|
if (ccTargetIsCpe) {
|
|
// cc left and right
|
|
if (m_reader.readBit() & m_reader.readBit()) {
|
|
++gainElementLists;
|
|
}
|
|
}
|
|
}
|
|
m_reader.skipBits(4); // 1 bit cc domain, 1 bit gain element sign, 2 bits gain element scale
|
|
AacIcsInfo ics;
|
|
std::int16_t specData[1024];
|
|
parseIndividualChannelStream(ics, specData);
|
|
for (std::uint8_t c = 1; c < gainElementLists; ++c) {
|
|
if (swCceFlag || m_reader.readBit()) {
|
|
parseHuffmanScaleFactor();
|
|
} else {
|
|
for (std::uint8_t group = 0; group < ics.windowCount; ++group) {
|
|
for (std::uint8_t sfb = 0; sfb < ics.maxSfb; ++sfb) {
|
|
if (ics.sfbCb[group][sfb] != AacScaleFactorTypes::ZeroHcb) {
|
|
parseHuffmanScaleFactor();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses "low frequency element".
|
|
*/
|
|
void AacFrameElementParser::parseLowFrequencyElement()
|
|
{
|
|
parseSingleChannelElement();
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses/skips "data stream element".
|
|
*/
|
|
void AacFrameElementParser::parseDataStreamElement()
|
|
{
|
|
std::uint8_t byteAligned = m_reader.readBit();
|
|
std::uint16_t count = m_reader.readBits<std::uint16_t>(8);
|
|
if (count == 0xFF) {
|
|
count += m_reader.readBits<std::uint16_t>(8);
|
|
}
|
|
if (byteAligned) {
|
|
m_reader.align();
|
|
}
|
|
m_reader.skipBits(count * 8);
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses "program config element".
|
|
*/
|
|
void AacFrameElementParser::parseProgramConfigElement()
|
|
{
|
|
m_pce.elementInstanceTag = m_reader.readBits<std::uint8_t>(4);
|
|
m_pce.objectType = m_reader.readBits<std::uint8_t>(2);
|
|
m_pce.samplingFrequencyIndex = m_reader.readBits<std::uint8_t>(4);
|
|
m_pce.frontChannelElementCount = m_reader.readBits<std::uint8_t>(4);
|
|
m_pce.sideChannelElementCount = m_reader.readBits<std::uint8_t>(4);
|
|
m_pce.backChannelElementCount = m_reader.readBits<std::uint8_t>(4);
|
|
m_pce.lfeChannelElementCount = m_reader.readBits<std::uint8_t>(2);
|
|
m_pce.assocDataElementCount = m_reader.readBits<std::uint8_t>(3);
|
|
m_pce.validCcElementCount = m_reader.readBits<std::uint8_t>(4);
|
|
if ((m_pce.monoMixdownPresent = m_reader.readBit())) {
|
|
m_pce.monoMixdownElementNumber = m_reader.readBits<std::uint8_t>(4);
|
|
}
|
|
if ((m_pce.stereoMixdownPresent = m_reader.readBit())) {
|
|
m_pce.stereoMixdownElementNumber = m_reader.readBits<std::uint8_t>(4);
|
|
}
|
|
if ((m_pce.matrixMixdownIdxPresent = m_reader.readBit())) {
|
|
m_pce.matrixMixdownIdx = m_reader.readBits<std::uint8_t>(2);
|
|
m_pce.pseudoSurroundEnable = m_reader.readBit();
|
|
}
|
|
std::uint8_t i;
|
|
for (i = 0; i < m_pce.frontChannelElementCount; ++i) {
|
|
m_pce.frontElementIsCpe[i] = m_reader.readBit();
|
|
m_pce.frontElementTagSelect[i] = m_reader.readBits<std::uint8_t>(4);
|
|
if (m_pce.frontElementIsCpe[i]) { // channel coupling element
|
|
m_pce.cpeChannel[m_pce.frontElementTagSelect[i]] = m_pce.channels;
|
|
m_pce.frontChannelCount += 2;
|
|
m_pce.channels += 2;
|
|
} else { // single channel element
|
|
m_pce.sceChannel[m_pce.frontElementTagSelect[i]] = m_pce.channels;
|
|
++m_pce.frontChannelCount;
|
|
++m_pce.channels;
|
|
}
|
|
}
|
|
for (i = 0; i < m_pce.sideChannelElementCount; ++i) {
|
|
m_pce.sideElementIsCpe[i] = m_reader.readBit();
|
|
m_pce.sideElementTagSelect[i] = m_reader.readBits<std::uint8_t>(4);
|
|
if (m_pce.sideElementIsCpe[i]) { // channel coupling element
|
|
m_pce.cpeChannel[m_pce.sideElementTagSelect[i]] = m_pce.channels;
|
|
m_pce.sideChannelCount += 2;
|
|
m_pce.channels += 2;
|
|
} else { // single channel element
|
|
m_pce.sceChannel[m_pce.sideElementTagSelect[i]] = m_pce.channels;
|
|
++m_pce.sideChannelCount;
|
|
++m_pce.channels;
|
|
}
|
|
}
|
|
for (i = 0; i < m_pce.backChannelElementCount; ++i) {
|
|
m_pce.backElementIsCpe[i] = m_reader.readBit();
|
|
m_pce.backElementTagSelect[i] = m_reader.readBits<std::uint8_t>(4);
|
|
if (m_pce.backElementIsCpe[i]) { // channel coupling element
|
|
m_pce.cpeChannel[m_pce.backElementTagSelect[i]] = m_pce.channels;
|
|
m_pce.backChannelCount += 2;
|
|
m_pce.channels += 2;
|
|
} else { // single channel element
|
|
m_pce.sceChannel[m_pce.backElementTagSelect[i]] = m_pce.channels;
|
|
++m_pce.backChannelCount;
|
|
++m_pce.channels;
|
|
}
|
|
}
|
|
for (i = 0; i < m_pce.lfeChannelElementCount; ++i) {
|
|
m_pce.lfeElementTagSelect[i] = m_reader.readBits<std::uint8_t>(4);
|
|
m_pce.sceChannel[m_pce.lfeElementTagSelect[i]] = m_pce.channels;
|
|
++m_pce.lfeChannelCount;
|
|
++m_pce.channels;
|
|
}
|
|
for (i = 0; i < m_pce.assocDataElementCount; ++i) {
|
|
m_pce.assocDataElementTagSelect[i] = m_reader.readBits<std::uint8_t>(4);
|
|
}
|
|
for (i = 0; i < m_pce.validCcElementCount; ++i) {
|
|
m_pce.ccElementIsIndSw[i] = m_reader.readBit();
|
|
m_pce.validCcElementTagSelect[i] = m_reader.readBits<std::uint8_t>(4);
|
|
}
|
|
m_reader.align();
|
|
m_pce.commentFieldBytes = m_reader.readBits<std::uint8_t>(8);
|
|
for (i = 0; i < m_pce.commentFieldBytes; ++i) {
|
|
m_pce.commentFieldData[i] = m_reader.readBits<std::uint8_t>(8);
|
|
}
|
|
m_pce.commentFieldData[i] = 0;
|
|
if (m_pce.channels > aacMaxChannels) {
|
|
throw NotImplementedException(); // supported channel maximum exceeded
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses "fill element".
|
|
*/
|
|
void AacFrameElementParser::parseFillElement(std::uint8_t sbrElement)
|
|
{
|
|
std::uint16_t count = m_reader.readBits<std::uint8_t>(4);
|
|
bool crcFlag = 0;
|
|
if (count == 0xF) {
|
|
count += m_reader.readBits<std::uint8_t>(8);
|
|
}
|
|
while (count > 0) {
|
|
continueWhile:
|
|
switch (m_reader.readBits<std::uint8_t>(4)) { // extension type
|
|
using namespace AacExtensionTypes;
|
|
case DynamicRange:
|
|
count -= parseDynamicRange();
|
|
break;
|
|
case SbrDataCrc:
|
|
crcFlag = true;
|
|
case SbrData:
|
|
if (sbrElement == aacInvalidSbrElement) {
|
|
throw InvalidDataException();
|
|
} else {
|
|
// ensure SBR element exists
|
|
if (!m_sbrElements[sbrElement]) {
|
|
m_sbrElements[sbrElement] = makeSbrInfo(sbrElement);
|
|
}
|
|
parseSbrExtensionData(sbrElement, count, crcFlag);
|
|
// set global flags
|
|
m_sbrPresentFlag = 1;
|
|
if (m_sbrElements[sbrElement]->ps) {
|
|
m_psUsed[sbrElement] = 1;
|
|
m_psUsedGlobal = 1;
|
|
}
|
|
}
|
|
count = 0;
|
|
break;
|
|
case FillData:
|
|
m_reader.skipBits(4 + 8 * (count - 1));
|
|
count = 0;
|
|
break;
|
|
case DataElement:
|
|
// data element version
|
|
if (m_reader.readBits<std::uint8_t>(4) == 0) {
|
|
// ANC data
|
|
std::uint8_t dataElementLength = 0, loopCounter = 0;
|
|
std::uint16_t dataElementLengthPart;
|
|
do {
|
|
dataElementLengthPart = m_reader.readBits<std::uint8_t>(8);
|
|
dataElementLength += dataElementLengthPart;
|
|
++loopCounter;
|
|
} while (dataElementLengthPart == 0xFF);
|
|
for (std::uint16_t i = 0; i < dataElementLength; ++i) {
|
|
m_reader.skipBits(8); // data element byte
|
|
count -= dataElementLength + loopCounter + 1;
|
|
goto continueWhile;
|
|
// FIXME: loop will run at most once
|
|
}
|
|
}
|
|
m_reader.skipBits(8 * (count - 1));
|
|
count = 0;
|
|
break;
|
|
case Fill:
|
|
case SacData:
|
|
default:
|
|
m_reader.skipBits(4 + 8 * (count - 1));
|
|
count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses a raw data block.
|
|
*
|
|
* Reads the element type first and then calls the appropriate method for the element type.
|
|
*/
|
|
void AacFrameElementParser::parseRawDataBlock()
|
|
{
|
|
if (m_mpeg4AudioObjectId < Mpeg4AudioObjectIds::ErAacLc) {
|
|
for (;;) {
|
|
switch (m_reader.readBits<std::uint8_t>(3)) { // parse element type
|
|
using namespace AacSyntaxElementTypes;
|
|
case SingleChannelElement:
|
|
parseSingleChannelElement();
|
|
break;
|
|
case ChannelPairElement:
|
|
parseChannelPairElement();
|
|
break;
|
|
case ChannelCouplingElement:
|
|
parseCouplingChannelElement();
|
|
break;
|
|
case LowFrequencyElement:
|
|
parseLowFrequencyElement();
|
|
break;
|
|
case DataStreamElement:
|
|
parseDataStreamElement();
|
|
break;
|
|
case ProgramConfigElement:
|
|
parseProgramConfigElement();
|
|
break;
|
|
case FillElement:
|
|
parseFillElement();
|
|
break;
|
|
case EndOfFrame:
|
|
goto endOfBlock;
|
|
default:;
|
|
}
|
|
}
|
|
} else { // error resilience
|
|
switch (m_mpeg4ChannelConfig) {
|
|
using namespace Mpeg4ChannelConfigs;
|
|
using namespace AacSyntaxElementTypes;
|
|
case FrontCenter:
|
|
parseSingleChannelElement();
|
|
break;
|
|
case FrontLeftFrontRight:
|
|
parseChannelPairElement();
|
|
break;
|
|
case FrontCenterFrontLeftFrontRight:
|
|
parseSingleChannelElement();
|
|
parseChannelPairElement();
|
|
break;
|
|
case FrontCenterFrontLeftFrontRightBackCenter:
|
|
parseSingleChannelElement();
|
|
parseChannelPairElement();
|
|
parseSingleChannelElement();
|
|
break;
|
|
case FrontCenterFrontLeftFrontRightBackLeftBackRight:
|
|
parseSingleChannelElement();
|
|
parseChannelPairElement();
|
|
parseChannelPairElement();
|
|
break;
|
|
case FrontCenterFrontLeftFrontRightBackLeftBackRightLFEChannel:
|
|
parseSingleChannelElement();
|
|
parseChannelPairElement();
|
|
parseChannelPairElement();
|
|
parseSingleChannelElement();
|
|
break;
|
|
case FrontCenterFrontLeftFrontRightSideLeftSideRightBackLeftBackRightLFEChannel:
|
|
parseSingleChannelElement();
|
|
parseChannelPairElement();
|
|
parseChannelPairElement();
|
|
parseChannelPairElement();
|
|
parseSingleChannelElement();
|
|
break;
|
|
}
|
|
}
|
|
endOfBlock:;
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses the frame data from the specified \a stream at the current position.
|
|
*/
|
|
void AacFrameElementParser::parse(const AdtsFrame &adtsFrame, std::istream &stream, std::size_t dataSize)
|
|
{
|
|
auto data = make_unique<char[]>(dataSize);
|
|
stream.read(data.get(), dataSize);
|
|
parse(adtsFrame, data, dataSize);
|
|
}
|
|
|
|
/*!
|
|
* \brief Parses the specified frame \a data.
|
|
*/
|
|
void AacFrameElementParser::parse(const AdtsFrame &adtsFrame, std::unique_ptr<char[]> &data, std::size_t dataSize)
|
|
{
|
|
m_reader.reset(data.get(), dataSize);
|
|
m_mpeg4AudioObjectId = adtsFrame.mpeg4AudioObjectId();
|
|
m_mpeg4SamplingFrequencyIndex = adtsFrame.mpeg4SamplingFrequencyIndex();
|
|
parseRawDataBlock();
|
|
}
|
|
|
|
/// \endcond
|
|
|
|
} // namespace TagParser
|