4 #include "../adts/adtsframe.h" 6 #include "../mp4/mp4ids.h" 8 #include "../exceptions.h" 10 #include <c++utilities/io/bitreader.h> 11 #include <c++utilities/misc/memory.h> 29 const byte maxPredictionSfb[16] = { 33, 33, 38, 40, 40, 40, 41, 41, 37, 37, 37, 34, 64, 64, 64, 64 };
31 const uint8_t swb512WindowCount[] = { 0, 0, 0, 36, 36, 37, 31, 31, 0, 0, 0, 0 };
33 const byte swb480WindowCount[] = { 0, 0, 0, 35, 35, 37, 30, 30, 0, 0, 0, 0 };
35 const byte swb960WindowCount[] = { 40, 40, 45, 49, 49, 49, 46, 46, 42, 42, 42, 40 };
37 const byte swb1024WindowCount[] = { 41, 41, 47, 49, 49, 51, 47, 47, 43, 43, 43, 40 };
39 const byte swb128WindowCount[] = { 12, 12, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15 };
41 const uint16 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,
42 212, 240, 276, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024 };
44 const uint16 swbOffset128_96[] = { 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128 };
46 const uint16 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,
47 240, 268, 304, 344, 384, 424, 464, 504, 544, 584, 624, 664, 704, 744, 784, 824, 864, 904, 944, 984, 1024 };
49 const uint16 swbOffset128_64[] = { 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128 };
51 const uint16 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,
52 264, 292, 320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800, 832, 864, 896, 928, 1024 };
54 const uint16 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,
55 208, 236, 268, 300, 332, 364, 396, 428, 460, 512 };
57 const uint16 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,
58 212, 240, 272, 304, 336, 368, 400, 432, 480 };
60 const uint16 swbOffset128_48[] = { 0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128 };
62 const uint16 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,
63 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 };
65 const uint16 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,
66 212, 236, 260, 288, 320, 352, 384, 416, 448, 480, 512 };
68 const uint16 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,
69 200, 224, 256, 288, 320, 352, 384, 416, 448, 480 };
71 const uint16 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,
72 204, 220, 240, 260, 284, 308, 336, 364, 396, 432, 468, 508, 552, 600, 652, 704, 768, 832, 896, 960, 1024 };
74 const uint16 swbOffset512_24[]
75 = { 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 };
77 const uint16 swbOffset480_24[]
78 = { 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 };
80 const uint16 swbOffset128_24[] = { 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128 };
82 const uint16 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,
83 280, 300, 320, 344, 368, 396, 424, 456, 492, 532, 572, 616, 664, 716, 772, 832, 896, 960, 1024 };
85 const uint16 swbOffset128_16[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128 };
87 const uint16 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,
88 372, 396, 420, 448, 476, 508, 544, 580, 620, 664, 712, 764, 820, 880, 944, 1024 };
90 const uint16 swbOffset128_8[] = { 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128 };
92 const uint16 *swbOffset1024Window[] = {
107 const uint16 *swbOffset512Window[] = {
122 const uint16 *swbOffset480Window[] = {
137 const uint16 *swbOffset128Window[] = {
159 AacLtpInfo::AacLtpInfo()
167 , shortLagPresent{ 0 }
178 , resetGroupNumber(0)
179 , predictionUsed{ 0 }
203 , coefCompress{ { 0 } }
214 , alevcode{ { { 0 } } }
215 , aloccode{ { { 0 } } }
226 , excludedChannelsPresent(0)
229 , dynamicRangeSign{ 0 }
230 , dynamicRangeControl{ 0 }
232 , additionalExcludedChannels{ 0 }
254 : aacElementId(sbrElementType)
255 , samplingFrequency(samplingFrequency)
329 , bsInvfModePrev{ { 0 } }
335 , patchNoSubbands{ 0 }
336 , patchStartSubband{ 0 }
339 bsAddHarmonic{ { 0 } }
340 , bsAddHarmonicPrev{ { 0 } }
351 , bsAlterScalePrev(0)
352 , bsNoiseBandsPrev(0)
355 prevEnvIsShort{ -1, -1 }
362 , frameLength(frameLength)
394 , bsProtocolVersion(0)
406 , bsSamplerateMode(1)
407 , bsAddHarmonicFlag{ 0 }
408 , bsAddHarmonicFlagPrev{ 0 }
415 , bsRelBord0{ { 0 } }
416 , bsRelBord1{ { 0 } }
425 throw NotImplementedException();
426 switch (sbrElementType) {
427 using namespace AacSyntaxElementTypes;
439 : elementInstanceTag(0)
441 , samplingFrequencyIndex(0)
442 , frontChannelElementCount(0)
443 , sideChannelElementCount(0)
444 , backChannelElementCount(0)
445 , lfeChannelElementCount(0)
446 , assocDataElementCount(0)
447 , validCcElementCount(0)
448 , monoMixdownPresent(0)
449 , monoMixdownElementNumber(0)
450 , stereoMixdownPresent(0)
451 , stereoMixdownElementNumber(0)
452 , matrixMixdownIdxPresent(0)
453 , pseudoSurroundEnable(0)
454 , matrixMixdownIdx(0)
455 , frontElementIsCpe{ 0 }
456 , frontElementTagSelect{ 0 }
457 , sideElementIsCpe{ 0 }
458 , sideElementTagSelect{ 0 }
459 , backElementIsCpe{ 0 }
460 , backElementTagSelect{ 0 }
461 , lfeElementTagSelect{ 0 }
462 , assocDataElementTagSelect{ 0 }
463 , ccElementIsIndSw{ 0 }
464 , validCcElementTagSelect{ 0 }
466 , commentFieldBytes(0)
467 , commentFieldData{ 0 }
468 , frontChannelCount(0)
469 , sideChannelCount(0)
470 , backChannelCount(0)
483 , windowGroupCount(0)
486 , windowGroupLengths{ 0 }
488 , scaleFactorGrouping(0)
489 , sectionSfbOffset{ { 0 } }
493 , sectionStart{ { 0 } }
494 , sectionEnd{ { 0 } }
496 , sectionsPerGroup{ 0 }
498 , scaleFactors{ { 0 } }
499 , midSideCodingMaskPresent(0)
500 , midSideCodingUsed{ { 0 } }
503 , pulseDataPresent(0)
505 , gainControlPresent(0)
506 , predictorDataPresent(0)
507 , reorderedSpectralDataLength(0)
508 , longestCodewordLength(0)
513 , sfEscapesPresent(0)
514 , rvlcEscapesLength(0)
515 , dpcmNoiseLastPos(0)
530 void AacFrameElementParser::parseLtpInfo(
const AacIcsInfo &ics, AacLtpInfo <p)
534 if ((ltp.lagUpdate = m_reader.readBit())) {
535 ltp.lag = m_reader.readBits<uint16>(10);
538 ltp.lag = m_reader.readBits<uint16>(11);
540 if (ltp.lag > (m_frameLength << 1)) {
541 throw InvalidDataException();
543 ltp.coef = m_reader.readBits<byte>(3);
544 switch (ics.windowSequence) {
546 for (byte w = 0; w < ics.windowCount; ++w) {
547 if ((ltp.shortUsed[w] = m_reader.readBit())) {
548 if ((ltp.shortLagPresent[w] = m_reader.readBit())) {
549 ltp.shortLag[w] = m_reader.readBits<byte>(4);
555 ltp.lastBand = std::min<byte>(ics.maxSfb,
aacMaxLtpSfb);
556 for (byte sfb = 0; sfb < ltp.lastBand; ++sfb) {
557 ltp.longUsed[sfb] = m_reader.readBit();
565 void AacFrameElementParser::parseIcsInfo(AacIcsInfo &ics)
567 using namespace AacIcsSequenceTypes;
568 if (m_reader.readBit()) {
569 throw InvalidDataException();
571 ics.windowSequence = m_reader.readBits<byte>(2);
572 ics.windowShape = m_reader.readBit();
574 throw InvalidDataException();
577 ics.maxSfb = m_reader.readBits<byte>(4);
578 ics.scaleFactorGrouping = m_reader.readBits<byte>(7);
580 ics.maxSfb = m_reader.readBits<byte>(6);
582 calculateWindowGroupingInfo(ics);
584 if ((ics.predictorDataPresent = m_reader.readBit())) {
585 switch (m_mpeg4AudioObjectId) {
588 if ((ics.predictor.reset = m_reader.readBit())) {
589 ics.predictor.resetGroupNumber = m_reader.readBits<byte>(5);
590 ics.predictor.maxSfb = ics.maxSfb;
592 if (ics.predictor.maxSfb > maxPredictionSfb[m_mpeg4SamplingFrequencyIndex]) {
593 ics.predictor.maxSfb = maxPredictionSfb[m_mpeg4SamplingFrequencyIndex];
595 for (byte sfb = 0; sfb < ics.predictor.maxSfb; ++sfb) {
596 ics.predictor.predictionUsed[sfb] = m_reader.readBit();
602 if ((ics.ltp1.dataPresent = m_reader.readBit())) {
603 parseLtpInfo(ics, ics.ltp1);
605 if (m_commonWindow) {
606 if ((ics.ltp2.dataPresent = m_reader.readBit())) {
607 parseLtpInfo(ics, ics.ltp2);
612 if ((ics.ltp1.dataPresent = m_reader.readBit())) {
613 parseLtpInfo(ics, ics.ltp1);
624 void AacFrameElementParser::parseSectionData(AacIcsInfo &ics)
627 const byte sectionEscValue = (1 << sectionBits) - 1;
628 for (byte groupIndex = 0, sectionIndex = 0; groupIndex < ics.windowGroupCount; ++groupIndex, sectionIndex = 0) {
629 for (byte i = 0, sectionLength, sectionLengthIncrease; i < ics.maxSfb; i += sectionLength, ++sectionIndex) {
630 ics.sectionCb[groupIndex][sectionIndex] = m_reader.readBits<byte>(m_aacSectionDataResilienceFlag ? 5 : 4);
632 sectionLengthIncrease
633 = (!m_aacSectionDataResilienceFlag && (ics.sectionCb[groupIndex][sectionIndex] < 16 || ics.sectionCb[groupIndex][sectionIndex] > 32)
634 && ics.sectionCb[groupIndex][sectionIndex] != 11)
635 ? m_reader.readBits<byte>(sectionBits)
637 while (sectionLengthIncrease == sectionEscValue) {
638 sectionLength += sectionLengthIncrease;
639 sectionLengthIncrease = m_reader.readBits<byte>(sectionBits);
641 sectionLength += sectionLengthIncrease;
642 ics.sectionStart[groupIndex][sectionIndex] = i;
643 ics.sectionEnd[groupIndex][sectionIndex] = i + sectionLength;
645 if (i + sectionLength > 8 * 15) {
646 throw InvalidDataException();
647 }
else if (sectionIndex >= 8 * 15) {
648 throw InvalidDataException();
652 throw InvalidDataException();
654 throw InvalidDataException();
657 for (byte sfb = i; sfb < i + sectionLength; ++sfb) {
658 ics.sfbCb[groupIndex][sfb] = ics.sectionCb[groupIndex][sectionIndex];
661 ics.sectionsPerGroup[groupIndex] = sectionIndex;
668 void AacFrameElementParser::decodeScaleFactorData(AacIcsInfo &ics)
671 byte noisePcmFlag = 1;
672 int16 scaleFactor = ics.globalGain;
673 int16 isPosition = 0;
674 int16 noiseEnergy = ics.globalGain - 90;
675 using namespace AacScaleFactorTypes;
676 for (byte group = 0; group < ics.windowGroupCount; ++group) {
677 for (byte sfb = 0; sfb < ics.maxSfb; ++sfb) {
678 switch (ics.sfbCb[group][sfb]) {
680 ics.scaleFactors[group][sfb] = 0;
684 ics.scaleFactors[group][sfb] = (isPosition += (parseHuffmanScaleFactor() - 60));
689 tmp = m_reader.readBits<int16>(9);
691 tmp = parseHuffmanScaleFactor() - 60;
693 ics.scaleFactors[group][sfb] = (noiseEnergy += tmp);
696 scaleFactor += parseHuffmanScaleFactor() - 60;
697 if (scaleFactor < 0 || scaleFactor > 255) {
698 throw InvalidDataException();
700 ics.scaleFactors[group][sfb] = 0;
710 void AacFrameElementParser::decodeRvlcScaleFactorData(AacIcsInfo &ics)
712 if (ics.rvlcSfLength) {
713 m_reader.skipBits(ics.rvlcSfLength);
715 if (ics.sfEscapesPresent) {
716 m_reader.skipBits(ics.rvlcEscapesLength);
724 void AacFrameElementParser::parseScaleFactorData(AacIcsInfo &ics)
726 if (!m_aacScalefactorDataResilienceFlag) {
727 decodeScaleFactorData(ics);
729 decodeRvlcScaleFactorData(ics);
736 void AacFrameElementParser::parsePulseData(AacIcsInfo &ics)
738 AacPulseInfo &p = ics.pulse;
739 p.count = m_reader.readBits<byte>(2);
740 p.startSfb = m_reader.readBits<byte>(6);
741 if (p.startSfb > ics.swbCount) {
742 throw InvalidDataException();
744 for (byte i = 0; i <= p.count; ++i) {
745 p.offset[i] = m_reader.readBits<byte>(5);
746 p.amp[i] = m_reader.readBits<byte>(4);
753 void AacFrameElementParser::parseTnsData(AacIcsInfo &ics)
755 byte filtBits, lengthBits, orderBits, startCoefBits, coefBits;
765 for (byte window = 0; window < ics.windowCount; ++window) {
766 if ((ics.tns.filt[window] = m_reader.readBits<byte>(filtBits))) {
767 startCoefBits = (ics.tns.coefRes[window] = m_reader.readBit()) ? 4 : 3;
769 for (byte filt = 0; filt < ics.tns.filt[window]; ++filt) {
770 ics.tns.length[window][filt] = m_reader.readBits<byte>(lengthBits);
771 if ((ics.tns.order[window][filt] = m_reader.readBits<byte>(orderBits))) {
772 ics.tns.direction[window][filt] = m_reader.readBit();
773 ics.tns.coefCompress[window][filt] = m_reader.readBit();
774 coefBits = startCoefBits - ics.tns.coefCompress[window][filt];
775 for (byte i = 0; i < ics.tns.order[window][filt]; ++i) {
776 ics.tns.coef[window][filt][i] = m_reader.readBits<byte>(coefBits);
786 void AacFrameElementParser::parseGainControlData(AacIcsInfo &ics)
788 AacSsrInfo &ssr = ics.ssr;
789 ssr.maxBand = m_reader.readBits<byte>(2);
790 switch (ics.windowSequence) {
791 using namespace AacIcsSequenceTypes;
793 for (byte bd = 1; bd <= ssr.maxBand; ++bd) {
794 for (byte wd = 0; wd < 1; ++wd) {
795 ssr.adjustNum[bd][wd] = m_reader.readBits<byte>(3);
796 for (byte ad = 0; ad < ssr.adjustNum[bd][wd]; ++ad) {
797 ssr.alevcode[bd][wd][ad] = m_reader.readBits<byte>(4);
798 ssr.aloccode[bd][wd][ad] = m_reader.readBits<byte>(5);
804 for (byte bd = 1; bd <= ssr.maxBand; ++bd) {
805 for (byte wd = 0; wd < 2; ++wd) {
806 ssr.adjustNum[bd][wd] = m_reader.readBits<byte>(3);
807 for (byte ad = 0; ad < ssr.adjustNum[bd][wd]; ++ad) {
808 ssr.alevcode[bd][wd][ad] = m_reader.readBits<byte>(4);
809 ssr.aloccode[bd][wd][ad] = m_reader.readBits<byte>(wd ? 2 : 4);
815 for (byte bd = 1; bd <= ssr.maxBand; ++bd) {
816 for (byte wd = 0; wd < 8; ++wd) {
817 ssr.adjustNum[bd][wd] = m_reader.readBits<byte>(3);
818 for (byte ad = 0; ad < ssr.adjustNum[bd][wd]; ++ad) {
819 ssr.alevcode[bd][wd][ad] = m_reader.readBits<byte>(4);
820 ssr.aloccode[bd][wd][ad] = m_reader.readBits<byte>(2);
826 for (byte bd = 1; bd <= ssr.maxBand; ++bd) {
827 for (byte wd = 0; wd < 2; ++wd) {
828 ssr.adjustNum[bd][wd] = m_reader.readBits<byte>(3);
829 for (byte ad = 0; ad < ssr.adjustNum[bd][wd]; ++ad) {
830 ssr.alevcode[bd][wd][ad] = m_reader.readBits<byte>(4);
831 ssr.aloccode[bd][wd][ad] = m_reader.readBits<byte>(wd ? 5 : 4);
842 void AacFrameElementParser::parseSpectralData(AacIcsInfo &ics, int16 *specData)
846 for (byte group = 0; group < ics.windowGroupCount; ++group) {
848 for (byte section = 0; section < ics.sectionsPerGroup[group]; ++section) {
849 using namespace AacScaleFactorTypes;
850 byte sectionCb = ics.sectionCb[group][section];
860 for (uint16 k = ics.sectionSfbOffset[group][ics.sectionStart[group][section]];
861 k < ics.sectionSfbOffset[group][ics.sectionEnd[group][section]]; k += increment) {
862 parseHuffmanSpectralData(sectionCb, specData);
874 void AacFrameElementParser::parseSideInfo(AacIcsInfo &ics,
bool scaleFlag)
876 ics.globalGain = m_reader.readBits<byte>(8);
877 if (!m_commonWindow && !scaleFlag) {
880 parseSectionData(ics);
881 parseScaleFactorData(ics);
883 if ((ics.pulseDataPresent = m_reader.readBit())) {
886 if ((ics.tnsDataPresent = m_reader.readBit())) {
889 if ((ics.gainControlPresent = m_reader.readBit())) {
891 throw InvalidDataException();
893 parseGainControlData(ics);
897 if (m_aacScalefactorDataResilienceFlag) {
898 decodeRvlcScaleFactorData(ics);
902 byte AacFrameElementParser::parseExcludedChannels()
904 for (byte i = 0; i < 7; ++i) {
909 for (byte i = 0; i < 7; ++i) {
916 byte AacFrameElementParser::parseDynamicRange()
920 if (m_reader.readBit()) {
922 m_reader.skipBits(4);
926 size += parseExcludedChannels();
928 if (m_reader.readBit()) {
929 m_drc.
bandCount += m_reader.readBits<byte>(4);
930 m_reader.skipBits(4);
932 for (byte i = 0; i < m_drc.
bandCount; ++i, ++size) {
933 m_drc.
bandTop[i] = m_reader.readBits<byte>(8);
936 if (m_reader.readBit()) {
938 m_reader.skipBits(1);
941 for (byte i = 0; i < m_drc.
bandCount; ++i) {
949 int16 AacFrameElementParser::sbrHuffmanDec(
SbrHuffTab table)
954 bit = m_reader.readBit();
955 index = table[index][bit];
960 void AacFrameElementParser::parseSbrGrid(std::shared_ptr<AacSbrInfo> &sbr, byte channel)
962 byte tmp, bsEnvCount, bsRelCount0, bsRelCount1;
963 switch ((sbr->bsFrameClass[channel] = m_reader.readBits<byte>(2))) {
964 using namespace BsFrameClasses;
966 tmp = m_reader.readBits<byte>(2);
967 sbr->absBordLead[channel] = 0;
968 sbr->absBordTrail[channel] = sbr->timeSlotsCount;
969 sbr->relLeadCount[channel] = (bsEnvCount = min(1 << tmp, 5)) - 1;
970 sbr->relTrailCount[channel] = 0;
971 tmp = m_reader.readBit();
972 for (byte env = 0; env < bsEnvCount; ++env) {
973 sbr->f[channel][env] = tmp;
977 sbr->absBordLead[channel] = 0;
978 sbr->absBordTrail[channel] = m_reader.readBits<byte>(2) + sbr->timeSlotsCount;
979 sbr->relLeadCount[channel] = 0;
980 sbr->relTrailCount[channel] = bsEnvCount = m_reader.readBits<byte>(2);
981 for (byte rel = 0; rel < bsEnvCount; ++rel) {
982 sbr->bsRelBord[channel][rel] = 2 * m_reader.readBits<byte>(2) + 2;
984 sbr->bsPointer[channel] = m_reader.readBits<byte>(sbrLog2(bsEnvCount + 2));
985 for (byte env = 0; env <= bsEnvCount; ++env) {
986 sbr->f[channel][bsEnvCount - env] = m_reader.readBit();
990 sbr->absBordLead[channel] = m_reader.readBits<byte>(2);
991 sbr->absBordTrail[channel] = sbr->timeSlotsCount;
992 sbr->relLeadCount[channel] = bsEnvCount = m_reader.readBits<byte>(2);
993 sbr->relTrailCount[channel] = 0;
994 for (byte rel = 0; rel < bsEnvCount; ++rel) {
995 sbr->bsRelBord[channel][rel] = 2 * m_reader.readBits<byte>(2) + 2;
997 sbr->bsPointer[channel] = m_reader.readBits<byte>(sbrLog2(bsEnvCount + 2));
998 for (byte env = 0; env < bsEnvCount; ++env) {
999 sbr->f[channel][env] = m_reader.readBit();
1003 sbr->absBordLead[channel] = m_reader.readBits<byte>(2);
1004 sbr->absBordTrail[channel] = m_reader.readBits<byte>(2) + sbr->timeSlotsCount;
1005 bsRelCount0 = m_reader.readBits<byte>(2);
1006 bsRelCount1 = m_reader.readBits<byte>(2);
1007 bsEnvCount = min(5, sbr->bsRelCount0[channel] + sbr->bsRelCount1[channel] + 1);
1008 for (byte rel = 0; rel < sbr->bsRelCount0[channel]; ++rel) {
1009 sbr->bsRelBord0[channel][rel] = 2 * m_reader.readBits<byte>(2) + 2;
1011 for (byte rel = 0; rel < sbr->bsRelCount1[channel]; ++rel) {
1012 sbr->bsRelBord1[channel][rel] = 2 * m_reader.readBits<byte>(2) + 2;
1014 sbr->bsPointer[channel] = m_reader.readBits<byte>(sbrLog2(sbr->bsRelCount0[channel] + sbr->bsRelCount1[channel] + 2));
1015 for (byte env = 0; env < bsEnvCount; ++env) {
1016 sbr->f[channel][env] = m_reader.readBit();
1018 sbr->relLeadCount[channel] = sbr->bsRelCount0[channel];
1019 sbr->relTrailCount[channel] = sbr->bsRelCount1[channel];
1023 if ((sbr->le[channel] = min<byte>(bsEnvCount, sbr->bsFrameClass[channel] ==
BsFrameClasses::VarVar ? 5 : 4)) <= 0) {
1024 throw InvalidDataException();
1026 sbr->lq[channel] = sbr->le[channel] > 1 ? 2 : 1;
1030 void AacFrameElementParser::parseSbrDtdf(std::shared_ptr<AacSbrInfo> &sbr, byte channel)
1032 for (byte i = 0; i < sbr->le[channel]; ++i) {
1033 sbr->bsDfEnv[channel][i] = m_reader.readBit();
1035 for (byte i = 0; i < sbr->lq[channel]; ++i) {
1036 sbr->bsDfNoise[channel][i] = m_reader.readBit();
1040 void AacFrameElementParser::parseInvfMode(std::shared_ptr<AacSbrInfo> &sbr, byte channel)
1042 for (byte i = 0; i < sbr->nq; ++i) {
1043 sbr->bsInvfMode[channel][i] = m_reader.readBits<byte>(2);
1047 void AacFrameElementParser::parseSbrEnvelope(std::shared_ptr<AacSbrInfo> &sbr, byte channel)
1052 sbr->ampRes[channel] = 0;
1054 sbr->ampRes[channel] = sbr->bsAmpRes;
1056 if ((sbr->bsCoupling) && (channel == 1)) {
1058 if (sbr->ampRes[channel]) {
1067 if (sbr->ampRes[channel]) {
1075 for (byte env = 0; env < sbr->le[channel]; ++env) {
1076 if (sbr->bsDfEnv[channel][env] == 0) {
1077 if ((sbr->bsCoupling == 1) && (channel == 1)) {
1078 if (sbr->ampRes[channel]) {
1079 sbr->e[channel][0][env] = m_reader.readBits<uint16>(5) << delta;
1081 sbr->e[channel][0][env] = m_reader.readBits<uint16>(6) << delta;
1084 if (sbr->ampRes[channel]) {
1085 sbr->e[channel][0][env] = m_reader.readBits<uint16>(6) << delta;
1087 sbr->e[channel][0][env] = m_reader.readBits<uint16>(7) << delta;
1090 for (byte band = 1; band < sbr->n[sbr->f[channel][env]]; ++band) {
1091 sbr->e[channel][band][env] = sbrHuffmanDec(fHuff) << delta;
1094 for (byte band = 0; band < sbr->n[sbr->f[channel][env]]; ++band) {
1095 sbr->e[channel][band][env] = sbrHuffmanDec(fHuff) << delta;
1102 void AacFrameElementParser::parseSbrNoise(std::shared_ptr<AacSbrInfo> &sbr, byte channel)
1106 if ((sbr->bsCoupling == 1) && (channel == 1)) {
1115 for (byte noise = 0; noise < sbr->lq[channel]; ++noise) {
1116 if (sbr->bsDfNoise[channel][noise] == 0) {
1117 if ((sbr->bsCoupling == 1) && (channel == 1)) {
1118 sbr->q[channel][0][noise] = m_reader.readBits<byte>(5) << delta;
1120 sbr->q[channel][0][noise] = m_reader.readBits<byte>(5) << delta;
1122 for (byte band = 1; band < sbr->nq; ++band) {
1123 sbr->q[channel][band][noise] = sbrHuffmanDec(fHuff) << delta;
1126 for (byte band = 0; band < sbr->nq; ++band) {
1127 sbr->q[channel][band][noise] = sbrHuffmanDec(fHuff) << delta;
1134 void AacFrameElementParser::parseSbrSinusoidalCoding(std::shared_ptr<AacSbrInfo> &sbr, byte channel)
1136 for (byte i = 0; i < sbr->nHigh; ++i) {
1137 sbr->bsAddHarmonic[channel][i] = m_reader.readBit();
1141 uint16 AacFrameElementParser::parseSbrExtension(std::shared_ptr<AacSbrInfo> &sbr, byte extensionId, byte)
1145 switch (extensionId) {
1146 using namespace AacSbrExtensionIds;
1148 if (sbr->psResetFlag) {
1149 sbr->ps->headerRead = 0;
1151 res = parsePsData(sbr->ps, header);
1152 if (sbr->psUsed == 0 && header == 1) {
1156 sbr->psResetFlag = 0;
1161 return parseDrmPsData(sbr->drmPs);
1163 sbr->bsExtendedData = m_reader.readBits<byte>(6);
1168 uint16 AacFrameElementParser::parsePsData(std::shared_ptr<AacPsInfo> &ps, byte &header)
1170 if (m_reader.readBit()) {
1173 ps->use34HybridBands = 0;
1174 if ((ps->enableIID = m_reader.readBit())) {
1175 ps->iidMode = m_reader.readBits<byte>(3);
1178 throw NotImplementedException();
1181 uint16 AacFrameElementParser::parseDrmPsData(std::shared_ptr<AacDrmPsInfo> &drmPs)
1183 throw NotImplementedException();
1186 void AacFrameElementParser::parseSbrSingleChannelElement(std::shared_ptr<AacSbrInfo> &sbr)
1188 if (m_reader.readBit()) {
1189 m_reader.skipBits(4);
1191 if (sbr->isDrmSbr) {
1192 m_reader.skipBits(1);
1194 parseSbrGrid(sbr, 0);
1195 parseSbrDtdf(sbr, 0);
1196 parseInvfMode(sbr, 0);
1197 parseSbrEnvelope(sbr, 0);
1198 parseSbrNoise(sbr, 0);
1200 if ((sbr->bsAddHarmonicFlag[0] = m_reader.readBit())) {
1201 parseSbrSinusoidalCoding(sbr, 0);
1203 if ((sbr->bsExtendedData = m_reader.readBit())) {
1204 uint16 cnt = m_reader.readBits<uint16>(4);
1206 cnt += m_reader.readBits<uint16>(8);
1208 uint16 bitsLeft = 8 * cnt;
1209 while (bitsLeft > 7) {
1210 sbr->bsExtensionId = m_reader.readBits<byte>(2);
1211 uint16 tmpBitCount = 2 + parseSbrExtension(sbr, sbr->bsExtensionId, bitsLeft);
1212 if (tmpBitCount > bitsLeft) {
1213 throw InvalidDataException();
1215 bitsLeft -= tmpBitCount;
1219 m_reader.skipBits(bitsLeft);
1224 void AacFrameElementParser::parseSbrChannelPairElement(std::shared_ptr<AacSbrInfo> &sbr)
1226 if (m_reader.readBit()) {
1227 m_reader.skipBits(8);
1229 if ((sbr->bsCoupling = m_reader.readBit())) {
1230 parseSbrGrid(sbr, 0);
1232 sbr->bsFrameClass[1] = sbr->bsFrameClass[0];
1233 sbr->le[1] = sbr->le[0];
1234 sbr->lq[1] = sbr->lq[0];
1235 sbr->bsPointer[1] = sbr->bsPointer[0];
1236 for (byte n = 0; n < sbr->le[0]; ++n) {
1237 sbr->te[1][n] = sbr->te[0][n];
1238 sbr->f[1][n] = sbr->f[0][n];
1240 for (byte n = 0; n < sbr->lq[0]; ++n) {
1241 sbr->tq[1][n] = sbr->tq[0][n];
1243 parseSbrDtdf(sbr, 0);
1244 parseSbrDtdf(sbr, 1);
1245 parseInvfMode(sbr, 0);
1246 for (byte n = 0; n < sbr->nq; ++n) {
1247 sbr->bsInvfMode[1][n] = sbr->bsInvfMode[0][n];
1249 parseSbrEnvelope(sbr, 0);
1250 parseSbrNoise(sbr, 0);
1251 parseSbrEnvelope(sbr, 1);
1252 parseSbrNoise(sbr, 1);
1254 parseSbrGrid(sbr, 0);
1255 parseSbrGrid(sbr, 1);
1256 parseSbrDtdf(sbr, 0);
1257 parseSbrDtdf(sbr, 1);
1258 parseInvfMode(sbr, 0);
1259 parseInvfMode(sbr, 1);
1260 parseSbrEnvelope(sbr, 0);
1261 parseSbrEnvelope(sbr, 1);
1262 parseSbrNoise(sbr, 0);
1263 parseSbrNoise(sbr, 1);
1265 if ((sbr->bsAddHarmonicFlag[0] = m_reader.readBit())) {
1266 parseSbrSinusoidalCoding(sbr, 0);
1268 if ((sbr->bsAddHarmonicFlag[1] = m_reader.readBit())) {
1269 parseSbrSinusoidalCoding(sbr, 1);
1272 if (sbr->bsCoupling) {
1275 if ((sbr->bsExtendedData = m_reader.readBit())) {
1276 uint16 cnt = m_reader.readBits<uint16>(4);
1278 cnt += m_reader.readBits<uint16>(8);
1280 uint16 bitsLeft = 8 * cnt;
1281 while (bitsLeft > 7) {
1282 sbr->bsExtensionId = m_reader.readBits<byte>(2);
1283 uint16 tmpBitCount = 2 + parseSbrExtension(sbr, sbr->bsExtensionId, bitsLeft);
1284 if (tmpBitCount > bitsLeft) {
1285 throw InvalidDataException();
1287 bitsLeft -= tmpBitCount;
1291 m_reader.skipBits(bitsLeft);
1296 shared_ptr<AacSbrInfo> AacFrameElementParser::makeSbrInfo(byte sbrElement,
bool isDrm)
1300 throw InvalidDataException();
1302 return make_shared<AacSbrInfo>(m_elementId[sbrElement],
1306 m_frameLength, isDrm);
1309 void AacFrameElementParser::parseSbrExtensionData(byte sbrElement, uint16 count,
bool crcFlag)
1313 std::shared_ptr<AacSbrInfo> &sbr = m_sbrElements[sbrElement];
1314 if (m_psResetFlag) {
1315 sbr->psResetFlag = m_psResetFlag;
1317 if (!sbr->isDrmSbr) {
1319 sbr->bsSbrCrcBits = m_reader.readBits<uint16>(10);
1328 if ((sbr->bsHeaderFlag = m_reader.readBit())) {
1329 sbr->bsStartFreq = m_reader.readBits<byte>(4);
1330 sbr->bsStopFreq = m_reader.readBits<byte>(4);
1331 sbr->bsXoverBand = m_reader.readBits<byte>(3);
1332 m_reader.skipBits(2);
1333 byte bsExtraHeader1 = m_reader.readBit();
1334 byte bsExtraHeader2 = m_reader.readBit();
1335 if (bsExtraHeader1) {
1336 sbr->bsFreqScale = m_reader.readBits<byte>(2);
1337 sbr->bsAlterScale = m_reader.readBit();
1338 sbr->bsNoiseBands = m_reader.readBits<byte>(2);
1340 sbr->bsFreqScale = 2;
1341 sbr->bsAlterScale = 1;
1342 sbr->bsNoiseBands = 2;
1344 if (bsExtraHeader2) {
1345 sbr->bsLimiterBands = m_reader.readBits<byte>(2);
1346 sbr->bsLimiterGains = m_reader.readBits<byte>(2);
1347 sbr->bsInterpolFreq = m_reader.readBit();
1348 sbr->bsSmoothingMode = m_reader.readBit();
1350 sbr->bsLimiterBands = 2;
1351 sbr->bsLimiterGains = 2;
1352 sbr->bsInterpolFreq = 1;
1353 sbr->bsSmoothingMode = 1;
1356 if (sbr->headerCount) {
1357 if (sbr->reset || (sbr->bsHeaderFlag && sbr->justSeeked)) {
1360 sbr->rate = sbr->bsSamplerateMode ? 2 : 1;
1361 switch (sbr->aacElementId) {
1362 using namespace AacSyntaxElementTypes;
1364 parseSbrSingleChannelElement(sbr);
1367 parseSbrChannelPairElement(sbr);
1373 byte AacFrameElementParser::parseHuffmanScaleFactor()
1377 offset +=
aacHcbSf[offset][m_reader.readBit()];
1379 throw InvalidDataException();
1385 void AacFrameElementParser::parseHuffmanSpectralData(byte cb, int16 *sp)
1390 huffman2StepQuad(cb, sp);
1393 huffmanBinaryQuadSign(cb, sp);
1396 huffmanBinaryPair(cb, sp);
1399 huffman2StepPair(cb, sp);
1402 huffman2StepPair(cb, sp);
1406 huffmanBinaryPairSign(cb, sp);
1410 huffman2StepPairSign(cb, sp);
1414 huffman2StepPairSign(11, sp);
1415 }
catch (
const InvalidDataException &) {
1416 sp[0] = huffmanGetEscape(sp[0]);
1417 sp[1] = huffmanGetEscape(sp[1]);
1420 sp[0] = huffmanGetEscape(sp[0]);
1421 sp[1] = huffmanGetEscape(sp[1]);
1425 huffman2StepPair(11, sp);
1426 }
catch (
const InvalidDataException &) {
1427 sp[0] = huffmanCodebook(0);
1428 sp[1] = huffmanCodebook(1);
1431 sp[0] = huffmanCodebook(0);
1432 sp[1] = huffmanCodebook(1);
1451 huffman2StepPairSign(11, sp);
1452 }
catch (
const InvalidDataException &) {
1453 sp[0] = huffmanGetEscape(sp[0]);
1454 sp[1] = huffmanGetEscape(sp[1]);
1455 vcb11CheckLav(cb, sp);
1458 sp[0] = huffmanGetEscape(sp[0]);
1459 sp[1] = huffmanGetEscape(sp[1]);
1460 vcb11CheckLav(cb, sp);
1463 throw InvalidDataException();
1467 void AacFrameElementParser::huffmanSignBits(int16 *sp, byte len)
1469 for (int16 *end = sp + len; sp < end; ++sp) {
1471 if (m_reader.readBit()) {
1478 void AacFrameElementParser::huffman2StepQuad(byte cb, int16 *sp)
1480 uint32 cw = m_reader.showBits<uint32>(
aacHcbN[cb]);
1484 m_reader.skipBits(
aacHcbN[cb]);
1485 offset += m_reader.showBits<uint16>(extraBits);
1491 throw InvalidDataException();
1499 void AacFrameElementParser::huffmanBinaryQuadSign(byte cb, int16 *sp)
1502 huffman2StepQuad(cb, sp);
1503 }
catch (
const InvalidDataException &) {
1504 huffmanSignBits(sp, 4);
1507 huffmanSignBits(sp, 4);
1510 void AacFrameElementParser::huffmanBinaryPair(byte cb, int16 *sp)
1517 throw InvalidDataException();
1523 void AacFrameElementParser::huffman2StepPair(byte cb, int16 *sp)
1525 uint32 cw = m_reader.showBits<uint32>(
aacHcbN[cb]);
1529 m_reader.skipBits(
aacHcbN[cb]);
1530 offset += m_reader.showBits<uint16>(extraBits);
1536 throw InvalidDataException();
1542 void AacFrameElementParser::huffmanBinaryPairSign(byte cb, int16 *sp)
1545 huffmanBinaryPair(cb, sp);
1546 }
catch (
const InvalidDataException &) {
1547 huffmanSignBits(sp, 2);
1550 huffmanSignBits(sp, 2);
1553 void AacFrameElementParser::huffman2StepPairSign(byte cb, int16 *sp)
1556 huffman2StepPair(cb, sp);
1557 }
catch (
const InvalidDataException &) {
1558 huffmanSignBits(sp, 2);
1561 huffmanSignBits(sp, 2);
1564 int16 AacFrameElementParser::huffmanGetEscape(int16 sp)
1577 for (size = 4; m_reader.readBit(); ++size) {
1579 const int16 off = m_reader.readBits<int16>(size);
1580 return neg ? -(off | (1 << size)) : (off | (1 << size));
1583 void AacFrameElementParser::vcb11CheckLav(byte cb, int16 *sp)
1585 static const uint16_t vcb11LavTab[] = { 16, 31, 47, 63, 95, 127, 159, 191, 223, 255, 319, 383, 511, 767, 1023, 2047 };
1587 if (cb < 16 || cb > 31)
1589 max = vcb11LavTab[cb - 16];
1590 if ((abs(sp[0]) > max) || (abs(sp[1]) > max)) {
1599 void AacFrameElementParser::calculateWindowGroupingInfo(AacIcsInfo &ics)
1601 using namespace AacIcsSequenceTypes;
1602 switch (ics.windowSequence) {
1606 ics.windowCount = ics.windowGroupCount = ics.windowGroupLengths[0] = 1;
1608 if (m_frameLength == 512) {
1609 ics.swbCount = swb512WindowCount[m_mpeg4SamplingFrequencyIndex];
1611 ics.swbCount = swb480WindowCount[m_mpeg4SamplingFrequencyIndex];
1614 if (m_frameLength == 1024) {
1615 ics.swbCount = swb1024WindowCount[m_mpeg4SamplingFrequencyIndex];
1617 ics.swbCount = swb960WindowCount[m_mpeg4SamplingFrequencyIndex];
1620 if (ics.maxSfb > ics.swbCount) {
1621 throw InvalidDataException();
1624 if (m_frameLength == 512) {
1625 for (byte i = 0; i <= ics.swbCount; ++i) {
1626 ics.sectionSfbOffset[0][i] = swbOffset512Window[m_mpeg4SamplingFrequencyIndex][i];
1627 ics.swbOffset[i] = swbOffset512Window[m_mpeg4SamplingFrequencyIndex][i];
1630 for (byte i = 0; i <= ics.swbCount; ++i) {
1631 ics.sectionSfbOffset[0][i] = swbOffset480Window[m_mpeg4SamplingFrequencyIndex][i];
1632 ics.swbOffset[i] = swbOffset480Window[m_mpeg4SamplingFrequencyIndex][i];
1636 for (byte i = 0; i <= ics.swbCount; ++i) {
1637 ics.sectionSfbOffset[0][i] = swbOffset1024Window[m_mpeg4SamplingFrequencyIndex][i];
1638 ics.swbOffset[i] = swbOffset1024Window[m_mpeg4SamplingFrequencyIndex][i];
1641 ics.sectionSfbOffset[0][ics.swbCount] = ics.swbOffset[ics.swbCount] = ics.maxSwbOffset = m_frameLength;
1644 ics.windowCount = 8;
1645 ics.windowGroupCount = ics.windowGroupLengths[0] = 1;
1646 ics.swbCount = swb128WindowCount[m_mpeg4SamplingFrequencyIndex];
1647 if (ics.maxSfb > ics.swbCount) {
1648 throw InvalidDataException();
1650 for (byte i = 0; i < ics.swbCount; ++i) {
1651 ics.swbOffset[i] = swbOffset128Window[m_mpeg4SamplingFrequencyIndex][i];
1653 ics.swbOffset[ics.swbCount] = ics.maxSwbOffset = m_frameLength / 8;
1654 for (byte i = 0; i < ics.windowCount - 1; ++i) {
1655 if (!(ics.scaleFactorGrouping & (1 << (6 - i)))) {
1656 ics.windowGroupLengths[ics.windowGroupCount] = 1;
1657 ++ics.windowGroupCount;
1659 ++(ics.windowGroupLengths[ics.windowGroupCount - 1]);
1662 for (byte g = 0; g < ics.windowGroupCount; ++g) {
1663 byte sectionSfb = 0;
1664 uint16 offset = 0, width;
1665 for (byte i = 0; i < ics.swbCount; ++i) {
1666 if (i + 1 == ics.swbCount) {
1667 width = (m_frameLength / 8) - swbOffset128Window[m_mpeg4SamplingFrequencyIndex][i];
1669 width = swbOffset128Window[m_mpeg4SamplingFrequencyIndex][i + 1] - swbOffset128Window[m_mpeg4SamplingFrequencyIndex][i];
1671 width *= ics.windowGroupLengths[g];
1672 ics.sectionSfbOffset[g][sectionSfb++] = offset;
1675 ics.sectionSfbOffset[g][sectionSfb] = offset;
1679 throw InvalidDataException();
1686 void AacFrameElementParser::parseIndividualChannelStream(AacIcsInfo &ics, int16 *specData,
bool scaleFlag)
1688 parseSideInfo(ics, scaleFlag);
1690 if (ics.tnsDataPresent) {
1696 throw NotImplementedException();
1698 if (m_aacSpectralDataResilienceFlag) {
1700 throw NotImplementedException();
1702 parseSpectralData(ics, specData);
1704 if (ics.pulseDataPresent) {
1706 throw InvalidDataException();
1717 void AacFrameElementParser::parseSingleChannelElement()
1720 throw NotImplementedException();
1724 int16 specData[1024] = { 0 };
1726 m_elementInstanceTag[m_elementCount] = m_reader.readBits<byte>(4);
1729 parseIndividualChannelStream(m_ics1, specData);
1731 throw InvalidDataException();
1735 parseFillElement(m_elementCount);
1739 m_channelCount += m_elementChannelCount[m_elementCount];
1746 void AacFrameElementParser::parseChannelPairElement()
1749 throw NotImplementedException();
1753 m_elementChannelCount[m_elementCount] = 2;
1755 int16 specData1[1024] = { 0 };
1756 int16 specData2[1024] = { 0 };
1759 m_elementInstanceTag[m_elementCount] = m_reader.readBits<byte>(4);
1760 if ((m_commonWindow = m_reader.readBit())) {
1762 parseIcsInfo(m_ics1);
1765 for (byte sfb = 0; sfb < m_ics1.
maxSfb; ++sfb) {
1773 parseLtpInfo(m_ics1, m_ics1.
ltp1);
1780 parseIndividualChannelStream(m_ics1, specData1);
1783 parseLtpInfo(m_ics1, m_ics1.
ltp2);
1786 parseIndividualChannelStream(m_ics2, specData2);
1789 parseFillElement(m_elementCount);
1793 m_channelCount += 2;
1800 void AacFrameElementParser::parseCouplingChannelElement()
1802 m_reader.skipBits(4);
1803 byte swCceFlag = m_reader.readBit();
1804 byte coupledElementCount = m_reader.readBits<byte>(3);
1805 byte gainElementLists = 0;
1806 for (byte c = 0; c < coupledElementCount; ++c) {
1808 byte ccTargetIsCpe = m_reader.readBit();
1810 m_reader.skipBits(4);
1811 if (ccTargetIsCpe) {
1813 if (m_reader.readBit() & m_reader.readBit()) {
1818 m_reader.skipBits(4);
1820 int16 specData[1024];
1821 parseIndividualChannelStream(ics, specData);
1822 for (byte c = 1; c < gainElementLists; ++c) {
1823 if (swCceFlag || m_reader.readBit()) {
1824 parseHuffmanScaleFactor();
1826 for (byte group = 0; group < ics.windowCount; ++group) {
1827 for (byte sfb = 0; sfb < ics.maxSfb; ++sfb) {
1829 parseHuffmanScaleFactor();
1840 void AacFrameElementParser::parseLowFrequencyElement()
1842 parseSingleChannelElement();
1848 void AacFrameElementParser::parseDataStreamElement()
1850 byte byteAligned = m_reader.readBit();
1851 uint16 count = m_reader.readBits<uint16>(8);
1852 if (count == 0xFF) {
1853 count += m_reader.readBits<uint16>(8);
1858 m_reader.skipBits(count * 8);
1864 void AacFrameElementParser::parseProgramConfigElement()
1867 m_pce.
objectType = m_reader.readBits<byte>(2);
1945 throw NotImplementedException();
1952 void AacFrameElementParser::parseFillElement(byte sbrElement)
1954 uint16 count = m_reader.readBits<byte>(4);
1957 count += m_reader.readBits<byte>(8);
1961 switch (m_reader.readBits<byte>(4)) {
1962 using namespace AacExtensionTypes;
1964 count -= parseDynamicRange();
1970 throw InvalidDataException();
1973 if (!m_sbrElements[sbrElement]) {
1974 m_sbrElements[sbrElement] = makeSbrInfo(sbrElement);
1976 parseSbrExtensionData(sbrElement, count, crcFlag);
1978 m_sbrPresentFlag = 1;
1979 if (m_sbrElements[sbrElement]->ps) {
1980 m_psUsed[sbrElement] = 1;
1987 m_reader.skipBits(4 + 8 * (count - 1));
1992 if (m_reader.readBits<byte>(4) == 0) {
1994 byte dataElementLength = 0, loopCounter = 0;
1995 uint16 dataElementLengthPart;
1997 dataElementLengthPart = m_reader.readBits<byte>(8);
1998 dataElementLength += dataElementLengthPart;
2000 }
while (dataElementLengthPart == 0xFF);
2001 for (uint16 i = 0; i < dataElementLength; ++i) {
2002 m_reader.skipBits(8);
2003 count -= dataElementLength + loopCounter + 1;
2007 m_reader.skipBits(8 * (count - 1));
2012 m_reader.skipBits(4 + 8 * (count - 1));
2023 void AacFrameElementParser::parseRawDataBlock()
2027 switch (m_reader.readBits<byte>(3)) {
2028 using namespace AacSyntaxElementTypes;
2030 parseSingleChannelElement();
2033 parseChannelPairElement();
2036 parseCouplingChannelElement();
2039 parseLowFrequencyElement();
2042 parseDataStreamElement();
2045 parseProgramConfigElement();
2056 switch (m_mpeg4ChannelConfig) {
2057 using namespace Mpeg4ChannelConfigs;
2058 using namespace AacSyntaxElementTypes;
2060 parseSingleChannelElement();
2063 parseChannelPairElement();
2066 parseSingleChannelElement();
2067 parseChannelPairElement();
2070 parseSingleChannelElement();
2071 parseChannelPairElement();
2072 parseSingleChannelElement();
2075 parseSingleChannelElement();
2076 parseChannelPairElement();
2077 parseChannelPairElement();
2080 parseSingleChannelElement();
2081 parseChannelPairElement();
2082 parseChannelPairElement();
2083 parseSingleChannelElement();
2086 parseSingleChannelElement();
2087 parseChannelPairElement();
2088 parseChannelPairElement();
2089 parseChannelPairElement();
2090 parseSingleChannelElement();
2102 auto data = make_unique<char[]>(dataSize);
2103 stream.read(data.get(), dataSize);
2104 parse(adtsFrame, data, dataSize);
2112 m_reader.reset(data.get(), dataSize);
2115 parseRawDataBlock();
const sbyte(* SbrHuffTab)[2]
byte backChannelElementCount
const int aacHcbBinTableSize[]
byte sideElementIsCpe[16]
byte monoMixdownElementNumber
AacIcsInfo()
Constructs a new ICS info object.
byte validCcElementTagSelect[16]
const sbyte tHuffmanEnv15dB[120][2]
byte stereoMixdownPresent
AacPulseInfo()
Constructs a new pulse info object.
byte predictorDataPresent
byte stereoMixdownElementNumber
byte assocDataElementTagSelect[16]
AacSbrInfo(byte sbrElementType, uint16 samplingFrequency, uint16 frameLength, bool isDrm)
Constructs a new SBR info object.
AacSsrInfo()
Constructs a new SSR info object.
constexpr auto aacSbrRate
const sbyte tHuffmanNoiseBal30dB[24][2]
const sbyte tHuffmanEnvBal15dB[48][2]
const sbyte tHuffmanEnvBal30dB[24][2]
const int aacHcb2QuadTableSize[]
const AacHcb2Pair *const aacHcb2PairTable[]
byte samplingFrequencyIndex
AacTnsInfo()
Constructs a new TNS info object.
const AacHcb2Quad *const aacHcb2QuadTable[]
byte pseudoSurroundEnable
AacDrmPsInfo()
Constructs a new DRM-PS info object.
AacPsInfo()
Constructs a new PS info object.
byte ccElementIsIndSw[16]
byte sideElementTagSelect[16]
byte excludeMask[aacMaxChannels]
constexpr auto aacNoTimeSlots
void parse(const AdtsFrame &adtsFrame, std::unique_ptr< char[]> &data, std::size_t dataSize)
Parses the specified frame data.
byte dynamicRangeControl[17]
Contains utility classes helping to read and write streams.
byte frontElementIsCpe[16]
byte sideChannelElementCount
byte backElementIsCpe[16]
const sbyte fHuffmanEnv15dB[120][2]
byte mpeg4AudioObjectId() const
Returns the MPEG-4 audio object type ID.
byte matrixMixdownIdxPresent
AacDrcInfo()
Constructs a new DRC info object.
byte backElementTagSelect[16]
byte assocDataElementCount
const AacHcbBinPair *const aacHcbBinTable[]
byte dynamicRangeSign[17]
const int aacHcb2PairTableSize[]
constexpr auto aacMaxLtpSfb
byte lfeChannelElementCount
const sbyte fHuffmanEnv30dB[62][2]
byte midSideCodingUsed[aacMaxWindowGroups][aacMaxSfb]
constexpr auto aacInvalidSbrElement
byte additionalExcludedChannels[aacMaxChannels]
byte excludedChannelsPresent
const AacHcb *const aacHcbTable[]
byte commentFieldData[257]
const sbyte tHuffmanEnv30dB[62][2]
const sbyte fHuffmanEnvBal30dB[24][2]
AacProgramConfig()
Constructs a new program config object.
constexpr auto aacMaxSyntaxElements
byte lfeElementTagSelect[16]
byte midSideCodingMaskPresent
constexpr auto aacMaxChannels
byte frontElementTagSelect[16]
byte mpeg4SamplingFrequencyIndex() const
Returns the MPEG-4 sample rate index.
AacPredictorInfo()
Constructs a new predictor info object.
const sbyte fHuffmanEnvBal15dB[48][2]
const sbyte tHuffmanNoise30dB[62][2]
uint32 mpeg4SamplingFrequencyTable[13]
constexpr auto aacNoTimeSlots960
byte frontChannelElementCount