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
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 * N 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
80 #include "bitstream.h"
86 #include "aacdectab.h"
87 #include "mpeg4audio.h"
94 static VLC vlc_scalefactors
;
95 static VLC vlc_spectral
[11];
99 * Configure output channel order based on the current program configuration element.
101 * @param che_pos current channel position configuration
102 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one.
104 * @return Returns error status. 0 - OK, !0 - error
106 static int output_configure(AACContext
*ac
, enum ChannelPosition che_pos
[4][MAX_ELEM_ID
],
107 enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
]) {
108 AVCodecContext
*avctx
= ac
->avccontext
;
109 int i
, type
, channels
= 0;
111 if(!memcmp(che_pos
, new_che_pos
, 4 * MAX_ELEM_ID
* sizeof(new_che_pos
[0][0])))
112 return 0; /* no change */
114 memcpy(che_pos
, new_che_pos
, 4 * MAX_ELEM_ID
* sizeof(new_che_pos
[0][0]));
116 /* Allocate or free elements depending on if they are in the
117 * current program configuration.
119 * Set up default 1:1 output mapping.
121 * For a 5.1 stream the output order will be:
122 * [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ]
125 for(i
= 0; i
< MAX_ELEM_ID
; i
++) {
126 for(type
= 0; type
< 4; type
++) {
127 if(che_pos
[type
][i
]) {
128 if(!ac
->che
[type
][i
] && !(ac
->che
[type
][i
] = av_mallocz(sizeof(ChannelElement
))))
129 return AVERROR(ENOMEM
);
130 if(type
!= TYPE_CCE
) {
131 ac
->output_data
[channels
++] = ac
->che
[type
][i
]->ch
[0].ret
;
132 if(type
== TYPE_CPE
) {
133 ac
->output_data
[channels
++] = ac
->che
[type
][i
]->ch
[1].ret
;
137 av_freep(&ac
->che
[type
][i
]);
141 avctx
->channels
= channels
;
146 * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
148 * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present.
149 * @param sce_map mono (Single Channel Element) map
150 * @param type speaker type/position for these channels
152 static void decode_channel_map(enum ChannelPosition
*cpe_map
,
153 enum ChannelPosition
*sce_map
, enum ChannelPosition type
, GetBitContext
* gb
, int n
) {
155 enum ChannelPosition
*map
= cpe_map
&& get_bits1(gb
) ? cpe_map
: sce_map
; // stereo or mono map
156 map
[get_bits(gb
, 4)] = type
;
161 * Decode program configuration element; reference: table 4.2.
163 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one.
165 * @return Returns error status. 0 - OK, !0 - error
167 static int decode_pce(AACContext
* ac
, enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
],
168 GetBitContext
* gb
) {
169 int num_front
, num_side
, num_back
, num_lfe
, num_assoc_data
, num_cc
;
171 skip_bits(gb
, 2); // object_type
173 ac
->m4ac
.sampling_index
= get_bits(gb
, 4);
174 if(ac
->m4ac
.sampling_index
> 11) {
175 av_log(ac
->avccontext
, AV_LOG_ERROR
, "invalid sampling rate index %d\n", ac
->m4ac
.sampling_index
);
178 ac
->m4ac
.sample_rate
= ff_mpeg4audio_sample_rates
[ac
->m4ac
.sampling_index
];
179 num_front
= get_bits(gb
, 4);
180 num_side
= get_bits(gb
, 4);
181 num_back
= get_bits(gb
, 4);
182 num_lfe
= get_bits(gb
, 2);
183 num_assoc_data
= get_bits(gb
, 3);
184 num_cc
= get_bits(gb
, 4);
187 skip_bits(gb
, 4); // mono_mixdown_tag
189 skip_bits(gb
, 4); // stereo_mixdown_tag
192 skip_bits(gb
, 3); // mixdown_coeff_index and pseudo_surround
194 decode_channel_map(new_che_pos
[TYPE_CPE
], new_che_pos
[TYPE_SCE
], AAC_CHANNEL_FRONT
, gb
, num_front
);
195 decode_channel_map(new_che_pos
[TYPE_CPE
], new_che_pos
[TYPE_SCE
], AAC_CHANNEL_SIDE
, gb
, num_side
);
196 decode_channel_map(new_che_pos
[TYPE_CPE
], new_che_pos
[TYPE_SCE
], AAC_CHANNEL_BACK
, gb
, num_back
);
197 decode_channel_map(NULL
, new_che_pos
[TYPE_LFE
], AAC_CHANNEL_LFE
, gb
, num_lfe
);
199 skip_bits_long(gb
, 4 * num_assoc_data
);
201 decode_channel_map(new_che_pos
[TYPE_CCE
], new_che_pos
[TYPE_CCE
], AAC_CHANNEL_CC
, gb
, num_cc
);
205 /* comment field, first byte is length */
206 skip_bits_long(gb
, 8 * get_bits(gb
, 8));
211 * Set up channel positions based on a default channel configuration
212 * as specified in table 1.17.
214 * @param new_che_pos New channel position configuration - we only do something if it differs from the current one.
216 * @return Returns error status. 0 - OK, !0 - error
218 static int set_default_channel_config(AACContext
*ac
, enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
],
221 if(channel_config
< 1 || channel_config
> 7) {
222 av_log(ac
->avccontext
, AV_LOG_ERROR
, "invalid default channel configuration (%d)\n",
227 /* default channel configurations:
229 * 1ch : front center (mono)
230 * 2ch : L + R (stereo)
231 * 3ch : front center + L + R
232 * 4ch : front center + L + R + back center
233 * 5ch : front center + L + R + back stereo
234 * 6ch : front center + L + R + back stereo + LFE
235 * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE
238 if(channel_config
!= 2)
239 new_che_pos
[TYPE_SCE
][0] = AAC_CHANNEL_FRONT
; // front center (or mono)
240 if(channel_config
> 1)
241 new_che_pos
[TYPE_CPE
][0] = AAC_CHANNEL_FRONT
; // L + R (or stereo)
242 if(channel_config
== 4)
243 new_che_pos
[TYPE_SCE
][1] = AAC_CHANNEL_BACK
; // back center
244 if(channel_config
> 4)
245 new_che_pos
[TYPE_CPE
][(channel_config
== 7) + 1]
246 = AAC_CHANNEL_BACK
; // back stereo
247 if(channel_config
> 5)
248 new_che_pos
[TYPE_LFE
][0] = AAC_CHANNEL_LFE
; // LFE
249 if(channel_config
== 7)
250 new_che_pos
[TYPE_CPE
][1] = AAC_CHANNEL_FRONT
; // outer front left + outer front right
256 * Decode GA "General Audio" specific configuration; reference: table 4.1.
258 * @return Returns error status. 0 - OK, !0 - error
260 static int decode_ga_specific_config(AACContext
* ac
, GetBitContext
* gb
, int channel_config
) {
261 enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
];
262 int extension_flag
, ret
;
264 if(get_bits1(gb
)) { // frameLengthFlag
265 av_log_missing_feature(ac
->avccontext
, "960/120 MDCT window is", 1);
269 if (get_bits1(gb
)) // dependsOnCoreCoder
270 skip_bits(gb
, 14); // coreCoderDelay
271 extension_flag
= get_bits1(gb
);
273 if(ac
->m4ac
.object_type
== AOT_AAC_SCALABLE
||
274 ac
->m4ac
.object_type
== AOT_ER_AAC_SCALABLE
)
275 skip_bits(gb
, 3); // layerNr
277 memset(new_che_pos
, 0, 4 * MAX_ELEM_ID
* sizeof(new_che_pos
[0][0]));
278 if (channel_config
== 0) {
279 skip_bits(gb
, 4); // element_instance_tag
280 if((ret
= decode_pce(ac
, new_che_pos
, gb
)))
283 if((ret
= set_default_channel_config(ac
, new_che_pos
, channel_config
)))
286 if((ret
= output_configure(ac
, ac
->che_pos
, new_che_pos
)))
289 if (extension_flag
) {
290 switch (ac
->m4ac
.object_type
) {
292 skip_bits(gb
, 5); // numOfSubFrame
293 skip_bits(gb
, 11); // layer_length
297 case AOT_ER_AAC_SCALABLE
:
299 skip_bits(gb
, 3); /* aacSectionDataResilienceFlag
300 * aacScalefactorDataResilienceFlag
301 * aacSpectralDataResilienceFlag
305 skip_bits1(gb
); // extensionFlag3 (TBD in version 3)
311 * Decode audio specific configuration; reference: table 1.13.
313 * @param data pointer to AVCodecContext extradata
314 * @param data_size size of AVCCodecContext extradata
316 * @return Returns error status. 0 - OK, !0 - error
318 static int decode_audio_specific_config(AACContext
* ac
, void *data
, int data_size
) {
322 init_get_bits(&gb
, data
, data_size
* 8);
324 if((i
= ff_mpeg4audio_get_config(&ac
->m4ac
, data
, data_size
)) < 0)
326 if(ac
->m4ac
.sampling_index
> 11) {
327 av_log(ac
->avccontext
, AV_LOG_ERROR
, "invalid sampling rate index %d\n", ac
->m4ac
.sampling_index
);
331 skip_bits_long(&gb
, i
);
333 switch (ac
->m4ac
.object_type
) {
335 if (decode_ga_specific_config(ac
, &gb
, ac
->m4ac
.chan_config
))
339 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Audio object type %s%d is not supported.\n",
340 ac
->m4ac
.sbr
== 1? "SBR+" : "", ac
->m4ac
.object_type
);
347 * linear congruential pseudorandom number generator
349 * @param previous_val pointer to the current state of the generator
351 * @return Returns a 32-bit pseudorandom integer
353 static av_always_inline
int lcg_random(int previous_val
) {
354 return previous_val
* 1664525 + 1013904223;
357 static av_cold
int aac_decode_init(AVCodecContext
* avccontext
) {
358 AACContext
* ac
= avccontext
->priv_data
;
361 ac
->avccontext
= avccontext
;
363 if (avccontext
->extradata_size
<= 0 ||
364 decode_audio_specific_config(ac
, avccontext
->extradata
, avccontext
->extradata_size
))
367 avccontext
->sample_fmt
= SAMPLE_FMT_S16
;
368 avccontext
->sample_rate
= ac
->m4ac
.sample_rate
;
369 avccontext
->frame_size
= 1024;
371 AAC_INIT_VLC_STATIC( 0, 144);
372 AAC_INIT_VLC_STATIC( 1, 114);
373 AAC_INIT_VLC_STATIC( 2, 188);
374 AAC_INIT_VLC_STATIC( 3, 180);
375 AAC_INIT_VLC_STATIC( 4, 172);
376 AAC_INIT_VLC_STATIC( 5, 140);
377 AAC_INIT_VLC_STATIC( 6, 168);
378 AAC_INIT_VLC_STATIC( 7, 114);
379 AAC_INIT_VLC_STATIC( 8, 262);
380 AAC_INIT_VLC_STATIC( 9, 248);
381 AAC_INIT_VLC_STATIC(10, 384);
383 dsputil_init(&ac
->dsp
, avccontext
);
385 ac
->random_state
= 0x1f2e3d4c;
387 // -1024 - Compensate wrong IMDCT method.
388 // 32768 - Required to scale values to the correct range for the bias method
389 // for float to int16 conversion.
391 if(ac
->dsp
.float_to_int16
== ff_float_to_int16_c
) {
392 ac
->add_bias
= 385.0f
;
393 ac
->sf_scale
= 1. / (-1024. * 32768.);
397 ac
->sf_scale
= 1. / -1024.;
401 #ifndef CONFIG_HARDCODED_TABLES
402 for (i
= 0; i
< 316; i
++)
403 ff_aac_pow2sf_tab
[i
] = pow(2, (i
- 200)/4.);
404 #endif /* CONFIG_HARDCODED_TABLES */
406 INIT_VLC_STATIC(&vlc_scalefactors
, 7, sizeof(ff_aac_scalefactor_code
)/sizeof(ff_aac_scalefactor_code
[0]),
407 ff_aac_scalefactor_bits
, sizeof(ff_aac_scalefactor_bits
[0]), sizeof(ff_aac_scalefactor_bits
[0]),
408 ff_aac_scalefactor_code
, sizeof(ff_aac_scalefactor_code
[0]), sizeof(ff_aac_scalefactor_code
[0]),
411 ff_mdct_init(&ac
->mdct
, 11, 1);
412 ff_mdct_init(&ac
->mdct_small
, 8, 1);
413 // window initialization
414 ff_kbd_window_init(ff_aac_kbd_long_1024
, 4.0, 1024);
415 ff_kbd_window_init(ff_aac_kbd_short_128
, 6.0, 128);
416 ff_sine_window_init(ff_sine_1024
, 1024);
417 ff_sine_window_init(ff_sine_128
, 128);
423 * Skip data_stream_element; reference: table 4.10.
425 static void skip_data_stream_element(GetBitContext
* gb
) {
426 int byte_align
= get_bits1(gb
);
427 int count
= get_bits(gb
, 8);
429 count
+= get_bits(gb
, 8);
432 skip_bits_long(gb
, 8 * count
);
436 * Decode Individual Channel Stream info; reference: table 4.6.
438 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information.
440 static int decode_ics_info(AACContext
* ac
, IndividualChannelStream
* ics
, GetBitContext
* gb
, int common_window
) {
442 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Reserved bit set.\n");
443 memset(ics
, 0, sizeof(IndividualChannelStream
));
446 ics
->window_sequence
[1] = ics
->window_sequence
[0];
447 ics
->window_sequence
[0] = get_bits(gb
, 2);
448 ics
->use_kb_window
[1] = ics
->use_kb_window
[0];
449 ics
->use_kb_window
[0] = get_bits1(gb
);
450 ics
->num_window_groups
= 1;
451 ics
->group_len
[0] = 1;
452 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
454 ics
->max_sfb
= get_bits(gb
, 4);
455 for (i
= 0; i
< 7; i
++) {
457 ics
->group_len
[ics
->num_window_groups
-1]++;
459 ics
->num_window_groups
++;
460 ics
->group_len
[ics
->num_window_groups
-1] = 1;
463 ics
->num_windows
= 8;
464 ics
->swb_offset
= swb_offset_128
[ac
->m4ac
.sampling_index
];
465 ics
->num_swb
= ff_aac_num_swb_128
[ac
->m4ac
.sampling_index
];
466 ics
->tns_max_bands
= tns_max_bands_128
[ac
->m4ac
.sampling_index
];
468 ics
->max_sfb
= get_bits(gb
, 6);
469 ics
->num_windows
= 1;
470 ics
->swb_offset
= swb_offset_1024
[ac
->m4ac
.sampling_index
];
471 ics
->num_swb
= ff_aac_num_swb_1024
[ac
->m4ac
.sampling_index
];
472 ics
->tns_max_bands
= tns_max_bands_1024
[ac
->m4ac
.sampling_index
];
474 av_log_missing_feature(ac
->avccontext
, "Predictor bit set but LTP is", 1);
475 memset(ics
, 0, sizeof(IndividualChannelStream
));
480 if(ics
->max_sfb
> ics
->num_swb
) {
481 av_log(ac
->avccontext
, AV_LOG_ERROR
,
482 "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
483 ics
->max_sfb
, ics
->num_swb
);
484 memset(ics
, 0, sizeof(IndividualChannelStream
));
492 * Decode band types (section_data payload); reference: table 4.46.
494 * @param band_type array of the used band type
495 * @param band_type_run_end array of the last scalefactor band of a band type run
497 * @return Returns error status. 0 - OK, !0 - error
499 static int decode_band_types(AACContext
* ac
, enum BandType band_type
[120],
500 int band_type_run_end
[120], GetBitContext
* gb
, IndividualChannelStream
* ics
) {
502 const int bits
= (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) ? 3 : 5;
503 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
505 while (k
< ics
->max_sfb
) {
506 uint8_t sect_len
= k
;
508 int sect_band_type
= get_bits(gb
, 4);
509 if (sect_band_type
== 12) {
510 av_log(ac
->avccontext
, AV_LOG_ERROR
, "invalid band type\n");
513 while ((sect_len_incr
= get_bits(gb
, bits
)) == (1 << bits
)-1)
514 sect_len
+= sect_len_incr
;
515 sect_len
+= sect_len_incr
;
516 if (sect_len
> ics
->max_sfb
) {
517 av_log(ac
->avccontext
, AV_LOG_ERROR
,
518 "Number of bands (%d) exceeds limit (%d).\n",
519 sect_len
, ics
->max_sfb
);
522 for (; k
< sect_len
; k
++) {
523 band_type
[idx
] = sect_band_type
;
524 band_type_run_end
[idx
++] = sect_len
;
532 * Decode scalefactors; reference: table 4.47.
534 * @param global_gain first scalefactor value as scalefactors are differentially coded
535 * @param band_type array of the used band type
536 * @param band_type_run_end array of the last scalefactor band of a band type run
537 * @param sf array of scalefactors or intensity stereo positions
539 * @return Returns error status. 0 - OK, !0 - error
541 static int decode_scalefactors(AACContext
* ac
, float sf
[120], GetBitContext
* gb
,
542 unsigned int global_gain
, IndividualChannelStream
* ics
,
543 enum BandType band_type
[120], int band_type_run_end
[120]) {
544 const int sf_offset
= ac
->sf_offset
+ (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
? 12 : 0);
546 int offset
[3] = { global_gain
, global_gain
- 90, 100 };
548 static const char *sf_str
[3] = { "Global gain", "Noise gain", "Intensity stereo position" };
549 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
550 for (i
= 0; i
< ics
->max_sfb
;) {
551 int run_end
= band_type_run_end
[idx
];
552 if (band_type
[idx
] == ZERO_BT
) {
553 for(; i
< run_end
; i
++, idx
++)
555 }else if((band_type
[idx
] == INTENSITY_BT
) || (band_type
[idx
] == INTENSITY_BT2
)) {
556 for(; i
< run_end
; i
++, idx
++) {
557 offset
[2] += get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60;
558 if(offset
[2] > 255U) {
559 av_log(ac
->avccontext
, AV_LOG_ERROR
,
560 "%s (%d) out of range.\n", sf_str
[2], offset
[2]);
563 sf
[idx
] = ff_aac_pow2sf_tab
[-offset
[2] + 300];
565 }else if(band_type
[idx
] == NOISE_BT
) {
566 for(; i
< run_end
; i
++, idx
++) {
568 offset
[1] += get_bits(gb
, 9) - 256;
570 offset
[1] += get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60;
571 if(offset
[1] > 255U) {
572 av_log(ac
->avccontext
, AV_LOG_ERROR
,
573 "%s (%d) out of range.\n", sf_str
[1], offset
[1]);
576 sf
[idx
] = -ff_aac_pow2sf_tab
[ offset
[1] + sf_offset
];
579 for(; i
< run_end
; i
++, idx
++) {
580 offset
[0] += get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60;
581 if(offset
[0] > 255U) {
582 av_log(ac
->avccontext
, AV_LOG_ERROR
,
583 "%s (%d) out of range.\n", sf_str
[0], offset
[0]);
586 sf
[idx
] = -ff_aac_pow2sf_tab
[ offset
[0] + sf_offset
];
595 * Decode pulse data; reference: table 4.7.
597 static void decode_pulses(Pulse
* pulse
, GetBitContext
* gb
, const uint16_t * swb_offset
) {
599 pulse
->num_pulse
= get_bits(gb
, 2) + 1;
600 pulse
->pos
[0] = get_bits(gb
, 5) + swb_offset
[get_bits(gb
, 6)];
601 pulse
->amp
[0] = get_bits(gb
, 4);
602 for (i
= 1; i
< pulse
->num_pulse
; i
++) {
603 pulse
->pos
[i
] = get_bits(gb
, 5) + pulse
->pos
[i
-1];
604 pulse
->amp
[i
] = get_bits(gb
, 4);
609 * Decode Temporal Noise Shaping data; reference: table 4.48.
611 * @return Returns error status. 0 - OK, !0 - error
613 static int decode_tns(AACContext
* ac
, TemporalNoiseShaping
* tns
,
614 GetBitContext
* gb
, const IndividualChannelStream
* ics
) {
615 int w
, filt
, i
, coef_len
, coef_res
, coef_compress
;
616 const int is8
= ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
;
617 const int tns_max_order
= is8
? 7 : ac
->m4ac
.object_type
== AOT_AAC_MAIN
? 20 : 12;
618 for (w
= 0; w
< ics
->num_windows
; w
++) {
619 if ((tns
->n_filt
[w
] = get_bits(gb
, 2 - is8
))) {
620 coef_res
= get_bits1(gb
);
622 for (filt
= 0; filt
< tns
->n_filt
[w
]; filt
++) {
624 tns
->length
[w
][filt
] = get_bits(gb
, 6 - 2*is8
);
626 if ((tns
->order
[w
][filt
] = get_bits(gb
, 5 - 2*is8
)) > tns_max_order
) {
627 av_log(ac
->avccontext
, AV_LOG_ERROR
, "TNS filter order %d is greater than maximum %d.",
628 tns
->order
[w
][filt
], tns_max_order
);
629 tns
->order
[w
][filt
] = 0;
632 tns
->direction
[w
][filt
] = get_bits1(gb
);
633 coef_compress
= get_bits1(gb
);
634 coef_len
= coef_res
+ 3 - coef_compress
;
635 tmp2_idx
= 2*coef_compress
+ coef_res
;
637 for (i
= 0; i
< tns
->order
[w
][filt
]; i
++)
638 tns
->coef
[w
][filt
][i
] = tns_tmp2_map
[tmp2_idx
][get_bits(gb
, coef_len
)];
646 * Decode Mid/Side data; reference: table 4.54.
648 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
649 * [1] mask is decoded from bitstream; [2] mask is all 1s;
650 * [3] reserved for scalable AAC
652 static void decode_mid_side_stereo(ChannelElement
* cpe
, GetBitContext
* gb
,
655 if (ms_present
== 1) {
656 for (idx
= 0; idx
< cpe
->ch
[0].ics
.num_window_groups
* cpe
->ch
[0].ics
.max_sfb
; idx
++)
657 cpe
->ms_mask
[idx
] = get_bits1(gb
);
658 } else if (ms_present
== 2) {
659 memset(cpe
->ms_mask
, 1, cpe
->ch
[0].ics
.num_window_groups
* cpe
->ch
[0].ics
.max_sfb
* sizeof(cpe
->ms_mask
[0]));
664 * Decode spectral data; reference: table 4.50.
665 * Dequantize and scale spectral data; reference: 4.6.3.3.
667 * @param coef array of dequantized, scaled spectral data
668 * @param sf array of scalefactors or intensity stereo positions
669 * @param pulse_present set if pulses are present
670 * @param pulse pointer to pulse data struct
671 * @param band_type array of the used band type
673 * @return Returns error status. 0 - OK, !0 - error
675 static int decode_spectrum_and_dequant(AACContext
* ac
, float coef
[1024], GetBitContext
* gb
, float sf
[120],
676 int pulse_present
, const Pulse
* pulse
, const IndividualChannelStream
* ics
, enum BandType band_type
[120]) {
677 int i
, k
, g
, idx
= 0;
678 const int c
= 1024/ics
->num_windows
;
679 const uint16_t * offsets
= ics
->swb_offset
;
680 float *coef_base
= coef
;
682 for (g
= 0; g
< ics
->num_windows
; g
++)
683 memset(coef
+ g
* 128 + offsets
[ics
->max_sfb
], 0, sizeof(float)*(c
- offsets
[ics
->max_sfb
]));
685 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
686 for (i
= 0; i
< ics
->max_sfb
; i
++, idx
++) {
687 const int cur_band_type
= band_type
[idx
];
688 const int dim
= cur_band_type
>= FIRST_PAIR_BT
? 2 : 4;
689 const int is_cb_unsigned
= IS_CODEBOOK_UNSIGNED(cur_band_type
);
691 if (cur_band_type
== ZERO_BT
) {
692 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
693 memset(coef
+ group
* 128 + offsets
[i
], 0, (offsets
[i
+1] - offsets
[i
])*sizeof(float));
695 }else if (cur_band_type
== NOISE_BT
) {
696 const float scale
= sf
[idx
] / ((offsets
[i
+1] - offsets
[i
]) * PNS_MEAN_ENERGY
);
697 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
698 for (k
= offsets
[i
]; k
< offsets
[i
+1]; k
++) {
699 ac
->random_state
= lcg_random(ac
->random_state
);
700 coef
[group
*128+k
] = ac
->random_state
* scale
;
703 }else if (cur_band_type
!= INTENSITY_BT2
&& cur_band_type
!= INTENSITY_BT
) {
704 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
705 for (k
= offsets
[i
]; k
< offsets
[i
+1]; k
+= dim
) {
706 const int index
= get_vlc2(gb
, vlc_spectral
[cur_band_type
- 1].table
, 6, 3);
707 const int coef_tmp_idx
= (group
<< 7) + k
;
710 if(index
>= ff_aac_spectral_sizes
[cur_band_type
- 1]) {
711 av_log(ac
->avccontext
, AV_LOG_ERROR
,
712 "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n",
713 cur_band_type
- 1, index
, ff_aac_spectral_sizes
[cur_band_type
- 1]);
716 vq_ptr
= &ff_aac_codebook_vectors
[cur_band_type
- 1][index
* dim
];
717 if (is_cb_unsigned
) {
718 for (j
= 0; j
< dim
; j
++)
720 coef
[coef_tmp_idx
+ j
] = 1 - 2*(int)get_bits1(gb
);
722 for (j
= 0; j
< dim
; j
++)
723 coef
[coef_tmp_idx
+ j
] = 1.0f
;
725 if (cur_band_type
== ESC_BT
) {
726 for (j
= 0; j
< 2; j
++) {
727 if (vq_ptr
[j
] == 64.0f
) {
729 /* The total length of escape_sequence must be < 22 bits according
730 to the specification (i.e. max is 11111111110xxxxxxxxxx). */
731 while (get_bits1(gb
) && n
< 15) n
++;
733 av_log(ac
->avccontext
, AV_LOG_ERROR
, "error in spectral data, ESC overflow\n");
736 n
= (1<<n
) + get_bits(gb
, n
);
737 coef
[coef_tmp_idx
+ j
] *= cbrtf(fabsf(n
)) * n
;
739 coef
[coef_tmp_idx
+ j
] *= vq_ptr
[j
];
742 for (j
= 0; j
< dim
; j
++)
743 coef
[coef_tmp_idx
+ j
] *= vq_ptr
[j
];
744 for (j
= 0; j
< dim
; j
++)
745 coef
[coef_tmp_idx
+ j
] *= sf
[idx
];
750 coef
+= ics
->group_len
[g
]<<7;
754 for(i
= 0; i
< pulse
->num_pulse
; i
++){
755 float co
= coef_base
[ pulse
->pos
[i
] ];
756 float ico
= -pulse
->amp
[i
];
758 ico
= co
/ sqrtf(sqrtf(fabsf(co
))) + (co
> 0 ? -ico
: ico
);
759 coef_base
[ pulse
->pos
[i
] ] = cbrtf(fabsf(ico
)) * ico
;
766 * Decode an individual_channel_stream payload; reference: table 4.44.
768 * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information.
769 * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
771 * @return Returns error status. 0 - OK, !0 - error
773 static int decode_ics(AACContext
* ac
, SingleChannelElement
* sce
, GetBitContext
* gb
, int common_window
, int scale_flag
) {
775 TemporalNoiseShaping
* tns
= &sce
->tns
;
776 IndividualChannelStream
* ics
= &sce
->ics
;
777 float * out
= sce
->coeffs
;
778 int global_gain
, pulse_present
= 0;
780 /* This assignment is to silence a GCC warning about the variable being used
781 * uninitialized when in fact it always is.
785 global_gain
= get_bits(gb
, 8);
787 if (!common_window
&& !scale_flag
) {
788 if (decode_ics_info(ac
, ics
, gb
, 0) < 0)
792 if (decode_band_types(ac
, sce
->band_type
, sce
->band_type_run_end
, gb
, ics
) < 0)
794 if (decode_scalefactors(ac
, sce
->sf
, gb
, global_gain
, ics
, sce
->band_type
, sce
->band_type_run_end
) < 0)
799 if ((pulse_present
= get_bits1(gb
))) {
800 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
801 av_log(ac
->avccontext
, AV_LOG_ERROR
, "Pulse tool not allowed in eight short sequence.\n");
804 decode_pulses(&pulse
, gb
, ics
->swb_offset
);
806 if ((tns
->present
= get_bits1(gb
)) && decode_tns(ac
, tns
, gb
, ics
))
809 av_log_missing_feature(ac
->avccontext
, "SSR", 1);
814 if (decode_spectrum_and_dequant(ac
, out
, gb
, sce
->sf
, pulse_present
, &pulse
, ics
, sce
->band_type
) < 0)
820 * Mid/Side stereo decoding; reference: 4.6.8.1.3.
822 static void apply_mid_side_stereo(ChannelElement
* cpe
) {
823 const IndividualChannelStream
* ics
= &cpe
->ch
[0].ics
;
824 float *ch0
= cpe
->ch
[0].coeffs
;
825 float *ch1
= cpe
->ch
[1].coeffs
;
826 int g
, i
, k
, group
, idx
= 0;
827 const uint16_t * offsets
= ics
->swb_offset
;
828 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
829 for (i
= 0; i
< ics
->max_sfb
; i
++, idx
++) {
830 if (cpe
->ms_mask
[idx
] &&
831 cpe
->ch
[0].band_type
[idx
] < NOISE_BT
&& cpe
->ch
[1].band_type
[idx
] < NOISE_BT
) {
832 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
833 for (k
= offsets
[i
]; k
< offsets
[i
+1]; k
++) {
834 float tmp
= ch0
[group
*128 + k
] - ch1
[group
*128 + k
];
835 ch0
[group
*128 + k
] += ch1
[group
*128 + k
];
836 ch1
[group
*128 + k
] = tmp
;
841 ch0
+= ics
->group_len
[g
]*128;
842 ch1
+= ics
->group_len
[g
]*128;
847 * intensity stereo decoding; reference: 4.6.8.2.3
849 * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
850 * [1] mask is decoded from bitstream; [2] mask is all 1s;
851 * [3] reserved for scalable AAC
853 static void apply_intensity_stereo(ChannelElement
* cpe
, int ms_present
) {
854 const IndividualChannelStream
* ics
= &cpe
->ch
[1].ics
;
855 SingleChannelElement
* sce1
= &cpe
->ch
[1];
856 float *coef0
= cpe
->ch
[0].coeffs
, *coef1
= cpe
->ch
[1].coeffs
;
857 const uint16_t * offsets
= ics
->swb_offset
;
858 int g
, group
, i
, k
, idx
= 0;
861 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
862 for (i
= 0; i
< ics
->max_sfb
;) {
863 if (sce1
->band_type
[idx
] == INTENSITY_BT
|| sce1
->band_type
[idx
] == INTENSITY_BT2
) {
864 const int bt_run_end
= sce1
->band_type_run_end
[idx
];
865 for (; i
< bt_run_end
; i
++, idx
++) {
866 c
= -1 + 2 * (sce1
->band_type
[idx
] - 14);
868 c
*= 1 - 2 * cpe
->ms_mask
[idx
];
869 scale
= c
* sce1
->sf
[idx
];
870 for (group
= 0; group
< ics
->group_len
[g
]; group
++)
871 for (k
= offsets
[i
]; k
< offsets
[i
+1]; k
++)
872 coef1
[group
*128 + k
] = scale
* coef0
[group
*128 + k
];
875 int bt_run_end
= sce1
->band_type_run_end
[idx
];
876 idx
+= bt_run_end
- i
;
880 coef0
+= ics
->group_len
[g
]*128;
881 coef1
+= ics
->group_len
[g
]*128;
886 * Decode a channel_pair_element; reference: table 4.4.
888 * @param elem_id Identifies the instance of a syntax element.
890 * @return Returns error status. 0 - OK, !0 - error
892 static int decode_cpe(AACContext
* ac
, GetBitContext
* gb
, int elem_id
) {
893 int i
, ret
, common_window
, ms_present
= 0;
894 ChannelElement
* cpe
;
896 cpe
= ac
->che
[TYPE_CPE
][elem_id
];
897 common_window
= get_bits1(gb
);
899 if (decode_ics_info(ac
, &cpe
->ch
[0].ics
, gb
, 1))
901 i
= cpe
->ch
[1].ics
.use_kb_window
[0];
902 cpe
->ch
[1].ics
= cpe
->ch
[0].ics
;
903 cpe
->ch
[1].ics
.use_kb_window
[1] = i
;
904 ms_present
= get_bits(gb
, 2);
905 if(ms_present
== 3) {
906 av_log(ac
->avccontext
, AV_LOG_ERROR
, "ms_present = 3 is reserved.\n");
908 } else if(ms_present
)
909 decode_mid_side_stereo(cpe
, gb
, ms_present
);
911 if ((ret
= decode_ics(ac
, &cpe
->ch
[0], gb
, common_window
, 0)))
913 if ((ret
= decode_ics(ac
, &cpe
->ch
[1], gb
, common_window
, 0)))
916 if (common_window
&& ms_present
)
917 apply_mid_side_stereo(cpe
);
919 apply_intensity_stereo(cpe
, ms_present
);
924 * Decode coupling_channel_element; reference: table 4.8.
926 * @param elem_id Identifies the instance of a syntax element.
928 * @return Returns error status. 0 - OK, !0 - error
930 static int decode_cce(AACContext
* ac
, GetBitContext
* gb
, ChannelElement
* che
) {
932 int c
, g
, sfb
, ret
, idx
= 0;
935 SingleChannelElement
* sce
= &che
->ch
[0];
936 ChannelCoupling
* coup
= &che
->coup
;
938 coup
->coupling_point
= 2*get_bits1(gb
);
939 coup
->num_coupled
= get_bits(gb
, 3);
940 for (c
= 0; c
<= coup
->num_coupled
; c
++) {
942 coup
->type
[c
] = get_bits1(gb
) ? TYPE_CPE
: TYPE_SCE
;
943 coup
->id_select
[c
] = get_bits(gb
, 4);
944 if (coup
->type
[c
] == TYPE_CPE
) {
945 coup
->ch_select
[c
] = get_bits(gb
, 2);
946 if (coup
->ch_select
[c
] == 3)
949 coup
->ch_select
[c
] = 1;
951 coup
->coupling_point
+= get_bits1(gb
);
953 if (coup
->coupling_point
== 2) {
954 av_log(ac
->avccontext
, AV_LOG_ERROR
,
955 "Independently switched CCE with 'invalid' domain signalled.\n");
956 memset(coup
, 0, sizeof(ChannelCoupling
));
960 sign
= get_bits(gb
, 1);
961 scale
= pow(2., pow(2., get_bits(gb
, 2) - 3));
963 if ((ret
= decode_ics(ac
, sce
, gb
, 0, 0)))
966 for (c
= 0; c
< num_gain
; c
++) {
969 float gain_cache
= 1.;
971 cge
= coup
->coupling_point
== AFTER_IMDCT
? 1 : get_bits1(gb
);
972 gain
= cge
? get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60: 0;
973 gain_cache
= pow(scale
, gain
);
975 for (g
= 0; g
< sce
->ics
.num_window_groups
; g
++)
976 for (sfb
= 0; sfb
< sce
->ics
.max_sfb
; sfb
++, idx
++)
977 if (sce
->band_type
[idx
] != ZERO_BT
) {
979 int t
= get_vlc2(gb
, vlc_scalefactors
.table
, 7, 3) - 60;
987 gain_cache
= pow(scale
, gain
) * s
;
990 coup
->gain
[c
][idx
] = gain_cache
;
997 * Decode Spectral Band Replication extension data; reference: table 4.55.
999 * @param crc flag indicating the presence of CRC checksum
1000 * @param cnt length of TYPE_FIL syntactic element in bytes
1002 * @return Returns number of bytes consumed from the TYPE_FIL element.
1004 static int decode_sbr_extension(AACContext
* ac
, GetBitContext
* gb
, int crc
, int cnt
) {
1005 // TODO : sbr_extension implementation
1006 av_log_missing_feature(ac
->avccontext
, "SBR", 0);
1007 skip_bits_long(gb
, 8*cnt
- 4); // -4 due to reading extension type
1012 * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
1014 * @return Returns number of bytes consumed.
1016 static int decode_drc_channel_exclusions(DynamicRangeControl
*che_drc
, GetBitContext
* gb
) {
1018 int num_excl_chan
= 0;
1021 for (i
= 0; i
< 7; i
++)
1022 che_drc
->exclude_mask
[num_excl_chan
++] = get_bits1(gb
);
1023 } while (num_excl_chan
< MAX_CHANNELS
- 7 && get_bits1(gb
));
1025 return num_excl_chan
/ 7;
1029 * Decode dynamic range information; reference: table 4.52.
1031 * @param cnt length of TYPE_FIL syntactic element in bytes
1033 * @return Returns number of bytes consumed.
1035 static int decode_dynamic_range(DynamicRangeControl
*che_drc
, GetBitContext
* gb
, int cnt
) {
1037 int drc_num_bands
= 1;
1040 /* pce_tag_present? */
1042 che_drc
->pce_instance_tag
= get_bits(gb
, 4);
1043 skip_bits(gb
, 4); // tag_reserved_bits
1047 /* excluded_chns_present? */
1049 n
+= decode_drc_channel_exclusions(che_drc
, gb
);
1052 /* drc_bands_present? */
1053 if (get_bits1(gb
)) {
1054 che_drc
->band_incr
= get_bits(gb
, 4);
1055 che_drc
->interpolation_scheme
= get_bits(gb
, 4);
1057 drc_num_bands
+= che_drc
->band_incr
;
1058 for (i
= 0; i
< drc_num_bands
; i
++) {
1059 che_drc
->band_top
[i
] = get_bits(gb
, 8);
1064 /* prog_ref_level_present? */
1065 if (get_bits1(gb
)) {
1066 che_drc
->prog_ref_level
= get_bits(gb
, 7);
1067 skip_bits1(gb
); // prog_ref_level_reserved_bits
1071 for (i
= 0; i
< drc_num_bands
; i
++) {
1072 che_drc
->dyn_rng_sgn
[i
] = get_bits1(gb
);
1073 che_drc
->dyn_rng_ctl
[i
] = get_bits(gb
, 7);
1081 * Decode extension data (incomplete); reference: table 4.51.
1083 * @param cnt length of TYPE_FIL syntactic element in bytes
1085 * @return Returns number of bytes consumed
1087 static int decode_extension_payload(AACContext
* ac
, GetBitContext
* gb
, int cnt
) {
1090 switch (get_bits(gb
, 4)) { // extension type
1091 case EXT_SBR_DATA_CRC
:
1094 res
= decode_sbr_extension(ac
, gb
, crc_flag
, cnt
);
1096 case EXT_DYNAMIC_RANGE
:
1097 res
= decode_dynamic_range(&ac
->che_drc
, gb
, cnt
);
1101 case EXT_DATA_ELEMENT
:
1103 skip_bits_long(gb
, 8*cnt
- 4);
1110 * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
1112 * @param decode 1 if tool is used normally, 0 if tool is used in LTP.
1113 * @param coef spectral coefficients
1115 static void apply_tns(float coef
[1024], TemporalNoiseShaping
* tns
, IndividualChannelStream
* ics
, int decode
) {
1116 const int mmm
= FFMIN(ics
->tns_max_bands
, ics
->max_sfb
);
1118 int bottom
, top
, order
, start
, end
, size
, inc
;
1119 float lpc
[TNS_MAX_ORDER
];
1121 for (w
= 0; w
< ics
->num_windows
; w
++) {
1122 bottom
= ics
->num_swb
;
1123 for (filt
= 0; filt
< tns
->n_filt
[w
]; filt
++) {
1125 bottom
= FFMAX(0, top
- tns
->length
[w
][filt
]);
1126 order
= tns
->order
[w
][filt
];
1131 compute_lpc_coefs(tns
->coef
[w
][filt
], order
, lpc
, 0, 0, 0);
1133 start
= ics
->swb_offset
[FFMIN(bottom
, mmm
)];
1134 end
= ics
->swb_offset
[FFMIN( top
, mmm
)];
1135 if ((size
= end
- start
) <= 0)
1137 if (tns
->direction
[w
][filt
]) {
1138 inc
= -1; start
= end
- 1;
1145 for (m
= 0; m
< size
; m
++, start
+= inc
)
1146 for (i
= 1; i
<= FFMIN(m
, order
); i
++)
1147 coef
[start
] -= coef
[start
- i
*inc
] * lpc
[i
-1];
1153 * Conduct IMDCT and windowing.
1155 static void imdct_and_windowing(AACContext
* ac
, SingleChannelElement
* sce
) {
1156 IndividualChannelStream
* ics
= &sce
->ics
;
1157 float * in
= sce
->coeffs
;
1158 float * out
= sce
->ret
;
1159 float * saved
= sce
->saved
;
1160 const float * swindow
= ics
->use_kb_window
[0] ? ff_aac_kbd_short_128
: ff_sine_128
;
1161 const float * lwindow_prev
= ics
->use_kb_window
[1] ? ff_aac_kbd_long_1024
: ff_sine_1024
;
1162 const float * swindow_prev
= ics
->use_kb_window
[1] ? ff_aac_kbd_short_128
: ff_sine_128
;
1163 float * buf
= ac
->buf_mdct
;
1164 DECLARE_ALIGNED(16, float, temp
[128]);
1168 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
1169 if (ics
->window_sequence
[1] == ONLY_LONG_SEQUENCE
|| ics
->window_sequence
[1] == LONG_STOP_SEQUENCE
)
1170 av_log(ac
->avccontext
, AV_LOG_WARNING
,
1171 "Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. "
1172 "If you heard an audible artifact, please submit the sample to the FFmpeg developers.\n");
1173 for (i
= 0; i
< 1024; i
+= 128)
1174 ff_imdct_half(&ac
->mdct_small
, buf
+ i
, in
+ i
);
1176 ff_imdct_half(&ac
->mdct
, buf
, in
);
1178 /* window overlapping
1179 * NOTE: To simplify the overlapping code, all 'meaningless' short to long
1180 * and long to short transitions are considered to be short to short
1181 * transitions. This leaves just two cases (long to long and short to short)
1182 * with a little special sauce for EIGHT_SHORT_SEQUENCE.
1184 if ((ics
->window_sequence
[1] == ONLY_LONG_SEQUENCE
|| ics
->window_sequence
[1] == LONG_STOP_SEQUENCE
) &&
1185 (ics
->window_sequence
[0] == ONLY_LONG_SEQUENCE
|| ics
->window_sequence
[0] == LONG_START_SEQUENCE
)) {
1186 ac
->dsp
.vector_fmul_window( out
, saved
, buf
, lwindow_prev
, ac
->add_bias
, 512);
1188 for (i
= 0; i
< 448; i
++)
1189 out
[i
] = saved
[i
] + ac
->add_bias
;
1191 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
1192 ac
->dsp
.vector_fmul_window(out
+ 448 + 0*128, saved
+ 448, buf
+ 0*128, swindow_prev
, ac
->add_bias
, 64);
1193 ac
->dsp
.vector_fmul_window(out
+ 448 + 1*128, buf
+ 0*128 + 64, buf
+ 1*128, swindow
, ac
->add_bias
, 64);
1194 ac
->dsp
.vector_fmul_window(out
+ 448 + 2*128, buf
+ 1*128 + 64, buf
+ 2*128, swindow
, ac
->add_bias
, 64);
1195 ac
->dsp
.vector_fmul_window(out
+ 448 + 3*128, buf
+ 2*128 + 64, buf
+ 3*128, swindow
, ac
->add_bias
, 64);
1196 ac
->dsp
.vector_fmul_window(temp
, buf
+ 3*128 + 64, buf
+ 4*128, swindow
, ac
->add_bias
, 64);
1197 memcpy( out
+ 448 + 4*128, temp
, 64 * sizeof(float));
1199 ac
->dsp
.vector_fmul_window(out
+ 448, saved
+ 448, buf
, swindow_prev
, ac
->add_bias
, 64);
1200 for (i
= 576; i
< 1024; i
++)
1201 out
[i
] = buf
[i
-512] + ac
->add_bias
;
1206 if (ics
->window_sequence
[0] == EIGHT_SHORT_SEQUENCE
) {
1207 for (i
= 0; i
< 64; i
++)
1208 saved
[i
] = temp
[64 + i
] - ac
->add_bias
;
1209 ac
->dsp
.vector_fmul_window(saved
+ 64, buf
+ 4*128 + 64, buf
+ 5*128, swindow
, 0, 64);
1210 ac
->dsp
.vector_fmul_window(saved
+ 192, buf
+ 5*128 + 64, buf
+ 6*128, swindow
, 0, 64);
1211 ac
->dsp
.vector_fmul_window(saved
+ 320, buf
+ 6*128 + 64, buf
+ 7*128, swindow
, 0, 64);
1212 memcpy( saved
+ 448, buf
+ 7*128 + 64, 64 * sizeof(float));
1213 } else if (ics
->window_sequence
[0] == LONG_START_SEQUENCE
) {
1214 memcpy( saved
, buf
+ 512, 448 * sizeof(float));
1215 memcpy( saved
+ 448, buf
+ 7*128 + 64, 64 * sizeof(float));
1216 } else { // LONG_STOP or ONLY_LONG
1217 memcpy( saved
, buf
+ 512, 512 * sizeof(float));
1222 * Apply dependent channel coupling (applied before IMDCT).
1224 * @param index index into coupling gain array
1226 static void apply_dependent_coupling(AACContext
* ac
, SingleChannelElement
* sce
, ChannelElement
* cc
, int index
) {
1227 IndividualChannelStream
* ics
= &cc
->ch
[0].ics
;
1228 const uint16_t * offsets
= ics
->swb_offset
;
1229 float * dest
= sce
->coeffs
;
1230 const float * src
= cc
->ch
[0].coeffs
;
1231 int g
, i
, group
, k
, idx
= 0;
1232 if(ac
->m4ac
.object_type
== AOT_AAC_LTP
) {
1233 av_log(ac
->avccontext
, AV_LOG_ERROR
,
1234 "Dependent coupling is not supported together with LTP\n");
1237 for (g
= 0; g
< ics
->num_window_groups
; g
++) {
1238 for (i
= 0; i
< ics
->max_sfb
; i
++, idx
++) {
1239 if (cc
->ch
[0].band_type
[idx
] != ZERO_BT
) {
1240 for (group
= 0; group
< ics
->group_len
[g
]; group
++) {
1241 for (k
= offsets
[i
]; k
< offsets
[i
+1]; k
++) {
1243 dest
[group
*128+k
] += cc
->coup
.gain
[index
][idx
] * src
[group
*128+k
];
1248 dest
+= ics
->group_len
[g
]*128;
1249 src
+= ics
->group_len
[g
]*128;
1254 * Apply independent channel coupling (applied after IMDCT).
1256 * @param index index into coupling gain array
1258 static void apply_independent_coupling(AACContext
* ac
, SingleChannelElement
* sce
, ChannelElement
* cc
, int index
) {
1260 for (i
= 0; i
< 1024; i
++)
1261 sce
->ret
[i
] += cc
->coup
.gain
[index
][0] * (cc
->ch
[0].ret
[i
] - ac
->add_bias
);
1265 * channel coupling transformation interface
1267 * @param index index into coupling gain array
1268 * @param apply_coupling_method pointer to (in)dependent coupling function
1270 static void apply_channel_coupling(AACContext
* ac
, ChannelElement
* cc
,
1271 void (*apply_coupling_method
)(AACContext
* ac
, SingleChannelElement
* sce
, ChannelElement
* cc
, int index
))
1275 ChannelCoupling
* coup
= &cc
->coup
;
1276 for (c
= 0; c
<= coup
->num_coupled
; c
++) {
1277 if (ac
->che
[coup
->type
[c
]][coup
->id_select
[c
]]) {
1278 if (coup
->ch_select
[c
] != 2) {
1279 apply_coupling_method(ac
, &ac
->che
[coup
->type
[c
]][coup
->id_select
[c
]]->ch
[0], cc
, index
);
1280 if (coup
->ch_select
[c
] != 0)
1283 if (coup
->ch_select
[c
] != 1)
1284 apply_coupling_method(ac
, &ac
->che
[coup
->type
[c
]][coup
->id_select
[c
]]->ch
[1], cc
, index
++);
1286 av_log(ac
->avccontext
, AV_LOG_ERROR
,
1287 "coupling target %sE[%d] not available\n",
1288 coup
->type
[c
] == TYPE_CPE
? "CP" : "SC", coup
->id_select
[c
]);
1295 * Convert spectral data to float samples, applying all supported tools as appropriate.
1297 static void spectral_to_sample(AACContext
* ac
) {
1299 for (i
= 0; i
< MAX_ELEM_ID
; i
++) {
1300 for(type
= 0; type
< 4; type
++) {
1301 ChannelElement
*che
= ac
->che
[type
][i
];
1303 if(che
->coup
.coupling_point
== BEFORE_TNS
)
1304 apply_channel_coupling(ac
, che
, apply_dependent_coupling
);
1305 if(che
->ch
[0].tns
.present
)
1306 apply_tns(che
->ch
[0].coeffs
, &che
->ch
[0].tns
, &che
->ch
[0].ics
, 1);
1307 if(che
->ch
[1].tns
.present
)
1308 apply_tns(che
->ch
[1].coeffs
, &che
->ch
[1].tns
, &che
->ch
[1].ics
, 1);
1309 if(che
->coup
.coupling_point
== BETWEEN_TNS_AND_IMDCT
)
1310 apply_channel_coupling(ac
, che
, apply_dependent_coupling
);
1311 imdct_and_windowing(ac
, &che
->ch
[0]);
1312 if(type
== TYPE_CPE
)
1313 imdct_and_windowing(ac
, &che
->ch
[1]);
1314 if(che
->coup
.coupling_point
== AFTER_IMDCT
)
1315 apply_channel_coupling(ac
, che
, apply_independent_coupling
);
1321 static int aac_decode_frame(AVCodecContext
* avccontext
, void * data
, int * data_size
, const uint8_t * buf
, int buf_size
) {
1322 AACContext
* ac
= avccontext
->priv_data
;
1324 enum RawDataBlockType elem_type
;
1325 int err
, elem_id
, data_size_tmp
;
1327 init_get_bits(&gb
, buf
, buf_size
*8);
1330 while ((elem_type
= get_bits(&gb
, 3)) != TYPE_END
) {
1331 elem_id
= get_bits(&gb
, 4);
1334 if(elem_type
== TYPE_SCE
&& elem_id
== 1 &&
1335 !ac
->che
[TYPE_SCE
][elem_id
] && ac
->che
[TYPE_LFE
][0]) {
1336 /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
1337 instead of SCE[0] CPE[0] CPE[0] LFE[0]. If we seem to have
1338 encountered such a stream, transfer the LFE[0] element to SCE[1] */
1339 ac
->che
[TYPE_SCE
][elem_id
] = ac
->che
[TYPE_LFE
][0];
1340 ac
->che
[TYPE_LFE
][0] = NULL
;
1342 if(elem_type
< TYPE_DSE
) {
1343 if(!ac
->che
[elem_type
][elem_id
])
1345 if(elem_type
!= TYPE_CCE
)
1346 ac
->che
[elem_type
][elem_id
]->coup
.coupling_point
= 4;
1349 switch (elem_type
) {
1352 err
= decode_ics(ac
, &ac
->che
[TYPE_SCE
][elem_id
]->ch
[0], &gb
, 0, 0);
1356 err
= decode_cpe(ac
, &gb
, elem_id
);
1360 err
= decode_cce(ac
, &gb
, ac
->che
[TYPE_CCE
][elem_id
]);
1364 err
= decode_ics(ac
, &ac
->che
[TYPE_LFE
][elem_id
]->ch
[0], &gb
, 0, 0);
1368 skip_data_stream_element(&gb
);
1374 enum ChannelPosition new_che_pos
[4][MAX_ELEM_ID
];
1375 memset(new_che_pos
, 0, 4 * MAX_ELEM_ID
* sizeof(new_che_pos
[0][0]));
1376 if((err
= decode_pce(ac
, new_che_pos
, &gb
)))
1378 err
= output_configure(ac
, ac
->che_pos
, new_che_pos
);
1384 elem_id
+= get_bits(&gb
, 8) - 1;
1386 elem_id
-= decode_extension_payload(ac
, &gb
, elem_id
);
1387 err
= 0; /* FIXME */
1391 err
= -1; /* should not happen, but keeps compiler happy */
1399 spectral_to_sample(ac
);
1401 if (!ac
->is_saved
) {
1407 data_size_tmp
= 1024 * avccontext
->channels
* sizeof(int16_t);
1408 if(*data_size
< data_size_tmp
) {
1409 av_log(avccontext
, AV_LOG_ERROR
,
1410 "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
1411 *data_size
, data_size_tmp
);
1414 *data_size
= data_size_tmp
;
1416 ac
->dsp
.float_to_int16_interleave(data
, (const float **)ac
->output_data
, 1024, avccontext
->channels
);
1421 static av_cold
int aac_decode_close(AVCodecContext
* avccontext
) {
1422 AACContext
* ac
= avccontext
->priv_data
;
1425 for (i
= 0; i
< MAX_ELEM_ID
; i
++) {
1426 for(type
= 0; type
< 4; type
++)
1427 av_freep(&ac
->che
[type
][i
]);
1430 ff_mdct_end(&ac
->mdct
);
1431 ff_mdct_end(&ac
->mdct_small
);
1435 AVCodec aac_decoder
= {
1444 .long_name
= NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
1445 .sample_fmts
= (enum SampleFormat
[]){SAMPLE_FMT_S16
,SAMPLE_FMT_NONE
},