3 * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
4 * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * @file libavcodec/aac.c
26 * @author Oded Shimon ( ods15 ods15 dyndns org )
27 * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
34 * N (code in SoC repo) gain control
36 * Y window shapes - standard
37 * N window shapes - Low Delay
38 * Y filterbank - standard
39 * N (code in SoC repo) filterbank - Scalable Sample Rate
40 * Y Temporal Noise Shaping
41 * N (code in SoC repo) Long Term Prediction
44 * Y frequency domain prediction
45 * Y Perceptual Noise Substitution
47 * N Scalable Inverse AAC Quantization
48 * N Frequency Selective Switch
50 * Y quantization & coding - AAC
51 * N quantization & coding - TwinVQ
52 * N quantization & coding - BSAC
53 * N AAC Error Resilience tools
54 * N Error Resilience payload syntax
55 * N Error Protection tool
57 * N Silence Compression
60 * N Structured Audio tools
61 * N Structured Audio Sample Bank Format
63 * N Harmonic and Individual Lines plus Noise
64 * N Text-To-Speech Interface
65 * N (in progress) Spectral Band Replication
66 * Y (not in this code) Layer-1
67 * Y (not in this code) Layer-2
68 * Y (not in this code) Layer-3
69 * N SinuSoidal Coding (Transient, Sinusoid, Noise)
70 * N (planned) Parametric Stereo
71 * N Direct Stream Transfer
73 * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication.
74 * - HE AAC v2 comprises LC AAC with Spectral Band Replication and
87 #include "aacdectab.h"
88 #include "mpeg4audio.h"
89 #include "aac_parser.h"
101 static VLC vlc_scalefactors
;
102 static VLC vlc_spectral
[11];
105 static ChannelElement
*get_che(AACContext
*ac
, int type
, int elem_id
)
107 if (ac
->tag_che_map
[type
][elem_id
]) {
108 return ac
->tag_che_map
[type
][elem_id
];
110 if (ac
->tags_mapped
>= tags_per_config
[ac
->m4ac
.chan_config
]) {
113 switch (ac
->m4ac
.chan_config
) {
115 if (ac
->tags_mapped
== 3 && type
== TYPE_CPE
) {
117 return ac
->tag_che_map
[TYPE_CPE
][elem_id
] = ac
->che
[TYPE_CPE
][2];
120 /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
121 instead of SCE[0] CPE[0] CPE[0] LFE[0]. If we seem to have
122 encountered such a stream, transfer the LFE[0] element to SCE[1] */
123 if (ac
->tags_mapped
== tags_per_config
[ac
->m4ac
.chan_config
] - 1 && (type
== TYPE_LFE
|| type
== TYPE_SCE
)) {
125 return ac
->tag_che_map
[type
][elem_id
] = ac
->che
[TYPE_LFE
][0];
128 if (ac
->tags_mapped
== 2 && type
== TYPE_CPE
) {
130 return ac
->tag_che_map
[TYPE_CPE
][elem_id
] = ac
->che
[TYPE_CPE
][1];
133 if (ac
->tags_mapped
== 2 && ac
->m4ac
.chan_config
== 4 && type
== TYPE_SCE
) {
135 return ac
->tag_che_map
[TYPE_SCE
][elem_id
] = ac
->che
[TYPE_SCE
][1];
139 if (ac
->tags_mapped
== (ac
->m4ac
.chan_config
!= 2) && type
== TYPE_CPE
) {
141 return ac
->tag_che_map
[TYPE_CPE
][elem_id
] = ac
->che
[TYPE_CPE
][0];
142 } else if (ac
->m4ac
.chan_config
== 2) {
146 if (!ac
->tags_mapped
&& type
== TYPE_SCE
) {
148 return ac
->tag_che_map
[TYPE_SCE
][elem_id
] = ac
->che
[TYPE_SCE
][0];
156 * Check for the channel element in the current channel position configuration.
157 * If it exists, make sure the appropriate element is allocated and map the
158 * channel order to match the internal FFmpeg channel layout.
160 * @param che_pos current channel position configuration
161 * @param type channel element type
162 * @param id channel element id
163 * @param channels count of the number of channels in the configuration
165 * @return Returns error status. 0 - OK, !0 - error
167 static int che_configure(AACContext
*ac
,
168 enum ChannelPosition che_pos
[4][MAX_ELEM_ID
],
172 if (che_pos
[type
][id
]) {
173 if (!ac
->che
[type
][id
] && !(ac
->che
[type
][id
] = av_mallocz(sizeof(ChannelElement
))))
174 return AVERROR(ENOMEM
);
175 if (type
!= TYPE_CCE
) {
176 ac
->output_data
[(*channels
)++] = ac
->che
[type
][id
]->ch
[0].ret
;
177 if (type
== TYPE_CPE
) {
178 ac
->output_data
[(*channels
)++] = ac
->che
[type
][id
]->ch
[1].ret
;
182 av_freep(&ac
->che
[type
][id
]);
187 * Configure output channel order based on the current program configuration element.
189 * @param che_pos current channel position configuration
190 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one.
192 * @return Returns error status. 0 - OK, !0 - error
194 static int output_configure(AACContext
*ac
,
195 enum ChannelPosition che_pos
[4][MAX_ELEM_ID
],
196 enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
],
197 int channel_config
, enum OCStatus oc_type
)
199 AVCodecContext
*avctx
= ac
->avccontext
;
200 int i
, type
, channels
= 0, ret
;
202 memcpy(che_pos
, new_che_pos
, 4 * MAX_ELEM_ID
* sizeof(new_che_pos
[0][0]));
204 if (channel_config
) {
205 for (i
= 0; i
< tags_per_config
[channel_config
]; i
++) {
206 if ((ret
= che_configure(ac
, che_pos
,
207 aac_channel_layout_map
[channel_config
- 1][i
][0],
208 aac_channel_layout_map
[channel_config
- 1][i
][1],
213 memset(ac
->tag_che_map
, 0, 4 * MAX_ELEM_ID
* sizeof(ac
->che
[0][0]));
216 avctx
->channel_layout
= aac_channel_layout
[channel_config
- 1];
218 /* Allocate or free elements depending on if they are in the
219 * current program configuration.
221 * Set up default 1:1 output mapping.
223 * For a 5.1 stream the output order will be:
224 * [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ]
227 for (i
= 0; i
< MAX_ELEM_ID
; i
++) {
228 for (type
= 0; type
< 4; type
++) {
229 if ((ret
= che_configure(ac
, che_pos
, type
, i
, &channels
)))
234 memcpy(ac
->tag_che_map
, ac
->che
, 4 * MAX_ELEM_ID
* sizeof(ac
->che
[0][0]));
235 ac
->tags_mapped
= 4 * MAX_ELEM_ID
;
237 avctx
->channel_layout
= 0;
240 avctx
->channels
= channels
;
242 ac
->output_configured
= oc_type
;
248 * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
250 * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present.
251 * @param sce_map mono (Single Channel Element) map
252 * @param type speaker type/position for these channels
254 static void decode_channel_map(enum ChannelPosition
*cpe_map
,
255 enum ChannelPosition
*sce_map
,
256 enum ChannelPosition type
,
257 GetBitContext
*gb
, int n
)
260 enum ChannelPosition
*map
= cpe_map
&& get_bits1(gb
) ? cpe_map
: sce_map
; // stereo or mono map
261 map
[get_bits(gb
, 4)] = type
;
266 * Decode program configuration element; reference: table 4.2.
268 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one.
270 * @return Returns error status. 0 - OK, !0 - error
272 static int decode_pce(AACContext
*ac
, enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
],
275 int num_front
, num_side
, num_back
, num_lfe
, num_assoc_data
, num_cc
, sampling_index
;
277 skip_bits(gb
, 2); // object_type
279 sampling_index
= get_bits(gb
, 4);
280 if (ac
->m4ac
.sampling_index
!= sampling_index
)
281 av_log(ac
->avccontext
, AV_LOG_WARNING
, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");
283 num_front
= get_bits(gb
, 4);
284 num_side
= get_bits(gb
, 4);
285 num_back
= get_bits(gb
, 4);
286 num_lfe
= get_bits(gb
, 2);
287 num_assoc_data
= get_bits(gb
, 3);
288 num_cc
= get_bits(gb
, 4);
291 skip_bits(gb
, 4); // mono_mixdown_tag
293 skip_bits(gb
, 4); // stereo_mixdown_tag
296 skip_bits(gb
, 3); // mixdown_coeff_index and pseudo_surround
298 decode_channel_map(new_che_pos
[TYPE_CPE
], new_che_pos
[TYPE_SCE
], AAC_CHANNEL_FRONT
, gb
, num_front
);
299 decode_channel_map(new_che_pos
[TYPE_CPE
], new_che_pos
[TYPE_SCE
], AAC_CHANNEL_SIDE
, gb
, num_side
);
300 decode_channel_map(new_che_pos
[TYPE_CPE
], new_che_pos
[TYPE_SCE
], AAC_CHANNEL_BACK
, gb
, num_back
);
301 decode_channel_map(NULL
, new_che_pos
[TYPE_LFE
], AAC_CHANNEL_LFE
, gb
, num_lfe
);
303 skip_bits_long(gb
, 4 * num_assoc_data
);
305 decode_channel_map(new_che_pos
[TYPE_CCE
], new_che_pos
[TYPE_CCE
], AAC_CHANNEL_CC
, gb
, num_cc
);
309 /* comment field, first byte is length */
310 skip_bits_long(gb
, 8 * get_bits(gb
, 8));
315 * Set up channel positions based on a default channel configuration
316 * as specified in table 1.17.
318 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one.
320 * @return Returns error status. 0 - OK, !0 - error
322 static int set_default_channel_config(AACContext
*ac
,
323 enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
],
326 if (channel_config
< 1 || channel_config
> 7) {
327 av_log(ac
->avccontext
, AV_LOG_ERROR
, "invalid default channel configuration (%d)\n",
332 /* default channel configurations:
334 * 1ch : front center (mono)
335 * 2ch : L + R (stereo)
336 * 3ch : front center + L + R
337 * 4ch : front center + L + R + back center
338 * 5ch : front center + L + R + back stereo
339 * 6ch : front center + L + R + back stereo + LFE
340 * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE
343 if (channel_config
!= 2)
344 new_che_pos
[TYPE_SCE
][0] = AAC_CHANNEL_FRONT
; // front center (or mono)
345 if (channel_config
> 1)
346 new_che_pos
[TYPE_CPE
][0] = AAC_CHANNEL_FRONT
; // L + R (or stereo)
347 if (channel_config
== 4)
348 new_che_pos
[TYPE_SCE
][1] = AAC_CHANNEL_BACK
; // back center
349 if (channel_config
> 4)
350 new_che_pos
[TYPE_CPE
][(channel_config
== 7) + 1]
351 = AAC_CHANNEL_BACK
; // back stereo
352 if (channel_config
> 5)
353 new_che_pos
[TYPE_LFE
][0] = AAC_CHANNEL_LFE
; // LFE
354 if (channel_config
== 7)
355 new_che_pos
[TYPE_CPE
][1] = AAC_CHANNEL_FRONT
; // outer front left + outer front right
361 * Decode GA "General Audio" specific configuration; reference: table 4.1.
363 * @return Returns error status. 0 - OK, !0 - error
365 static int decode_ga_specific_config(AACContext
*ac
, GetBitContext
*gb
,
368 enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
];
369 int extension_flag
, ret
;
371 if (get_bits1(gb
)) { // frameLengthFlag
372 av_log_missing_feature(ac
->avccontext
, "960/120 MDCT window is", 1);
376 if (get_bits1(gb
)) // dependsOnCoreCoder
377 skip_bits(gb
, 14); // coreCoderDelay
378 extension_flag
= get_bits1(gb
);
380 if (ac
->m4ac
.object_type
== AOT_AAC_SCALABLE
||
381 ac
->m4ac
.object_type
== AOT_ER_AAC_SCALABLE
)
382 skip_bits(gb
, 3); // layerNr
384 memset(new_che_pos
, 0, 4 * MAX_ELEM_ID
* sizeof(new_che_pos
[0][0]));
385 if (channel_config
== 0) {
386 skip_bits(gb
, 4); // element_instance_tag
387 if ((ret
= decode_pce(ac
, new_che_pos
, gb
)))
390 if ((ret
= set_default_channel_config(ac
, new_che_pos
, channel_config
)))
393 if ((ret
= output_configure(ac
, ac
->che_pos
, new_che_pos
, channel_config
, OC_LOCKED
)))
396 if (extension_flag
) {
397 switch (ac
->m4ac
.object_type
) {
399 skip_bits(gb
, 5); // numOfSubFrame
400 skip_bits(gb
, 11); // layer_length
404 case AOT_ER_AAC_SCALABLE
:
406 skip_bits(gb
, 3); /* aacSectionDataResilienceFlag
407 * aacScalefactorDataResilienceFlag
408 * aacSpectralDataResilienceFlag
412 skip_bits1(gb
); // extensionFlag3 (TBD in version 3)
418 * Decode audio specific configuration; reference: table 1.13.
420 * @param data pointer to AVCodecContext extradata
421 * @param data_size size of AVCCodecContext extradata
423 * @return Returns error status. 0 - OK, !0 - error
425 static int decode_audio_specific_config(AACContext
*ac
, void *data
,
431 init_get_bits(&gb
, data
, data_size
* 8);
433 if ((i
= ff_mpeg4audio_get_config(&ac
->m4ac
, data
, data_size
)) < 0)
435 if (ac
->m4ac
.sampling_index
> 12) {
436 av_log(ac
->avccontext
, AV_LOG_ERROR
, "invalid sampling rate index %d\n", ac
->m4ac
.sampling_index
);
440 skip_bits_long(&gb
, i
);
442 switch (ac
->m4ac
.object_type
) {
445 if (decode_ga_specific_config(ac
, &gb
, ac
->m4ac
.chan_config
))
449 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Audio object type %s%d is not supported.\n",
450 ac
->m4ac
.sbr
== 1? "SBR+" : "", ac
->m4ac
.object_type
);
457 * linear congruential pseudorandom number generator
459 * @param previous_val pointer to the current state of the generator
461 * @return Returns a 32-bit pseudorandom integer
463 static av_always_inline
int lcg_random(int previous_val
)
465 return previous_val
* 1664525 + 1013904223;
468 static void reset_predict_state(PredictorState
*ps
)
478 static void reset_all_predictors(PredictorState
*ps
)
481 for (i
= 0; i
< MAX_PREDICTORS
; i
++)
482 reset_predict_state(&ps
[i
]);
485 static void reset_predictor_group(PredictorState
*ps
, int group_num
)
488 for (i
= group_num
- 1; i
< MAX_PREDICTORS
; i
+= 30)
489 reset_predict_state(&ps
[i
]);
492 static av_cold
int aac_decode_init(AVCodecContext
*avccontext
)
494 AACContext
*ac
= avccontext
->priv_data
;
497 ac
->avccontext
= avccontext
;
499 if (avccontext
->extradata_size
> 0) {
500 if (decode_audio_specific_config(ac
, avccontext
->extradata
, avccontext
->extradata_size
))
502 avccontext
->sample_rate
= ac
->m4ac
.sample_rate
;
503 } else if (avccontext
->channels
> 0) {
504 ac
->m4ac
.sample_rate
= avccontext
->sample_rate
;
507 avccontext
->sample_fmt
= SAMPLE_FMT_S16
;
508 avccontext
->frame_size
= 1024;
510 AAC_INIT_VLC_STATIC( 0, 144);
511 AAC_INIT_VLC_STATIC( 1, 114);
512 AAC_INIT_VLC_STATIC( 2, 188);
513 AAC_INIT_VLC_STATIC( 3, 180);
514 AAC_INIT_VLC_STATIC( 4, 172);
515 AAC_INIT_VLC_STATIC( 5, 140);
516 AAC_INIT_VLC_STATIC( 6, 168);
517 AAC_INIT_VLC_STATIC( 7, 114);
518 AAC_INIT_VLC_STATIC( 8, 262);
519 AAC_INIT_VLC_STATIC( 9, 248);
520 AAC_INIT_VLC_STATIC(10, 384);
522 dsputil_init(&ac
->dsp
, avccontext
);
524 ac
->random_state
= 0x1f2e3d4c;
526 // -1024 - Compensate wrong IMDCT method.
527 // 32768 - Required to scale values to the correct range for the bias method
528 // for float to int16 conversion.
530 if (ac
->dsp
.float_to_int16_interleave
== ff_float_to_int16_interleave_c
) {
531 ac
->add_bias
= 385.0f
;
532 ac
->sf_scale
= 1. / (-1024. * 32768.);
536 ac
->sf_scale
= 1. / -1024.;
540 #if !CONFIG_HARDCODED_TABLES
541 for (i
= 0; i
< 428; i
++)
542 ff_aac_pow2sf_tab
[i
] = pow(2, (i
- 200) / 4.);
543 #endif /* CONFIG_HARDCODED_TABLES */
545 INIT_VLC_STATIC(&vlc_scalefactors
,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code
),
546 ff_aac_scalefactor_bits
, sizeof(ff_aac_scalefactor_bits
[0]), sizeof(ff_aac_scalefactor_bits
[0]),
547 ff_aac_scalefactor_code
, sizeof(ff_aac_scalefactor_code
[0]), sizeof(ff_aac_scalefactor_code
[0]),
550 ff_mdct_init(&ac
->mdct
, 11, 1, 1.0);
551 ff_mdct_init(&ac
->mdct_small
, 8, 1, 1.0);
552 // window initialization
553 ff_kbd_window_init(ff_aac_kbd_long_1024
, 4.0, 1024);
554 ff_kbd_window_init(ff_aac_kbd_short_128
, 6.0, 128);
555 ff_sine_window_init(ff_sine_1024
, 1024);
556 ff_sine_window_init(ff_sine_128
, 128);
562 * Skip data_stream_element; reference: table 4.10.
564 static void skip_data_stream_element(GetBitContext
*gb
)
566 int byte_align
= get_bits1(gb
);
567 int count
= get_bits(gb
, 8);
569 count
+= get_bits(gb
, 8);
572 skip_bits_long(gb
, 8 * count
);
575 static int decode_prediction(AACContext
*ac
, IndividualChannelStream
*ics
,
580 ics
->predictor_reset_group
= get_bits(gb
, 5);
581 if (ics
->predictor_reset_group
== 0 || ics
->predictor_reset_group
> 30) {
582 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Invalid Predictor Reset Group.\n");
586 for (sfb
= 0; sfb
< FFMIN(ics
->max_sfb
, ff_aac_pred_sfb_max
[ac
->m4ac
.sampling_index
]); sfb
++) {
587 ics
->prediction_used
[sfb
] = get_bits1(gb
);
593 * Decode Individual Channel Stream info; reference: table 4.6.
595 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information.
597 static int decode_ics_info(AACContext
*ac
, IndividualChannelStream
*ics
,
598 GetBitContext
*gb
, int common_window
)
601 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Reserved bit set.\n");
602 memset(ics
, 0, sizeof(IndividualChannelStream
));
605 ics
->window_sequence
[1] = ics
->window_sequence
[0];
606 ics
->window_sequence
[0] = get_bits(gb
, 2);
607 ics
->use_kb_window
[1] = ics
->use_kb_window
[0];
608 ics
->use_kb_window
[0] = get_bits1(gb
);
609 ics
->num_window_groups
= 1;
610 ics
->group_len
[0] = 1;
611 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
613 ics
->max_sfb
= get_bits(gb
, 4);
614 for (i
= 0; i
< 7; i
++) {
616 ics
->group_len
[ics
->num_window_groups
- 1]++;
618 ics
->num_window_groups
++;
619 ics
->group_len
[ics
->num_window_groups
- 1] = 1;
622 ics
->num_windows
= 8;
623 ics
->swb_offset
= ff_swb_offset_128
[ac
->m4ac
.sampling_index
];
624 ics
->num_swb
= ff_aac_num_swb_128
[ac
->m4ac
.sampling_index
];
625 ics
->tns_max_bands
= ff_tns_max_bands_128
[ac
->m4ac
.sampling_index
];
626 ics
->predictor_present
= 0;
628 ics
->max_sfb
= get_bits(gb
, 6);
629 ics
->num_windows
= 1;
630 ics
->swb_offset
= ff_swb_offset_1024
[ac
->m4ac
.sampling_index
];
631 ics
->num_swb
= ff_aac_num_swb_1024
[ac
->m4ac
.sampling_index
];
632 ics
->tns_max_bands
= ff_tns_max_bands_1024
[ac
->m4ac
.sampling_index
];
633 ics
->predictor_present
= get_bits1(gb
);
634 ics
->predictor_reset_group
= 0;
635 if (ics
->predictor_present
) {
636 if (ac
->m4ac
.object_type
== AOT_AAC_MAIN
) {
637 if (decode_prediction(ac
, ics
, gb
)) {
638 memset(ics
, 0, sizeof(IndividualChannelStream
));
641 } else if (ac
->m4ac
.object_type
== AOT_AAC_LC
) {
642 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Prediction is not allowed in AAC-LC.\n");
643 memset(ics
, 0, sizeof(IndividualChannelStream
));
646 av_log_missing_feature(ac
->avccontext
, "Predictor bit set but LTP is", 1);
647 memset(ics
, 0, sizeof(IndividualChannelStream
));
653 if (ics
->max_sfb
> ics
->num_swb
) {
654 av_log(ac
->avccontext
, AV_LOG_ERROR
,
655 "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
656 ics
->max_sfb
, ics
->num_swb
);
657 memset(ics
, 0, sizeof(IndividualChannelStream
));
665 * Decode band types (section_data payload); reference: table 4.46.
667 * @param band_type array of the used band type
668 * @param band_type_run_end array of the last scalefactor band of a band type run
670 * @return Returns error status. 0 - OK, !0 - error
672 static int decode_band_types(AACContext
*ac
, enum BandType band_type
[120],
673 int band_type_run_end
[120], GetBitContext
*gb
,
674 IndividualChannelStream
*ics
)
677 const int bits
= (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) ? 3 : 5;
678 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
680 while (k
< ics
->max_sfb
) {
681 uint8_t sect_end
= k
;
683 int sect_band_type
= get_bits(gb
, 4);
684 if (sect_band_type
== 12) {
685 av_log(ac
->avccontext
, AV_LOG_ERROR
, "invalid band type\n");
688 while ((sect_len_incr
= get_bits(gb
, bits
)) == (1 << bits
) - 1)
689 sect_end
+= sect_len_incr
;
690 sect_end
+= sect_len_incr
;
691 if (sect_end
> ics
->max_sfb
) {
692 av_log(ac
->avccontext
, AV_LOG_ERROR
,
693 "Number of bands (%d) exceeds limit (%d).\n",
694 sect_end
, ics
->max_sfb
);
697 for (; k
< sect_end
; k
++) {
698 band_type
[idx
] = sect_band_type
;
699 band_type_run_end
[idx
++] = sect_end
;
707 * Decode scalefactors; reference: table 4.47.
709 * @param global_gain first scalefactor value as scalefactors are differentially coded
710 * @param band_type array of the used band type
711 * @param band_type_run_end array of the last scalefactor band of a band type run
712 * @param sf array of scalefactors or intensity stereo positions
714 * @return Returns error status. 0 - OK, !0 - error
716 static int decode_scalefactors(AACContext
*ac
, float sf
[120], GetBitContext
*gb
,
717 unsigned int global_gain
,
718 IndividualChannelStream
*ics
,
719 enum BandType band_type
[120],
720 int band_type_run_end
[120])
722 const int sf_offset
= ac
->sf_offset
+ (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
? 12 : 0);
724 int offset
[3] = { global_gain
, global_gain
- 90, 100 };
726 static const char *sf_str
[3] = { "Global gain", "Noise gain", "Intensity stereo position" };
727 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
728 for (i
= 0; i
< ics
->max_sfb
;) {
729 int run_end
= band_type_run_end
[idx
];
730 if (band_type
[idx
] == ZERO_BT
) {
731 for (; i
< run_end
; i
++, idx
++)
733 } else if ((band_type
[idx
] == INTENSITY_BT
) || (band_type
[idx
] == INTENSITY_BT2
)) {
734 for (; i
< run_end
; i
++, idx
++) {
735 offset
[2] += get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60;
736 if (offset
[2] > 255U) {
737 av_log(ac
->avccontext
, AV_LOG_ERROR
,
738 "%s (%d) out of range.\n", sf_str
[2], offset
[2]);
741 sf
[idx
] = ff_aac_pow2sf_tab
[-offset
[2] + 300];
743 } else if (band_type
[idx
] == NOISE_BT
) {
744 for (; i
< run_end
; i
++, idx
++) {
745 if (noise_flag
-- > 0)
746 offset
[1] += get_bits(gb
, 9) - 256;
748 offset
[1] += get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60;
749 if (offset
[1] > 255U) {
750 av_log(ac
->avccontext
, AV_LOG_ERROR
,
751 "%s (%d) out of range.\n", sf_str
[1], offset
[1]);
754 sf
[idx
] = -ff_aac_pow2sf_tab
[offset
[1] + sf_offset
+ 100];
757 for (; i
< run_end
; i
++, idx
++) {
758 offset
[0] += get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60;
759 if (offset
[0] > 255U) {
760 av_log(ac
->avccontext
, AV_LOG_ERROR
,
761 "%s (%d) out of range.\n", sf_str
[0], offset
[0]);
764 sf
[idx
] = -ff_aac_pow2sf_tab
[ offset
[0] + sf_offset
];
773 * Decode pulse data; reference: table 4.7.
775 static int decode_pulses(Pulse
*pulse
, GetBitContext
*gb
,
776 const uint16_t *swb_offset
, int num_swb
)
779 pulse
->num_pulse
= get_bits(gb
, 2) + 1;
780 pulse_swb
= get_bits(gb
, 6);
781 if (pulse_swb
>= num_swb
)
783 pulse
->pos
[0] = swb_offset
[pulse_swb
];
784 pulse
->pos
[0] += get_bits(gb
, 5);
785 if (pulse
->pos
[0] > 1023)
787 pulse
->amp
[0] = get_bits(gb
, 4);
788 for (i
= 1; i
< pulse
->num_pulse
; i
++) {
789 pulse
->pos
[i
] = get_bits(gb
, 5) + pulse
->pos
[i
- 1];
790 if (pulse
->pos
[i
] > 1023)
792 pulse
->amp
[i
] = get_bits(gb
, 4);
798 * Decode Temporal Noise Shaping data; reference: table 4.48.
800 * @return Returns error status. 0 - OK, !0 - error
802 static int decode_tns(AACContext
*ac
, TemporalNoiseShaping
*tns
,
803 GetBitContext
*gb
, const IndividualChannelStream
*ics
)
805 int w
, filt
, i
, coef_len
, coef_res
, coef_compress
;
806 const int is8
= ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
;
807 const int tns_max_order
= is8
? 7 : ac
->m4ac
.object_type
== AOT_AAC_MAIN
? 20 : 12;
808 for (w
= 0; w
< ics
->num_windows
; w
++) {
809 if ((tns
->n_filt
[w
] = get_bits(gb
, 2 - is8
))) {
810 coef_res
= get_bits1(gb
);
812 for (filt
= 0; filt
< tns
->n_filt
[w
]; filt
++) {
814 tns
->length
[w
][filt
] = get_bits(gb
, 6 - 2 * is8
);
816 if ((tns
->order
[w
][filt
] = get_bits(gb
, 5 - 2 * is8
)) > tns_max_order
) {
817 av_log(ac
->avccontext
, AV_LOG_ERROR
, "TNS filter order %d is greater than maximum %d.",
818 tns
->order
[w
][filt
], tns_max_order
);
819 tns
->order
[w
][filt
] = 0;
822 if (tns
->order
[w
][filt
]) {
823 tns
->direction
[w
][filt
] = get_bits1(gb
);
824 coef_compress
= get_bits1(gb
);
825 coef_len
= coef_res
+ 3 - coef_compress
;
826 tmp2_idx
= 2 * coef_compress
+ coef_res
;
828 for (i
= 0; i
< tns
->order
[w
][filt
]; i
++)
829 tns
->coef
[w
][filt
][i
] = tns_tmp2_map
[tmp2_idx
][get_bits(gb
, coef_len
)];
838 * Decode Mid/Side data; reference: table 4.54.
840 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
841 * [1] mask is decoded from bitstream; [2] mask is all 1s;
842 * [3] reserved for scalable AAC
844 static void decode_mid_side_stereo(ChannelElement
*cpe
, GetBitContext
*gb
,
848 if (ms_present
== 1) {
849 for (idx
= 0; idx
< cpe
->ch
[0].ics
.num_window_groups
* cpe
->ch
[0].ics
.max_sfb
; idx
++)
850 cpe
->ms_mask
[idx
] = get_bits1(gb
);
851 } else if (ms_present
== 2) {
852 memset(cpe
->ms_mask
, 1, cpe
->ch
[0].ics
.num_window_groups
* cpe
->ch
[0].ics
.max_sfb
* sizeof(cpe
->ms_mask
[0]));
857 * Decode spectral data; reference: table 4.50.
858 * Dequantize and scale spectral data; reference: 4.6.3.3.
860 * @param coef array of dequantized, scaled spectral data
861 * @param sf array of scalefactors or intensity stereo positions
862 * @param pulse_present set if pulses are present
863 * @param pulse pointer to pulse data struct
864 * @param band_type array of the used band type
866 * @return Returns error status. 0 - OK, !0 - error
868 static int decode_spectrum_and_dequant(AACContext
*ac
, float coef
[1024],
869 GetBitContext
*gb
, float sf
[120],
870 int pulse_present
, const Pulse
*pulse
,
871 const IndividualChannelStream
*ics
,
872 enum BandType band_type
[120])
874 int i
, k
, g
, idx
= 0;
875 const int c
= 1024 / ics
->num_windows
;
876 const uint16_t *offsets
= ics
->swb_offset
;
877 float *coef_base
= coef
;
878 static const float sign_lookup
[] = { 1.0f
, -1.0f
};
880 for (g
= 0; g
< ics
->num_windows
; g
++)
881 memset(coef
+ g
* 128 + offsets
[ics
->max_sfb
], 0, sizeof(float) * (c
- offsets
[ics
->max_sfb
]));
883 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
884 for (i
= 0; i
< ics
->max_sfb
; i
++, idx
++) {
885 const int cur_band_type
= band_type
[idx
];
886 const int dim
= cur_band_type
>= FIRST_PAIR_BT
? 2 : 4;
887 const int is_cb_unsigned
= IS_CODEBOOK_UNSIGNED(cur_band_type
);
889 if (cur_band_type
== ZERO_BT
|| cur_band_type
== INTENSITY_BT2
|| cur_band_type
== INTENSITY_BT
) {
890 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
891 memset(coef
+ group
* 128 + offsets
[i
], 0, (offsets
[i
+ 1] - offsets
[i
]) * sizeof(float));
893 } else if (cur_band_type
== NOISE_BT
) {
894 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
897 float *cf
= coef
+ group
* 128 + offsets
[i
];
898 int len
= offsets
[i
+1] - offsets
[i
];
900 for (k
= 0; k
< len
; k
++) {
901 ac
->random_state
= lcg_random(ac
->random_state
);
902 cf
[k
] = ac
->random_state
;
905 band_energy
= ac
->dsp
.scalarproduct_float(cf
, cf
, len
);
906 scale
= sf
[idx
] / sqrtf(band_energy
);
907 ac
->dsp
.vector_fmul_scalar(cf
, cf
, scale
, len
);
910 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
912 const float **vqp
= vq
;
913 float *cf
= coef
+ (group
<< 7) + offsets
[i
];
914 int len
= offsets
[i
+ 1] - offsets
[i
];
916 for (k
= offsets
[i
]; k
< offsets
[i
+ 1]; k
+= dim
) {
917 const int index
= get_vlc2(gb
, vlc_spectral
[cur_band_type
- 1].table
, 6, 3);
918 const int coef_tmp_idx
= (group
<< 7) + k
;
921 if (index
>= ff_aac_spectral_sizes
[cur_band_type
- 1]) {
922 av_log(ac
->avccontext
, AV_LOG_ERROR
,
923 "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n",
924 cur_band_type
- 1, index
, ff_aac_spectral_sizes
[cur_band_type
- 1]);
927 vq_ptr
= &ff_aac_codebook_vectors
[cur_band_type
- 1][index
* dim
];
929 if (is_cb_unsigned
) {
931 coef
[coef_tmp_idx
] = sign_lookup
[get_bits1(gb
)];
933 coef
[coef_tmp_idx
+ 1] = sign_lookup
[get_bits1(gb
)];
936 coef
[coef_tmp_idx
+ 2] = sign_lookup
[get_bits1(gb
)];
938 coef
[coef_tmp_idx
+ 3] = sign_lookup
[get_bits1(gb
)];
940 if (cur_band_type
== ESC_BT
) {
941 for (j
= 0; j
< 2; j
++) {
942 if (vq_ptr
[j
] == 64.0f
) {
944 /* The total length of escape_sequence must be < 22 bits according
945 to the specification (i.e. max is 11111111110xxxxxxxxxx). */
946 while (get_bits1(gb
) && n
< 15) n
++;
948 av_log(ac
->avccontext
, AV_LOG_ERROR
, "error in spectral data, ESC overflow\n");
951 n
= (1 << n
) + get_bits(gb
, n
);
952 coef
[coef_tmp_idx
+ j
] *= cbrtf(n
) * n
;
954 coef
[coef_tmp_idx
+ j
] *= vq_ptr
[j
];
960 if (is_cb_unsigned
&& cur_band_type
!= ESC_BT
) {
961 ac
->dsp
.vector_fmul_sv_scalar
[dim
>>2](
962 cf
, cf
, vq
, sf
[idx
], len
);
963 } else if (cur_band_type
== ESC_BT
) {
964 ac
->dsp
.vector_fmul_scalar(cf
, cf
, sf
[idx
], len
);
965 } else { /* !is_cb_unsigned */
966 ac
->dsp
.sv_fmul_scalar
[dim
>>2](cf
, vq
, sf
[idx
], len
);
971 coef
+= ics
->group_len
[g
] << 7;
976 for (i
= 0; i
< pulse
->num_pulse
; i
++) {
977 float co
= coef_base
[ pulse
->pos
[i
] ];
978 while (offsets
[idx
+ 1] <= pulse
->pos
[i
])
980 if (band_type
[idx
] != NOISE_BT
&& sf
[idx
]) {
981 float ico
= -pulse
->amp
[i
];
984 ico
= co
/ sqrtf(sqrtf(fabsf(co
))) + (co
> 0 ? -ico
: ico
);
986 coef_base
[ pulse
->pos
[i
] ] = cbrtf(fabsf(ico
)) * ico
* sf
[idx
];
993 static av_always_inline
float flt16_round(float pf
)
997 tmp
.i
= (tmp
.i
+ 0x00008000U
) & 0xFFFF0000U
;
1001 static av_always_inline
float flt16_even(float pf
)
1005 tmp
.i
= (tmp
.i
+ 0x00007FFFU
+ (tmp
.i
& 0x00010000U
>> 16)) & 0xFFFF0000U
;
1009 static av_always_inline
float flt16_trunc(float pf
)
1013 pun
.i
&= 0xFFFF0000U
;
1017 static void predict(AACContext
*ac
, PredictorState
*ps
, float *coef
,
1020 const float a
= 0.953125; // 61.0 / 64
1021 const float alpha
= 0.90625; // 29.0 / 32
1026 k1
= ps
->var0
> 1 ? ps
->cor0
* flt16_even(a
/ ps
->var0
) : 0;
1027 k2
= ps
->var1
> 1 ? ps
->cor1
* flt16_even(a
/ ps
->var1
) : 0;
1029 pv
= flt16_round(k1
* ps
->r0
+ k2
* ps
->r1
);
1031 *coef
+= pv
* ac
->sf_scale
;
1033 e0
= *coef
/ ac
->sf_scale
;
1034 e1
= e0
- k1
* ps
->r0
;
1036 ps
->cor1
= flt16_trunc(alpha
* ps
->cor1
+ ps
->r1
* e1
);
1037 ps
->var1
= flt16_trunc(alpha
* ps
->var1
+ 0.5 * (ps
->r1
* ps
->r1
+ e1
* e1
));
1038 ps
->cor0
= flt16_trunc(alpha
* ps
->cor0
+ ps
->r0
* e0
);
1039 ps
->var0
= flt16_trunc(alpha
* ps
->var0
+ 0.5 * (ps
->r0
* ps
->r0
+ e0
* e0
));
1041 ps
->r1
= flt16_trunc(a
* (ps
->r0
- k1
* e0
));
1042 ps
->r0
= flt16_trunc(a
* e0
);
1046 * Apply AAC-Main style frequency domain prediction.
1048 static void apply_prediction(AACContext
*ac
, SingleChannelElement
*sce
)
1052 if (!sce
->ics
.predictor_initialized
) {
1053 reset_all_predictors(sce
->predictor_state
);
1054 sce
->ics
.predictor_initialized
= 1;
1057 if (sce
->ics
.window_sequence
[0] != EIGHT_SHORT_SEQUENCE
) {
1058 for (sfb
= 0; sfb
< ff_aac_pred_sfb_max
[ac
->m4ac
.sampling_index
]; sfb
++) {
1059 for (k
= sce
->ics
.swb_offset
[sfb
]; k
< sce
->ics
.swb_offset
[sfb
+ 1]; k
++) {
1060 predict(ac
, &sce
->predictor_state
[k
], &sce
->coeffs
[k
],
1061 sce
->ics
.predictor_present
&& sce
->ics
.prediction_used
[sfb
]);
1064 if (sce
->ics
.predictor_reset_group
)
1065 reset_predictor_group(sce
->predictor_state
, sce
->ics
.predictor_reset_group
);
1067 reset_all_predictors(sce
->predictor_state
);
1071 * Decode an individual_channel_stream payload; reference: table 4.44.
1073 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information.
1074 * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
1076 * @return Returns error status. 0 - OK, !0 - error
1078 static int decode_ics(AACContext
*ac
, SingleChannelElement
*sce
,
1079 GetBitContext
*gb
, int common_window
, int scale_flag
)
1082 TemporalNoiseShaping
*tns
= &sce
->tns
;
1083 IndividualChannelStream
*ics
= &sce
->ics
;
1084 float *out
= sce
->coeffs
;
1085 int global_gain
, pulse_present
= 0;
1087 /* This assignment is to silence a GCC warning about the variable being used
1088 * uninitialized when in fact it always is.
1090 pulse
.num_pulse
= 0;
1092 global_gain
= get_bits(gb
, 8);
1094 if (!common_window
&& !scale_flag
) {
1095 if (decode_ics_info(ac
, ics
, gb
, 0) < 0)
1099 if (decode_band_types(ac
, sce
->band_type
, sce
->band_type_run_end
, gb
, ics
) < 0)
1101 if (decode_scalefactors(ac
, sce
->sf
, gb
, global_gain
, ics
, sce
->band_type
, sce
->band_type_run_end
) < 0)
1106 if ((pulse_present
= get_bits1(gb
))) {
1107 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
1108 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Pulse tool not allowed in eight short sequence.\n");
1111 if (decode_pulses(&pulse
, gb
, ics
->swb_offset
, ics
->num_swb
)) {
1112 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Pulse data corrupt or invalid.\n");
1116 if ((tns
->present
= get_bits1(gb
)) && decode_tns(ac
, tns
, gb
, ics
))
1118 if (get_bits1(gb
)) {
1119 av_log_missing_feature(ac
->avccontext
, "SSR", 1);
1124 if (decode_spectrum_and_dequant(ac
, out
, gb
, sce
->sf
, pulse_present
, &pulse
, ics
, sce
->band_type
) < 0)
1127 if (ac
->m4ac
.object_type
== AOT_AAC_MAIN
&& !common_window
)
1128 apply_prediction(ac
, sce
);
1134 * Mid/Side stereo decoding; reference: 4.6.8.1.3.
1136 static void apply_mid_side_stereo(AACContext
*ac
, ChannelElement
*cpe
)
1138 const IndividualChannelStream
*ics
= &cpe
->ch
[0].ics
;
1139 float *ch0
= cpe
->ch
[0].coeffs
;
1140 float *ch1
= cpe
->ch
[1].coeffs
;
1141 int g
, i
, group
, idx
= 0;
1142 const uint16_t *offsets
= ics
->swb_offset
;
1143 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
1144 for (i
= 0; i
< ics
->max_sfb
; i
++, idx
++) {
1145 if (cpe
->ms_mask
[idx
] &&
1146 cpe
->ch
[0].band_type
[idx
] < NOISE_BT
&& cpe
->ch
[1].band_type
[idx
] < NOISE_BT
) {
1147 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
1148 ac
->dsp
.butterflies_float(ch0
+ group
* 128 + offsets
[i
],
1149 ch1
+ group
* 128 + offsets
[i
],
1150 offsets
[i
+1] - offsets
[i
]);
1154 ch0
+= ics
->group_len
[g
] * 128;
1155 ch1
+= ics
->group_len
[g
] * 128;
1160 * intensity stereo decoding; reference: 4.6.8.2.3
1162 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
1163 * [1] mask is decoded from bitstream; [2] mask is all 1s;
1164 * [3] reserved for scalable AAC
1166 static void apply_intensity_stereo(ChannelElement
*cpe
, int ms_present
)
1168 const IndividualChannelStream
*ics
= &cpe
->ch
[1].ics
;
1169 SingleChannelElement
*sce1
= &cpe
->ch
[1];
1170 float *coef0
= cpe
->ch
[0].coeffs
, *coef1
= cpe
->ch
[1].coeffs
;
1171 const uint16_t *offsets
= ics
->swb_offset
;
1172 int g
, group
, i
, k
, idx
= 0;
1175 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
1176 for (i
= 0; i
< ics
->max_sfb
;) {
1177 if (sce1
->band_type
[idx
] == INTENSITY_BT
|| sce1
->band_type
[idx
] == INTENSITY_BT2
) {
1178 const int bt_run_end
= sce1
->band_type_run_end
[idx
];
1179 for (; i
< bt_run_end
; i
++, idx
++) {
1180 c
= -1 + 2 * (sce1
->band_type
[idx
] - 14);
1182 c
*= 1 - 2 * cpe
->ms_mask
[idx
];
1183 scale
= c
* sce1
->sf
[idx
];
1184 for (group
= 0; group
< ics
->group_len
[g
]; group
++)
1185 for (k
= offsets
[i
]; k
< offsets
[i
+ 1]; k
++)
1186 coef1
[group
* 128 + k
] = scale
* coef0
[group
* 128 + k
];
1189 int bt_run_end
= sce1
->band_type_run_end
[idx
];
1190 idx
+= bt_run_end
- i
;
1194 coef0
+= ics
->group_len
[g
] * 128;
1195 coef1
+= ics
->group_len
[g
] * 128;
1200 * Decode a channel_pair_element; reference: table 4.4.
1202 * @param elem_id Identifies the instance of a syntax element.
1204 * @return Returns error status. 0 - OK, !0 - error
1206 static int decode_cpe(AACContext
*ac
, GetBitContext
*gb
, ChannelElement
*cpe
)
1208 int i
, ret
, common_window
, ms_present
= 0;
1210 common_window
= get_bits1(gb
);
1211 if (common_window
) {
1212 if (decode_ics_info(ac
, &cpe
->ch
[0].ics
, gb
, 1))
1214 i
= cpe
->ch
[1].ics
.use_kb_window
[0];
1215 cpe
->ch
[1].ics
= cpe
->ch
[0].ics
;
1216 cpe
->ch
[1].ics
.use_kb_window
[1] = i
;
1217 ms_present
= get_bits(gb
, 2);
1218 if (ms_present
== 3) {
1219 av_log(ac
->avccontext
, AV_LOG_ERROR
, "ms_present = 3 is reserved.\n");
1221 } else if (ms_present
)
1222 decode_mid_side_stereo(cpe
, gb
, ms_present
);
1224 if ((ret
= decode_ics(ac
, &cpe
->ch
[0], gb
, common_window
, 0)))
1226 if ((ret
= decode_ics(ac
, &cpe
->ch
[1], gb
, common_window
, 0)))
1229 if (common_window
) {
1231 apply_mid_side_stereo(ac
, cpe
);
1232 if (ac
->m4ac
.object_type
== AOT_AAC_MAIN
) {
1233 apply_prediction(ac
, &cpe
->ch
[0]);
1234 apply_prediction(ac
, &cpe
->ch
[1]);
1238 apply_intensity_stereo(cpe
, ms_present
);
1243 * Decode coupling_channel_element; reference: table 4.8.
1245 * @param elem_id Identifies the instance of a syntax element.
1247 * @return Returns error status. 0 - OK, !0 - error
1249 static int decode_cce(AACContext
*ac
, GetBitContext
*gb
, ChannelElement
*che
)
1255 SingleChannelElement
*sce
= &che
->ch
[0];
1256 ChannelCoupling
*coup
= &che
->coup
;
1258 coup
->coupling_point
= 2 * get_bits1(gb
);
1259 coup
->num_coupled
= get_bits(gb
, 3);
1260 for (c
= 0; c
<= coup
->num_coupled
; c
++) {
1262 coup
->type
[c
] = get_bits1(gb
) ? TYPE_CPE
: TYPE_SCE
;
1263 coup
->id_select
[c
] = get_bits(gb
, 4);
1264 if (coup
->type
[c
] == TYPE_CPE
) {
1265 coup
->ch_select
[c
] = get_bits(gb
, 2);
1266 if (coup
->ch_select
[c
] == 3)
1269 coup
->ch_select
[c
] = 2;
1271 coup
->coupling_point
+= get_bits1(gb
) || (coup
->coupling_point
>> 1);
1273 sign
= get_bits(gb
, 1);
1274 scale
= pow(2., pow(2., (int)get_bits(gb
, 2) - 3));
1276 if ((ret
= decode_ics(ac
, sce
, gb
, 0, 0)))
1279 for (c
= 0; c
< num_gain
; c
++) {
1283 float gain_cache
= 1.;
1285 cge
= coup
->coupling_point
== AFTER_IMDCT
? 1 : get_bits1(gb
);
1286 gain
= cge
? get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60: 0;
1287 gain_cache
= pow(scale
, -gain
);
1289 if (coup
->coupling_point
== AFTER_IMDCT
) {
1290 coup
->gain
[c
][0] = gain_cache
;
1292 for (g
= 0; g
< sce
->ics
.num_window_groups
; g
++) {
1293 for (sfb
= 0; sfb
< sce
->ics
.max_sfb
; sfb
++, idx
++) {
1294 if (sce
->band_type
[idx
] != ZERO_BT
) {
1296 int t
= get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60;
1304 gain_cache
= pow(scale
, -t
) * s
;
1307 coup
->gain
[c
][idx
] = gain_cache
;
1317 * Decode Spectral Band Replication extension data; reference: table 4.55.
1319 * @param crc flag indicating the presence of CRC checksum
1320 * @param cnt length of TYPE_FIL syntactic element in bytes
1322 * @return Returns number of bytes consumed from the TYPE_FIL element.
1324 static int decode_sbr_extension(AACContext
*ac
, GetBitContext
*gb
,
1327 // TODO : sbr_extension implementation
1328 av_log_missing_feature(ac
->avccontext
, "SBR", 0);
1329 skip_bits_long(gb
, 8 * cnt
- 4); // -4 due to reading extension type
1334 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
1336 * @return Returns number of bytes consumed.
1338 static int decode_drc_channel_exclusions(DynamicRangeControl
*che_drc
,
1342 int num_excl_chan
= 0;
1345 for (i
= 0; i
< 7; i
++)
1346 che_drc
->exclude_mask
[num_excl_chan
++] = get_bits1(gb
);
1347 } while (num_excl_chan
< MAX_CHANNELS
- 7 && get_bits1(gb
));
1349 return num_excl_chan
/ 7;
1353 * Decode dynamic range information; reference: table 4.52.
1355 * @param cnt length of TYPE_FIL syntactic element in bytes
1357 * @return Returns number of bytes consumed.
1359 static int decode_dynamic_range(DynamicRangeControl
*che_drc
,
1360 GetBitContext
*gb
, int cnt
)
1363 int drc_num_bands
= 1;
1366 /* pce_tag_present? */
1367 if (get_bits1(gb
)) {
1368 che_drc
->pce_instance_tag
= get_bits(gb
, 4);
1369 skip_bits(gb
, 4); // tag_reserved_bits
1373 /* excluded_chns_present? */
1374 if (get_bits1(gb
)) {
1375 n
+= decode_drc_channel_exclusions(che_drc
, gb
);
1378 /* drc_bands_present? */
1379 if (get_bits1(gb
)) {
1380 che_drc
->band_incr
= get_bits(gb
, 4);
1381 che_drc
->interpolation_scheme
= get_bits(gb
, 4);
1383 drc_num_bands
+= che_drc
->band_incr
;
1384 for (i
= 0; i
< drc_num_bands
; i
++) {
1385 che_drc
->band_top
[i
] = get_bits(gb
, 8);
1390 /* prog_ref_level_present? */
1391 if (get_bits1(gb
)) {
1392 che_drc
->prog_ref_level
= get_bits(gb
, 7);
1393 skip_bits1(gb
); // prog_ref_level_reserved_bits
1397 for (i
= 0; i
< drc_num_bands
; i
++) {
1398 che_drc
->dyn_rng_sgn
[i
] = get_bits1(gb
);
1399 che_drc
->dyn_rng_ctl
[i
] = get_bits(gb
, 7);
1407 * Decode extension data (incomplete); reference: table 4.51.
1409 * @param cnt length of TYPE_FIL syntactic element in bytes
1411 * @return Returns number of bytes consumed
1413 static int decode_extension_payload(AACContext
*ac
, GetBitContext
*gb
, int cnt
)
1417 switch (get_bits(gb
, 4)) { // extension type
1418 case EXT_SBR_DATA_CRC
:
1421 res
= decode_sbr_extension(ac
, gb
, crc_flag
, cnt
);
1423 case EXT_DYNAMIC_RANGE
:
1424 res
= decode_dynamic_range(&ac
->che_drc
, gb
, cnt
);
1428 case EXT_DATA_ELEMENT
:
1430 skip_bits_long(gb
, 8 * cnt
- 4);
1437 * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
1439 * @param decode 1 if tool is used normally, 0 if tool is used in LTP.
1440 * @param coef spectral coefficients
1442 static void apply_tns(float coef
[1024], TemporalNoiseShaping
*tns
,
1443 IndividualChannelStream
*ics
, int decode
)
1445 const int mmm
= FFMIN(ics
->tns_max_bands
, ics
->max_sfb
);
1447 int bottom
, top
, order
, start
, end
, size
, inc
;
1448 float lpc
[TNS_MAX_ORDER
];
1450 for (w
= 0; w
< ics
->num_windows
; w
++) {
1451 bottom
= ics
->num_swb
;
1452 for (filt
= 0; filt
< tns
->n_filt
[w
]; filt
++) {
1454 bottom
= FFMAX(0, top
- tns
->length
[w
][filt
]);
1455 order
= tns
->order
[w
][filt
];
1460 compute_lpc_coefs(tns
->coef
[w
][filt
], order
, lpc
, 0, 0, 0);
1462 start
= ics
->swb_offset
[FFMIN(bottom
, mmm
)];
1463 end
= ics
->swb_offset
[FFMIN( top
, mmm
)];
1464 if ((size
= end
- start
) <= 0)
1466 if (tns
->direction
[w
][filt
]) {
1475 for (m
= 0; m
< size
; m
++, start
+= inc
)
1476 for (i
= 1; i
<= FFMIN(m
, order
); i
++)
1477 coef
[start
] -= coef
[start
- i
* inc
] * lpc
[i
- 1];
1483 * Conduct IMDCT and windowing.
1485 static void imdct_and_windowing(AACContext
*ac
, SingleChannelElement
*sce
)
1487 IndividualChannelStream
*ics
= &sce
->ics
;
1488 float *in
= sce
->coeffs
;
1489 float *out
= sce
->ret
;
1490 float *saved
= sce
->saved
;
1491 const float *swindow
= ics
->use_kb_window
[0] ? ff_aac_kbd_short_128
: ff_sine_128
;
1492 const float *lwindow_prev
= ics
->use_kb_window
[1] ? ff_aac_kbd_long_1024
: ff_sine_1024
;
1493 const float *swindow_prev
= ics
->use_kb_window
[1] ? ff_aac_kbd_short_128
: ff_sine_128
;
1494 float *buf
= ac
->buf_mdct
;
1495 float *temp
= ac
->temp
;
1499 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
1500 if (ics
->window_sequence
[1] == ONLY_LONG_SEQUENCE
|| ics
->window_sequence
[1] == LONG_STOP_SEQUENCE
)
1501 av_log(ac
->avccontext
, AV_LOG_WARNING
,
1502 "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. "
1503 "If you heard an audible artifact, please submit the sample to the FFmpeg developers.\n");
1504 for (i
= 0; i
< 1024; i
+= 128)
1505 ff_imdct_half(&ac
->mdct_small
, buf
+ i
, in
+ i
);
1507 ff_imdct_half(&ac
->mdct
, buf
, in
);
1509 /* window overlapping
1510 * NOTE: To simplify the overlapping code, all 'meaningless' short to long
1511 * and long to short transitions are considered to be short to short
1512 * transitions. This leaves just two cases (long to long and short to short)
1513 * with a little special sauce for EIGHT_SHORT_SEQUENCE.
1515 if ((ics
->window_sequence
[1] == ONLY_LONG_SEQUENCE
|| ics
->window_sequence
[1] == LONG_STOP_SEQUENCE
) &&
1516 (ics
->window_sequence
[0] == ONLY_LONG_SEQUENCE
|| ics
->window_sequence
[0] == LONG_START_SEQUENCE
)) {
1517 ac
->dsp
.vector_fmul_window( out
, saved
, buf
, lwindow_prev
, ac
->add_bias
, 512);
1519 for (i
= 0; i
< 448; i
++)
1520 out
[i
] = saved
[i
] + ac
->add_bias
;
1522 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
1523 ac
->dsp
.vector_fmul_window(out
+ 448 + 0*128, saved
+ 448, buf
+ 0*128, swindow_prev
, ac
->add_bias
, 64);
1524 ac
->dsp
.vector_fmul_window(out
+ 448 + 1*128, buf
+ 0*128 + 64, buf
+ 1*128, swindow
, ac
->add_bias
, 64);
1525 ac
->dsp
.vector_fmul_window(out
+ 448 + 2*128, buf
+ 1*128 + 64, buf
+ 2*128, swindow
, ac
->add_bias
, 64);
1526 ac
->dsp
.vector_fmul_window(out
+ 448 + 3*128, buf
+ 2*128 + 64, buf
+ 3*128, swindow
, ac
->add_bias
, 64);
1527 ac
->dsp
.vector_fmul_window(temp
, buf
+ 3*128 + 64, buf
+ 4*128, swindow
, ac
->add_bias
, 64);
1528 memcpy( out
+ 448 + 4*128, temp
, 64 * sizeof(float));
1530 ac
->dsp
.vector_fmul_window(out
+ 448, saved
+ 448, buf
, swindow_prev
, ac
->add_bias
, 64);
1531 for (i
= 576; i
< 1024; i
++)
1532 out
[i
] = buf
[i
-512] + ac
->add_bias
;
1537 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
1538 for (i
= 0; i
< 64; i
++)
1539 saved
[i
] = temp
[64 + i
] - ac
->add_bias
;
1540 ac
->dsp
.vector_fmul_window(saved
+ 64, buf
+ 4*128 + 64, buf
+ 5*128, swindow
, 0, 64);
1541 ac
->dsp
.vector_fmul_window(saved
+ 192, buf
+ 5*128 + 64, buf
+ 6*128, swindow
, 0, 64);
1542 ac
->dsp
.vector_fmul_window(saved
+ 320, buf
+ 6*128 + 64, buf
+ 7*128, swindow
, 0, 64);
1543 memcpy( saved
+ 448, buf
+ 7*128 + 64, 64 * sizeof(float));
1544 } else if (ics
->window_sequence
[0] == LONG_START_SEQUENCE
) {
1545 memcpy( saved
, buf
+ 512, 448 * sizeof(float));
1546 memcpy( saved
+ 448, buf
+ 7*128 + 64, 64 * sizeof(float));
1547 } else { // LONG_STOP or ONLY_LONG
1548 memcpy( saved
, buf
+ 512, 512 * sizeof(float));
1553 * Apply dependent channel coupling (applied before IMDCT).
1555 * @param index index into coupling gain array
1557 static void apply_dependent_coupling(AACContext
*ac
,
1558 SingleChannelElement
*target
,
1559 ChannelElement
*cce
, int index
)
1561 IndividualChannelStream
*ics
= &cce
->ch
[0].ics
;
1562 const uint16_t *offsets
= ics
->swb_offset
;
1563 float *dest
= target
->coeffs
;
1564 const float *src
= cce
->ch
[0].coeffs
;
1565 int g
, i
, group
, k
, idx
= 0;
1566 if (ac
->m4ac
.object_type
== AOT_AAC_LTP
) {
1567 av_log(ac
->avccontext
, AV_LOG_ERROR
,
1568 "Dependent coupling is not supported together with LTP\n");
1571 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
1572 for (i
= 0; i
< ics
->max_sfb
; i
++, idx
++) {
1573 if (cce
->ch
[0].band_type
[idx
] != ZERO_BT
) {
1574 const float gain
= cce
->coup
.gain
[index
][idx
];
1575 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
1576 for (k
= offsets
[i
]; k
< offsets
[i
+ 1]; k
++) {
1578 dest
[group
* 128 + k
] += gain
* src
[group
* 128 + k
];
1583 dest
+= ics
->group_len
[g
] * 128;
1584 src
+= ics
->group_len
[g
] * 128;
1589 * Apply independent channel coupling (applied after IMDCT).
1591 * @param index index into coupling gain array
1593 static void apply_independent_coupling(AACContext
*ac
,
1594 SingleChannelElement
*target
,
1595 ChannelElement
*cce
, int index
)
1598 const float gain
= cce
->coup
.gain
[index
][0];
1599 const float bias
= ac
->add_bias
;
1600 const float *src
= cce
->ch
[0].ret
;
1601 float *dest
= target
->ret
;
1603 for (i
= 0; i
< 1024; i
++)
1604 dest
[i
] += gain
* (src
[i
] - bias
);
1608 * channel coupling transformation interface
1610 * @param index index into coupling gain array
1611 * @param apply_coupling_method pointer to (in)dependent coupling function
1613 static void apply_channel_coupling(AACContext
*ac
, ChannelElement
*cc
,
1614 enum RawDataBlockType type
, int elem_id
,
1615 enum CouplingPoint coupling_point
,
1616 void (*apply_coupling_method
)(AACContext
*ac
, SingleChannelElement
*target
, ChannelElement
*cce
, int index
))
1620 for (i
= 0; i
< MAX_ELEM_ID
; i
++) {
1621 ChannelElement
*cce
= ac
->che
[TYPE_CCE
][i
];
1624 if (cce
&& cce
->coup
.coupling_point
== coupling_point
) {
1625 ChannelCoupling
*coup
= &cce
->coup
;
1627 for (c
= 0; c
<= coup
->num_coupled
; c
++) {
1628 if (coup
->type
[c
] == type
&& coup
->id_select
[c
] == elem_id
) {
1629 if (coup
->ch_select
[c
] != 1) {
1630 apply_coupling_method(ac
, &cc
->ch
[0], cce
, index
);
1631 if (coup
->ch_select
[c
] != 0)
1634 if (coup
->ch_select
[c
] != 2)
1635 apply_coupling_method(ac
, &cc
->ch
[1], cce
, index
++);
1637 index
+= 1 + (coup
->ch_select
[c
] == 3);
1644 * Convert spectral data to float samples, applying all supported tools as appropriate.
1646 static void spectral_to_sample(AACContext
*ac
)
1649 for (type
= 3; type
>= 0; type
--) {
1650 for (i
= 0; i
< MAX_ELEM_ID
; i
++) {
1651 ChannelElement
*che
= ac
->che
[type
][i
];
1653 if (type
<= TYPE_CPE
)
1654 apply_channel_coupling(ac
, che
, type
, i
, BEFORE_TNS
, apply_dependent_coupling
);
1655 if (che
->ch
[0].tns
.present
)
1656 apply_tns(che
->ch
[0].coeffs
, &che
->ch
[0].tns
, &che
->ch
[0].ics
, 1);
1657 if (che
->ch
[1].tns
.present
)
1658 apply_tns(che
->ch
[1].coeffs
, &che
->ch
[1].tns
, &che
->ch
[1].ics
, 1);
1659 if (type
<= TYPE_CPE
)
1660 apply_channel_coupling(ac
, che
, type
, i
, BETWEEN_TNS_AND_IMDCT
, apply_dependent_coupling
);
1661 if (type
!= TYPE_CCE
|| che
->coup
.coupling_point
== AFTER_IMDCT
)
1662 imdct_and_windowing(ac
, &che
->ch
[0]);
1663 if (type
== TYPE_CPE
)
1664 imdct_and_windowing(ac
, &che
->ch
[1]);
1665 if (type
<= TYPE_CCE
)
1666 apply_channel_coupling(ac
, che
, type
, i
, AFTER_IMDCT
, apply_independent_coupling
);
1672 static int parse_adts_frame_header(AACContext
*ac
, GetBitContext
*gb
)
1675 AACADTSHeaderInfo hdr_info
;
1677 size
= ff_aac_parse_header(gb
, &hdr_info
);
1679 if (ac
->output_configured
!= OC_LOCKED
&& hdr_info
.chan_config
) {
1680 enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
];
1681 memset(new_che_pos
, 0, 4 * MAX_ELEM_ID
* sizeof(new_che_pos
[0][0]));
1682 ac
->m4ac
.chan_config
= hdr_info
.chan_config
;
1683 if (set_default_channel_config(ac
, new_che_pos
, hdr_info
.chan_config
))
1685 if (output_configure(ac
, ac
->che_pos
, new_che_pos
, hdr_info
.chan_config
, OC_TRIAL_FRAME
))
1687 } else if (ac
->output_configured
!= OC_LOCKED
) {
1688 ac
->output_configured
= OC_NONE
;
1690 ac
->m4ac
.sample_rate
= hdr_info
.sample_rate
;
1691 ac
->m4ac
.sampling_index
= hdr_info
.sampling_index
;
1692 ac
->m4ac
.object_type
= hdr_info
.object_type
;
1693 if (hdr_info
.num_aac_frames
== 1) {
1694 if (!hdr_info
.crc_absent
)
1697 av_log_missing_feature(ac
->avccontext
, "More than one AAC RDB per ADTS frame is", 0);
1704 static int aac_decode_frame(AVCodecContext
*avccontext
, void *data
,
1705 int *data_size
, AVPacket
*avpkt
)
1707 const uint8_t *buf
= avpkt
->data
;
1708 int buf_size
= avpkt
->size
;
1709 AACContext
*ac
= avccontext
->priv_data
;
1710 ChannelElement
*che
= NULL
;
1712 enum RawDataBlockType elem_type
;
1713 int err
, elem_id
, data_size_tmp
;
1715 init_get_bits(&gb
, buf
, buf_size
* 8);
1717 if (show_bits(&gb
, 12) == 0xfff) {
1718 if (parse_adts_frame_header(ac
, &gb
) < 0) {
1719 av_log(avccontext
, AV_LOG_ERROR
, "Error decoding AAC frame header.\n");
1722 if (ac
->m4ac
.sampling_index
> 12) {
1723 av_log(ac
->avccontext
, AV_LOG_ERROR
, "invalid sampling rate index %d\n", ac
->m4ac
.sampling_index
);
1729 while ((elem_type
= get_bits(&gb
, 3)) != TYPE_END
) {
1730 elem_id
= get_bits(&gb
, 4);
1732 if (elem_type
< TYPE_DSE
&& !(che
=get_che(ac
, elem_type
, elem_id
))) {
1733 av_log(ac
->avccontext
, AV_LOG_ERROR
, "channel element %d.%d is not allocated\n", elem_type
, elem_id
);
1737 switch (elem_type
) {
1740 err
= decode_ics(ac
, &che
->ch
[0], &gb
, 0, 0);
1744 err
= decode_cpe(ac
, &gb
, che
);
1748 err
= decode_cce(ac
, &gb
, che
);
1752 err
= decode_ics(ac
, &che
->ch
[0], &gb
, 0, 0);
1756 skip_data_stream_element(&gb
);
1761 enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
];
1762 memset(new_che_pos
, 0, 4 * MAX_ELEM_ID
* sizeof(new_che_pos
[0][0]));
1763 if ((err
= decode_pce(ac
, new_che_pos
, &gb
)))
1765 if (ac
->output_configured
<= OC_TRIAL_PCE
)
1766 av_log(avccontext
, AV_LOG_ERROR
,
1767 "Not evaluating a further program_config_element as this construct is dubious at best.\n");
1769 err
= output_configure(ac
, ac
->che_pos
, new_che_pos
, 0, OC_TRIAL_PCE
);
1775 elem_id
+= get_bits(&gb
, 8) - 1;
1777 elem_id
-= decode_extension_payload(ac
, &gb
, elem_id
);
1778 err
= 0; /* FIXME */
1782 err
= -1; /* should not happen, but keeps compiler happy */
1790 spectral_to_sample(ac
);
1792 if (!ac
->is_saved
) {
1798 data_size_tmp
= 1024 * avccontext
->channels
* sizeof(int16_t);
1799 if (*data_size
< data_size_tmp
) {
1800 av_log(avccontext
, AV_LOG_ERROR
,
1801 "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
1802 *data_size
, data_size_tmp
);
1805 *data_size
= data_size_tmp
;
1807 ac
->dsp
.float_to_int16_interleave(data
, (const float **)ac
->output_data
, 1024, avccontext
->channels
);
1809 if (ac
->output_configured
)
1810 ac
->output_configured
= OC_LOCKED
;
1815 static av_cold
int aac_decode_close(AVCodecContext
*avccontext
)
1817 AACContext
*ac
= avccontext
->priv_data
;
1820 for (i
= 0; i
< MAX_ELEM_ID
; i
++) {
1821 for (type
= 0; type
< 4; type
++)
1822 av_freep(&ac
->che
[type
][i
]);
1825 ff_mdct_end(&ac
->mdct
);
1826 ff_mdct_end(&ac
->mdct_small
);
1830 AVCodec aac_decoder
= {
1839 .long_name
= NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
1840 .sample_fmts
= (const enum SampleFormat
[]) {
1841 SAMPLE_FMT_S16
,SAMPLE_FMT_NONE
1843 .channel_layouts
= aac_channel_layout
,