alsdec.c
Go to the documentation of this file.
1 /*
2  * MPEG-4 ALS decoder
3  * Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ googlemail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * MPEG-4 ALS decoder
25  * @author Thilo Borgmann <thilo.borgmann _at_ googlemail.com>
26  */
27 
28 
29 //#define DEBUG
30 
31 
32 #include "avcodec.h"
33 #include "get_bits.h"
34 #include "unary.h"
35 #include "mpeg4audio.h"
36 #include "bytestream.h"
37 #include "bgmc.h"
38 #include "dsputil.h"
39 #include "internal.h"
40 #include "libavutil/samplefmt.h"
41 #include "libavutil/crc.h"
42 
43 #include <stdint.h>
44 
45 /** Rice parameters and corresponding index offsets for decoding the
46  * indices of scaled PARCOR values. The table chosen is set globally
47  * by the encoder and stored in ALSSpecificConfig.
48  */
49 static const int8_t parcor_rice_table[3][20][2] = {
50  { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4},
51  { 12, 3}, { -7, 3}, { 9, 3}, { -5, 3}, { 6, 3},
52  { -4, 3}, { 3, 3}, { -3, 2}, { 3, 2}, { -2, 2},
53  { 3, 2}, { -1, 2}, { 2, 2}, { -1, 2}, { 2, 2} },
54  { {-58, 3}, {-42, 4}, {-46, 4}, { 37, 5}, {-36, 4},
55  { 29, 4}, {-29, 4}, { 25, 4}, {-23, 4}, { 20, 4},
56  {-17, 4}, { 16, 4}, {-12, 4}, { 12, 3}, {-10, 4},
57  { 7, 3}, { -4, 4}, { 3, 3}, { -1, 3}, { 1, 3} },
58  { {-59, 3}, {-45, 5}, {-50, 4}, { 38, 4}, {-39, 4},
59  { 32, 4}, {-30, 4}, { 25, 3}, {-23, 3}, { 20, 3},
60  {-20, 3}, { 16, 3}, {-13, 3}, { 10, 3}, { -7, 3},
61  { 3, 3}, { 0, 3}, { -1, 3}, { 2, 3}, { -1, 2} }
62 };
63 
64 
65 /** Scaled PARCOR values used for the first two PARCOR coefficients.
66  * To be indexed by the Rice coded indices.
67  * Generated by: parcor_scaled_values[i] = 32 + ((i * (i+1)) << 7) - (1 << 20)
68  * Actual values are divided by 32 in order to be stored in 16 bits.
69  */
70 static const int16_t parcor_scaled_values[] = {
71  -1048544 / 32, -1048288 / 32, -1047776 / 32, -1047008 / 32,
72  -1045984 / 32, -1044704 / 32, -1043168 / 32, -1041376 / 32,
73  -1039328 / 32, -1037024 / 32, -1034464 / 32, -1031648 / 32,
74  -1028576 / 32, -1025248 / 32, -1021664 / 32, -1017824 / 32,
75  -1013728 / 32, -1009376 / 32, -1004768 / 32, -999904 / 32,
76  -994784 / 32, -989408 / 32, -983776 / 32, -977888 / 32,
77  -971744 / 32, -965344 / 32, -958688 / 32, -951776 / 32,
78  -944608 / 32, -937184 / 32, -929504 / 32, -921568 / 32,
79  -913376 / 32, -904928 / 32, -896224 / 32, -887264 / 32,
80  -878048 / 32, -868576 / 32, -858848 / 32, -848864 / 32,
81  -838624 / 32, -828128 / 32, -817376 / 32, -806368 / 32,
82  -795104 / 32, -783584 / 32, -771808 / 32, -759776 / 32,
83  -747488 / 32, -734944 / 32, -722144 / 32, -709088 / 32,
84  -695776 / 32, -682208 / 32, -668384 / 32, -654304 / 32,
85  -639968 / 32, -625376 / 32, -610528 / 32, -595424 / 32,
86  -580064 / 32, -564448 / 32, -548576 / 32, -532448 / 32,
87  -516064 / 32, -499424 / 32, -482528 / 32, -465376 / 32,
88  -447968 / 32, -430304 / 32, -412384 / 32, -394208 / 32,
89  -375776 / 32, -357088 / 32, -338144 / 32, -318944 / 32,
90  -299488 / 32, -279776 / 32, -259808 / 32, -239584 / 32,
91  -219104 / 32, -198368 / 32, -177376 / 32, -156128 / 32,
92  -134624 / 32, -112864 / 32, -90848 / 32, -68576 / 32,
93  -46048 / 32, -23264 / 32, -224 / 32, 23072 / 32,
94  46624 / 32, 70432 / 32, 94496 / 32, 118816 / 32,
95  143392 / 32, 168224 / 32, 193312 / 32, 218656 / 32,
96  244256 / 32, 270112 / 32, 296224 / 32, 322592 / 32,
97  349216 / 32, 376096 / 32, 403232 / 32, 430624 / 32,
98  458272 / 32, 486176 / 32, 514336 / 32, 542752 / 32,
99  571424 / 32, 600352 / 32, 629536 / 32, 658976 / 32,
100  688672 / 32, 718624 / 32, 748832 / 32, 779296 / 32,
101  810016 / 32, 840992 / 32, 872224 / 32, 903712 / 32,
102  935456 / 32, 967456 / 32, 999712 / 32, 1032224 / 32
103 };
104 
105 
106 /** Gain values of p(0) for long-term prediction.
107  * To be indexed by the Rice coded indices.
108  */
109 static const uint8_t ltp_gain_values [4][4] = {
110  { 0, 8, 16, 24},
111  {32, 40, 48, 56},
112  {64, 70, 76, 82},
113  {88, 92, 96, 100}
114 };
115 
116 
117 /** Inter-channel weighting factors for multi-channel correlation.
118  * To be indexed by the Rice coded indices.
119  */
120 static const int16_t mcc_weightings[] = {
121  204, 192, 179, 166, 153, 140, 128, 115,
122  102, 89, 76, 64, 51, 38, 25, 12,
123  0, -12, -25, -38, -51, -64, -76, -89,
124  -102, -115, -128, -140, -153, -166, -179, -192
125 };
126 
127 
128 /** Tail codes used in arithmetic coding using block Gilbert-Moore codes.
129  */
130 static const uint8_t tail_code[16][6] = {
131  { 74, 44, 25, 13, 7, 3},
132  { 68, 42, 24, 13, 7, 3},
133  { 58, 39, 23, 13, 7, 3},
134  {126, 70, 37, 19, 10, 5},
135  {132, 70, 37, 20, 10, 5},
136  {124, 70, 38, 20, 10, 5},
137  {120, 69, 37, 20, 11, 5},
138  {116, 67, 37, 20, 11, 5},
139  {108, 66, 36, 20, 10, 5},
140  {102, 62, 36, 20, 10, 5},
141  { 88, 58, 34, 19, 10, 5},
142  {162, 89, 49, 25, 13, 7},
143  {156, 87, 49, 26, 14, 7},
144  {150, 86, 47, 26, 14, 7},
145  {142, 84, 47, 26, 14, 7},
146  {131, 79, 46, 26, 14, 7}
147 };
148 
149 
150 enum RA_Flag {
151  RA_FLAG_NONE,
152  RA_FLAG_FRAMES,
153  RA_FLAG_HEADER
154 };
155 
156 
157 typedef struct {
158  uint32_t samples; ///< number of samples, 0xFFFFFFFF if unknown
159  int resolution; ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
160  int floating; ///< 1 = IEEE 32-bit floating-point, 0 = integer
161  int msb_first; ///< 1 = original CRC calculated on big-endian system, 0 = little-endian
162  int frame_length; ///< frame length for each frame (last frame may differ)
163  int ra_distance; ///< distance between RA frames (in frames, 0...255)
164  enum RA_Flag ra_flag; ///< indicates where the size of ra units is stored
165  int adapt_order; ///< adaptive order: 1 = on, 0 = off
166  int coef_table; ///< table index of Rice code parameters
167  int long_term_prediction; ///< long term prediction (LTP): 1 = on, 0 = off
168  int max_order; ///< maximum prediction order (0..1023)
169  int block_switching; ///< number of block switching levels
170  int bgmc; ///< "Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
171  int sb_part; ///< sub-block partition
172  int joint_stereo; ///< joint stereo: 1 = on, 0 = off
173  int mc_coding; ///< extended inter-channel coding (multi channel coding): 1 = on, 0 = off
174  int chan_config; ///< indicates that a chan_config_info field is present
175  int chan_sort; ///< channel rearrangement: 1 = on, 0 = off
176  int rlslms; ///< use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
177  int chan_config_info; ///< mapping of channels to loudspeaker locations. Unused until setting channel configuration is implemented.
178  int *chan_pos; ///< original channel positions
179  int crc_enabled; ///< enable Cyclic Redundancy Checksum
180 } ALSSpecificConfig;
181 
182 
183 typedef struct {
184  int stop_flag;
185  int master_channel;
186  int time_diff_flag;
187  int time_diff_sign;
188  int time_diff_index;
189  int weighting[6];
190 } ALSChannelData;
191 
192 
193 typedef struct {
194  AVCodecContext *avctx;
195  ALSSpecificConfig sconf;
196  GetBitContext gb;
197  DSPContext dsp;
198  const AVCRC *crc_table;
199  uint32_t crc_org; ///< CRC value of the original input data
200  uint32_t crc; ///< CRC value calculated from decoded data
201  unsigned int cur_frame_length; ///< length of the current frame to decode
202  unsigned int frame_id; ///< the frame ID / number of the current frame
203  unsigned int js_switch; ///< if true, joint-stereo decoding is enforced
204  unsigned int cs_switch; ///< if true, channel rearrangement is done
205  unsigned int num_blocks; ///< number of blocks used in the current frame
206  unsigned int s_max; ///< maximum Rice parameter allowed in entropy coding
207  uint8_t *bgmc_lut; ///< pointer at lookup tables used for BGMC
208  int *bgmc_lut_status; ///< pointer at lookup table status flags used for BGMC
209  int ltp_lag_length; ///< number of bits used for ltp lag value
210  int *const_block; ///< contains const_block flags for all channels
211  unsigned int *shift_lsbs; ///< contains shift_lsbs flags for all channels
212  unsigned int *opt_order; ///< contains opt_order flags for all channels
213  int *store_prev_samples; ///< contains store_prev_samples flags for all channels
214  int *use_ltp; ///< contains use_ltp flags for all channels
215  int *ltp_lag; ///< contains ltp lag values for all channels
216  int **ltp_gain; ///< gain values for ltp 5-tap filter for a channel
217  int *ltp_gain_buffer; ///< contains all gain values for ltp 5-tap filter
218  int32_t **quant_cof; ///< quantized parcor coefficients for a channel
219  int32_t *quant_cof_buffer; ///< contains all quantized parcor coefficients
220  int32_t **lpc_cof; ///< coefficients of the direct form prediction filter for a channel
221  int32_t *lpc_cof_buffer; ///< contains all coefficients of the direct form prediction filter
222  int32_t *lpc_cof_reversed_buffer; ///< temporary buffer to set up a reversed versio of lpc_cof_buffer
223  ALSChannelData **chan_data; ///< channel data for multi-channel correlation
224  ALSChannelData *chan_data_buffer; ///< contains channel data for all channels
225  int *reverted_channels; ///< stores a flag for each reverted channel
226  int32_t *prev_raw_samples; ///< contains unshifted raw samples from the previous block
227  int32_t **raw_samples; ///< decoded raw samples for each channel
228  int32_t *raw_buffer; ///< contains all decoded raw samples including carryover samples
229  uint8_t *crc_buffer; ///< buffer of byte order corrected samples used for CRC check
230 } ALSDecContext;
231 
232 
233 typedef struct {
234  unsigned int block_length; ///< number of samples within the block
235  unsigned int ra_block; ///< if true, this is a random access block
236  int *const_block; ///< if true, this is a constant value block
237  int js_blocks; ///< true if this block contains a difference signal
238  unsigned int *shift_lsbs; ///< shift of values for this block
239  unsigned int *opt_order; ///< prediction order of this block
240  int *store_prev_samples;///< if true, carryover samples have to be stored
241  int *use_ltp; ///< if true, long-term prediction is used
242  int *ltp_lag; ///< lag value for long-term prediction
243  int *ltp_gain; ///< gain values for ltp 5-tap filter
244  int32_t *quant_cof; ///< quantized parcor coefficients
245  int32_t *lpc_cof; ///< coefficients of the direct form prediction
246  int32_t *raw_samples; ///< decoded raw samples / residuals for this block
247  int32_t *prev_raw_samples; ///< contains unshifted raw samples from the previous block
248  int32_t *raw_other; ///< decoded raw samples of the other channel of a channel pair
249 } ALSBlockData;
250 
251 
252 static av_cold void dprint_specific_config(ALSDecContext *ctx)
253 {
254 #ifdef DEBUG
255  AVCodecContext *avctx = ctx->avctx;
256  ALSSpecificConfig *sconf = &ctx->sconf;
257 
258  av_dlog(avctx, "resolution = %i\n", sconf->resolution);
259  av_dlog(avctx, "floating = %i\n", sconf->floating);
260  av_dlog(avctx, "frame_length = %i\n", sconf->frame_length);
261  av_dlog(avctx, "ra_distance = %i\n", sconf->ra_distance);
262  av_dlog(avctx, "ra_flag = %i\n", sconf->ra_flag);
263  av_dlog(avctx, "adapt_order = %i\n", sconf->adapt_order);
264  av_dlog(avctx, "coef_table = %i\n", sconf->coef_table);
265  av_dlog(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction);
266  av_dlog(avctx, "max_order = %i\n", sconf->max_order);
267  av_dlog(avctx, "block_switching = %i\n", sconf->block_switching);
268  av_dlog(avctx, "bgmc = %i\n", sconf->bgmc);
269  av_dlog(avctx, "sb_part = %i\n", sconf->sb_part);
270  av_dlog(avctx, "joint_stereo = %i\n", sconf->joint_stereo);
271  av_dlog(avctx, "mc_coding = %i\n", sconf->mc_coding);
272  av_dlog(avctx, "chan_config = %i\n", sconf->chan_config);
273  av_dlog(avctx, "chan_sort = %i\n", sconf->chan_sort);
274  av_dlog(avctx, "RLSLMS = %i\n", sconf->rlslms);
275  av_dlog(avctx, "chan_config_info = %i\n", sconf->chan_config_info);
276 #endif
277 }
278 
279 
280 /** Read an ALSSpecificConfig from a buffer into the output struct.
281  */
282 static av_cold int read_specific_config(ALSDecContext *ctx)
283 {
284  GetBitContext gb;
285  uint64_t ht_size;
286  int i, config_offset;
287  MPEG4AudioConfig m4ac;
288  ALSSpecificConfig *sconf = &ctx->sconf;
289  AVCodecContext *avctx = ctx->avctx;
290  uint32_t als_id, header_size, trailer_size;
291  int ret;
292 
293  if ((ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size)) < 0)
294  return ret;
295 
296  config_offset = avpriv_mpeg4audio_get_config(&m4ac, avctx->extradata,
297  avctx->extradata_size * 8, 1);
298 
299  if (config_offset < 0)
300  return -1;
301 
302  skip_bits_long(&gb, config_offset);
303 
304  if (get_bits_left(&gb) < (30 << 3))
305  return -1;
306 
307  // read the fixed items
308  als_id = get_bits_long(&gb, 32);
309  avctx->sample_rate = m4ac.sample_rate;
310  skip_bits_long(&gb, 32); // sample rate already known
311  sconf->samples = get_bits_long(&gb, 32);
312  avctx->channels = m4ac.channels;
313  skip_bits(&gb, 16); // number of channels already known
314  skip_bits(&gb, 3); // skip file_type
315  sconf->resolution = get_bits(&gb, 3);
316  sconf->floating = get_bits1(&gb);
317  sconf->msb_first = get_bits1(&gb);
318  sconf->frame_length = get_bits(&gb, 16) + 1;
319  sconf->ra_distance = get_bits(&gb, 8);
320  sconf->ra_flag = get_bits(&gb, 2);
321  sconf->adapt_order = get_bits1(&gb);
322  sconf->coef_table = get_bits(&gb, 2);
323  sconf->long_term_prediction = get_bits1(&gb);
324  sconf->max_order = get_bits(&gb, 10);
325  sconf->block_switching = get_bits(&gb, 2);
326  sconf->bgmc = get_bits1(&gb);
327  sconf->sb_part = get_bits1(&gb);
328  sconf->joint_stereo = get_bits1(&gb);
329  sconf->mc_coding = get_bits1(&gb);
330  sconf->chan_config = get_bits1(&gb);
331  sconf->chan_sort = get_bits1(&gb);
332  sconf->crc_enabled = get_bits1(&gb);
333  sconf->rlslms = get_bits1(&gb);
334  skip_bits(&gb, 5); // skip 5 reserved bits
335  skip_bits1(&gb); // skip aux_data_enabled
336 
337 
338  // check for ALSSpecificConfig struct
339  if (als_id != MKBETAG('A','L','S','\0'))
340  return -1;
341 
342  ctx->cur_frame_length = sconf->frame_length;
343 
344  // read channel config
345  if (sconf->chan_config)
346  sconf->chan_config_info = get_bits(&gb, 16);
347  // TODO: use this to set avctx->channel_layout
348 
349 
350  // read channel sorting
351  if (sconf->chan_sort && avctx->channels > 1) {
352  int chan_pos_bits = av_ceil_log2(avctx->channels);
353  int bits_needed = avctx->channels * chan_pos_bits + 7;
354  if (get_bits_left(&gb) < bits_needed)
355  return -1;
356 
357  if (!(sconf->chan_pos = av_malloc(avctx->channels * sizeof(*sconf->chan_pos))))
358  return AVERROR(ENOMEM);
359 
360  ctx->cs_switch = 1;
361 
362  for (i = 0; i < avctx->channels; i++) {
363  int idx;
364 
365  idx = get_bits(&gb, chan_pos_bits);
366  if (idx >= avctx->channels) {
367  av_log(avctx, AV_LOG_WARNING, "Invalid channel reordering.\n");
368  ctx->cs_switch = 0;
369  break;
370  }
371  sconf->chan_pos[idx] = i;
372  }
373 
374  align_get_bits(&gb);
375  }
376 
377 
378  // read fixed header and trailer sizes,
379  // if size = 0xFFFFFFFF then there is no data field!
380  if (get_bits_left(&gb) < 64)
381  return -1;
382 
383  header_size = get_bits_long(&gb, 32);
384  trailer_size = get_bits_long(&gb, 32);
385  if (header_size == 0xFFFFFFFF)
386  header_size = 0;
387  if (trailer_size == 0xFFFFFFFF)
388  trailer_size = 0;
389 
390  ht_size = ((int64_t)(header_size) + (int64_t)(trailer_size)) << 3;
391 
392 
393  // skip the header and trailer data
394  if (get_bits_left(&gb) < ht_size)
395  return -1;
396 
397  if (ht_size > INT32_MAX)
398  return -1;
399 
400  skip_bits_long(&gb, ht_size);
401 
402 
403  // initialize CRC calculation
404  if (sconf->crc_enabled) {
405  if (get_bits_left(&gb) < 32)
406  return -1;
407 
408  if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
409  ctx->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
410  ctx->crc = 0xFFFFFFFF;
411  ctx->crc_org = ~get_bits_long(&gb, 32);
412  } else
413  skip_bits_long(&gb, 32);
414  }
415 
416 
417  // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data)
418 
419  dprint_specific_config(ctx);
420 
421  return 0;
422 }
423 
424 
425 /** Check the ALSSpecificConfig for unsupported features.
426  */
427 static int check_specific_config(ALSDecContext *ctx)
428 {
429  ALSSpecificConfig *sconf = &ctx->sconf;
430  int error = 0;
431 
432  // report unsupported feature and set error value
433  #define MISSING_ERR(cond, str, errval) \
434  { \
435  if (cond) { \
436  avpriv_report_missing_feature(ctx->avctx, \
437  str); \
438  error = errval; \
439  } \
440  }
441 
442  MISSING_ERR(sconf->floating, "Floating point decoding", AVERROR_PATCHWELCOME);
443  MISSING_ERR(sconf->rlslms, "Adaptive RLS-LMS prediction", AVERROR_PATCHWELCOME);
444 
445  return error;
446 }
447 
448 
449 /** Parse the bs_info field to extract the block partitioning used in
450  * block switching mode, refer to ISO/IEC 14496-3, section 11.6.2.
451  */
452 static void parse_bs_info(const uint32_t bs_info, unsigned int n,
453  unsigned int div, unsigned int **div_blocks,
454  unsigned int *num_blocks)
455 {
456  if (n < 31 && ((bs_info << n) & 0x40000000)) {
457  // if the level is valid and the investigated bit n is set
458  // then recursively check both children at bits (2n+1) and (2n+2)
459  n *= 2;
460  div += 1;
461  parse_bs_info(bs_info, n + 1, div, div_blocks, num_blocks);
462  parse_bs_info(bs_info, n + 2, div, div_blocks, num_blocks);
463  } else {
464  // else the bit is not set or the last level has been reached
465  // (bit implicitly not set)
466  **div_blocks = div;
467  (*div_blocks)++;
468  (*num_blocks)++;
469  }
470 }
471 
472 
473 /** Read and decode a Rice codeword.
474  */
475 static int32_t decode_rice(GetBitContext *gb, unsigned int k)
476 {
477  int max = get_bits_left(gb) - k;
478  int q = get_unary(gb, 0, max);
479  int r = k ? get_bits1(gb) : !(q & 1);
480 
481  if (k > 1) {
482  q <<= (k - 1);
483  q += get_bits_long(gb, k - 1);
484  } else if (!k) {
485  q >>= 1;
486  }
487  return r ? q : ~q;
488 }
489 
490 
491 /** Convert PARCOR coefficient k to direct filter coefficient.
492  */
493 static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
494 {
495  int i, j;
496 
497  for (i = 0, j = k - 1; i < j; i++, j--) {
498  int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
499  cof[j] += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);
500  cof[i] += tmp1;
501  }
502  if (i == j)
503  cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
504 
505  cof[k] = par[k];
506 }
507 
508 
509 /** Read block switching field if necessary and set actual block sizes.
510  * Also assure that the block sizes of the last frame correspond to the
511  * actual number of samples.
512  */
513 static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks,
514  uint32_t *bs_info)
515 {
516  ALSSpecificConfig *sconf = &ctx->sconf;
517  GetBitContext *gb = &ctx->gb;
518  unsigned int *ptr_div_blocks = div_blocks;
519  unsigned int b;
520 
521  if (sconf->block_switching) {
522  unsigned int bs_info_len = 1 << (sconf->block_switching + 2);
523  *bs_info = get_bits_long(gb, bs_info_len);
524  *bs_info <<= (32 - bs_info_len);
525  }
526 
527  ctx->num_blocks = 0;
528  parse_bs_info(*bs_info, 0, 0, &ptr_div_blocks, &ctx->num_blocks);
529 
530  // The last frame may have an overdetermined block structure given in
531  // the bitstream. In that case the defined block structure would need
532  // more samples than available to be consistent.
533  // The block structure is actually used but the block sizes are adapted
534  // to fit the actual number of available samples.
535  // Example: 5 samples, 2nd level block sizes: 2 2 2 2.
536  // This results in the actual block sizes: 2 2 1 0.
537  // This is not specified in 14496-3 but actually done by the reference
538  // codec RM22 revision 2.
539  // This appears to happen in case of an odd number of samples in the last
540  // frame which is actually not allowed by the block length switching part
541  // of 14496-3.
542  // The ALS conformance files feature an odd number of samples in the last
543  // frame.
544 
545  for (b = 0; b < ctx->num_blocks; b++)
546  div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b];
547 
548  if (ctx->cur_frame_length != ctx->sconf.frame_length) {
549  unsigned int remaining = ctx->cur_frame_length;
550 
551  for (b = 0; b < ctx->num_blocks; b++) {
552  if (remaining <= div_blocks[b]) {
553  div_blocks[b] = remaining;
554  ctx->num_blocks = b + 1;
555  break;
556  }
557 
558  remaining -= div_blocks[b];
559  }
560  }
561 }
562 
563 
564 /** Read the block data for a constant block
565  */
566 static int read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
567 {
568  ALSSpecificConfig *sconf = &ctx->sconf;
569  AVCodecContext *avctx = ctx->avctx;
570  GetBitContext *gb = &ctx->gb;
571 
572  if (bd->block_length <= 0)
573  return AVERROR_INVALIDDATA;
574 
575  *bd->raw_samples = 0;
576  *bd->const_block = get_bits1(gb); // 1 = constant value, 0 = zero block (silence)
577  bd->js_blocks = get_bits1(gb);
578 
579  // skip 5 reserved bits
580  skip_bits(gb, 5);
581 
582  if (*bd->const_block) {
583  unsigned int const_val_bits = sconf->floating ? 24 : avctx->bits_per_raw_sample;
584  *bd->raw_samples = get_sbits_long(gb, const_val_bits);
585  }
586 
587  // ensure constant block decoding by reusing this field
588  *bd->const_block = 1;
589 
590  return 0;
591 }
592 
593 
594 /** Decode the block data for a constant block
595  */
596 static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
597 {
598  int smp = bd->block_length - 1;
599  int32_t val = *bd->raw_samples;
600  int32_t *dst = bd->raw_samples + 1;
601 
602  // write raw samples into buffer
603  for (; smp; smp--)
604  *dst++ = val;
605 }
606 
607 
608 /** Read the block data for a non-constant block
609  */
610 static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
611 {
612  ALSSpecificConfig *sconf = &ctx->sconf;
613  AVCodecContext *avctx = ctx->avctx;
614  GetBitContext *gb = &ctx->gb;
615  unsigned int k;
616  unsigned int s[8];
617  unsigned int sx[8];
618  unsigned int sub_blocks, log2_sub_blocks, sb_length;
619  unsigned int start = 0;
620  unsigned int opt_order;
621  int sb;
622  int32_t *quant_cof = bd->quant_cof;
623  int32_t *current_res;
624 
625 
626  // ensure variable block decoding by reusing this field
627  *bd->const_block = 0;
628 
629  *bd->opt_order = 1;
630  bd->js_blocks = get_bits1(gb);
631 
632  opt_order = *bd->opt_order;
633 
634  // determine the number of subblocks for entropy decoding
635  if (!sconf->bgmc && !sconf->sb_part) {
636  log2_sub_blocks = 0;
637  } else {
638  if (sconf->bgmc && sconf->sb_part)
639  log2_sub_blocks = get_bits(gb, 2);
640  else
641  log2_sub_blocks = 2 * get_bits1(gb);
642  }
643 
644  sub_blocks = 1 << log2_sub_blocks;
645 
646  // do not continue in case of a damaged stream since
647  // block_length must be evenly divisible by sub_blocks
648  if (bd->block_length & (sub_blocks - 1)) {
649  av_log(avctx, AV_LOG_WARNING,
650  "Block length is not evenly divisible by the number of subblocks.\n");
651  return -1;
652  }
653 
654  sb_length = bd->block_length >> log2_sub_blocks;
655 
656  if (sconf->bgmc) {
657  s[0] = get_bits(gb, 8 + (sconf->resolution > 1));
658  for (k = 1; k < sub_blocks; k++)
659  s[k] = s[k - 1] + decode_rice(gb, 2);
660 
661  for (k = 0; k < sub_blocks; k++) {
662  sx[k] = s[k] & 0x0F;
663  s [k] >>= 4;
664  }
665  } else {
666  s[0] = get_bits(gb, 4 + (sconf->resolution > 1));
667  for (k = 1; k < sub_blocks; k++)
668  s[k] = s[k - 1] + decode_rice(gb, 0);
669  }
670  for (k = 1; k < sub_blocks; k++)
671  if (s[k] > 32) {
672  av_log(avctx, AV_LOG_ERROR, "k invalid for rice code.\n");
673  return AVERROR_INVALIDDATA;
674  }
675 
676  if (get_bits1(gb))
677  *bd->shift_lsbs = get_bits(gb, 4) + 1;
678 
679  *bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || *bd->shift_lsbs;
680 
681 
682  if (!sconf->rlslms) {
683  if (sconf->adapt_order) {
684  int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
685  2, sconf->max_order + 1));
686  *bd->opt_order = get_bits(gb, opt_order_length);
687  if (*bd->opt_order > sconf->max_order) {
688  *bd->opt_order = sconf->max_order;
689  av_log(avctx, AV_LOG_ERROR, "Predictor order too large.\n");
690  return AVERROR_INVALIDDATA;
691  }
692  } else {
693  *bd->opt_order = sconf->max_order;
694  }
695 
696  opt_order = *bd->opt_order;
697 
698  if (opt_order) {
699  int add_base;
700 
701  if (sconf->coef_table == 3) {
702  add_base = 0x7F;
703 
704  // read coefficient 0
705  quant_cof[0] = 32 * parcor_scaled_values[get_bits(gb, 7)];
706 
707  // read coefficient 1
708  if (opt_order > 1)
709  quant_cof[1] = -32 * parcor_scaled_values[get_bits(gb, 7)];
710 
711  // read coefficients 2 to opt_order
712  for (k = 2; k < opt_order; k++)
713  quant_cof[k] = get_bits(gb, 7);
714  } else {
715  int k_max;
716  add_base = 1;
717 
718  // read coefficient 0 to 19
719  k_max = FFMIN(opt_order, 20);
720  for (k = 0; k < k_max; k++) {
721  int rice_param = parcor_rice_table[sconf->coef_table][k][1];
722  int offset = parcor_rice_table[sconf->coef_table][k][0];
723  quant_cof[k] = decode_rice(gb, rice_param) + offset;
724  if (quant_cof[k] < -64 || quant_cof[k] > 63) {
725  av_log(avctx, AV_LOG_ERROR, "quant_cof %d is out of range.\n", quant_cof[k]);
726  return AVERROR_INVALIDDATA;
727  }
728  }
729 
730  // read coefficients 20 to 126
731  k_max = FFMIN(opt_order, 127);
732  for (; k < k_max; k++)
733  quant_cof[k] = decode_rice(gb, 2) + (k & 1);
734 
735  // read coefficients 127 to opt_order
736  for (; k < opt_order; k++)
737  quant_cof[k] = decode_rice(gb, 1);
738 
739  quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64];
740 
741  if (opt_order > 1)
742  quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64];
743  }
744 
745  for (k = 2; k < opt_order; k++)
746  quant_cof[k] = (quant_cof[k] << 14) + (add_base << 13);
747  }
748  }
749 
750  // read LTP gain and lag values
751  if (sconf->long_term_prediction) {
752  *bd->use_ltp = get_bits1(gb);
753 
754  if (*bd->use_ltp) {
755  int r, c;
756 
757  bd->ltp_gain[0] = decode_rice(gb, 1) << 3;
758  bd->ltp_gain[1] = decode_rice(gb, 2) << 3;
759 
760  r = get_unary(gb, 0, 3);
761  c = get_bits(gb, 2);
762  bd->ltp_gain[2] = ltp_gain_values[r][c];
763 
764  bd->ltp_gain[3] = decode_rice(gb, 2) << 3;
765  bd->ltp_gain[4] = decode_rice(gb, 1) << 3;
766 
767  *bd->ltp_lag = get_bits(gb, ctx->ltp_lag_length);
768  *bd->ltp_lag += FFMAX(4, opt_order + 1);
769  }
770  }
771 
772  // read first value and residuals in case of a random access block
773  if (bd->ra_block) {
774  if (opt_order)
775  bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);
776  if (opt_order > 1)
777  bd->raw_samples[1] = decode_rice(gb, FFMIN(s[0] + 3, ctx->s_max));
778  if (opt_order > 2)
779  bd->raw_samples[2] = decode_rice(gb, FFMIN(s[0] + 1, ctx->s_max));
780 
781  start = FFMIN(opt_order, 3);
782  }
783 
784  // read all residuals
785  if (sconf->bgmc) {
786  int delta[8];
787  unsigned int k [8];
788  unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);
789 
790  // read most significant bits
791  unsigned int high;
792  unsigned int low;
793  unsigned int value;
794 
795  ff_bgmc_decode_init(gb, &high, &low, &value);
796 
797  current_res = bd->raw_samples + start;
798 
799  for (sb = 0; sb < sub_blocks; sb++) {
800  unsigned int sb_len = sb_length - (sb ? 0 : start);
801 
802  k [sb] = s[sb] > b ? s[sb] - b : 0;
803  delta[sb] = 5 - s[sb] + k[sb];
804 
805  ff_bgmc_decode(gb, sb_len, current_res,
806  delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
807 
808  current_res += sb_len;
809  }
810 
811  ff_bgmc_decode_end(gb);
812 
813 
814  // read least significant bits and tails
815  current_res = bd->raw_samples + start;
816 
817  for (sb = 0; sb < sub_blocks; sb++, start = 0) {
818  unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]];
819  unsigned int cur_k = k[sb];
820  unsigned int cur_s = s[sb];
821 
822  for (; start < sb_length; start++) {
823  int32_t res = *current_res;
824 
825  if (res == cur_tail_code) {
826  unsigned int max_msb = (2 + (sx[sb] > 2) + (sx[sb] > 10))
827  << (5 - delta[sb]);
828 
829  res = decode_rice(gb, cur_s);
830 
831  if (res >= 0) {
832  res += (max_msb ) << cur_k;
833  } else {
834  res -= (max_msb - 1) << cur_k;
835  }
836  } else {
837  if (res > cur_tail_code)
838  res--;
839 
840  if (res & 1)
841  res = -res;
842 
843  res >>= 1;
844 
845  if (cur_k) {
846  res <<= cur_k;
847  res |= get_bits_long(gb, cur_k);
848  }
849  }
850 
851  *current_res++ = res;
852  }
853  }
854  } else {
855  current_res = bd->raw_samples + start;
856 
857  for (sb = 0; sb < sub_blocks; sb++, start = 0)
858  for (; start < sb_length; start++)
859  *current_res++ = decode_rice(gb, s[sb]);
860  }
861 
862  if (!sconf->mc_coding || ctx->js_switch)
863  align_get_bits(gb);
864 
865  return 0;
866 }
867 
868 
869 /** Decode the block data for a non-constant block
870  */
871 static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
872 {
873  ALSSpecificConfig *sconf = &ctx->sconf;
874  unsigned int block_length = bd->block_length;
875  unsigned int smp = 0;
876  unsigned int k;
877  int opt_order = *bd->opt_order;
878  int sb;
879  int64_t y;
880  int32_t *quant_cof = bd->quant_cof;
881  int32_t *lpc_cof = bd->lpc_cof;
882  int32_t *raw_samples = bd->raw_samples;
883  int32_t *raw_samples_end = bd->raw_samples + bd->block_length;
884  int32_t *lpc_cof_reversed = ctx->lpc_cof_reversed_buffer;
885 
886  // reverse long-term prediction
887  if (*bd->use_ltp) {
888  int ltp_smp;
889 
890  for (ltp_smp = FFMAX(*bd->ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) {
891  int center = ltp_smp - *bd->ltp_lag;
892  int begin = FFMAX(0, center - 2);
893  int end = center + 3;
894  int tab = 5 - (end - begin);
895  int base;
896 
897  y = 1 << 6;
898 
899  for (base = begin; base < end; base++, tab++)
900  y += MUL64(bd->ltp_gain[tab], raw_samples[base]);
901 
902  raw_samples[ltp_smp] += y >> 7;
903  }
904  }
905 
906  // reconstruct all samples from residuals
907  if (bd->ra_block) {
908  for (smp = 0; smp < opt_order; smp++) {
909  y = 1 << 19;
910 
911  for (sb = 0; sb < smp; sb++)
912  y += MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]);
913 
914  *raw_samples++ -= y >> 20;
915  parcor_to_lpc(smp, quant_cof, lpc_cof);
916  }
917  } else {
918  for (k = 0; k < opt_order; k++)
919  parcor_to_lpc(k, quant_cof, lpc_cof);
920 
921  // store previous samples in case that they have to be altered
922  if (*bd->store_prev_samples)
923  memcpy(bd->prev_raw_samples, raw_samples - sconf->max_order,
924  sizeof(*bd->prev_raw_samples) * sconf->max_order);
925 
926  // reconstruct difference signal for prediction (joint-stereo)
927  if (bd->js_blocks && bd->raw_other) {
928  int32_t *left, *right;
929 
930  if (bd->raw_other > raw_samples) { // D = R - L
931  left = raw_samples;
932  right = bd->raw_other;
933  } else { // D = R - L
934  left = bd->raw_other;
935  right = raw_samples;
936  }
937 
938  for (sb = -1; sb >= -sconf->max_order; sb--)
939  raw_samples[sb] = right[sb] - left[sb];
940  }
941 
942  // reconstruct shifted signal
943  if (*bd->shift_lsbs)
944  for (sb = -1; sb >= -sconf->max_order; sb--)
945  raw_samples[sb] >>= *bd->shift_lsbs;
946  }
947 
948  // reverse linear prediction coefficients for efficiency
949  lpc_cof = lpc_cof + opt_order;
950 
951  for (sb = 0; sb < opt_order; sb++)
952  lpc_cof_reversed[sb] = lpc_cof[-(sb + 1)];
953 
954  // reconstruct raw samples
955  raw_samples = bd->raw_samples + smp;
956  lpc_cof = lpc_cof_reversed + opt_order;
957 
958  for (; raw_samples < raw_samples_end; raw_samples++) {
959  y = 1 << 19;
960 
961  for (sb = -opt_order; sb < 0; sb++)
962  y += MUL64(lpc_cof[sb], raw_samples[sb]);
963 
964  *raw_samples -= y >> 20;
965  }
966 
967  raw_samples = bd->raw_samples;
968 
969  // restore previous samples in case that they have been altered
970  if (*bd->store_prev_samples)
971  memcpy(raw_samples - sconf->max_order, bd->prev_raw_samples,
972  sizeof(*raw_samples) * sconf->max_order);
973 
974  return 0;
975 }
976 
977 
978 /** Read the block data.
979  */
980 static int read_block(ALSDecContext *ctx, ALSBlockData *bd)
981 {
982  GetBitContext *gb = &ctx->gb;
983  int ret;
984 
985  *bd->shift_lsbs = 0;
986  // read block type flag and read the samples accordingly
987  if (get_bits1(gb)) {
988  if ((ret = read_var_block_data(ctx, bd)) < 0)
989  return ret;
990  } else {
991  if ((ret = read_const_block_data(ctx, bd)) < 0)
992  return ret;
993  }
994 
995  return 0;
996 }
997 
998 
999 /** Decode the block data.
1000  */
1001 static int decode_block(ALSDecContext *ctx, ALSBlockData *bd)
1002 {
1003  unsigned int smp;
1004 
1005  // read block type flag and read the samples accordingly
1006  if (*bd->const_block)
1007  decode_const_block_data(ctx, bd);
1008  else if (decode_var_block_data(ctx, bd))
1009  return -1;
1010 
1011  // TODO: read RLSLMS extension data
1012 
1013  if (*bd->shift_lsbs)
1014  for (smp = 0; smp < bd->block_length; smp++)
1015  bd->raw_samples[smp] <<= *bd->shift_lsbs;
1016 
1017  return 0;
1018 }
1019 
1020 
1021 /** Read and decode block data successively.
1022  */
1023 static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
1024 {
1025  int ret;
1026 
1027  ret = read_block(ctx, bd);
1028 
1029  if (ret)
1030  return ret;
1031 
1032  ret = decode_block(ctx, bd);
1033 
1034  return ret;
1035 }
1036 
1037 
1038 /** Compute the number of samples left to decode for the current frame and
1039  * sets these samples to zero.
1040  */
1041 static void zero_remaining(unsigned int b, unsigned int b_max,
1042  const unsigned int *div_blocks, int32_t *buf)
1043 {
1044  unsigned int count = 0;
1045 
1046  while (b < b_max)
1047  count += div_blocks[b++];
1048 
1049  if (count)
1050  memset(buf, 0, sizeof(*buf) * count);
1051 }
1052 
1053 
1054 /** Decode blocks independently.
1055  */
1056 static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,
1057  unsigned int c, const unsigned int *div_blocks,
1058  unsigned int *js_blocks)
1059 {
1060  unsigned int b;
1061  ALSBlockData bd = { 0 };
1062 
1063  bd.ra_block = ra_frame;
1064  bd.const_block = ctx->const_block;
1065  bd.shift_lsbs = ctx->shift_lsbs;
1066  bd.opt_order = ctx->opt_order;
1067  bd.store_prev_samples = ctx->store_prev_samples;
1068  bd.use_ltp = ctx->use_ltp;
1069  bd.ltp_lag = ctx->ltp_lag;
1070  bd.ltp_gain = ctx->ltp_gain[0];
1071  bd.quant_cof = ctx->quant_cof[0];
1072  bd.lpc_cof = ctx->lpc_cof[0];
1073  bd.prev_raw_samples = ctx->prev_raw_samples;
1074  bd.raw_samples = ctx->raw_samples[c];
1075 
1076 
1077  for (b = 0; b < ctx->num_blocks; b++) {
1078  bd.block_length = div_blocks[b];
1079 
1080  if (read_decode_block(ctx, &bd)) {
1081  // damaged block, write zero for the rest of the frame
1082  zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples);
1083  return -1;
1084  }
1085  bd.raw_samples += div_blocks[b];
1086  bd.ra_block = 0;
1087  }
1088 
1089  return 0;
1090 }
1091 
1092 
1093 /** Decode blocks dependently.
1094  */
1095 static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame,
1096  unsigned int c, const unsigned int *div_blocks,
1097  unsigned int *js_blocks)
1098 {
1099  ALSSpecificConfig *sconf = &ctx->sconf;
1100  unsigned int offset = 0;
1101  unsigned int b;
1102  ALSBlockData bd[2] = { { 0 } };
1103 
1104  bd[0].ra_block = ra_frame;
1105  bd[0].const_block = ctx->const_block;
1106  bd[0].shift_lsbs = ctx->shift_lsbs;
1107  bd[0].opt_order = ctx->opt_order;
1108  bd[0].store_prev_samples = ctx->store_prev_samples;
1109  bd[0].use_ltp = ctx->use_ltp;
1110  bd[0].ltp_lag = ctx->ltp_lag;
1111  bd[0].ltp_gain = ctx->ltp_gain[0];
1112  bd[0].quant_cof = ctx->quant_cof[0];
1113  bd[0].lpc_cof = ctx->lpc_cof[0];
1114  bd[0].prev_raw_samples = ctx->prev_raw_samples;
1115  bd[0].js_blocks = *js_blocks;
1116 
1117  bd[1].ra_block = ra_frame;
1118  bd[1].const_block = ctx->const_block;
1119  bd[1].shift_lsbs = ctx->shift_lsbs;
1120  bd[1].opt_order = ctx->opt_order;
1121  bd[1].store_prev_samples = ctx->store_prev_samples;
1122  bd[1].use_ltp = ctx->use_ltp;
1123  bd[1].ltp_lag = ctx->ltp_lag;
1124  bd[1].ltp_gain = ctx->ltp_gain[0];
1125  bd[1].quant_cof = ctx->quant_cof[0];
1126  bd[1].lpc_cof = ctx->lpc_cof[0];
1127  bd[1].prev_raw_samples = ctx->prev_raw_samples;
1128  bd[1].js_blocks = *(js_blocks + 1);
1129 
1130  // decode all blocks
1131  for (b = 0; b < ctx->num_blocks; b++) {
1132  unsigned int s;
1133 
1134  bd[0].block_length = div_blocks[b];
1135  bd[1].block_length = div_blocks[b];
1136 
1137  bd[0].raw_samples = ctx->raw_samples[c ] + offset;
1138  bd[1].raw_samples = ctx->raw_samples[c + 1] + offset;
1139 
1140  bd[0].raw_other = bd[1].raw_samples;
1141  bd[1].raw_other = bd[0].raw_samples;
1142 
1143  if(read_decode_block(ctx, &bd[0]) || read_decode_block(ctx, &bd[1])) {
1144  // damaged block, write zero for the rest of the frame
1145  zero_remaining(b, ctx->num_blocks, div_blocks, bd[0].raw_samples);
1146  zero_remaining(b, ctx->num_blocks, div_blocks, bd[1].raw_samples);
1147  return -1;
1148  }
1149 
1150  // reconstruct joint-stereo blocks
1151  if (bd[0].js_blocks) {
1152  if (bd[1].js_blocks)
1153  av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair.\n");
1154 
1155  for (s = 0; s < div_blocks[b]; s++)
1156  bd[0].raw_samples[s] = bd[1].raw_samples[s] - bd[0].raw_samples[s];
1157  } else if (bd[1].js_blocks) {
1158  for (s = 0; s < div_blocks[b]; s++)
1159  bd[1].raw_samples[s] = bd[1].raw_samples[s] + bd[0].raw_samples[s];
1160  }
1161 
1162  offset += div_blocks[b];
1163  bd[0].ra_block = 0;
1164  bd[1].ra_block = 0;
1165  }
1166 
1167  // store carryover raw samples,
1168  // the others channel raw samples are stored by the calling function.
1169  memmove(ctx->raw_samples[c] - sconf->max_order,
1170  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1171  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1172 
1173  return 0;
1174 }
1175 
1176 
1177 /** Read the channel data.
1178  */
1179 static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c)
1180 {
1181  GetBitContext *gb = &ctx->gb;
1182  ALSChannelData *current = cd;
1183  unsigned int channels = ctx->avctx->channels;
1184  int entries = 0;
1185 
1186  while (entries < channels && !(current->stop_flag = get_bits1(gb))) {
1187  current->master_channel = get_bits_long(gb, av_ceil_log2(channels));
1188 
1189  if (current->master_channel >= channels) {
1190  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid master channel.\n");
1191  return -1;
1192  }
1193 
1194  if (current->master_channel != c) {
1195  current->time_diff_flag = get_bits1(gb);
1196  current->weighting[0] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 31)];
1197  current->weighting[1] = mcc_weightings[av_clip(decode_rice(gb, 2) + 14, 0, 31)];
1198  current->weighting[2] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 31)];
1199 
1200  if (current->time_diff_flag) {
1201  current->weighting[3] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 31)];
1202  current->weighting[4] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 31)];
1203  current->weighting[5] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 31)];
1204 
1205  current->time_diff_sign = get_bits1(gb);
1206  current->time_diff_index = get_bits(gb, ctx->ltp_lag_length - 3) + 3;
1207  }
1208  }
1209 
1210  current++;
1211  entries++;
1212  }
1213 
1214  if (entries == channels) {
1215  av_log(ctx->avctx, AV_LOG_ERROR, "Damaged channel data.\n");
1216  return -1;
1217  }
1218 
1219  align_get_bits(gb);
1220  return 0;
1221 }
1222 
1223 
1224 /** Recursively reverts the inter-channel correlation for a block.
1225  */
1226 static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd,
1227  ALSChannelData **cd, int *reverted,
1228  unsigned int offset, int c)
1229 {
1230  ALSChannelData *ch = cd[c];
1231  unsigned int dep = 0;
1232  unsigned int channels = ctx->avctx->channels;
1233 
1234  if (reverted[c])
1235  return 0;
1236 
1237  reverted[c] = 1;
1238 
1239  while (dep < channels && !ch[dep].stop_flag) {
1240  revert_channel_correlation(ctx, bd, cd, reverted, offset,
1241  ch[dep].master_channel);
1242 
1243  dep++;
1244  }
1245 
1246  if (dep == channels) {
1247  av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation.\n");
1248  return -1;
1249  }
1250 
1251  bd->const_block = ctx->const_block + c;
1252  bd->shift_lsbs = ctx->shift_lsbs + c;
1253  bd->opt_order = ctx->opt_order + c;
1254  bd->store_prev_samples = ctx->store_prev_samples + c;
1255  bd->use_ltp = ctx->use_ltp + c;
1256  bd->ltp_lag = ctx->ltp_lag + c;
1257  bd->ltp_gain = ctx->ltp_gain[c];
1258  bd->lpc_cof = ctx->lpc_cof[c];
1259  bd->quant_cof = ctx->quant_cof[c];
1260  bd->raw_samples = ctx->raw_samples[c] + offset;
1261 
1262  dep = 0;
1263  while (!ch[dep].stop_flag) {
1264  unsigned int smp;
1265  unsigned int begin = 1;
1266  unsigned int end = bd->block_length - 1;
1267  int64_t y;
1268  int32_t *master = ctx->raw_samples[ch[dep].master_channel] + offset;
1269 
1270  if (ch[dep].time_diff_flag) {
1271  int t = ch[dep].time_diff_index;
1272 
1273  if (ch[dep].time_diff_sign) {
1274  t = -t;
1275  begin -= t;
1276  } else {
1277  end -= t;
1278  }
1279 
1280  for (smp = begin; smp < end; smp++) {
1281  y = (1 << 6) +
1282  MUL64(ch[dep].weighting[0], master[smp - 1 ]) +
1283  MUL64(ch[dep].weighting[1], master[smp ]) +
1284  MUL64(ch[dep].weighting[2], master[smp + 1 ]) +
1285  MUL64(ch[dep].weighting[3], master[smp - 1 + t]) +
1286  MUL64(ch[dep].weighting[4], master[smp + t]) +
1287  MUL64(ch[dep].weighting[5], master[smp + 1 + t]);
1288 
1289  bd->raw_samples[smp] += y >> 7;
1290  }
1291  } else {
1292  for (smp = begin; smp < end; smp++) {
1293  y = (1 << 6) +
1294  MUL64(ch[dep].weighting[0], master[smp - 1]) +
1295  MUL64(ch[dep].weighting[1], master[smp ]) +
1296  MUL64(ch[dep].weighting[2], master[smp + 1]);
1297 
1298  bd->raw_samples[smp] += y >> 7;
1299  }
1300  }
1301 
1302  dep++;
1303  }
1304 
1305  return 0;
1306 }
1307 
1308 
1309 /** Read the frame data.
1310  */
1311 static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
1312 {
1313  ALSSpecificConfig *sconf = &ctx->sconf;
1314  AVCodecContext *avctx = ctx->avctx;
1315  GetBitContext *gb = &ctx->gb;
1316  unsigned int div_blocks[32]; ///< block sizes.
1317  unsigned int c;
1318  unsigned int js_blocks[2];
1319 
1320  uint32_t bs_info = 0;
1321 
1322  // skip the size of the ra unit if present in the frame
1323  if (sconf->ra_flag == RA_FLAG_FRAMES && ra_frame)
1324  skip_bits_long(gb, 32);
1325 
1326  if (sconf->mc_coding && sconf->joint_stereo) {
1327  ctx->js_switch = get_bits1(gb);
1328  align_get_bits(gb);
1329  }
1330 
1331  if (!sconf->mc_coding || ctx->js_switch) {
1332  int independent_bs = !sconf->joint_stereo;
1333 
1334  for (c = 0; c < avctx->channels; c++) {
1335  js_blocks[0] = 0;
1336  js_blocks[1] = 0;
1337 
1338  get_block_sizes(ctx, div_blocks, &bs_info);
1339 
1340  // if joint_stereo and block_switching is set, independent decoding
1341  // is signaled via the first bit of bs_info
1342  if (sconf->joint_stereo && sconf->block_switching)
1343  if (bs_info >> 31)
1344  independent_bs = 2;
1345 
1346  // if this is the last channel, it has to be decoded independently
1347  if (c == avctx->channels - 1)
1348  independent_bs = 1;
1349 
1350  if (independent_bs) {
1351  if (decode_blocks_ind(ctx, ra_frame, c, div_blocks, js_blocks))
1352  return -1;
1353 
1354  independent_bs--;
1355  } else {
1356  if (decode_blocks(ctx, ra_frame, c, div_blocks, js_blocks))
1357  return -1;
1358 
1359  c++;
1360  }
1361 
1362  // store carryover raw samples
1363  memmove(ctx->raw_samples[c] - sconf->max_order,
1364  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1365  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1366  }
1367  } else { // multi-channel coding
1368  ALSBlockData bd = { 0 };
1369  int b, ret;
1370  int *reverted_channels = ctx->reverted_channels;
1371  unsigned int offset = 0;
1372 
1373  for (c = 0; c < avctx->channels; c++)
1374  if (ctx->chan_data[c] < ctx->chan_data_buffer) {
1375  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid channel data.\n");
1376  return -1;
1377  }
1378 
1379  memset(reverted_channels, 0, sizeof(*reverted_channels) * avctx->channels);
1380 
1381  bd.ra_block = ra_frame;
1382  bd.prev_raw_samples = ctx->prev_raw_samples;
1383 
1384  get_block_sizes(ctx, div_blocks, &bs_info);
1385 
1386  for (b = 0; b < ctx->num_blocks; b++) {
1387  bd.block_length = div_blocks[b];
1388 
1389  for (c = 0; c < avctx->channels; c++) {
1390  bd.const_block = ctx->const_block + c;
1391  bd.shift_lsbs = ctx->shift_lsbs + c;
1392  bd.opt_order = ctx->opt_order + c;
1393  bd.store_prev_samples = ctx->store_prev_samples + c;
1394  bd.use_ltp = ctx->use_ltp + c;
1395  bd.ltp_lag = ctx->ltp_lag + c;
1396  bd.ltp_gain = ctx->ltp_gain[c];
1397  bd.lpc_cof = ctx->lpc_cof[c];
1398  bd.quant_cof = ctx->quant_cof[c];
1399  bd.raw_samples = ctx->raw_samples[c] + offset;
1400  bd.raw_other = NULL;
1401 
1402  if ((ret = read_block(ctx, &bd)) < 0)
1403  return ret;
1404  if ((ret = read_channel_data(ctx, ctx->chan_data[c], c)) < 0)
1405  return ret;
1406  }
1407 
1408  for (c = 0; c < avctx->channels; c++)
1409  if (revert_channel_correlation(ctx, &bd, ctx->chan_data,
1410  reverted_channels, offset, c))
1411  return -1;
1412 
1413  for (c = 0; c < avctx->channels; c++) {
1414  bd.const_block = ctx->const_block + c;
1415  bd.shift_lsbs = ctx->shift_lsbs + c;
1416  bd.opt_order = ctx->opt_order + c;
1417  bd.store_prev_samples = ctx->store_prev_samples + c;
1418  bd.use_ltp = ctx->use_ltp + c;
1419  bd.ltp_lag = ctx->ltp_lag + c;
1420  bd.ltp_gain = ctx->ltp_gain[c];
1421  bd.lpc_cof = ctx->lpc_cof[c];
1422  bd.quant_cof = ctx->quant_cof[c];
1423  bd.raw_samples = ctx->raw_samples[c] + offset;
1424 
1425  if ((ret = decode_block(ctx, &bd)) < 0)
1426  return ret;
1427  }
1428 
1429  memset(reverted_channels, 0, avctx->channels * sizeof(*reverted_channels));
1430  offset += div_blocks[b];
1431  bd.ra_block = 0;
1432  }
1433 
1434  // store carryover raw samples
1435  for (c = 0; c < avctx->channels; c++)
1436  memmove(ctx->raw_samples[c] - sconf->max_order,
1437  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1438  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1439  }
1440 
1441  // TODO: read_diff_float_data
1442 
1443  return 0;
1444 }
1445 
1446 
1447 /** Decode an ALS frame.
1448  */
1449 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1450  AVPacket *avpkt)
1451 {
1452  ALSDecContext *ctx = avctx->priv_data;
1453  AVFrame *frame = data;
1454  ALSSpecificConfig *sconf = &ctx->sconf;
1455  const uint8_t *buffer = avpkt->data;
1456  int buffer_size = avpkt->size;
1457  int invalid_frame, ret;
1458  unsigned int c, sample, ra_frame, bytes_read, shift;
1459 
1460  init_get_bits(&ctx->gb, buffer, buffer_size * 8);
1461 
1462  // In the case that the distance between random access frames is set to zero
1463  // (sconf->ra_distance == 0) no frame is treated as a random access frame.
1464  // For the first frame, if prediction is used, all samples used from the
1465  // previous frame are assumed to be zero.
1466  ra_frame = sconf->ra_distance && !(ctx->frame_id % sconf->ra_distance);
1467 
1468  // the last frame to decode might have a different length
1469  if (sconf->samples != 0xFFFFFFFF)
1470  ctx->cur_frame_length = FFMIN(sconf->samples - ctx->frame_id * (uint64_t) sconf->frame_length,
1471  sconf->frame_length);
1472  else
1473  ctx->cur_frame_length = sconf->frame_length;
1474 
1475  // decode the frame data
1476  if ((invalid_frame = read_frame_data(ctx, ra_frame)) < 0)
1477  av_log(ctx->avctx, AV_LOG_WARNING,
1478  "Reading frame data failed. Skipping RA unit.\n");
1479 
1480  ctx->frame_id++;
1481 
1482  /* get output buffer */
1483  frame->nb_samples = ctx->cur_frame_length;
1484  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1485  return ret;
1486 
1487  // transform decoded frame into output format
1488  #define INTERLEAVE_OUTPUT(bps) \
1489  { \
1490  int##bps##_t *dest = (int##bps##_t*)frame->data[0]; \
1491  shift = bps - ctx->avctx->bits_per_raw_sample; \
1492  if (!ctx->cs_switch) { \
1493  for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1494  for (c = 0; c < avctx->channels; c++) \
1495  *dest++ = ctx->raw_samples[c][sample] << shift; \
1496  } else { \
1497  for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1498  for (c = 0; c < avctx->channels; c++) \
1499  *dest++ = ctx->raw_samples[sconf->chan_pos[c]][sample] << shift; \
1500  } \
1501  }
1502 
1503  if (ctx->avctx->bits_per_raw_sample <= 16) {
1504  INTERLEAVE_OUTPUT(16)
1505  } else {
1506  INTERLEAVE_OUTPUT(32)
1507  }
1508 
1509  // update CRC
1510  if (sconf->crc_enabled && (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
1511  int swap = HAVE_BIGENDIAN != sconf->msb_first;
1512 
1513  if (ctx->avctx->bits_per_raw_sample == 24) {
1514  int32_t *src = (int32_t *)frame->data[0];
1515 
1516  for (sample = 0;
1517  sample < ctx->cur_frame_length * avctx->channels;
1518  sample++) {
1519  int32_t v;
1520 
1521  if (swap)
1522  v = av_bswap32(src[sample]);
1523  else
1524  v = src[sample];
1525  if (!HAVE_BIGENDIAN)
1526  v >>= 8;
1527 
1528  ctx->crc = av_crc(ctx->crc_table, ctx->crc, (uint8_t*)(&v), 3);
1529  }
1530  } else {
1531  uint8_t *crc_source;
1532 
1533  if (swap) {
1534  if (ctx->avctx->bits_per_raw_sample <= 16) {
1535  int16_t *src = (int16_t*) frame->data[0];
1536  int16_t *dest = (int16_t*) ctx->crc_buffer;
1537  for (sample = 0;
1538  sample < ctx->cur_frame_length * avctx->channels;
1539  sample++)
1540  *dest++ = av_bswap16(src[sample]);
1541  } else {
1542  ctx->dsp.bswap_buf((uint32_t*)ctx->crc_buffer,
1543  (uint32_t *)frame->data[0],
1544  ctx->cur_frame_length * avctx->channels);
1545  }
1546  crc_source = ctx->crc_buffer;
1547  } else {
1548  crc_source = frame->data[0];
1549  }
1550 
1551  ctx->crc = av_crc(ctx->crc_table, ctx->crc, crc_source,
1552  ctx->cur_frame_length * avctx->channels *
1553  av_get_bytes_per_sample(avctx->sample_fmt));
1554  }
1555 
1556 
1557  // check CRC sums if this is the last frame
1558  if (ctx->cur_frame_length != sconf->frame_length &&
1559  ctx->crc_org != ctx->crc) {
1560  av_log(avctx, AV_LOG_ERROR, "CRC error.\n");
1561  }
1562  }
1563 
1564  *got_frame_ptr = 1;
1565 
1566  bytes_read = invalid_frame ? buffer_size :
1567  (get_bits_count(&ctx->gb) + 7) >> 3;
1568 
1569  return bytes_read;
1570 }
1571 
1572 
1573 /** Uninitialize the ALS decoder.
1574  */
1575 static av_cold int decode_end(AVCodecContext *avctx)
1576 {
1577  ALSDecContext *ctx = avctx->priv_data;
1578 
1579  av_freep(&ctx->sconf.chan_pos);
1580 
1581  ff_bgmc_end(&ctx->bgmc_lut, &ctx->bgmc_lut_status);
1582 
1583  av_freep(&ctx->const_block);
1584  av_freep(&ctx->shift_lsbs);
1585  av_freep(&ctx->opt_order);
1586  av_freep(&ctx->store_prev_samples);
1587  av_freep(&ctx->use_ltp);
1588  av_freep(&ctx->ltp_lag);
1589  av_freep(&ctx->ltp_gain);
1590  av_freep(&ctx->ltp_gain_buffer);
1591  av_freep(&ctx->quant_cof);
1592  av_freep(&ctx->lpc_cof);
1593  av_freep(&ctx->quant_cof_buffer);
1594  av_freep(&ctx->lpc_cof_buffer);
1595  av_freep(&ctx->lpc_cof_reversed_buffer);
1596  av_freep(&ctx->prev_raw_samples);
1597  av_freep(&ctx->raw_samples);
1598  av_freep(&ctx->raw_buffer);
1599  av_freep(&ctx->chan_data);
1600  av_freep(&ctx->chan_data_buffer);
1601  av_freep(&ctx->reverted_channels);
1602  av_freep(&ctx->crc_buffer);
1603 
1604  return 0;
1605 }
1606 
1607 
1608 /** Initialize the ALS decoder.
1609  */
1610 static av_cold int decode_init(AVCodecContext *avctx)
1611 {
1612  unsigned int c;
1613  unsigned int channel_size;
1614  int num_buffers;
1615  ALSDecContext *ctx = avctx->priv_data;
1616  ALSSpecificConfig *sconf = &ctx->sconf;
1617  ctx->avctx = avctx;
1618 
1619  if (!avctx->extradata) {
1620  av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n");
1621  return -1;
1622  }
1623 
1624  if (read_specific_config(ctx)) {
1625  av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
1626  decode_end(avctx);
1627  return -1;
1628  }
1629 
1630  if (check_specific_config(ctx)) {
1631  decode_end(avctx);
1632  return -1;
1633  }
1634 
1635  if (sconf->bgmc)
1636  ff_bgmc_init(avctx, &ctx->bgmc_lut, &ctx->bgmc_lut_status);
1637 
1638  if (sconf->floating) {
1639  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1640  avctx->bits_per_raw_sample = 32;
1641  } else {
1642  avctx->sample_fmt = sconf->resolution > 1
1643  ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16;
1644  avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
1645  }
1646 
1647  // set maximum Rice parameter for progressive decoding based on resolution
1648  // This is not specified in 14496-3 but actually done by the reference
1649  // codec RM22 revision 2.
1650  ctx->s_max = sconf->resolution > 1 ? 31 : 15;
1651 
1652  // set lag value for long-term prediction
1653  ctx->ltp_lag_length = 8 + (avctx->sample_rate >= 96000) +
1654  (avctx->sample_rate >= 192000);
1655 
1656  // allocate quantized parcor coefficient buffer
1657  num_buffers = sconf->mc_coding ? avctx->channels : 1;
1658 
1659  ctx->quant_cof = av_malloc(sizeof(*ctx->quant_cof) * num_buffers);
1660  ctx->lpc_cof = av_malloc(sizeof(*ctx->lpc_cof) * num_buffers);
1661  ctx->quant_cof_buffer = av_malloc(sizeof(*ctx->quant_cof_buffer) *
1662  num_buffers * sconf->max_order);
1663  ctx->lpc_cof_buffer = av_malloc(sizeof(*ctx->lpc_cof_buffer) *
1664  num_buffers * sconf->max_order);
1665  ctx->lpc_cof_reversed_buffer = av_malloc(sizeof(*ctx->lpc_cof_buffer) *
1666  sconf->max_order);
1667 
1668  if (!ctx->quant_cof || !ctx->lpc_cof ||
1669  !ctx->quant_cof_buffer || !ctx->lpc_cof_buffer ||
1670  !ctx->lpc_cof_reversed_buffer) {
1671  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1672  return AVERROR(ENOMEM);
1673  }
1674 
1675  // assign quantized parcor coefficient buffers
1676  for (c = 0; c < num_buffers; c++) {
1677  ctx->quant_cof[c] = ctx->quant_cof_buffer + c * sconf->max_order;
1678  ctx->lpc_cof[c] = ctx->lpc_cof_buffer + c * sconf->max_order;
1679  }
1680 
1681  // allocate and assign lag and gain data buffer for ltp mode
1682  ctx->const_block = av_malloc (sizeof(*ctx->const_block) * num_buffers);
1683  ctx->shift_lsbs = av_malloc (sizeof(*ctx->shift_lsbs) * num_buffers);
1684  ctx->opt_order = av_malloc (sizeof(*ctx->opt_order) * num_buffers);
1685  ctx->store_prev_samples = av_malloc(sizeof(*ctx->store_prev_samples) * num_buffers);
1686  ctx->use_ltp = av_mallocz(sizeof(*ctx->use_ltp) * num_buffers);
1687  ctx->ltp_lag = av_malloc (sizeof(*ctx->ltp_lag) * num_buffers);
1688  ctx->ltp_gain = av_malloc (sizeof(*ctx->ltp_gain) * num_buffers);
1689  ctx->ltp_gain_buffer = av_malloc (sizeof(*ctx->ltp_gain_buffer) *
1690  num_buffers * 5);
1691 
1692  if (!ctx->const_block || !ctx->shift_lsbs ||
1693  !ctx->opt_order || !ctx->store_prev_samples ||
1694  !ctx->use_ltp || !ctx->ltp_lag ||
1695  !ctx->ltp_gain || !ctx->ltp_gain_buffer) {
1696  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1697  decode_end(avctx);
1698  return AVERROR(ENOMEM);
1699  }
1700 
1701  for (c = 0; c < num_buffers; c++)
1702  ctx->ltp_gain[c] = ctx->ltp_gain_buffer + c * 5;
1703 
1704  // allocate and assign channel data buffer for mcc mode
1705  if (sconf->mc_coding) {
1706  ctx->chan_data_buffer = av_malloc(sizeof(*ctx->chan_data_buffer) *
1707  num_buffers * num_buffers);
1708  ctx->chan_data = av_malloc(sizeof(*ctx->chan_data) *
1709  num_buffers);
1710  ctx->reverted_channels = av_malloc(sizeof(*ctx->reverted_channels) *
1711  num_buffers);
1712 
1713  if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) {
1714  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1715  decode_end(avctx);
1716  return AVERROR(ENOMEM);
1717  }
1718 
1719  for (c = 0; c < num_buffers; c++)
1720  ctx->chan_data[c] = ctx->chan_data_buffer + c * num_buffers;
1721  } else {
1722  ctx->chan_data = NULL;
1723  ctx->chan_data_buffer = NULL;
1724  ctx->reverted_channels = NULL;
1725  }
1726 
1727  channel_size = sconf->frame_length + sconf->max_order;
1728 
1729  ctx->prev_raw_samples = av_malloc (sizeof(*ctx->prev_raw_samples) * sconf->max_order);
1730  ctx->raw_buffer = av_mallocz(sizeof(*ctx-> raw_buffer) * avctx->channels * channel_size);
1731  ctx->raw_samples = av_malloc (sizeof(*ctx-> raw_samples) * avctx->channels);
1732 
1733  // allocate previous raw sample buffer
1734  if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) {
1735  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1736  decode_end(avctx);
1737  return AVERROR(ENOMEM);
1738  }
1739 
1740  // assign raw samples buffers
1741  ctx->raw_samples[0] = ctx->raw_buffer + sconf->max_order;
1742  for (c = 1; c < avctx->channels; c++)
1743  ctx->raw_samples[c] = ctx->raw_samples[c - 1] + channel_size;
1744 
1745  // allocate crc buffer
1746  if (HAVE_BIGENDIAN != sconf->msb_first && sconf->crc_enabled &&
1747  (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
1748  ctx->crc_buffer = av_malloc(sizeof(*ctx->crc_buffer) *
1749  ctx->cur_frame_length *
1750  avctx->channels *
1751  av_get_bytes_per_sample(avctx->sample_fmt));
1752  if (!ctx->crc_buffer) {
1753  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1754  decode_end(avctx);
1755  return AVERROR(ENOMEM);
1756  }
1757  }
1758 
1759  ff_dsputil_init(&ctx->dsp, avctx);
1760 
1761  return 0;
1762 }
1763 
1764 
1765 /** Flush (reset) the frame ID after seeking.
1766  */
1767 static av_cold void flush(AVCodecContext *avctx)
1768 {
1769  ALSDecContext *ctx = avctx->priv_data;
1770 
1771  ctx->frame_id = 0;
1772 }
1773 
1774 
1775 AVCodec ff_als_decoder = {
1776  .name = "als",
1777  .type = AVMEDIA_TYPE_AUDIO,
1778  .id = AV_CODEC_ID_MP4ALS,
1779  .priv_data_size = sizeof(ALSDecContext),
1780  .init = decode_init,
1781  .close = decode_end,
1782  .decode = decode_frame,
1783  .flush = flush,
1784  .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1785  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
1786 };
MUL64
#define MUL64(a, b)
Definition: mathops.h:51
ff_als_decoder
AVCodec ff_als_decoder
Definition: alsdec.c:1775
decode_var_block_data
static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a non-constant block.
Definition: alsdec.c:871
start
Definition: start.py:1
ALSSpecificConfig::msb_first
int msb_first
1 = original CRC calculated on big-endian system, 0 = little-endian
Definition: alsdec.c:161
av_mallocz
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:205
ff_dsputil_init
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2675
v
float v
Definition: avf_showspectrum.c:88
s
const char * s
Definition: avisynth_c.h:668
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
shift
static int shift(int a, int b)
Definition: sonic.c:86
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
ALSDecContext::use_ltp
int * use_ltp
contains use_ltp flags for all channels
Definition: alsdec.c:214
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:275
ALSDecContext::raw_samples
int32_t ** raw_samples
decoded raw samples for each channel
Definition: alsdec.c:227
ALSDecContext::crc_buffer
uint8_t * crc_buffer
buffer of byte order corrected samples used for CRC check
Definition: alsdec.c:229
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
mcc_weightings
static const int16_t mcc_weightings[]
Inter-channel weighting factors for multi-channel correlation.
Definition: alsdec.c:120
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:198
max
if max(w)>1 w=0.9 *w/max(w)
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:154
ALSSpecificConfig::block_switching
int block_switching
number of block switching levels
Definition: alsdec.c:169
ALSSpecificConfig::rlslms
int rlslms
use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
Definition: alsdec.c:176
check_specific_config
static int check_specific_config(ALSDecContext *ctx)
Check the ALSSpecificConfig for unsupported features.
Definition: alsdec.c:427
av_bswap16
#define av_bswap16
Definition: sh4/bswap.h:31
ALSSpecificConfig::adapt_order
int adapt_order
adaptive order: 1 = on, 0 = off
Definition: alsdec.c:165
read_frame_data
static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
Read the frame data.
Definition: alsdec.c:1311
ALSDecContext::lpc_cof_reversed_buffer
int32_t * lpc_cof_reversed_buffer
temporary buffer to set up a reversed versio of lpc_cof_buffer
Definition: alsdec.c:222
ALSDecContext::gb
GetBitContext gb
Definition: alsdec.c:196
bgmc.h
Block Gilbert-Moore decoder header.
av_dlog
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
master
const char * master
Definition: vf_curves.c:97
ALSDecContext::js_switch
unsigned int js_switch
if true, joint-stereo decoding is enforced
Definition: alsdec.c:203
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: libavcodec/avcodec.h:2553
read_decode_block
static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
Read and decode block data successively.
Definition: alsdec.c:1023
INTERLEAVE_OUTPUT
#define INTERLEAVE_OUTPUT(bps)
AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:52
sample
#define sample
Definition: flacdsp_template.c:44
decode_rice
static int32_t decode_rice(GetBitContext *gb, unsigned int k)
Read and decode a Rice codeword.
Definition: alsdec.c:475
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:344
av_freep
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
ALSDecContext::ltp_lag
int * ltp_lag
contains ltp lag values for all channels
Definition: alsdec.c:215
ALSDecContext::const_block
int * const_block
contains const_block flags for all channels
Definition: alsdec.c:210
if
initialize output if(nPeaks >3)%at least 3 peaks in spectrum for trying to find f0 nf0peaks
ltp_gain_values
static const uint8_t ltp_gain_values[4][4]
Gain values of p(0) for long-term prediction.
Definition: alsdec.c:109
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Initialize the ALS decoder.
Definition: alsdec.c:1610
ALSBlockData::lpc_cof
int32_t * lpc_cof
coefficients of the direct form prediction
Definition: alsdec.c:245
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: libavcodec/avcodec.h:1869
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:78
decode_const_block_data
static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a constant block.
Definition: alsdec.c:596
delta
float delta
Definition: vorbis_enc_data.h:457
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:261
ALSDecContext::ltp_gain
int ** ltp_gain
gain values for ltp 5-tap filter for a channel
Definition: alsdec.c:216
b
#define b
Definition: input.c:42
end
end end
Definition: extra/f0detection.m:15
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: libavcodec/avcodec.h:1242
ALSSpecificConfig::chan_sort
int chan_sort
channel rearrangement: 1 = on, 0 = off
Definition: alsdec.c:175
CODEC_CAP_DR1
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: libavcodec/avcodec.h:743
ALSSpecificConfig::joint_stereo
int joint_stereo
joint stereo: 1 = on, 0 = off
Definition: alsdec.c:172
AVPacket::data
uint8_t * data
Definition: libavcodec/avcodec.h:1051
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:193
get_bits.h
bitstream reader API header.
decode_blocks_ind
static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame, unsigned int c, const unsigned int *div_blocks, unsigned int *js_blocks)
Decode blocks independently.
Definition: alsdec.c:1056
ff_bgmc_decode_init
void ff_bgmc_decode_init(GetBitContext *gb, unsigned int *h, unsigned int *l, unsigned int *v)
Initialize decoding and reads the first value.
Definition: bgmc.c:486
ALSBlockData::block_length
unsigned int block_length
number of samples within the block
Definition: alsdec.c:234
zero_remaining
static void zero_remaining(unsigned int b, unsigned int b_max, const unsigned int *div_blocks, int32_t *buf)
Compute the number of samples left to decode for the current frame and sets these samples to zero...
Definition: alsdec.c:1041
ALSSpecificConfig::ra_distance
int ra_distance
distance between RA frames (in frames, 0...255)
Definition: alsdec.c:163
ALSChannelData::weighting
int weighting[6]
Definition: alsdec.c:189
ALSDecContext::quant_cof_buffer
int32_t * quant_cof_buffer
contains all quantized parcor coefficients
Definition: alsdec.c:219
ALSDecContext::chan_data_buffer
ALSChannelData * chan_data_buffer
contains channel data for all channels
Definition: alsdec.c:224
frame
frame
Definition: stft.m:14
ALSSpecificConfig::bgmc
int bgmc
"Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
Definition: alsdec.c:170
ALSDecContext::cs_switch
unsigned int cs_switch
if true, channel rearrangement is done
Definition: alsdec.c:204
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:557
ALSBlockData::use_ltp
int * use_ltp
if true, long-term prediction is used
Definition: alsdec.c:241
ALSSpecificConfig::ra_flag
enum RA_Flag ra_flag
indicates where the size of ra units is stored
Definition: alsdec.c:164
ALSDecContext::ltp_lag_length
int ltp_lag_length
number of bits used for ltp lag value
Definition: alsdec.c:209
dprint_specific_config
static av_cold void dprint_specific_config(ALSDecContext *ctx)
Definition: alsdec.c:252
ALSBlockData::opt_order
unsigned int * opt_order
prediction order of this block
Definition: alsdec.c:239
ALSSpecificConfig::chan_pos
int * chan_pos
original channel positions
Definition: alsdec.c:178
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: libavutil/internal.h:123
ALSDecContext::avctx
AVCodecContext * avctx
Definition: alsdec.c:194
parcor_scaled_values
static const int16_t parcor_scaled_values[]
Scaled PARCOR values used for the first two PARCOR coefficients.
Definition: alsdec.c:70
data
Spectrum Plot time data
Definition: FFT of a Simple Sinusoid.m:14
r
const char * r
Definition: vf_curves.c:94
ALSDecContext::lpc_cof
int32_t ** lpc_cof
coefficients of the direct form prediction filter for a channel
Definition: alsdec.c:220
ALSSpecificConfig::chan_config_info
int chan_config_info
mapping of channels to loudspeaker locations. Unused until setting channel configuration is implement...
Definition: alsdec.c:177
ALSDecContext::num_blocks
unsigned int num_blocks
number of blocks used in the current frame
Definition: alsdec.c:205
AVMEDIA_TYPE_AUDIO
Definition: avutil.h:144
ff_bgmc_end
void ff_bgmc_end(uint8_t **cf_lut, int **cf_lut_status)
Release the lookup table arrays.
Definition: bgmc.c:478
av_log
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
AVCodec::name
const char * name
Name of the codec implementation.
Definition: libavcodec/avcodec.h:2861
ALSDecContext::prev_raw_samples
int32_t * prev_raw_samples
contains unshifted raw samples from the previous block
Definition: alsdec.c:226
decode_blocks
static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame, unsigned int c, const unsigned int *div_blocks, unsigned int *js_blocks)
Decode blocks dependently.
Definition: alsdec.c:1095
ff_bgmc_decode_end
void ff_bgmc_decode_end(GetBitContext *gb)
Finish decoding.
Definition: bgmc.c:496
ALSDecContext::crc_table
const AVCRC * crc_table
Definition: alsdec.c:198
offset
static const uint8_t offset[127][2]
Definition: vf_spp.c:70
FFMAX
#define FFMAX(a, b)
Definition: common.h:56
ALSDecContext::bgmc_lut_status
int * bgmc_lut_status
pointer at lookup table status flags used for BGMC
Definition: alsdec.c:208
avcodec.h
external API header
ALSDecContext::sconf
ALSSpecificConfig sconf
Definition: alsdec.c:195
ALSBlockData::store_prev_samples
int * store_prev_samples
if true, carryover samples have to be stored
Definition: alsdec.c:240
AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:53
ff_bgmc_init
int ff_bgmc_init(AVCodecContext *avctx, uint8_t **cf_lut, int **cf_lut_status)
Initialize the lookup table arrays.
Definition: bgmc.c:459
ALSDecContext::shift_lsbs
unsigned int * shift_lsbs
contains shift_lsbs flags for all channels
Definition: alsdec.c:211
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: libavcodec/avcodec.h:2459
FFMIN
#define FFMIN(a, b)
Definition: common.h:58
read_var_block_data
static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data for a non-constant block.
Definition: alsdec.c:610
ret
ret
Definition: avfilter.c:821
ALSSpecificConfig::chan_config
int chan_config
indicates that a chan_config_info field is present
Definition: alsdec.c:174
t
t
Definition: genspecsines3.m:6
int32_t
int32_t
Definition: audio_convert.c:194
ff_bgmc_decode
void ff_bgmc_decode(GetBitContext *gb, unsigned int num, int32_t *dst, int delta, unsigned int sx, unsigned int *h, unsigned int *l, unsigned int *v, uint8_t *cf_lut, int *cf_lut_status)
Read and decode a block Gilbert-Moore coded symbol.
Definition: bgmc.c:503
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Uninitialize the ALS decoder.
Definition: alsdec.c:1575
ALSBlockData::const_block
int * const_block
if true, this is a constant value block
Definition: alsdec.c:236
ALSSpecificConfig::floating
int floating
1 = IEEE 32-bit floating-point, 0 = integer
Definition: alsdec.c:160
ALSChannelData::time_diff_flag
int time_diff_flag
Definition: alsdec.c:186
ALSChannelData::master_channel
int master_channel
Definition: alsdec.c:185
ALSDecContext::crc
uint32_t crc
CRC value calculated from decoded data.
Definition: alsdec.c:200
ALSSpecificConfig::coef_table
int coef_table
table index of Rice code parameters
Definition: alsdec.c:166
read_const_block_data
static int read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data for a constant block.
Definition: alsdec.c:566
ALSSpecificConfig::sb_part
int sb_part
sub-block partition
Definition: alsdec.c:171
ALSDecContext::dsp
DSPContext dsp
Definition: alsdec.c:197
ALSBlockData::raw_other
int32_t * raw_other
decoded raw samples of the other channel of a channel pair
Definition: alsdec.c:248
ALSDecContext::bgmc_lut
uint8_t * bgmc_lut
pointer at lookup tables used for BGMC
Definition: alsdec.c:207
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:104
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
ALSBlockData::ltp_gain
int * ltp_gain
gain values for ltp 5-tap filter
Definition: alsdec.c:243
k
for k
Definition: genspecsines_sin.m:6
NULL
NULL
Definition: eval.c:55
ALSBlockData::js_blocks
int js_blocks
true if this block contains a difference signal
Definition: alsdec.c:237
start.dest
dest
Definition: start.py:60
av_bswap32
#define av_bswap32
Definition: bfin/bswap.h:33
ALSBlockData::ra_block
unsigned int ra_block
if true, this is a random access block
Definition: alsdec.c:235
src
AVS_Value src
Definition: avisynth_c.h:523
parcor_to_lpc
static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
Convert PARCOR coefficient k to direct filter coefficient.
Definition: alsdec.c:493
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: libavcodec/avcodec.h:1861
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:410
AVCodecContext
main external API structure.
Definition: libavcodec/avcodec.h:1134
close
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:375
ALSDecContext::chan_data
ALSChannelData ** chan_data
channel data for multi-channel correlation
Definition: alsdec.c:223
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode an ALS frame.
Definition: alsdec.c:1449
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: libavcodec/utils.c:823
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
MISSING_ERR
#define MISSING_ERR(cond, str, errval)
buf
void * buf
Definition: avisynth_c.h:594
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:273
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:298
value
double value
Definition: eval.c:82
av_malloc
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:73
ALSDecContext::s_max
unsigned int s_max
maximum Rice parameter allowed in entropy coding
Definition: alsdec.c:206
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:265
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
DSPContext::bswap_buf
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: dsputil.h:208
ALSBlockData::ltp_lag
int * ltp_lag
lag value for long-term prediction
Definition: alsdec.c:242
ALSDecContext::lpc_cof_buffer
int32_t * lpc_cof_buffer
contains all coefficients of the direct form prediction filter
Definition: alsdec.c:221
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:379
parcor_rice_table
static const int8_t parcor_rice_table[3][20][2]
Rice parameters and corresponding index offsets for decoding the indices of scaled PARCOR values...
Definition: alsdec.c:49
RA_Flag
RA_Flag
Definition: alsdec.c:150
read_specific_config
static av_cold int read_specific_config(ALSDecContext *ctx)
Read an ALSSpecificConfig from a buffer into the output struct.
Definition: alsdec.c:282
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:306
ALSSpecificConfig::long_term_prediction
int long_term_prediction
long term prediction (LTP): 1 = on, 0 = off
Definition: alsdec.c:167
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Buffer references ownership and permissions
ALSBlockData::raw_samples
int32_t * raw_samples
decoded raw samples / residuals for this block
Definition: alsdec.c:246
ALSDecContext::reverted_channels
int * reverted_channels
stores a flag for each reverted channel
Definition: alsdec.c:225
ALSDecContext::opt_order
unsigned int * opt_order
contains opt_order flags for all channels
Definition: alsdec.c:212
ALSDecContext::raw_buffer
int32_t * raw_buffer
contains all decoded raw samples including carryover samples
Definition: alsdec.c:228
n
n
Definition: genspecsines_sin.m:10
ALSSpecificConfig::max_order
int max_order
maximum prediction order (0..1023)
Definition: alsdec.c:168
ALSSpecificConfig::samples
uint32_t samples
number of samples, 0xFFFFFFFF if unknown
Definition: alsdec.c:158
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
CODEC_CAP_SUBFRAMES
#define CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: libavcodec/avcodec.h:791
ALSSpecificConfig::mc_coding
int mc_coding
extended inter-channel coding (multi channel coding): 1 = on, 0 = off
Definition: alsdec.c:173
tail_code
static const uint8_t tail_code[16][6]
Tail codes used in arithmetic coding using block Gilbert-Moore codes.
Definition: alsdec.c:130
internal.h
common internal api header.
ALSBlockData::prev_raw_samples
int32_t * prev_raw_samples
contains unshifted raw samples from the previous block
Definition: alsdec.c:247
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:33
flush
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
Definition: alsdec.c:1767
c
static double c[64]
Definition: vsrc_mptestsrc.c:88
ALSChannelData::time_diff_index
int time_diff_index
Definition: alsdec.c:188
ALSDecContext::ltp_gain_buffer
int * ltp_gain_buffer
contains all gain values for ltp 5-tap filter
Definition: alsdec.c:217
buffer
the buffer and buffer reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFilterBuffer structures They must not be accessed but through references stored in AVFilterBufferRef structures Several references can point to the same buffer
Definition: filter_design.txt:45
ALSBlockData::quant_cof
int32_t * quant_cof
quantized parcor coefficients
Definition: alsdec.c:244
y
function y
Definition: D.m:1
AVCRC
uint32_t AVCRC
Definition: crc.h:28
avpriv_mpeg4audio_get_config
int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf, int bit_size, int sync_extension)
Parse MPEG-4 systems extradata to retrieve audio configuration.
Definition: mpeg4audio.c:81
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Definition: libavcodec/avcodec.h:2460
dsputil.h
DSP utils.
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:283
parse_bs_info
static void parse_bs_info(const uint32_t bs_info, unsigned int n, unsigned int div, unsigned int **div_blocks, unsigned int *num_blocks)
Parse the bs_info field to extract the block partitioning used in block switching mode...
Definition: alsdec.c:452
ALSDecContext::quant_cof
int32_t ** quant_cof
quantized parcor coefficients for a channel
Definition: alsdec.c:218
AVCodecContext::channels
int channels
number of audio channels
Definition: libavcodec/avcodec.h:1862
dst
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
ALSSpecificConfig::crc_enabled
int crc_enabled
enable Cyclic Redundancy Checksum
Definition: alsdec.c:179
ALSDecContext::crc_org
uint32_t crc_org
CRC value of the original input data.
Definition: alsdec.c:199
decode_block
static int decode_block(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data.
Definition: alsdec.c:1001
AV_CODEC_ID_MP4ALS
Definition: libavcodec/avcodec.h:427
read_block
static int read_block(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data.
Definition: alsdec.c:980
ALSSpecificConfig::frame_length
int frame_length
frame length for each frame (last frame may differ)
Definition: alsdec.c:162
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:418
ALSChannelData::stop_flag
int stop_flag
Definition: alsdec.c:184
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:11128
ALSBlockData::shift_lsbs
unsigned int * shift_lsbs
shift of values for this block
Definition: alsdec.c:238
count
void INT64 INT64 count
Definition: avisynth_c.h:594
start
void INT64 start
Definition: avisynth_c.h:594
decode
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
HAVE_BIGENDIAN
#define HAVE_BIGENDIAN
Definition: config.h:116
read_channel_data
static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c)
Read the channel data.
Definition: alsdec.c:1179
get_block_sizes
static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks, uint32_t *bs_info)
Read block switching field if necessary and set actual block sizes.
Definition: alsdec.c:513
ALSDecContext::store_prev_samples
int * store_prev_samples
contains store_prev_samples flags for all channels
Definition: alsdec.c:213
ALSDecContext::frame_id
unsigned int frame_id
the frame ID / number of the current frame
Definition: alsdec.c:202
revert_channel_correlation
static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd, ALSChannelData **cd, int *reverted, unsigned int offset, int c)
Recursively reverts the inter-channel correlation for a block.
Definition: alsdec.c:1226
AVPacket
This structure stores compressed data.
Definition: libavcodec/avcodec.h:1028
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:127
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:467
ALSDecContext::cur_frame_length
unsigned int cur_frame_length
length of the current frame to decode
Definition: alsdec.c:201
DSPContext
DSPContext.
Definition: dsputil.h:127
ALSSpecificConfig::resolution
int resolution
000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
Definition: alsdec.c:159
ALSChannelData::time_diff_sign
int time_diff_sign
Definition: alsdec.c:187
AV_EF_CAREFUL
#define AV_EF_CAREFUL
Definition: libavcodec/avcodec.h:2465
Generated on Wed May 8 2024 06:52:01 for FFmpeg by   doxygen 1.8.11