You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

2539 lines
89KB

  1. /*
  2. * AAC decoder
  3. * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
  4. * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
  5. *
  6. * AAC LATM decoder
  7. * Copyright (c) 2008-2010 Paul Kendall <paul@kcbbs.gen.nz>
  8. * Copyright (c) 2010 Janne Grunau <janne-ffmpeg@jannau.net>
  9. *
  10. * This file is part of Libav.
  11. *
  12. * Libav is free software; you can redistribute it and/or
  13. * modify it under the terms of the GNU Lesser General Public
  14. * License as published by the Free Software Foundation; either
  15. * version 2.1 of the License, or (at your option) any later version.
  16. *
  17. * Libav is distributed in the hope that it will be useful,
  18. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20. * Lesser General Public License for more details.
  21. *
  22. * You should have received a copy of the GNU Lesser General Public
  23. * License along with Libav; if not, write to the Free Software
  24. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25. */
  26. /**
  27. * @file
  28. * AAC decoder
  29. * @author Oded Shimon ( ods15 ods15 dyndns org )
  30. * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
  31. */
  32. /*
  33. * supported tools
  34. *
  35. * Support? Name
  36. * N (code in SoC repo) gain control
  37. * Y block switching
  38. * Y window shapes - standard
  39. * N window shapes - Low Delay
  40. * Y filterbank - standard
  41. * N (code in SoC repo) filterbank - Scalable Sample Rate
  42. * Y Temporal Noise Shaping
  43. * Y Long Term Prediction
  44. * Y intensity stereo
  45. * Y channel coupling
  46. * Y frequency domain prediction
  47. * Y Perceptual Noise Substitution
  48. * Y Mid/Side stereo
  49. * N Scalable Inverse AAC Quantization
  50. * N Frequency Selective Switch
  51. * N upsampling filter
  52. * Y quantization & coding - AAC
  53. * N quantization & coding - TwinVQ
  54. * N quantization & coding - BSAC
  55. * N AAC Error Resilience tools
  56. * N Error Resilience payload syntax
  57. * N Error Protection tool
  58. * N CELP
  59. * N Silence Compression
  60. * N HVXC
  61. * N HVXC 4kbits/s VR
  62. * N Structured Audio tools
  63. * N Structured Audio Sample Bank Format
  64. * N MIDI
  65. * N Harmonic and Individual Lines plus Noise
  66. * N Text-To-Speech Interface
  67. * Y Spectral Band Replication
  68. * Y (not in this code) Layer-1
  69. * Y (not in this code) Layer-2
  70. * Y (not in this code) Layer-3
  71. * N SinuSoidal Coding (Transient, Sinusoid, Noise)
  72. * Y Parametric Stereo
  73. * N Direct Stream Transfer
  74. *
  75. * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication.
  76. * - HE AAC v2 comprises LC AAC with Spectral Band Replication and
  77. Parametric Stereo.
  78. */
  79. #include "avcodec.h"
  80. #include "internal.h"
  81. #include "get_bits.h"
  82. #include "dsputil.h"
  83. #include "fft.h"
  84. #include "fmtconvert.h"
  85. #include "lpc.h"
  86. #include "kbdwin.h"
  87. #include "sinewin.h"
  88. #include "aac.h"
  89. #include "aactab.h"
  90. #include "aacdectab.h"
  91. #include "cbrt_tablegen.h"
  92. #include "sbr.h"
  93. #include "aacsbr.h"
  94. #include "mpeg4audio.h"
  95. #include "aacadtsdec.h"
  96. #include <assert.h>
  97. #include <errno.h>
  98. #include <math.h>
  99. #include <string.h>
  100. #if ARCH_ARM
  101. # include "arm/aac.h"
  102. #endif
  103. union float754 {
  104. float f;
  105. uint32_t i;
  106. };
  107. static VLC vlc_scalefactors;
  108. static VLC vlc_spectral[11];
  109. static const char overread_err[] = "Input buffer exhausted before END element found\n";
  110. static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
  111. {
  112. // For PCE based channel configurations map the channels solely based on tags.
  113. if (!ac->m4ac.chan_config) {
  114. return ac->tag_che_map[type][elem_id];
  115. }
  116. // For indexed channel configurations map the channels solely based on position.
  117. switch (ac->m4ac.chan_config) {
  118. case 7:
  119. if (ac->tags_mapped == 3 && type == TYPE_CPE) {
  120. ac->tags_mapped++;
  121. return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
  122. }
  123. case 6:
  124. /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
  125. instead of SCE[0] CPE[0] CPE[1] LFE[0]. If we seem to have
  126. encountered such a stream, transfer the LFE[0] element to the SCE[1]'s mapping */
  127. if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
  128. ac->tags_mapped++;
  129. return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
  130. }
  131. case 5:
  132. if (ac->tags_mapped == 2 && type == TYPE_CPE) {
  133. ac->tags_mapped++;
  134. return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
  135. }
  136. case 4:
  137. if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) {
  138. ac->tags_mapped++;
  139. return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
  140. }
  141. case 3:
  142. case 2:
  143. if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) {
  144. ac->tags_mapped++;
  145. return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
  146. } else if (ac->m4ac.chan_config == 2) {
  147. return NULL;
  148. }
  149. case 1:
  150. if (!ac->tags_mapped && type == TYPE_SCE) {
  151. ac->tags_mapped++;
  152. return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
  153. }
  154. default:
  155. return NULL;
  156. }
  157. }
  158. /**
  159. * Check for the channel element in the current channel position configuration.
  160. * If it exists, make sure the appropriate element is allocated and map the
  161. * channel order to match the internal Libav channel layout.
  162. *
  163. * @param che_pos current channel position configuration
  164. * @param type channel element type
  165. * @param id channel element id
  166. * @param channels count of the number of channels in the configuration
  167. *
  168. * @return Returns error status. 0 - OK, !0 - error
  169. */
  170. static av_cold int che_configure(AACContext *ac,
  171. enum ChannelPosition che_pos[4][MAX_ELEM_ID],
  172. int type, int id, int *channels)
  173. {
  174. if (che_pos[type][id]) {
  175. if (!ac->che[type][id] && !(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))
  176. return AVERROR(ENOMEM);
  177. ff_aac_sbr_ctx_init(ac, &ac->che[type][id]->sbr);
  178. if (type != TYPE_CCE) {
  179. ac->output_data[(*channels)++] = ac->che[type][id]->ch[0].ret;
  180. if (type == TYPE_CPE ||
  181. (type == TYPE_SCE && ac->m4ac.ps == 1)) {
  182. ac->output_data[(*channels)++] = ac->che[type][id]->ch[1].ret;
  183. }
  184. }
  185. } else {
  186. if (ac->che[type][id])
  187. ff_aac_sbr_ctx_close(&ac->che[type][id]->sbr);
  188. av_freep(&ac->che[type][id]);
  189. }
  190. return 0;
  191. }
  192. /**
  193. * Configure output channel order based on the current program configuration element.
  194. *
  195. * @param che_pos current channel position configuration
  196. * @param new_che_pos New channel position configuration - we only do something if it differs from the current one.
  197. *
  198. * @return Returns error status. 0 - OK, !0 - error
  199. */
  200. static av_cold int output_configure(AACContext *ac,
  201. enum ChannelPosition che_pos[4][MAX_ELEM_ID],
  202. enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
  203. int channel_config, enum OCStatus oc_type)
  204. {
  205. AVCodecContext *avctx = ac->avctx;
  206. int i, type, channels = 0, ret;
  207. if (new_che_pos != che_pos)
  208. memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
  209. if (channel_config) {
  210. for (i = 0; i < tags_per_config[channel_config]; i++) {
  211. if ((ret = che_configure(ac, che_pos,
  212. aac_channel_layout_map[channel_config - 1][i][0],
  213. aac_channel_layout_map[channel_config - 1][i][1],
  214. &channels)))
  215. return ret;
  216. }
  217. memset(ac->tag_che_map, 0, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
  218. avctx->channel_layout = aac_channel_layout[channel_config - 1];
  219. } else {
  220. /* Allocate or free elements depending on if they are in the
  221. * current program configuration.
  222. *
  223. * Set up default 1:1 output mapping.
  224. *
  225. * For a 5.1 stream the output order will be:
  226. * [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ]
  227. */
  228. for (i = 0; i < MAX_ELEM_ID; i++) {
  229. for (type = 0; type < 4; type++) {
  230. if ((ret = che_configure(ac, che_pos, type, i, &channels)))
  231. return ret;
  232. }
  233. }
  234. memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
  235. avctx->channel_layout = 0;
  236. }
  237. avctx->channels = channels;
  238. ac->output_configured = oc_type;
  239. return 0;
  240. }
  241. /**
  242. * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
  243. *
  244. * @param cpe_map Stereo (Channel Pair Element) map, NULL if stereo bit is not present.
  245. * @param sce_map mono (Single Channel Element) map
  246. * @param type speaker type/position for these channels
  247. */
  248. static void decode_channel_map(enum ChannelPosition *cpe_map,
  249. enum ChannelPosition *sce_map,
  250. enum ChannelPosition type,
  251. GetBitContext *gb, int n)
  252. {
  253. while (n--) {
  254. enum ChannelPosition *map = cpe_map && get_bits1(gb) ? cpe_map : sce_map; // stereo or mono map
  255. map[get_bits(gb, 4)] = type;
  256. }
  257. }
  258. /**
  259. * Decode program configuration element; reference: table 4.2.
  260. *
  261. * @param new_che_pos New channel position configuration - we only do something if it differs from the current one.
  262. *
  263. * @return Returns error status. 0 - OK, !0 - error
  264. */
  265. static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
  266. enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
  267. GetBitContext *gb)
  268. {
  269. int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index;
  270. int comment_len;
  271. skip_bits(gb, 2); // object_type
  272. sampling_index = get_bits(gb, 4);
  273. if (m4ac->sampling_index != sampling_index)
  274. av_log(avctx, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");
  275. num_front = get_bits(gb, 4);
  276. num_side = get_bits(gb, 4);
  277. num_back = get_bits(gb, 4);
  278. num_lfe = get_bits(gb, 2);
  279. num_assoc_data = get_bits(gb, 3);
  280. num_cc = get_bits(gb, 4);
  281. if (get_bits1(gb))
  282. skip_bits(gb, 4); // mono_mixdown_tag
  283. if (get_bits1(gb))
  284. skip_bits(gb, 4); // stereo_mixdown_tag
  285. if (get_bits1(gb))
  286. skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
  287. decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_FRONT, gb, num_front);
  288. decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_SIDE, gb, num_side );
  289. decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_BACK, gb, num_back );
  290. decode_channel_map(NULL, new_che_pos[TYPE_LFE], AAC_CHANNEL_LFE, gb, num_lfe );
  291. skip_bits_long(gb, 4 * num_assoc_data);
  292. decode_channel_map(new_che_pos[TYPE_CCE], new_che_pos[TYPE_CCE], AAC_CHANNEL_CC, gb, num_cc );
  293. align_get_bits(gb);
  294. /* comment field, first byte is length */
  295. comment_len = get_bits(gb, 8) * 8;
  296. if (get_bits_left(gb) < comment_len) {
  297. av_log(avctx, AV_LOG_ERROR, overread_err);
  298. return -1;
  299. }
  300. skip_bits_long(gb, comment_len);
  301. return 0;
  302. }
  303. /**
  304. * Set up channel positions based on a default channel configuration
  305. * as specified in table 1.17.
  306. *
  307. * @param new_che_pos New channel position configuration - we only do something if it differs from the current one.
  308. *
  309. * @return Returns error status. 0 - OK, !0 - error
  310. */
  311. static av_cold int set_default_channel_config(AVCodecContext *avctx,
  312. enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
  313. int channel_config)
  314. {
  315. if (channel_config < 1 || channel_config > 7) {
  316. av_log(avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
  317. channel_config);
  318. return -1;
  319. }
  320. /* default channel configurations:
  321. *
  322. * 1ch : front center (mono)
  323. * 2ch : L + R (stereo)
  324. * 3ch : front center + L + R
  325. * 4ch : front center + L + R + back center
  326. * 5ch : front center + L + R + back stereo
  327. * 6ch : front center + L + R + back stereo + LFE
  328. * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE
  329. */
  330. if (channel_config != 2)
  331. new_che_pos[TYPE_SCE][0] = AAC_CHANNEL_FRONT; // front center (or mono)
  332. if (channel_config > 1)
  333. new_che_pos[TYPE_CPE][0] = AAC_CHANNEL_FRONT; // L + R (or stereo)
  334. if (channel_config == 4)
  335. new_che_pos[TYPE_SCE][1] = AAC_CHANNEL_BACK; // back center
  336. if (channel_config > 4)
  337. new_che_pos[TYPE_CPE][(channel_config == 7) + 1]
  338. = AAC_CHANNEL_BACK; // back stereo
  339. if (channel_config > 5)
  340. new_che_pos[TYPE_LFE][0] = AAC_CHANNEL_LFE; // LFE
  341. if (channel_config == 7)
  342. new_che_pos[TYPE_CPE][1] = AAC_CHANNEL_FRONT; // outer front left + outer front right
  343. return 0;
  344. }
  345. /**
  346. * Decode GA "General Audio" specific configuration; reference: table 4.1.
  347. *
  348. * @param ac pointer to AACContext, may be null
  349. * @param avctx pointer to AVCCodecContext, used for logging
  350. *
  351. * @return Returns error status. 0 - OK, !0 - error
  352. */
  353. static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
  354. GetBitContext *gb,
  355. MPEG4AudioConfig *m4ac,
  356. int channel_config)
  357. {
  358. enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
  359. int extension_flag, ret;
  360. if (get_bits1(gb)) { // frameLengthFlag
  361. av_log_missing_feature(avctx, "960/120 MDCT window is", 1);
  362. return -1;
  363. }
  364. if (get_bits1(gb)) // dependsOnCoreCoder
  365. skip_bits(gb, 14); // coreCoderDelay
  366. extension_flag = get_bits1(gb);
  367. if (m4ac->object_type == AOT_AAC_SCALABLE ||
  368. m4ac->object_type == AOT_ER_AAC_SCALABLE)
  369. skip_bits(gb, 3); // layerNr
  370. memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
  371. if (channel_config == 0) {
  372. skip_bits(gb, 4); // element_instance_tag
  373. if ((ret = decode_pce(avctx, m4ac, new_che_pos, gb)))
  374. return ret;
  375. } else {
  376. if ((ret = set_default_channel_config(avctx, new_che_pos, channel_config)))
  377. return ret;
  378. }
  379. if (ac && (ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR)))
  380. return ret;
  381. if (extension_flag) {
  382. switch (m4ac->object_type) {
  383. case AOT_ER_BSAC:
  384. skip_bits(gb, 5); // numOfSubFrame
  385. skip_bits(gb, 11); // layer_length
  386. break;
  387. case AOT_ER_AAC_LC:
  388. case AOT_ER_AAC_LTP:
  389. case AOT_ER_AAC_SCALABLE:
  390. case AOT_ER_AAC_LD:
  391. skip_bits(gb, 3); /* aacSectionDataResilienceFlag
  392. * aacScalefactorDataResilienceFlag
  393. * aacSpectralDataResilienceFlag
  394. */
  395. break;
  396. }
  397. skip_bits1(gb); // extensionFlag3 (TBD in version 3)
  398. }
  399. return 0;
  400. }
  401. /**
  402. * Decode audio specific configuration; reference: table 1.13.
  403. *
  404. * @param ac pointer to AACContext, may be null
  405. * @param avctx pointer to AVCCodecContext, used for logging
  406. * @param m4ac pointer to MPEG4AudioConfig, used for parsing
  407. * @param data pointer to AVCodecContext extradata
  408. * @param data_size size of AVCCodecContext extradata
  409. *
  410. * @return Returns error status or number of consumed bits. <0 - error
  411. */
  412. static int decode_audio_specific_config(AACContext *ac,
  413. AVCodecContext *avctx,
  414. MPEG4AudioConfig *m4ac,
  415. const uint8_t *data, int data_size)
  416. {
  417. GetBitContext gb;
  418. int i;
  419. av_dlog(avctx, "extradata size %d\n", avctx->extradata_size);
  420. for (i = 0; i < avctx->extradata_size; i++)
  421. av_dlog(avctx, "%02x ", avctx->extradata[i]);
  422. av_dlog(avctx, "\n");
  423. init_get_bits(&gb, data, data_size * 8);
  424. if ((i = ff_mpeg4audio_get_config(m4ac, data, data_size)) < 0)
  425. return -1;
  426. if (m4ac->sampling_index > 12) {
  427. av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index);
  428. return -1;
  429. }
  430. if (m4ac->sbr == 1 && m4ac->ps == -1)
  431. m4ac->ps = 1;
  432. skip_bits_long(&gb, i);
  433. switch (m4ac->object_type) {
  434. case AOT_AAC_MAIN:
  435. case AOT_AAC_LC:
  436. case AOT_AAC_LTP:
  437. if (decode_ga_specific_config(ac, avctx, &gb, m4ac, m4ac->chan_config))
  438. return -1;
  439. break;
  440. default:
  441. av_log(avctx, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
  442. m4ac->sbr == 1? "SBR+" : "", m4ac->object_type);
  443. return -1;
  444. }
  445. av_dlog(avctx, "AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\n",
  446. m4ac->object_type, m4ac->chan_config, m4ac->sampling_index,
  447. m4ac->sample_rate, m4ac->sbr, m4ac->ps);
  448. return get_bits_count(&gb);
  449. }
  450. /**
  451. * linear congruential pseudorandom number generator
  452. *
  453. * @param previous_val pointer to the current state of the generator
  454. *
  455. * @return Returns a 32-bit pseudorandom integer
  456. */
  457. static av_always_inline int lcg_random(int previous_val)
  458. {
  459. return previous_val * 1664525 + 1013904223;
  460. }
  461. static av_always_inline void reset_predict_state(PredictorState *ps)
  462. {
  463. ps->r0 = 0.0f;
  464. ps->r1 = 0.0f;
  465. ps->cor0 = 0.0f;
  466. ps->cor1 = 0.0f;
  467. ps->var0 = 1.0f;
  468. ps->var1 = 1.0f;
  469. }
  470. static void reset_all_predictors(PredictorState *ps)
  471. {
  472. int i;
  473. for (i = 0; i < MAX_PREDICTORS; i++)
  474. reset_predict_state(&ps[i]);
  475. }
  476. static void reset_predictor_group(PredictorState *ps, int group_num)
  477. {
  478. int i;
  479. for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
  480. reset_predict_state(&ps[i]);
  481. }
  482. #define AAC_INIT_VLC_STATIC(num, size) \
  483. INIT_VLC_STATIC(&vlc_spectral[num], 8, ff_aac_spectral_sizes[num], \
  484. ff_aac_spectral_bits[num], sizeof( ff_aac_spectral_bits[num][0]), sizeof( ff_aac_spectral_bits[num][0]), \
  485. ff_aac_spectral_codes[num], sizeof(ff_aac_spectral_codes[num][0]), sizeof(ff_aac_spectral_codes[num][0]), \
  486. size);
  487. static av_cold int aac_decode_init(AVCodecContext *avctx)
  488. {
  489. AACContext *ac = avctx->priv_data;
  490. float output_scale_factor;
  491. ac->avctx = avctx;
  492. ac->m4ac.sample_rate = avctx->sample_rate;
  493. if (avctx->extradata_size > 0) {
  494. if (decode_audio_specific_config(ac, ac->avctx, &ac->m4ac,
  495. avctx->extradata,
  496. avctx->extradata_size) < 0)
  497. return -1;
  498. }
  499. if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
  500. avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
  501. output_scale_factor = 1.0 / 32768.0;
  502. } else {
  503. avctx->sample_fmt = AV_SAMPLE_FMT_S16;
  504. output_scale_factor = 1.0;
  505. }
  506. AAC_INIT_VLC_STATIC( 0, 304);
  507. AAC_INIT_VLC_STATIC( 1, 270);
  508. AAC_INIT_VLC_STATIC( 2, 550);
  509. AAC_INIT_VLC_STATIC( 3, 300);
  510. AAC_INIT_VLC_STATIC( 4, 328);
  511. AAC_INIT_VLC_STATIC( 5, 294);
  512. AAC_INIT_VLC_STATIC( 6, 306);
  513. AAC_INIT_VLC_STATIC( 7, 268);
  514. AAC_INIT_VLC_STATIC( 8, 510);
  515. AAC_INIT_VLC_STATIC( 9, 366);
  516. AAC_INIT_VLC_STATIC(10, 462);
  517. ff_aac_sbr_init();
  518. dsputil_init(&ac->dsp, avctx);
  519. ff_fmt_convert_init(&ac->fmt_conv, avctx);
  520. ac->random_state = 0x1f2e3d4c;
  521. ff_aac_tableinit();
  522. INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
  523. ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]),
  524. ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
  525. 352);
  526. ff_mdct_init(&ac->mdct, 11, 1, output_scale_factor/1024.0);
  527. ff_mdct_init(&ac->mdct_small, 8, 1, output_scale_factor/128.0);
  528. ff_mdct_init(&ac->mdct_ltp, 11, 0, -2.0/output_scale_factor);
  529. // window initialization
  530. ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
  531. ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
  532. ff_init_ff_sine_windows(10);
  533. ff_init_ff_sine_windows( 7);
  534. cbrt_tableinit();
  535. return 0;
  536. }
  537. /**
  538. * Skip data_stream_element; reference: table 4.10.
  539. */
  540. static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
  541. {
  542. int byte_align = get_bits1(gb);
  543. int count = get_bits(gb, 8);
  544. if (count == 255)
  545. count += get_bits(gb, 8);
  546. if (byte_align)
  547. align_get_bits(gb);
  548. if (get_bits_left(gb) < 8 * count) {
  549. av_log(ac->avctx, AV_LOG_ERROR, overread_err);
  550. return -1;
  551. }
  552. skip_bits_long(gb, 8 * count);
  553. return 0;
  554. }
  555. static int decode_prediction(AACContext *ac, IndividualChannelStream *ics,
  556. GetBitContext *gb)
  557. {
  558. int sfb;
  559. if (get_bits1(gb)) {
  560. ics->predictor_reset_group = get_bits(gb, 5);
  561. if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) {
  562. av_log(ac->avctx, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n");
  563. return -1;
  564. }
  565. }
  566. for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->m4ac.sampling_index]); sfb++) {
  567. ics->prediction_used[sfb] = get_bits1(gb);
  568. }
  569. return 0;
  570. }
  571. /**
  572. * Decode Long Term Prediction data; reference: table 4.xx.
  573. */
  574. static void decode_ltp(AACContext *ac, LongTermPrediction *ltp,
  575. GetBitContext *gb, uint8_t max_sfb)
  576. {
  577. int sfb;
  578. ltp->lag = get_bits(gb, 11);
  579. ltp->coef = ltp_coef[get_bits(gb, 3)];
  580. for (sfb = 0; sfb < FFMIN(max_sfb, MAX_LTP_LONG_SFB); sfb++)
  581. ltp->used[sfb] = get_bits1(gb);
  582. }
  583. /**
  584. * Decode Individual Channel Stream info; reference: table 4.6.
  585. *
  586. * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information.
  587. */
  588. static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
  589. GetBitContext *gb, int common_window)
  590. {
  591. if (get_bits1(gb)) {
  592. av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
  593. memset(ics, 0, sizeof(IndividualChannelStream));
  594. return -1;
  595. }
  596. ics->window_sequence[1] = ics->window_sequence[0];
  597. ics->window_sequence[0] = get_bits(gb, 2);
  598. ics->use_kb_window[1] = ics->use_kb_window[0];
  599. ics->use_kb_window[0] = get_bits1(gb);
  600. ics->num_window_groups = 1;
  601. ics->group_len[0] = 1;
  602. if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
  603. int i;
  604. ics->max_sfb = get_bits(gb, 4);
  605. for (i = 0; i < 7; i++) {
  606. if (get_bits1(gb)) {
  607. ics->group_len[ics->num_window_groups - 1]++;
  608. } else {
  609. ics->num_window_groups++;
  610. ics->group_len[ics->num_window_groups - 1] = 1;
  611. }
  612. }
  613. ics->num_windows = 8;
  614. ics->swb_offset = ff_swb_offset_128[ac->m4ac.sampling_index];
  615. ics->num_swb = ff_aac_num_swb_128[ac->m4ac.sampling_index];
  616. ics->tns_max_bands = ff_tns_max_bands_128[ac->m4ac.sampling_index];
  617. ics->predictor_present = 0;
  618. } else {
  619. ics->max_sfb = get_bits(gb, 6);
  620. ics->num_windows = 1;
  621. ics->swb_offset = ff_swb_offset_1024[ac->m4ac.sampling_index];
  622. ics->num_swb = ff_aac_num_swb_1024[ac->m4ac.sampling_index];
  623. ics->tns_max_bands = ff_tns_max_bands_1024[ac->m4ac.sampling_index];
  624. ics->predictor_present = get_bits1(gb);
  625. ics->predictor_reset_group = 0;
  626. if (ics->predictor_present) {
  627. if (ac->m4ac.object_type == AOT_AAC_MAIN) {
  628. if (decode_prediction(ac, ics, gb)) {
  629. memset(ics, 0, sizeof(IndividualChannelStream));
  630. return -1;
  631. }
  632. } else if (ac->m4ac.object_type == AOT_AAC_LC) {
  633. av_log(ac->avctx, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
  634. memset(ics, 0, sizeof(IndividualChannelStream));
  635. return -1;
  636. } else {
  637. if ((ics->ltp.present = get_bits(gb, 1)))
  638. decode_ltp(ac, &ics->ltp, gb, ics->max_sfb);
  639. }
  640. }
  641. }
  642. if (ics->max_sfb > ics->num_swb) {
  643. av_log(ac->avctx, AV_LOG_ERROR,
  644. "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
  645. ics->max_sfb, ics->num_swb);
  646. memset(ics, 0, sizeof(IndividualChannelStream));
  647. return -1;
  648. }
  649. return 0;
  650. }
  651. /**
  652. * Decode band types (section_data payload); reference: table 4.46.
  653. *
  654. * @param band_type array of the used band type
  655. * @param band_type_run_end array of the last scalefactor band of a band type run
  656. *
  657. * @return Returns error status. 0 - OK, !0 - error
  658. */
  659. static int decode_band_types(AACContext *ac, enum BandType band_type[120],
  660. int band_type_run_end[120], GetBitContext *gb,
  661. IndividualChannelStream *ics)
  662. {
  663. int g, idx = 0;
  664. const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
  665. for (g = 0; g < ics->num_window_groups; g++) {
  666. int k = 0;
  667. while (k < ics->max_sfb) {
  668. uint8_t sect_end = k;
  669. int sect_len_incr;
  670. int sect_band_type = get_bits(gb, 4);
  671. if (sect_band_type == 12) {
  672. av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n");
  673. return -1;
  674. }
  675. while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits) - 1)
  676. sect_end += sect_len_incr;
  677. sect_end += sect_len_incr;
  678. if (get_bits_left(gb) < 0) {
  679. av_log(ac->avctx, AV_LOG_ERROR, overread_err);
  680. return -1;
  681. }
  682. if (sect_end > ics->max_sfb) {
  683. av_log(ac->avctx, AV_LOG_ERROR,
  684. "Number of bands (%d) exceeds limit (%d).\n",
  685. sect_end, ics->max_sfb);
  686. return -1;
  687. }
  688. for (; k < sect_end; k++) {
  689. band_type [idx] = sect_band_type;
  690. band_type_run_end[idx++] = sect_end;
  691. }
  692. }
  693. }
  694. return 0;
  695. }
  696. /**
  697. * Decode scalefactors; reference: table 4.47.
  698. *
  699. * @param global_gain first scalefactor value as scalefactors are differentially coded
  700. * @param band_type array of the used band type
  701. * @param band_type_run_end array of the last scalefactor band of a band type run
  702. * @param sf array of scalefactors or intensity stereo positions
  703. *
  704. * @return Returns error status. 0 - OK, !0 - error
  705. */
  706. static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,
  707. unsigned int global_gain,
  708. IndividualChannelStream *ics,
  709. enum BandType band_type[120],
  710. int band_type_run_end[120])
  711. {
  712. int g, i, idx = 0;
  713. int offset[3] = { global_gain, global_gain - 90, 0 };
  714. int clipped_offset;
  715. int noise_flag = 1;
  716. static const char *sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" };
  717. for (g = 0; g < ics->num_window_groups; g++) {
  718. for (i = 0; i < ics->max_sfb;) {
  719. int run_end = band_type_run_end[idx];
  720. if (band_type[idx] == ZERO_BT) {
  721. for (; i < run_end; i++, idx++)
  722. sf[idx] = 0.;
  723. } else if ((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) {
  724. for (; i < run_end; i++, idx++) {
  725. offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
  726. clipped_offset = av_clip(offset[2], -155, 100);
  727. if (offset[2] != clipped_offset) {
  728. av_log_ask_for_sample(ac->avctx, "Intensity stereo "
  729. "position clipped (%d -> %d).\nIf you heard an "
  730. "audible artifact, there may be a bug in the "
  731. "decoder. ", offset[2], clipped_offset);
  732. }
  733. sf[idx] = ff_aac_pow2sf_tab[-clipped_offset + POW_SF2_ZERO];
  734. }
  735. } else if (band_type[idx] == NOISE_BT) {
  736. for (; i < run_end; i++, idx++) {
  737. if (noise_flag-- > 0)
  738. offset[1] += get_bits(gb, 9) - 256;
  739. else
  740. offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
  741. clipped_offset = av_clip(offset[1], -100, 155);
  742. if (offset[1] != clipped_offset) {
  743. av_log_ask_for_sample(ac->avctx, "Noise gain clipped "
  744. "(%d -> %d).\nIf you heard an audible "
  745. "artifact, there may be a bug in the decoder. ",
  746. offset[1], clipped_offset);
  747. }
  748. sf[idx] = -ff_aac_pow2sf_tab[clipped_offset + POW_SF2_ZERO];
  749. }
  750. } else {
  751. for (; i < run_end; i++, idx++) {
  752. offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
  753. if (offset[0] > 255U) {
  754. av_log(ac->avctx, AV_LOG_ERROR,
  755. "%s (%d) out of range.\n", sf_str[0], offset[0]);
  756. return -1;
  757. }
  758. sf[idx] = -ff_aac_pow2sf_tab[offset[0] - 100 + POW_SF2_ZERO];
  759. }
  760. }
  761. }
  762. }
  763. return 0;
  764. }
  765. /**
  766. * Decode pulse data; reference: table 4.7.
  767. */
  768. static int decode_pulses(Pulse *pulse, GetBitContext *gb,
  769. const uint16_t *swb_offset, int num_swb)
  770. {
  771. int i, pulse_swb;
  772. pulse->num_pulse = get_bits(gb, 2) + 1;
  773. pulse_swb = get_bits(gb, 6);
  774. if (pulse_swb >= num_swb)
  775. return -1;
  776. pulse->pos[0] = swb_offset[pulse_swb];
  777. pulse->pos[0] += get_bits(gb, 5);
  778. if (pulse->pos[0] > 1023)
  779. return -1;
  780. pulse->amp[0] = get_bits(gb, 4);
  781. for (i = 1; i < pulse->num_pulse; i++) {
  782. pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1];
  783. if (pulse->pos[i] > 1023)
  784. return -1;
  785. pulse->amp[i] = get_bits(gb, 4);
  786. }
  787. return 0;
  788. }
  789. /**
  790. * Decode Temporal Noise Shaping data; reference: table 4.48.
  791. *
  792. * @return Returns error status. 0 - OK, !0 - error
  793. */
  794. static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns,
  795. GetBitContext *gb, const IndividualChannelStream *ics)
  796. {
  797. int w, filt, i, coef_len, coef_res, coef_compress;
  798. const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
  799. const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
  800. for (w = 0; w < ics->num_windows; w++) {
  801. if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
  802. coef_res = get_bits1(gb);
  803. for (filt = 0; filt < tns->n_filt[w]; filt++) {
  804. int tmp2_idx;
  805. tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
  806. if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
  807. av_log(ac->avctx, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n",
  808. tns->order[w][filt], tns_max_order);
  809. tns->order[w][filt] = 0;
  810. return -1;
  811. }
  812. if (tns->order[w][filt]) {
  813. tns->direction[w][filt] = get_bits1(gb);
  814. coef_compress = get_bits1(gb);
  815. coef_len = coef_res + 3 - coef_compress;
  816. tmp2_idx = 2 * coef_compress + coef_res;
  817. for (i = 0; i < tns->order[w][filt]; i++)
  818. tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
  819. }
  820. }
  821. }
  822. }
  823. return 0;
  824. }
  825. /**
  826. * Decode Mid/Side data; reference: table 4.54.
  827. *
  828. * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
  829. * [1] mask is decoded from bitstream; [2] mask is all 1s;
  830. * [3] reserved for scalable AAC
  831. */
  832. static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb,
  833. int ms_present)
  834. {
  835. int idx;
  836. if (ms_present == 1) {
  837. for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++)
  838. cpe->ms_mask[idx] = get_bits1(gb);
  839. } else if (ms_present == 2) {
  840. memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0]));
  841. }
  842. }
  843. #ifndef VMUL2
  844. static inline float *VMUL2(float *dst, const float *v, unsigned idx,
  845. const float *scale)
  846. {
  847. float s = *scale;
  848. *dst++ = v[idx & 15] * s;
  849. *dst++ = v[idx>>4 & 15] * s;
  850. return dst;
  851. }
  852. #endif
  853. #ifndef VMUL4
  854. static inline float *VMUL4(float *dst, const float *v, unsigned idx,
  855. const float *scale)
  856. {
  857. float s = *scale;
  858. *dst++ = v[idx & 3] * s;
  859. *dst++ = v[idx>>2 & 3] * s;
  860. *dst++ = v[idx>>4 & 3] * s;
  861. *dst++ = v[idx>>6 & 3] * s;
  862. return dst;
  863. }
  864. #endif
  865. #ifndef VMUL2S
  866. static inline float *VMUL2S(float *dst, const float *v, unsigned idx,
  867. unsigned sign, const float *scale)
  868. {
  869. union float754 s0, s1;
  870. s0.f = s1.f = *scale;
  871. s0.i ^= sign >> 1 << 31;
  872. s1.i ^= sign << 31;
  873. *dst++ = v[idx & 15] * s0.f;
  874. *dst++ = v[idx>>4 & 15] * s1.f;
  875. return dst;
  876. }
  877. #endif
  878. #ifndef VMUL4S
  879. static inline float *VMUL4S(float *dst, const float *v, unsigned idx,
  880. unsigned sign, const float *scale)
  881. {
  882. unsigned nz = idx >> 12;
  883. union float754 s = { .f = *scale };
  884. union float754 t;
  885. t.i = s.i ^ (sign & 1U<<31);
  886. *dst++ = v[idx & 3] * t.f;
  887. sign <<= nz & 1; nz >>= 1;
  888. t.i = s.i ^ (sign & 1U<<31);
  889. *dst++ = v[idx>>2 & 3] * t.f;
  890. sign <<= nz & 1; nz >>= 1;
  891. t.i = s.i ^ (sign & 1U<<31);
  892. *dst++ = v[idx>>4 & 3] * t.f;
  893. sign <<= nz & 1; nz >>= 1;
  894. t.i = s.i ^ (sign & 1U<<31);
  895. *dst++ = v[idx>>6 & 3] * t.f;
  896. return dst;
  897. }
  898. #endif
  899. /**
  900. * Decode spectral data; reference: table 4.50.
  901. * Dequantize and scale spectral data; reference: 4.6.3.3.
  902. *
  903. * @param coef array of dequantized, scaled spectral data
  904. * @param sf array of scalefactors or intensity stereo positions
  905. * @param pulse_present set if pulses are present
  906. * @param pulse pointer to pulse data struct
  907. * @param band_type array of the used band type
  908. *
  909. * @return Returns error status. 0 - OK, !0 - error
  910. */
  911. static int decode_spectrum_and_dequant(AACContext *ac, float coef[1024],
  912. GetBitContext *gb, const float sf[120],
  913. int pulse_present, const Pulse *pulse,
  914. const IndividualChannelStream *ics,
  915. enum BandType band_type[120])
  916. {
  917. int i, k, g, idx = 0;
  918. const int c = 1024 / ics->num_windows;
  919. const uint16_t *offsets = ics->swb_offset;
  920. float *coef_base = coef;
  921. for (g = 0; g < ics->num_windows; g++)
  922. memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float) * (c - offsets[ics->max_sfb]));
  923. for (g = 0; g < ics->num_window_groups; g++) {
  924. unsigned g_len = ics->group_len[g];
  925. for (i = 0; i < ics->max_sfb; i++, idx++) {
  926. const unsigned cbt_m1 = band_type[idx] - 1;
  927. float *cfo = coef + offsets[i];
  928. int off_len = offsets[i + 1] - offsets[i];
  929. int group;
  930. if (cbt_m1 >= INTENSITY_BT2 - 1) {
  931. for (group = 0; group < g_len; group++, cfo+=128) {
  932. memset(cfo, 0, off_len * sizeof(float));
  933. }
  934. } else if (cbt_m1 == NOISE_BT - 1) {
  935. for (group = 0; group < g_len; group++, cfo+=128) {
  936. float scale;
  937. float band_energy;
  938. for (k = 0; k < off_len; k++) {
  939. ac->random_state = lcg_random(ac->random_state);
  940. cfo[k] = ac->random_state;
  941. }
  942. band_energy = ac->dsp.scalarproduct_float(cfo, cfo, off_len);
  943. scale = sf[idx] / sqrtf(band_energy);
  944. ac->dsp.vector_fmul_scalar(cfo, cfo, scale, off_len);
  945. }
  946. } else {
  947. const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
  948. const uint16_t *cb_vector_idx = ff_aac_codebook_vector_idx[cbt_m1];
  949. VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table;
  950. OPEN_READER(re, gb);
  951. switch (cbt_m1 >> 1) {
  952. case 0:
  953. for (group = 0; group < g_len; group++, cfo+=128) {
  954. float *cf = cfo;
  955. int len = off_len;
  956. do {
  957. int code;
  958. unsigned cb_idx;
  959. UPDATE_CACHE(re, gb);
  960. GET_VLC(code, re, gb, vlc_tab, 8, 2);
  961. cb_idx = cb_vector_idx[code];
  962. cf = VMUL4(cf, vq, cb_idx, sf + idx);
  963. } while (len -= 4);
  964. }
  965. break;
  966. case 1:
  967. for (group = 0; group < g_len; group++, cfo+=128) {
  968. float *cf = cfo;
  969. int len = off_len;
  970. do {
  971. int code;
  972. unsigned nnz;
  973. unsigned cb_idx;
  974. uint32_t bits;
  975. UPDATE_CACHE(re, gb);
  976. GET_VLC(code, re, gb, vlc_tab, 8, 2);
  977. cb_idx = cb_vector_idx[code];
  978. nnz = cb_idx >> 8 & 15;
  979. bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
  980. LAST_SKIP_BITS(re, gb, nnz);
  981. cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx);
  982. } while (len -= 4);
  983. }
  984. break;
  985. case 2:
  986. for (group = 0; group < g_len; group++, cfo+=128) {
  987. float *cf = cfo;
  988. int len = off_len;
  989. do {
  990. int code;
  991. unsigned cb_idx;
  992. UPDATE_CACHE(re, gb);
  993. GET_VLC(code, re, gb, vlc_tab, 8, 2);
  994. cb_idx = cb_vector_idx[code];
  995. cf = VMUL2(cf, vq, cb_idx, sf + idx);
  996. } while (len -= 2);
  997. }
  998. break;
  999. case 3:
  1000. case 4:
  1001. for (group = 0; group < g_len; group++, cfo+=128) {
  1002. float *cf = cfo;
  1003. int len = off_len;
  1004. do {
  1005. int code;
  1006. unsigned nnz;
  1007. unsigned cb_idx;
  1008. unsigned sign;
  1009. UPDATE_CACHE(re, gb);
  1010. GET_VLC(code, re, gb, vlc_tab, 8, 2);
  1011. cb_idx = cb_vector_idx[code];
  1012. nnz = cb_idx >> 8 & 15;
  1013. sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12);
  1014. LAST_SKIP_BITS(re, gb, nnz);
  1015. cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx);
  1016. } while (len -= 2);
  1017. }
  1018. break;
  1019. default:
  1020. for (group = 0; group < g_len; group++, cfo+=128) {
  1021. float *cf = cfo;
  1022. uint32_t *icf = (uint32_t *) cf;
  1023. int len = off_len;
  1024. do {
  1025. int code;
  1026. unsigned nzt, nnz;
  1027. unsigned cb_idx;
  1028. uint32_t bits;
  1029. int j;
  1030. UPDATE_CACHE(re, gb);
  1031. GET_VLC(code, re, gb, vlc_tab, 8, 2);
  1032. if (!code) {
  1033. *icf++ = 0;
  1034. *icf++ = 0;
  1035. continue;
  1036. }
  1037. cb_idx = cb_vector_idx[code];
  1038. nnz = cb_idx >> 12;
  1039. nzt = cb_idx >> 8;
  1040. bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
  1041. LAST_SKIP_BITS(re, gb, nnz);
  1042. for (j = 0; j < 2; j++) {
  1043. if (nzt & 1<<j) {
  1044. uint32_t b;
  1045. int n;
  1046. /* The total length of escape_sequence must be < 22 bits according
  1047. to the specification (i.e. max is 111111110xxxxxxxxxxxx). */
  1048. UPDATE_CACHE(re, gb);
  1049. b = GET_CACHE(re, gb);
  1050. b = 31 - av_log2(~b);
  1051. if (b > 8) {
  1052. av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
  1053. return -1;
  1054. }
  1055. SKIP_BITS(re, gb, b + 1);
  1056. b += 4;
  1057. n = (1 << b) + SHOW_UBITS(re, gb, b);
  1058. LAST_SKIP_BITS(re, gb, b);
  1059. *icf++ = cbrt_tab[n] | (bits & 1U<<31);
  1060. bits <<= 1;
  1061. } else {
  1062. unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
  1063. *icf++ = (bits & 1U<<31) | v;
  1064. bits <<= !!v;
  1065. }
  1066. cb_idx >>= 4;
  1067. }
  1068. } while (len -= 2);
  1069. ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
  1070. }
  1071. }
  1072. CLOSE_READER(re, gb);
  1073. }
  1074. }
  1075. coef += g_len << 7;
  1076. }
  1077. if (pulse_present) {
  1078. idx = 0;
  1079. for (i = 0; i < pulse->num_pulse; i++) {
  1080. float co = coef_base[ pulse->pos[i] ];
  1081. while (offsets[idx + 1] <= pulse->pos[i])
  1082. idx++;
  1083. if (band_type[idx] != NOISE_BT && sf[idx]) {
  1084. float ico = -pulse->amp[i];
  1085. if (co) {
  1086. co /= sf[idx];
  1087. ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
  1088. }
  1089. coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
  1090. }
  1091. }
  1092. }
  1093. return 0;
  1094. }
  1095. static av_always_inline float flt16_round(float pf)
  1096. {
  1097. union float754 tmp;
  1098. tmp.f = pf;
  1099. tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U;
  1100. return tmp.f;
  1101. }
  1102. static av_always_inline float flt16_even(float pf)
  1103. {
  1104. union float754 tmp;
  1105. tmp.f = pf;
  1106. tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U >> 16)) & 0xFFFF0000U;
  1107. return tmp.f;
  1108. }
  1109. static av_always_inline float flt16_trunc(float pf)
  1110. {
  1111. union float754 pun;
  1112. pun.f = pf;
  1113. pun.i &= 0xFFFF0000U;
  1114. return pun.f;
  1115. }
  1116. static av_always_inline void predict(PredictorState *ps, float *coef,
  1117. int output_enable)
  1118. {
  1119. const float a = 0.953125; // 61.0 / 64
  1120. const float alpha = 0.90625; // 29.0 / 32
  1121. float e0, e1;
  1122. float pv;
  1123. float k1, k2;
  1124. float r0 = ps->r0, r1 = ps->r1;
  1125. float cor0 = ps->cor0, cor1 = ps->cor1;
  1126. float var0 = ps->var0, var1 = ps->var1;
  1127. k1 = var0 > 1 ? cor0 * flt16_even(a / var0) : 0;
  1128. k2 = var1 > 1 ? cor1 * flt16_even(a / var1) : 0;
  1129. pv = flt16_round(k1 * r0 + k2 * r1);
  1130. if (output_enable)
  1131. *coef += pv;
  1132. e0 = *coef;
  1133. e1 = e0 - k1 * r0;
  1134. ps->cor1 = flt16_trunc(alpha * cor1 + r1 * e1);
  1135. ps->var1 = flt16_trunc(alpha * var1 + 0.5f * (r1 * r1 + e1 * e1));
  1136. ps->cor0 = flt16_trunc(alpha * cor0 + r0 * e0);
  1137. ps->var0 = flt16_trunc(alpha * var0 + 0.5f * (r0 * r0 + e0 * e0));
  1138. ps->r1 = flt16_trunc(a * (r0 - k1 * e0));
  1139. ps->r0 = flt16_trunc(a * e0);
  1140. }
  1141. /**
  1142. * Apply AAC-Main style frequency domain prediction.
  1143. */
  1144. static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
  1145. {
  1146. int sfb, k;
  1147. if (!sce->ics.predictor_initialized) {
  1148. reset_all_predictors(sce->predictor_state);
  1149. sce->ics.predictor_initialized = 1;
  1150. }
  1151. if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
  1152. for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) {
  1153. for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
  1154. predict(&sce->predictor_state[k], &sce->coeffs[k],
  1155. sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
  1156. }
  1157. }
  1158. if (sce->ics.predictor_reset_group)
  1159. reset_predictor_group(sce->predictor_state, sce->ics.predictor_reset_group);
  1160. } else
  1161. reset_all_predictors(sce->predictor_state);
  1162. }
  1163. /**
  1164. * Decode an individual_channel_stream payload; reference: table 4.44.
  1165. *
  1166. * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information.
  1167. * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
  1168. *
  1169. * @return Returns error status. 0 - OK, !0 - error
  1170. */
  1171. static int decode_ics(AACContext *ac, SingleChannelElement *sce,
  1172. GetBitContext *gb, int common_window, int scale_flag)
  1173. {
  1174. Pulse pulse;
  1175. TemporalNoiseShaping *tns = &sce->tns;
  1176. IndividualChannelStream *ics = &sce->ics;
  1177. float *out = sce->coeffs;
  1178. int global_gain, pulse_present = 0;
  1179. /* This assignment is to silence a GCC warning about the variable being used
  1180. * uninitialized when in fact it always is.
  1181. */
  1182. pulse.num_pulse = 0;
  1183. global_gain = get_bits(gb, 8);
  1184. if (!common_window && !scale_flag) {
  1185. if (decode_ics_info(ac, ics, gb, 0) < 0)
  1186. return -1;
  1187. }
  1188. if (decode_band_types(ac, sce->band_type, sce->band_type_run_end, gb, ics) < 0)
  1189. return -1;
  1190. if (decode_scalefactors(ac, sce->sf, gb, global_gain, ics, sce->band_type, sce->band_type_run_end) < 0)
  1191. return -1;
  1192. pulse_present = 0;
  1193. if (!scale_flag) {
  1194. if ((pulse_present = get_bits1(gb))) {
  1195. if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
  1196. av_log(ac->avctx, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
  1197. return -1;
  1198. }
  1199. if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
  1200. av_log(ac->avctx, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n");
  1201. return -1;
  1202. }
  1203. }
  1204. if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics))
  1205. return -1;
  1206. if (get_bits1(gb)) {
  1207. av_log_missing_feature(ac->avctx, "SSR", 1);
  1208. return -1;
  1209. }
  1210. }
  1211. if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0)
  1212. return -1;
  1213. if (ac->m4ac.object_type == AOT_AAC_MAIN && !common_window)
  1214. apply_prediction(ac, sce);
  1215. return 0;
  1216. }
  1217. /**
  1218. * Mid/Side stereo decoding; reference: 4.6.8.1.3.
  1219. */
  1220. static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
  1221. {
  1222. const IndividualChannelStream *ics = &cpe->ch[0].ics;
  1223. float *ch0 = cpe->ch[0].coeffs;
  1224. float *ch1 = cpe->ch[1].coeffs;
  1225. int g, i, group, idx = 0;
  1226. const uint16_t *offsets = ics->swb_offset;
  1227. for (g = 0; g < ics->num_window_groups; g++) {
  1228. for (i = 0; i < ics->max_sfb; i++, idx++) {
  1229. if (cpe->ms_mask[idx] &&
  1230. cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) {
  1231. for (group = 0; group < ics->group_len[g]; group++) {
  1232. ac->dsp.butterflies_float(ch0 + group * 128 + offsets[i],
  1233. ch1 + group * 128 + offsets[i],
  1234. offsets[i+1] - offsets[i]);
  1235. }
  1236. }
  1237. }
  1238. ch0 += ics->group_len[g] * 128;
  1239. ch1 += ics->group_len[g] * 128;
  1240. }
  1241. }
  1242. /**
  1243. * intensity stereo decoding; reference: 4.6.8.2.3
  1244. *
  1245. * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
  1246. * [1] mask is decoded from bitstream; [2] mask is all 1s;
  1247. * [3] reserved for scalable AAC
  1248. */
  1249. static void apply_intensity_stereo(AACContext *ac, ChannelElement *cpe, int ms_present)
  1250. {
  1251. const IndividualChannelStream *ics = &cpe->ch[1].ics;
  1252. SingleChannelElement *sce1 = &cpe->ch[1];
  1253. float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
  1254. const uint16_t *offsets = ics->swb_offset;
  1255. int g, group, i, idx = 0;
  1256. int c;
  1257. float scale;
  1258. for (g = 0; g < ics->num_window_groups; g++) {
  1259. for (i = 0; i < ics->max_sfb;) {
  1260. if (sce1->band_type[idx] == INTENSITY_BT || sce1->band_type[idx] == INTENSITY_BT2) {
  1261. const int bt_run_end = sce1->band_type_run_end[idx];
  1262. for (; i < bt_run_end; i++, idx++) {
  1263. c = -1 + 2 * (sce1->band_type[idx] - 14);
  1264. if (ms_present)
  1265. c *= 1 - 2 * cpe->ms_mask[idx];
  1266. scale = c * sce1->sf[idx];
  1267. for (group = 0; group < ics->group_len[g]; group++)
  1268. ac->dsp.vector_fmul_scalar(coef1 + group * 128 + offsets[i],
  1269. coef0 + group * 128 + offsets[i],
  1270. scale,
  1271. offsets[i + 1] - offsets[i]);
  1272. }
  1273. } else {
  1274. int bt_run_end = sce1->band_type_run_end[idx];
  1275. idx += bt_run_end - i;
  1276. i = bt_run_end;
  1277. }
  1278. }
  1279. coef0 += ics->group_len[g] * 128;
  1280. coef1 += ics->group_len[g] * 128;
  1281. }
  1282. }
  1283. /**
  1284. * Decode a channel_pair_element; reference: table 4.4.
  1285. *
  1286. * @return Returns error status. 0 - OK, !0 - error
  1287. */
  1288. static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
  1289. {
  1290. int i, ret, common_window, ms_present = 0;
  1291. common_window = get_bits1(gb);
  1292. if (common_window) {
  1293. if (decode_ics_info(ac, &cpe->ch[0].ics, gb, 1))
  1294. return -1;
  1295. i = cpe->ch[1].ics.use_kb_window[0];
  1296. cpe->ch[1].ics = cpe->ch[0].ics;
  1297. cpe->ch[1].ics.use_kb_window[1] = i;
  1298. if (cpe->ch[1].ics.predictor_present && (ac->m4ac.object_type != AOT_AAC_MAIN))
  1299. if ((cpe->ch[1].ics.ltp.present = get_bits(gb, 1)))
  1300. decode_ltp(ac, &cpe->ch[1].ics.ltp, gb, cpe->ch[1].ics.max_sfb);
  1301. ms_present = get_bits(gb, 2);
  1302. if (ms_present == 3) {
  1303. av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
  1304. return -1;
  1305. } else if (ms_present)
  1306. decode_mid_side_stereo(cpe, gb, ms_present);
  1307. }
  1308. if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
  1309. return ret;
  1310. if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
  1311. return ret;
  1312. if (common_window) {
  1313. if (ms_present)
  1314. apply_mid_side_stereo(ac, cpe);
  1315. if (ac->m4ac.object_type == AOT_AAC_MAIN) {
  1316. apply_prediction(ac, &cpe->ch[0]);
  1317. apply_prediction(ac, &cpe->ch[1]);
  1318. }
  1319. }
  1320. apply_intensity_stereo(ac, cpe, ms_present);
  1321. return 0;
  1322. }
  1323. static const float cce_scale[] = {
  1324. 1.09050773266525765921, //2^(1/8)
  1325. 1.18920711500272106672, //2^(1/4)
  1326. M_SQRT2,
  1327. 2,
  1328. };
  1329. /**
  1330. * Decode coupling_channel_element; reference: table 4.8.
  1331. *
  1332. * @return Returns error status. 0 - OK, !0 - error
  1333. */
  1334. static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
  1335. {
  1336. int num_gain = 0;
  1337. int c, g, sfb, ret;
  1338. int sign;
  1339. float scale;
  1340. SingleChannelElement *sce = &che->ch[0];
  1341. ChannelCoupling *coup = &che->coup;
  1342. coup->coupling_point = 2 * get_bits1(gb);
  1343. coup->num_coupled = get_bits(gb, 3);
  1344. for (c = 0; c <= coup->num_coupled; c++) {
  1345. num_gain++;
  1346. coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
  1347. coup->id_select[c] = get_bits(gb, 4);
  1348. if (coup->type[c] == TYPE_CPE) {
  1349. coup->ch_select[c] = get_bits(gb, 2);
  1350. if (coup->ch_select[c] == 3)
  1351. num_gain++;
  1352. } else
  1353. coup->ch_select[c] = 2;
  1354. }
  1355. coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
  1356. sign = get_bits(gb, 1);
  1357. scale = cce_scale[get_bits(gb, 2)];
  1358. if ((ret = decode_ics(ac, sce, gb, 0, 0)))
  1359. return ret;
  1360. for (c = 0; c < num_gain; c++) {
  1361. int idx = 0;
  1362. int cge = 1;
  1363. int gain = 0;
  1364. float gain_cache = 1.;
  1365. if (c) {
  1366. cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
  1367. gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
  1368. gain_cache = powf(scale, -gain);
  1369. }
  1370. if (coup->coupling_point == AFTER_IMDCT) {
  1371. coup->gain[c][0] = gain_cache;
  1372. } else {
  1373. for (g = 0; g < sce->ics.num_window_groups; g++) {
  1374. for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
  1375. if (sce->band_type[idx] != ZERO_BT) {
  1376. if (!cge) {
  1377. int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
  1378. if (t) {
  1379. int s = 1;
  1380. t = gain += t;
  1381. if (sign) {
  1382. s -= 2 * (t & 0x1);
  1383. t >>= 1;
  1384. }
  1385. gain_cache = powf(scale, -t) * s;
  1386. }
  1387. }
  1388. coup->gain[c][idx] = gain_cache;
  1389. }
  1390. }
  1391. }
  1392. }
  1393. }
  1394. return 0;
  1395. }
  1396. /**
  1397. * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
  1398. *
  1399. * @return Returns number of bytes consumed.
  1400. */
  1401. static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc,
  1402. GetBitContext *gb)
  1403. {
  1404. int i;
  1405. int num_excl_chan = 0;
  1406. do {
  1407. for (i = 0; i < 7; i++)
  1408. che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
  1409. } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
  1410. return num_excl_chan / 7;
  1411. }
  1412. /**
  1413. * Decode dynamic range information; reference: table 4.52.
  1414. *
  1415. * @param cnt length of TYPE_FIL syntactic element in bytes
  1416. *
  1417. * @return Returns number of bytes consumed.
  1418. */
  1419. static int decode_dynamic_range(DynamicRangeControl *che_drc,
  1420. GetBitContext *gb, int cnt)
  1421. {
  1422. int n = 1;
  1423. int drc_num_bands = 1;
  1424. int i;
  1425. /* pce_tag_present? */
  1426. if (get_bits1(gb)) {
  1427. che_drc->pce_instance_tag = get_bits(gb, 4);
  1428. skip_bits(gb, 4); // tag_reserved_bits
  1429. n++;
  1430. }
  1431. /* excluded_chns_present? */
  1432. if (get_bits1(gb)) {
  1433. n += decode_drc_channel_exclusions(che_drc, gb);
  1434. }
  1435. /* drc_bands_present? */
  1436. if (get_bits1(gb)) {
  1437. che_drc->band_incr = get_bits(gb, 4);
  1438. che_drc->interpolation_scheme = get_bits(gb, 4);
  1439. n++;
  1440. drc_num_bands += che_drc->band_incr;
  1441. for (i = 0; i < drc_num_bands; i++) {
  1442. che_drc->band_top[i] = get_bits(gb, 8);
  1443. n++;
  1444. }
  1445. }
  1446. /* prog_ref_level_present? */
  1447. if (get_bits1(gb)) {
  1448. che_drc->prog_ref_level = get_bits(gb, 7);
  1449. skip_bits1(gb); // prog_ref_level_reserved_bits
  1450. n++;
  1451. }
  1452. for (i = 0; i < drc_num_bands; i++) {
  1453. che_drc->dyn_rng_sgn[i] = get_bits1(gb);
  1454. che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
  1455. n++;
  1456. }
  1457. return n;
  1458. }
  1459. /**
  1460. * Decode extension data (incomplete); reference: table 4.51.
  1461. *
  1462. * @param cnt length of TYPE_FIL syntactic element in bytes
  1463. *
  1464. * @return Returns number of bytes consumed
  1465. */
  1466. static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
  1467. ChannelElement *che, enum RawDataBlockType elem_type)
  1468. {
  1469. int crc_flag = 0;
  1470. int res = cnt;
  1471. switch (get_bits(gb, 4)) { // extension type
  1472. case EXT_SBR_DATA_CRC:
  1473. crc_flag++;
  1474. case EXT_SBR_DATA:
  1475. if (!che) {
  1476. av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
  1477. return res;
  1478. } else if (!ac->m4ac.sbr) {
  1479. av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
  1480. skip_bits_long(gb, 8 * cnt - 4);
  1481. return res;
  1482. } else if (ac->m4ac.sbr == -1 && ac->output_configured == OC_LOCKED) {
  1483. av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
  1484. skip_bits_long(gb, 8 * cnt - 4);
  1485. return res;
  1486. } else if (ac->m4ac.ps == -1 && ac->output_configured < OC_LOCKED && ac->avctx->channels == 1) {
  1487. ac->m4ac.sbr = 1;
  1488. ac->m4ac.ps = 1;
  1489. output_configure(ac, ac->che_pos, ac->che_pos, ac->m4ac.chan_config, ac->output_configured);
  1490. } else {
  1491. ac->m4ac.sbr = 1;
  1492. }
  1493. res = ff_decode_sbr_extension(ac, &che->sbr, gb, crc_flag, cnt, elem_type);
  1494. break;
  1495. case EXT_DYNAMIC_RANGE:
  1496. res = decode_dynamic_range(&ac->che_drc, gb, cnt);
  1497. break;
  1498. case EXT_FILL:
  1499. case EXT_FILL_DATA:
  1500. case EXT_DATA_ELEMENT:
  1501. default:
  1502. skip_bits_long(gb, 8 * cnt - 4);
  1503. break;
  1504. };
  1505. return res;
  1506. }
  1507. /**
  1508. * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
  1509. *
  1510. * @param decode 1 if tool is used normally, 0 if tool is used in LTP.
  1511. * @param coef spectral coefficients
  1512. */
  1513. static void apply_tns(float coef[1024], TemporalNoiseShaping *tns,
  1514. IndividualChannelStream *ics, int decode)
  1515. {
  1516. const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
  1517. int w, filt, m, i;
  1518. int bottom, top, order, start, end, size, inc;
  1519. float lpc[TNS_MAX_ORDER];
  1520. float tmp[TNS_MAX_ORDER];
  1521. for (w = 0; w < ics->num_windows; w++) {
  1522. bottom = ics->num_swb;
  1523. for (filt = 0; filt < tns->n_filt[w]; filt++) {
  1524. top = bottom;
  1525. bottom = FFMAX(0, top - tns->length[w][filt]);
  1526. order = tns->order[w][filt];
  1527. if (order == 0)
  1528. continue;
  1529. // tns_decode_coef
  1530. compute_lpc_coefs(tns->coef[w][filt], order, lpc, 0, 0, 0);
  1531. start = ics->swb_offset[FFMIN(bottom, mmm)];
  1532. end = ics->swb_offset[FFMIN( top, mmm)];
  1533. if ((size = end - start) <= 0)
  1534. continue;
  1535. if (tns->direction[w][filt]) {
  1536. inc = -1;
  1537. start = end - 1;
  1538. } else {
  1539. inc = 1;
  1540. }
  1541. start += w * 128;
  1542. if (decode) {
  1543. // ar filter
  1544. for (m = 0; m < size; m++, start += inc)
  1545. for (i = 1; i <= FFMIN(m, order); i++)
  1546. coef[start] -= coef[start - i * inc] * lpc[i - 1];
  1547. } else {
  1548. // ma filter
  1549. for (m = 0; m < size; m++, start += inc) {
  1550. tmp[0] = coef[start];
  1551. for (i = 1; i <= FFMIN(m, order); i++)
  1552. coef[start] += tmp[i] * lpc[i - 1];
  1553. for (i = order; i > 0; i--)
  1554. tmp[i] = tmp[i - 1];
  1555. }
  1556. }
  1557. }
  1558. }
  1559. }
  1560. /**
  1561. * Apply windowing and MDCT to obtain the spectral
  1562. * coefficient from the predicted sample by LTP.
  1563. */
  1564. static void windowing_and_mdct_ltp(AACContext *ac, float *out,
  1565. float *in, IndividualChannelStream *ics)
  1566. {
  1567. const float *lwindow = ics->use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
  1568. const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
  1569. const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
  1570. const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
  1571. if (ics->window_sequence[0] != LONG_STOP_SEQUENCE) {
  1572. ac->dsp.vector_fmul(in, in, lwindow_prev, 1024);
  1573. } else {
  1574. memset(in, 0, 448 * sizeof(float));
  1575. ac->dsp.vector_fmul(in + 448, in + 448, swindow_prev, 128);
  1576. memcpy(in + 576, in + 576, 448 * sizeof(float));
  1577. }
  1578. if (ics->window_sequence[0] != LONG_START_SEQUENCE) {
  1579. ac->dsp.vector_fmul_reverse(in + 1024, in + 1024, lwindow, 1024);
  1580. } else {
  1581. memcpy(in + 1024, in + 1024, 448 * sizeof(float));
  1582. ac->dsp.vector_fmul_reverse(in + 1024 + 448, in + 1024 + 448, swindow, 128);
  1583. memset(in + 1024 + 576, 0, 448 * sizeof(float));
  1584. }
  1585. ac->mdct_ltp.mdct_calc(&ac->mdct_ltp, out, in);
  1586. }
  1587. /**
  1588. * Apply the long term prediction
  1589. */
  1590. static void apply_ltp(AACContext *ac, SingleChannelElement *sce)
  1591. {
  1592. const LongTermPrediction *ltp = &sce->ics.ltp;
  1593. const uint16_t *offsets = sce->ics.swb_offset;
  1594. int i, sfb;
  1595. if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
  1596. float *predTime = sce->ret;
  1597. float *predFreq = ac->buf_mdct;
  1598. int16_t num_samples = 2048;
  1599. if (ltp->lag < 1024)
  1600. num_samples = ltp->lag + 1024;
  1601. for (i = 0; i < num_samples; i++)
  1602. predTime[i] = sce->ltp_state[i + 2048 - ltp->lag] * ltp->coef;
  1603. memset(&predTime[i], 0, (2048 - i) * sizeof(float));
  1604. windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
  1605. if (sce->tns.present)
  1606. apply_tns(predFreq, &sce->tns, &sce->ics, 0);
  1607. for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
  1608. if (ltp->used[sfb])
  1609. for (i = offsets[sfb]; i < offsets[sfb + 1]; i++)
  1610. sce->coeffs[i] += predFreq[i];
  1611. }
  1612. }
  1613. /**
  1614. * Update the LTP buffer for next frame
  1615. */
  1616. static void update_ltp(AACContext *ac, SingleChannelElement *sce)
  1617. {
  1618. IndividualChannelStream *ics = &sce->ics;
  1619. float *saved = sce->saved;
  1620. float *saved_ltp = sce->coeffs;
  1621. const float *lwindow = ics->use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
  1622. const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
  1623. int i;
  1624. if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
  1625. memcpy(saved_ltp, saved, 512 * sizeof(float));
  1626. memset(saved_ltp + 576, 0, 448 * sizeof(float));
  1627. ac->dsp.vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
  1628. for (i = 0; i < 64; i++)
  1629. saved_ltp[i + 512] = ac->buf_mdct[1023 - i] * swindow[63 - i];
  1630. } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
  1631. memcpy(saved_ltp, ac->buf_mdct + 512, 448 * sizeof(float));
  1632. memset(saved_ltp + 576, 0, 448 * sizeof(float));
  1633. ac->dsp.vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
  1634. for (i = 0; i < 64; i++)
  1635. saved_ltp[i + 512] = ac->buf_mdct[1023 - i] * swindow[63 - i];
  1636. } else { // LONG_STOP or ONLY_LONG
  1637. ac->dsp.vector_fmul_reverse(saved_ltp, ac->buf_mdct + 512, &lwindow[512], 512);
  1638. for (i = 0; i < 512; i++)
  1639. saved_ltp[i + 512] = ac->buf_mdct[1023 - i] * lwindow[511 - i];
  1640. }
  1641. memcpy(sce->ltp_state, sce->ltp_state+1024, 1024 * sizeof(*sce->ltp_state));
  1642. memcpy(sce->ltp_state+1024, sce->ret, 1024 * sizeof(*sce->ltp_state));
  1643. memcpy(sce->ltp_state+2048, saved_ltp, 1024 * sizeof(*sce->ltp_state));
  1644. }
  1645. /**
  1646. * Conduct IMDCT and windowing.
  1647. */
  1648. static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
  1649. {
  1650. IndividualChannelStream *ics = &sce->ics;
  1651. float *in = sce->coeffs;
  1652. float *out = sce->ret;
  1653. float *saved = sce->saved;
  1654. const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
  1655. const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
  1656. const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
  1657. float *buf = ac->buf_mdct;
  1658. float *temp = ac->temp;
  1659. int i;
  1660. // imdct
  1661. if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
  1662. for (i = 0; i < 1024; i += 128)
  1663. ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
  1664. } else
  1665. ac->mdct.imdct_half(&ac->mdct, buf, in);
  1666. /* window overlapping
  1667. * NOTE: To simplify the overlapping code, all 'meaningless' short to long
  1668. * and long to short transitions are considered to be short to short
  1669. * transitions. This leaves just two cases (long to long and short to short)
  1670. * with a little special sauce for EIGHT_SHORT_SEQUENCE.
  1671. */
  1672. if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
  1673. (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
  1674. ac->dsp.vector_fmul_window( out, saved, buf, lwindow_prev, 512);
  1675. } else {
  1676. memcpy( out, saved, 448 * sizeof(float));
  1677. if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
  1678. ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448, buf + 0*128, swindow_prev, 64);
  1679. ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow, 64);
  1680. ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow, 64);
  1681. ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow, 64);
  1682. ac->dsp.vector_fmul_window(temp, buf + 3*128 + 64, buf + 4*128, swindow, 64);
  1683. memcpy( out + 448 + 4*128, temp, 64 * sizeof(float));
  1684. } else {
  1685. ac->dsp.vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, 64);
  1686. memcpy( out + 576, buf + 64, 448 * sizeof(float));
  1687. }
  1688. }
  1689. // buffer update
  1690. if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
  1691. memcpy( saved, temp + 64, 64 * sizeof(float));
  1692. ac->dsp.vector_fmul_window(saved + 64, buf + 4*128 + 64, buf + 5*128, swindow, 64);
  1693. ac->dsp.vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 64);
  1694. ac->dsp.vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 64);
  1695. memcpy( saved + 448, buf + 7*128 + 64, 64 * sizeof(float));
  1696. } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
  1697. memcpy( saved, buf + 512, 448 * sizeof(float));
  1698. memcpy( saved + 448, buf + 7*128 + 64, 64 * sizeof(float));
  1699. } else { // LONG_STOP or ONLY_LONG
  1700. memcpy( saved, buf + 512, 512 * sizeof(float));
  1701. }
  1702. }
  1703. /**
  1704. * Apply dependent channel coupling (applied before IMDCT).
  1705. *
  1706. * @param index index into coupling gain array
  1707. */
  1708. static void apply_dependent_coupling(AACContext *ac,
  1709. SingleChannelElement *target,
  1710. ChannelElement *cce, int index)
  1711. {
  1712. IndividualChannelStream *ics = &cce->ch[0].ics;
  1713. const uint16_t *offsets = ics->swb_offset;
  1714. float *dest = target->coeffs;
  1715. const float *src = cce->ch[0].coeffs;
  1716. int g, i, group, k, idx = 0;
  1717. if (ac->m4ac.object_type == AOT_AAC_LTP) {
  1718. av_log(ac->avctx, AV_LOG_ERROR,
  1719. "Dependent coupling is not supported together with LTP\n");
  1720. return;
  1721. }
  1722. for (g = 0; g < ics->num_window_groups; g++) {
  1723. for (i = 0; i < ics->max_sfb; i++, idx++) {
  1724. if (cce->ch[0].band_type[idx] != ZERO_BT) {
  1725. const float gain = cce->coup.gain[index][idx];
  1726. for (group = 0; group < ics->group_len[g]; group++) {
  1727. for (k = offsets[i]; k < offsets[i + 1]; k++) {
  1728. // XXX dsputil-ize
  1729. dest[group * 128 + k] += gain * src[group * 128 + k];
  1730. }
  1731. }
  1732. }
  1733. }
  1734. dest += ics->group_len[g] * 128;
  1735. src += ics->group_len[g] * 128;
  1736. }
  1737. }
  1738. /**
  1739. * Apply independent channel coupling (applied after IMDCT).
  1740. *
  1741. * @param index index into coupling gain array
  1742. */
  1743. static void apply_independent_coupling(AACContext *ac,
  1744. SingleChannelElement *target,
  1745. ChannelElement *cce, int index)
  1746. {
  1747. int i;
  1748. const float gain = cce->coup.gain[index][0];
  1749. const float *src = cce->ch[0].ret;
  1750. float *dest = target->ret;
  1751. const int len = 1024 << (ac->m4ac.sbr == 1);
  1752. for (i = 0; i < len; i++)
  1753. dest[i] += gain * src[i];
  1754. }
  1755. /**
  1756. * channel coupling transformation interface
  1757. *
  1758. * @param apply_coupling_method pointer to (in)dependent coupling function
  1759. */
  1760. static void apply_channel_coupling(AACContext *ac, ChannelElement *cc,
  1761. enum RawDataBlockType type, int elem_id,
  1762. enum CouplingPoint coupling_point,
  1763. void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
  1764. {
  1765. int i, c;
  1766. for (i = 0; i < MAX_ELEM_ID; i++) {
  1767. ChannelElement *cce = ac->che[TYPE_CCE][i];
  1768. int index = 0;
  1769. if (cce && cce->coup.coupling_point == coupling_point) {
  1770. ChannelCoupling *coup = &cce->coup;
  1771. for (c = 0; c <= coup->num_coupled; c++) {
  1772. if (coup->type[c] == type && coup->id_select[c] == elem_id) {
  1773. if (coup->ch_select[c] != 1) {
  1774. apply_coupling_method(ac, &cc->ch[0], cce, index);
  1775. if (coup->ch_select[c] != 0)
  1776. index++;
  1777. }
  1778. if (coup->ch_select[c] != 2)
  1779. apply_coupling_method(ac, &cc->ch[1], cce, index++);
  1780. } else
  1781. index += 1 + (coup->ch_select[c] == 3);
  1782. }
  1783. }
  1784. }
  1785. }
  1786. /**
  1787. * Convert spectral data to float samples, applying all supported tools as appropriate.
  1788. */
  1789. static void spectral_to_sample(AACContext *ac)
  1790. {
  1791. int i, type;
  1792. for (type = 3; type >= 0; type--) {
  1793. for (i = 0; i < MAX_ELEM_ID; i++) {
  1794. ChannelElement *che = ac->che[type][i];
  1795. if (che) {
  1796. if (type <= TYPE_CPE)
  1797. apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling);
  1798. if (ac->m4ac.object_type == AOT_AAC_LTP) {
  1799. if (che->ch[0].ics.predictor_present) {
  1800. if (che->ch[0].ics.ltp.present)
  1801. apply_ltp(ac, &che->ch[0]);
  1802. if (che->ch[1].ics.ltp.present && type == TYPE_CPE)
  1803. apply_ltp(ac, &che->ch[1]);
  1804. }
  1805. }
  1806. if (che->ch[0].tns.present)
  1807. apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
  1808. if (che->ch[1].tns.present)
  1809. apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
  1810. if (type <= TYPE_CPE)
  1811. apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling);
  1812. if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
  1813. imdct_and_windowing(ac, &che->ch[0]);
  1814. if (ac->m4ac.object_type == AOT_AAC_LTP)
  1815. update_ltp(ac, &che->ch[0]);
  1816. if (type == TYPE_CPE) {
  1817. imdct_and_windowing(ac, &che->ch[1]);
  1818. if (ac->m4ac.object_type == AOT_AAC_LTP)
  1819. update_ltp(ac, &che->ch[1]);
  1820. }
  1821. if (ac->m4ac.sbr > 0) {
  1822. ff_sbr_apply(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret);
  1823. }
  1824. }
  1825. if (type <= TYPE_CCE)
  1826. apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling);
  1827. }
  1828. }
  1829. }
  1830. }
  1831. static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
  1832. {
  1833. int size;
  1834. AACADTSHeaderInfo hdr_info;
  1835. size = ff_aac_parse_header(gb, &hdr_info);
  1836. if (size > 0) {
  1837. if (ac->output_configured != OC_LOCKED && hdr_info.chan_config) {
  1838. enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
  1839. memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
  1840. ac->m4ac.chan_config = hdr_info.chan_config;
  1841. if (set_default_channel_config(ac->avctx, new_che_pos, hdr_info.chan_config))
  1842. return -7;
  1843. if (output_configure(ac, ac->che_pos, new_che_pos, hdr_info.chan_config, OC_TRIAL_FRAME))
  1844. return -7;
  1845. } else if (ac->output_configured != OC_LOCKED) {
  1846. ac->output_configured = OC_NONE;
  1847. }
  1848. if (ac->output_configured != OC_LOCKED) {
  1849. ac->m4ac.sbr = -1;
  1850. ac->m4ac.ps = -1;
  1851. }
  1852. ac->m4ac.sample_rate = hdr_info.sample_rate;
  1853. ac->m4ac.sampling_index = hdr_info.sampling_index;
  1854. ac->m4ac.object_type = hdr_info.object_type;
  1855. if (!ac->avctx->sample_rate)
  1856. ac->avctx->sample_rate = hdr_info.sample_rate;
  1857. if (hdr_info.num_aac_frames == 1) {
  1858. if (!hdr_info.crc_absent)
  1859. skip_bits(gb, 16);
  1860. } else {
  1861. av_log_missing_feature(ac->avctx, "More than one AAC RDB per ADTS frame is", 0);
  1862. return -1;
  1863. }
  1864. }
  1865. return size;
  1866. }
  1867. static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
  1868. int *data_size, GetBitContext *gb)
  1869. {
  1870. AACContext *ac = avctx->priv_data;
  1871. ChannelElement *che = NULL, *che_prev = NULL;
  1872. enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;
  1873. int err, elem_id, data_size_tmp;
  1874. int samples = 0, multiplier;
  1875. if (show_bits(gb, 12) == 0xfff) {
  1876. if (parse_adts_frame_header(ac, gb) < 0) {
  1877. av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
  1878. return -1;
  1879. }
  1880. if (ac->m4ac.sampling_index > 12) {
  1881. av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
  1882. return -1;
  1883. }
  1884. }
  1885. ac->tags_mapped = 0;
  1886. // parse
  1887. while ((elem_type = get_bits(gb, 3)) != TYPE_END) {
  1888. elem_id = get_bits(gb, 4);
  1889. if (elem_type < TYPE_DSE) {
  1890. if (!(che=get_che(ac, elem_type, elem_id))) {
  1891. av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n",
  1892. elem_type, elem_id);
  1893. return -1;
  1894. }
  1895. samples = 1024;
  1896. }
  1897. switch (elem_type) {
  1898. case TYPE_SCE:
  1899. err = decode_ics(ac, &che->ch[0], gb, 0, 0);
  1900. break;
  1901. case TYPE_CPE:
  1902. err = decode_cpe(ac, gb, che);
  1903. break;
  1904. case TYPE_CCE:
  1905. err = decode_cce(ac, gb, che);
  1906. break;
  1907. case TYPE_LFE:
  1908. err = decode_ics(ac, &che->ch[0], gb, 0, 0);
  1909. break;
  1910. case TYPE_DSE:
  1911. err = skip_data_stream_element(ac, gb);
  1912. break;
  1913. case TYPE_PCE: {
  1914. enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
  1915. memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
  1916. if ((err = decode_pce(avctx, &ac->m4ac, new_che_pos, gb)))
  1917. break;
  1918. if (ac->output_configured > OC_TRIAL_PCE)
  1919. av_log(avctx, AV_LOG_ERROR,
  1920. "Not evaluating a further program_config_element as this construct is dubious at best.\n");
  1921. else
  1922. err = output_configure(ac, ac->che_pos, new_che_pos, 0, OC_TRIAL_PCE);
  1923. break;
  1924. }
  1925. case TYPE_FIL:
  1926. if (elem_id == 15)
  1927. elem_id += get_bits(gb, 8) - 1;
  1928. if (get_bits_left(gb) < 8 * elem_id) {
  1929. av_log(avctx, AV_LOG_ERROR, overread_err);
  1930. return -1;
  1931. }
  1932. while (elem_id > 0)
  1933. elem_id -= decode_extension_payload(ac, gb, elem_id, che_prev, elem_type_prev);
  1934. err = 0; /* FIXME */
  1935. break;
  1936. default:
  1937. err = -1; /* should not happen, but keeps compiler happy */
  1938. break;
  1939. }
  1940. che_prev = che;
  1941. elem_type_prev = elem_type;
  1942. if (err)
  1943. return err;
  1944. if (get_bits_left(gb) < 3) {
  1945. av_log(avctx, AV_LOG_ERROR, overread_err);
  1946. return -1;
  1947. }
  1948. }
  1949. spectral_to_sample(ac);
  1950. multiplier = (ac->m4ac.sbr == 1) ? ac->m4ac.ext_sample_rate > ac->m4ac.sample_rate : 0;
  1951. samples <<= multiplier;
  1952. if (ac->output_configured < OC_LOCKED) {
  1953. avctx->sample_rate = ac->m4ac.sample_rate << multiplier;
  1954. avctx->frame_size = samples;
  1955. }
  1956. data_size_tmp = samples * avctx->channels *
  1957. av_get_bytes_per_sample(avctx->sample_fmt);
  1958. if (*data_size < data_size_tmp) {
  1959. av_log(avctx, AV_LOG_ERROR,
  1960. "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
  1961. *data_size, data_size_tmp);
  1962. return -1;
  1963. }
  1964. *data_size = data_size_tmp;
  1965. if (samples) {
  1966. if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT)
  1967. ac->fmt_conv.float_interleave(data, (const float **)ac->output_data,
  1968. samples, avctx->channels);
  1969. else
  1970. ac->fmt_conv.float_to_int16_interleave(data, (const float **)ac->output_data,
  1971. samples, avctx->channels);
  1972. }
  1973. if (ac->output_configured)
  1974. ac->output_configured = OC_LOCKED;
  1975. return 0;
  1976. }
  1977. static int aac_decode_frame(AVCodecContext *avctx, void *data,
  1978. int *data_size, AVPacket *avpkt)
  1979. {
  1980. const uint8_t *buf = avpkt->data;
  1981. int buf_size = avpkt->size;
  1982. GetBitContext gb;
  1983. int buf_consumed;
  1984. int buf_offset;
  1985. int err;
  1986. init_get_bits(&gb, buf, buf_size * 8);
  1987. if ((err = aac_decode_frame_int(avctx, data, data_size, &gb)) < 0)
  1988. return err;
  1989. buf_consumed = (get_bits_count(&gb) + 7) >> 3;
  1990. for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
  1991. if (buf[buf_offset])
  1992. break;
  1993. return buf_size > buf_offset ? buf_consumed : buf_size;
  1994. }
  1995. static av_cold int aac_decode_close(AVCodecContext *avctx)
  1996. {
  1997. AACContext *ac = avctx->priv_data;
  1998. int i, type;
  1999. for (i = 0; i < MAX_ELEM_ID; i++) {
  2000. for (type = 0; type < 4; type++) {
  2001. if (ac->che[type][i])
  2002. ff_aac_sbr_ctx_close(&ac->che[type][i]->sbr);
  2003. av_freep(&ac->che[type][i]);
  2004. }
  2005. }
  2006. ff_mdct_end(&ac->mdct);
  2007. ff_mdct_end(&ac->mdct_small);
  2008. ff_mdct_end(&ac->mdct_ltp);
  2009. return 0;
  2010. }
  2011. #define LOAS_SYNC_WORD 0x2b7 ///< 11 bits LOAS sync word
  2012. struct LATMContext {
  2013. AACContext aac_ctx; ///< containing AACContext
  2014. int initialized; ///< initilized after a valid extradata was seen
  2015. // parser data
  2016. int audio_mux_version_A; ///< LATM syntax version
  2017. int frame_length_type; ///< 0/1 variable/fixed frame length
  2018. int frame_length; ///< frame length for fixed frame length
  2019. };
  2020. static inline uint32_t latm_get_value(GetBitContext *b)
  2021. {
  2022. int length = get_bits(b, 2);
  2023. return get_bits_long(b, (length+1)*8);
  2024. }
  2025. static int latm_decode_audio_specific_config(struct LATMContext *latmctx,
  2026. GetBitContext *gb)
  2027. {
  2028. AVCodecContext *avctx = latmctx->aac_ctx.avctx;
  2029. MPEG4AudioConfig m4ac;
  2030. int config_start_bit = get_bits_count(gb);
  2031. int bits_consumed, esize;
  2032. if (config_start_bit % 8) {
  2033. av_log_missing_feature(latmctx->aac_ctx.avctx, "audio specific "
  2034. "config not byte aligned.\n", 1);
  2035. return AVERROR_INVALIDDATA;
  2036. } else {
  2037. bits_consumed =
  2038. decode_audio_specific_config(NULL, avctx, &m4ac,
  2039. gb->buffer + (config_start_bit / 8),
  2040. get_bits_left(gb) / 8);
  2041. if (bits_consumed < 0)
  2042. return AVERROR_INVALIDDATA;
  2043. esize = (bits_consumed+7) / 8;
  2044. if (avctx->extradata_size <= esize) {
  2045. av_free(avctx->extradata);
  2046. avctx->extradata = av_malloc(esize + FF_INPUT_BUFFER_PADDING_SIZE);
  2047. if (!avctx->extradata)
  2048. return AVERROR(ENOMEM);
  2049. }
  2050. avctx->extradata_size = esize;
  2051. memcpy(avctx->extradata, gb->buffer + (config_start_bit/8), esize);
  2052. memset(avctx->extradata+esize, 0, FF_INPUT_BUFFER_PADDING_SIZE);
  2053. skip_bits_long(gb, bits_consumed);
  2054. }
  2055. return bits_consumed;
  2056. }
  2057. static int read_stream_mux_config(struct LATMContext *latmctx,
  2058. GetBitContext *gb)
  2059. {
  2060. int ret, audio_mux_version = get_bits(gb, 1);
  2061. latmctx->audio_mux_version_A = 0;
  2062. if (audio_mux_version)
  2063. latmctx->audio_mux_version_A = get_bits(gb, 1);
  2064. if (!latmctx->audio_mux_version_A) {
  2065. if (audio_mux_version)
  2066. latm_get_value(gb); // taraFullness
  2067. skip_bits(gb, 1); // allStreamSameTimeFraming
  2068. skip_bits(gb, 6); // numSubFrames
  2069. // numPrograms
  2070. if (get_bits(gb, 4)) { // numPrograms
  2071. av_log_missing_feature(latmctx->aac_ctx.avctx,
  2072. "multiple programs are not supported\n", 1);
  2073. return AVERROR_PATCHWELCOME;
  2074. }
  2075. // for each program (which there is only on in DVB)
  2076. // for each layer (which there is only on in DVB)
  2077. if (get_bits(gb, 3)) { // numLayer
  2078. av_log_missing_feature(latmctx->aac_ctx.avctx,
  2079. "multiple layers are not supported\n", 1);
  2080. return AVERROR_PATCHWELCOME;
  2081. }
  2082. // for all but first stream: use_same_config = get_bits(gb, 1);
  2083. if (!audio_mux_version) {
  2084. if ((ret = latm_decode_audio_specific_config(latmctx, gb)) < 0)
  2085. return ret;
  2086. } else {
  2087. int ascLen = latm_get_value(gb);
  2088. if ((ret = latm_decode_audio_specific_config(latmctx, gb)) < 0)
  2089. return ret;
  2090. ascLen -= ret;
  2091. skip_bits_long(gb, ascLen);
  2092. }
  2093. latmctx->frame_length_type = get_bits(gb, 3);
  2094. switch (latmctx->frame_length_type) {
  2095. case 0:
  2096. skip_bits(gb, 8); // latmBufferFullness
  2097. break;
  2098. case 1:
  2099. latmctx->frame_length = get_bits(gb, 9);
  2100. break;
  2101. case 3:
  2102. case 4:
  2103. case 5:
  2104. skip_bits(gb, 6); // CELP frame length table index
  2105. break;
  2106. case 6:
  2107. case 7:
  2108. skip_bits(gb, 1); // HVXC frame length table index
  2109. break;
  2110. }
  2111. if (get_bits(gb, 1)) { // other data
  2112. if (audio_mux_version) {
  2113. latm_get_value(gb); // other_data_bits
  2114. } else {
  2115. int esc;
  2116. do {
  2117. esc = get_bits(gb, 1);
  2118. skip_bits(gb, 8);
  2119. } while (esc);
  2120. }
  2121. }
  2122. if (get_bits(gb, 1)) // crc present
  2123. skip_bits(gb, 8); // config_crc
  2124. }
  2125. return 0;
  2126. }
  2127. static int read_payload_length_info(struct LATMContext *ctx, GetBitContext *gb)
  2128. {
  2129. uint8_t tmp;
  2130. if (ctx->frame_length_type == 0) {
  2131. int mux_slot_length = 0;
  2132. do {
  2133. tmp = get_bits(gb, 8);
  2134. mux_slot_length += tmp;
  2135. } while (tmp == 255);
  2136. return mux_slot_length;
  2137. } else if (ctx->frame_length_type == 1) {
  2138. return ctx->frame_length;
  2139. } else if (ctx->frame_length_type == 3 ||
  2140. ctx->frame_length_type == 5 ||
  2141. ctx->frame_length_type == 7) {
  2142. skip_bits(gb, 2); // mux_slot_length_coded
  2143. }
  2144. return 0;
  2145. }
  2146. static int read_audio_mux_element(struct LATMContext *latmctx,
  2147. GetBitContext *gb)
  2148. {
  2149. int err;
  2150. uint8_t use_same_mux = get_bits(gb, 1);
  2151. if (!use_same_mux) {
  2152. if ((err = read_stream_mux_config(latmctx, gb)) < 0)
  2153. return err;
  2154. } else if (!latmctx->aac_ctx.avctx->extradata) {
  2155. av_log(latmctx->aac_ctx.avctx, AV_LOG_DEBUG,
  2156. "no decoder config found\n");
  2157. return AVERROR(EAGAIN);
  2158. }
  2159. if (latmctx->audio_mux_version_A == 0) {
  2160. int mux_slot_length_bytes = read_payload_length_info(latmctx, gb);
  2161. if (mux_slot_length_bytes * 8 > get_bits_left(gb)) {
  2162. av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR, "incomplete frame\n");
  2163. return AVERROR_INVALIDDATA;
  2164. } else if (mux_slot_length_bytes * 8 + 256 < get_bits_left(gb)) {
  2165. av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR,
  2166. "frame length mismatch %d << %d\n",
  2167. mux_slot_length_bytes * 8, get_bits_left(gb));
  2168. return AVERROR_INVALIDDATA;
  2169. }
  2170. }
  2171. return 0;
  2172. }
  2173. static int latm_decode_frame(AVCodecContext *avctx, void *out, int *out_size,
  2174. AVPacket *avpkt)
  2175. {
  2176. struct LATMContext *latmctx = avctx->priv_data;
  2177. int muxlength, err;
  2178. GetBitContext gb;
  2179. if (avpkt->size == 0)
  2180. return 0;
  2181. init_get_bits(&gb, avpkt->data, avpkt->size * 8);
  2182. // check for LOAS sync word
  2183. if (get_bits(&gb, 11) != LOAS_SYNC_WORD)
  2184. return AVERROR_INVALIDDATA;
  2185. muxlength = get_bits(&gb, 13) + 3;
  2186. // not enough data, the parser should have sorted this
  2187. if (muxlength > avpkt->size)
  2188. return AVERROR_INVALIDDATA;
  2189. if ((err = read_audio_mux_element(latmctx, &gb)) < 0)
  2190. return err;
  2191. if (!latmctx->initialized) {
  2192. if (!avctx->extradata) {
  2193. *out_size = 0;
  2194. return avpkt->size;
  2195. } else {
  2196. aac_decode_close(avctx);
  2197. if ((err = aac_decode_init(avctx)) < 0)
  2198. return err;
  2199. latmctx->initialized = 1;
  2200. }
  2201. }
  2202. if (show_bits(&gb, 12) == 0xfff) {
  2203. av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR,
  2204. "ADTS header detected, probably as result of configuration "
  2205. "misparsing\n");
  2206. return AVERROR_INVALIDDATA;
  2207. }
  2208. if ((err = aac_decode_frame_int(avctx, out, out_size, &gb)) < 0)
  2209. return err;
  2210. return muxlength;
  2211. }
  2212. av_cold static int latm_decode_init(AVCodecContext *avctx)
  2213. {
  2214. struct LATMContext *latmctx = avctx->priv_data;
  2215. int ret;
  2216. ret = aac_decode_init(avctx);
  2217. if (avctx->extradata_size > 0) {
  2218. latmctx->initialized = !ret;
  2219. } else {
  2220. latmctx->initialized = 0;
  2221. }
  2222. return ret;
  2223. }
  2224. AVCodec ff_aac_decoder = {
  2225. "aac",
  2226. AVMEDIA_TYPE_AUDIO,
  2227. CODEC_ID_AAC,
  2228. sizeof(AACContext),
  2229. aac_decode_init,
  2230. NULL,
  2231. aac_decode_close,
  2232. aac_decode_frame,
  2233. .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
  2234. .sample_fmts = (const enum AVSampleFormat[]) {
  2235. AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
  2236. },
  2237. .channel_layouts = aac_channel_layout,
  2238. };
  2239. /*
  2240. Note: This decoder filter is intended to decode LATM streams transferred
  2241. in MPEG transport streams which only contain one program.
  2242. To do a more complex LATM demuxing a separate LATM demuxer should be used.
  2243. */
  2244. AVCodec ff_aac_latm_decoder = {
  2245. .name = "aac_latm",
  2246. .type = AVMEDIA_TYPE_AUDIO,
  2247. .id = CODEC_ID_AAC_LATM,
  2248. .priv_data_size = sizeof(struct LATMContext),
  2249. .init = latm_decode_init,
  2250. .close = aac_decode_close,
  2251. .decode = latm_decode_frame,
  2252. .long_name = NULL_IF_CONFIG_SMALL("AAC LATM (Advanced Audio Codec LATM syntax)"),
  2253. .sample_fmts = (const enum AVSampleFormat[]) {
  2254. AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
  2255. },
  2256. .channel_layouts = aac_channel_layout,
  2257. };