FFmpeg
alsdec.c
Go to the documentation of this file.
1 /*
2  * MPEG-4 ALS decoder
3  * Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ mail.de>
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_ mail.de>
26  */
27 
28 #include <inttypes.h>
29 
30 #include "avcodec.h"
31 #include "get_bits.h"
32 #include "unary.h"
33 #include "mpeg4audio.h"
34 #include "bgmc.h"
35 #include "bswapdsp.h"
36 #include "internal.h"
37 #include "mlz.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/crc.h"
41 #include "libavutil/intfloat.h"
42 #include "libavutil/intreadwrite.h"
43 
44 #include <stdint.h>
45 
46 /** Rice parameters and corresponding index offsets for decoding the
47  * indices of scaled PARCOR values. The table chosen is set globally
48  * by the encoder and stored in ALSSpecificConfig.
49  */
50 static const int8_t parcor_rice_table[3][20][2] = {
51  { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4},
52  { 12, 3}, { -7, 3}, { 9, 3}, { -5, 3}, { 6, 3},
53  { -4, 3}, { 3, 3}, { -3, 2}, { 3, 2}, { -2, 2},
54  { 3, 2}, { -1, 2}, { 2, 2}, { -1, 2}, { 2, 2} },
55  { {-58, 3}, {-42, 4}, {-46, 4}, { 37, 5}, {-36, 4},
56  { 29, 4}, {-29, 4}, { 25, 4}, {-23, 4}, { 20, 4},
57  {-17, 4}, { 16, 4}, {-12, 4}, { 12, 3}, {-10, 4},
58  { 7, 3}, { -4, 4}, { 3, 3}, { -1, 3}, { 1, 3} },
59  { {-59, 3}, {-45, 5}, {-50, 4}, { 38, 4}, {-39, 4},
60  { 32, 4}, {-30, 4}, { 25, 3}, {-23, 3}, { 20, 3},
61  {-20, 3}, { 16, 3}, {-13, 3}, { 10, 3}, { -7, 3},
62  { 3, 3}, { 0, 3}, { -1, 3}, { 2, 3}, { -1, 2} }
63 };
64 
65 
66 /** Scaled PARCOR values used for the first two PARCOR coefficients.
67  * To be indexed by the Rice coded indices.
68  * Generated by: parcor_scaled_values[i] = 32 + ((i * (i+1)) << 7) - (1 << 20)
69  * Actual values are divided by 32 in order to be stored in 16 bits.
70  */
71 static const int16_t parcor_scaled_values[] = {
72  -1048544 / 32, -1048288 / 32, -1047776 / 32, -1047008 / 32,
73  -1045984 / 32, -1044704 / 32, -1043168 / 32, -1041376 / 32,
74  -1039328 / 32, -1037024 / 32, -1034464 / 32, -1031648 / 32,
75  -1028576 / 32, -1025248 / 32, -1021664 / 32, -1017824 / 32,
76  -1013728 / 32, -1009376 / 32, -1004768 / 32, -999904 / 32,
77  -994784 / 32, -989408 / 32, -983776 / 32, -977888 / 32,
78  -971744 / 32, -965344 / 32, -958688 / 32, -951776 / 32,
79  -944608 / 32, -937184 / 32, -929504 / 32, -921568 / 32,
80  -913376 / 32, -904928 / 32, -896224 / 32, -887264 / 32,
81  -878048 / 32, -868576 / 32, -858848 / 32, -848864 / 32,
82  -838624 / 32, -828128 / 32, -817376 / 32, -806368 / 32,
83  -795104 / 32, -783584 / 32, -771808 / 32, -759776 / 32,
84  -747488 / 32, -734944 / 32, -722144 / 32, -709088 / 32,
85  -695776 / 32, -682208 / 32, -668384 / 32, -654304 / 32,
86  -639968 / 32, -625376 / 32, -610528 / 32, -595424 / 32,
87  -580064 / 32, -564448 / 32, -548576 / 32, -532448 / 32,
88  -516064 / 32, -499424 / 32, -482528 / 32, -465376 / 32,
89  -447968 / 32, -430304 / 32, -412384 / 32, -394208 / 32,
90  -375776 / 32, -357088 / 32, -338144 / 32, -318944 / 32,
91  -299488 / 32, -279776 / 32, -259808 / 32, -239584 / 32,
92  -219104 / 32, -198368 / 32, -177376 / 32, -156128 / 32,
93  -134624 / 32, -112864 / 32, -90848 / 32, -68576 / 32,
94  -46048 / 32, -23264 / 32, -224 / 32, 23072 / 32,
95  46624 / 32, 70432 / 32, 94496 / 32, 118816 / 32,
96  143392 / 32, 168224 / 32, 193312 / 32, 218656 / 32,
97  244256 / 32, 270112 / 32, 296224 / 32, 322592 / 32,
98  349216 / 32, 376096 / 32, 403232 / 32, 430624 / 32,
99  458272 / 32, 486176 / 32, 514336 / 32, 542752 / 32,
100  571424 / 32, 600352 / 32, 629536 / 32, 658976 / 32,
101  688672 / 32, 718624 / 32, 748832 / 32, 779296 / 32,
102  810016 / 32, 840992 / 32, 872224 / 32, 903712 / 32,
103  935456 / 32, 967456 / 32, 999712 / 32, 1032224 / 32
104 };
105 
106 
107 /** Gain values of p(0) for long-term prediction.
108  * To be indexed by the Rice coded indices.
109  */
110 static const uint8_t ltp_gain_values [4][4] = {
111  { 0, 8, 16, 24},
112  {32, 40, 48, 56},
113  {64, 70, 76, 82},
114  {88, 92, 96, 100}
115 };
116 
117 
118 /** Inter-channel weighting factors for multi-channel correlation.
119  * To be indexed by the Rice coded indices.
120  */
121 static const int16_t mcc_weightings[] = {
122  204, 192, 179, 166, 153, 140, 128, 115,
123  102, 89, 76, 64, 51, 38, 25, 12,
124  0, -12, -25, -38, -51, -64, -76, -89,
125  -102, -115, -128, -140, -153, -166, -179, -192
126 };
127 
128 
129 /** Tail codes used in arithmetic coding using block Gilbert-Moore codes.
130  */
131 static const uint8_t tail_code[16][6] = {
132  { 74, 44, 25, 13, 7, 3},
133  { 68, 42, 24, 13, 7, 3},
134  { 58, 39, 23, 13, 7, 3},
135  {126, 70, 37, 19, 10, 5},
136  {132, 70, 37, 20, 10, 5},
137  {124, 70, 38, 20, 10, 5},
138  {120, 69, 37, 20, 11, 5},
139  {116, 67, 37, 20, 11, 5},
140  {108, 66, 36, 20, 10, 5},
141  {102, 62, 36, 20, 10, 5},
142  { 88, 58, 34, 19, 10, 5},
143  {162, 89, 49, 25, 13, 7},
144  {156, 87, 49, 26, 14, 7},
145  {150, 86, 47, 26, 14, 7},
146  {142, 84, 47, 26, 14, 7},
147  {131, 79, 46, 26, 14, 7}
148 };
149 
150 
151 enum RA_Flag {
155 };
156 
157 
158 typedef struct ALSSpecificConfig {
159  uint32_t samples; ///< number of samples, 0xFFFFFFFF if unknown
160  int resolution; ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
161  int floating; ///< 1 = IEEE 32-bit floating-point, 0 = integer
162  int msb_first; ///< 1 = original CRC calculated on big-endian system, 0 = little-endian
163  int frame_length; ///< frame length for each frame (last frame may differ)
164  int ra_distance; ///< distance between RA frames (in frames, 0...255)
165  enum RA_Flag ra_flag; ///< indicates where the size of ra units is stored
166  int adapt_order; ///< adaptive order: 1 = on, 0 = off
167  int coef_table; ///< table index of Rice code parameters
168  int long_term_prediction; ///< long term prediction (LTP): 1 = on, 0 = off
169  int max_order; ///< maximum prediction order (0..1023)
170  int block_switching; ///< number of block switching levels
171  int bgmc; ///< "Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
172  int sb_part; ///< sub-block partition
173  int joint_stereo; ///< joint stereo: 1 = on, 0 = off
174  int mc_coding; ///< extended inter-channel coding (multi channel coding): 1 = on, 0 = off
175  int chan_config; ///< indicates that a chan_config_info field is present
176  int chan_sort; ///< channel rearrangement: 1 = on, 0 = off
177  int rlslms; ///< use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
178  int chan_config_info; ///< mapping of channels to loudspeaker locations. Unused until setting channel configuration is implemented.
179  int *chan_pos; ///< original channel positions
180  int crc_enabled; ///< enable Cyclic Redundancy Checksum
182 
183 
184 typedef struct ALSChannelData {
190  int weighting[6];
192 
193 
194 typedef struct ALSDecContext {
199  const AVCRC *crc_table;
200  uint32_t crc_org; ///< CRC value of the original input data
201  uint32_t crc; ///< CRC value calculated from decoded data
202  unsigned int cur_frame_length; ///< length of the current frame to decode
203  unsigned int frame_id; ///< the frame ID / number of the current frame
204  unsigned int js_switch; ///< if true, joint-stereo decoding is enforced
205  unsigned int cs_switch; ///< if true, channel rearrangement is done
206  unsigned int num_blocks; ///< number of blocks used in the current frame
207  unsigned int s_max; ///< maximum Rice parameter allowed in entropy coding
208  uint8_t *bgmc_lut; ///< pointer at lookup tables used for BGMC
209  int *bgmc_lut_status; ///< pointer at lookup table status flags used for BGMC
210  int ltp_lag_length; ///< number of bits used for ltp lag value
211  int *const_block; ///< contains const_block flags for all channels
212  unsigned int *shift_lsbs; ///< contains shift_lsbs flags for all channels
213  unsigned int *opt_order; ///< contains opt_order flags for all channels
214  int *store_prev_samples; ///< contains store_prev_samples flags for all channels
215  int *use_ltp; ///< contains use_ltp flags for all channels
216  int *ltp_lag; ///< contains ltp lag values for all channels
217  int **ltp_gain; ///< gain values for ltp 5-tap filter for a channel
218  int *ltp_gain_buffer; ///< contains all gain values for ltp 5-tap filter
219  int32_t **quant_cof; ///< quantized parcor coefficients for a channel
220  int32_t *quant_cof_buffer; ///< contains all quantized parcor coefficients
221  int32_t **lpc_cof; ///< coefficients of the direct form prediction filter for a channel
222  int32_t *lpc_cof_buffer; ///< contains all coefficients of the direct form prediction filter
223  int32_t *lpc_cof_reversed_buffer; ///< temporary buffer to set up a reversed versio of lpc_cof_buffer
224  ALSChannelData **chan_data; ///< channel data for multi-channel correlation
225  ALSChannelData *chan_data_buffer; ///< contains channel data for all channels
226  int *reverted_channels; ///< stores a flag for each reverted channel
227  int32_t *prev_raw_samples; ///< contains unshifted raw samples from the previous block
228  int32_t **raw_samples; ///< decoded raw samples for each channel
229  int32_t *raw_buffer; ///< contains all decoded raw samples including carryover samples
230  uint8_t *crc_buffer; ///< buffer of byte order corrected samples used for CRC check
231  MLZ* mlz; ///< masked lz decompression structure
232  SoftFloat_IEEE754 *acf; ///< contains common multiplier for all channels
233  int *last_acf_mantissa; ///< contains the last acf mantissa data of common multiplier for all channels
234  int *shift_value; ///< value by which the binary point is to be shifted for all channels
235  int *last_shift_value; ///< contains last shift value for all channels
236  int **raw_mantissa; ///< decoded mantissa bits of the difference signal
237  unsigned char *larray; ///< buffer to store the output of masked lz decompression
238  int *nbits; ///< contains the number of bits to read for masked lz decompression for all samples
239 } ALSDecContext;
240 
241 
242 typedef struct ALSBlockData {
243  unsigned int block_length; ///< number of samples within the block
244  unsigned int ra_block; ///< if true, this is a random access block
245  int *const_block; ///< if true, this is a constant value block
246  int js_blocks; ///< true if this block contains a difference signal
247  unsigned int *shift_lsbs; ///< shift of values for this block
248  unsigned int *opt_order; ///< prediction order of this block
249  int *store_prev_samples;///< if true, carryover samples have to be stored
250  int *use_ltp; ///< if true, long-term prediction is used
251  int *ltp_lag; ///< lag value for long-term prediction
252  int *ltp_gain; ///< gain values for ltp 5-tap filter
253  int32_t *quant_cof; ///< quantized parcor coefficients
254  int32_t *lpc_cof; ///< coefficients of the direct form prediction
255  int32_t *raw_samples; ///< decoded raw samples / residuals for this block
256  int32_t *prev_raw_samples; ///< contains unshifted raw samples from the previous block
257  int32_t *raw_other; ///< decoded raw samples of the other channel of a channel pair
258 } ALSBlockData;
259 
260 
262 {
263 #ifdef DEBUG
264  AVCodecContext *avctx = ctx->avctx;
265  ALSSpecificConfig *sconf = &ctx->sconf;
266 
267  ff_dlog(avctx, "resolution = %i\n", sconf->resolution);
268  ff_dlog(avctx, "floating = %i\n", sconf->floating);
269  ff_dlog(avctx, "frame_length = %i\n", sconf->frame_length);
270  ff_dlog(avctx, "ra_distance = %i\n", sconf->ra_distance);
271  ff_dlog(avctx, "ra_flag = %i\n", sconf->ra_flag);
272  ff_dlog(avctx, "adapt_order = %i\n", sconf->adapt_order);
273  ff_dlog(avctx, "coef_table = %i\n", sconf->coef_table);
274  ff_dlog(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction);
275  ff_dlog(avctx, "max_order = %i\n", sconf->max_order);
276  ff_dlog(avctx, "block_switching = %i\n", sconf->block_switching);
277  ff_dlog(avctx, "bgmc = %i\n", sconf->bgmc);
278  ff_dlog(avctx, "sb_part = %i\n", sconf->sb_part);
279  ff_dlog(avctx, "joint_stereo = %i\n", sconf->joint_stereo);
280  ff_dlog(avctx, "mc_coding = %i\n", sconf->mc_coding);
281  ff_dlog(avctx, "chan_config = %i\n", sconf->chan_config);
282  ff_dlog(avctx, "chan_sort = %i\n", sconf->chan_sort);
283  ff_dlog(avctx, "RLSLMS = %i\n", sconf->rlslms);
284  ff_dlog(avctx, "chan_config_info = %i\n", sconf->chan_config_info);
285 #endif
286 }
287 
288 
289 /** Read an ALSSpecificConfig from a buffer into the output struct.
290  */
292 {
293  GetBitContext gb;
294  uint64_t ht_size;
295  int i, config_offset;
296  MPEG4AudioConfig m4ac = {0};
297  ALSSpecificConfig *sconf = &ctx->sconf;
298  AVCodecContext *avctx = ctx->avctx;
299  uint32_t als_id, header_size, trailer_size;
300  int ret;
301 
302  if ((ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size)) < 0)
303  return ret;
304 
305  config_offset = avpriv_mpeg4audio_get_config2(&m4ac, avctx->extradata,
306  avctx->extradata_size, 1, avctx);
307 
308  if (config_offset < 0)
309  return AVERROR_INVALIDDATA;
310 
311  skip_bits_long(&gb, config_offset);
312 
313  if (get_bits_left(&gb) < (30 << 3))
314  return AVERROR_INVALIDDATA;
315 
316  // read the fixed items
317  als_id = get_bits_long(&gb, 32);
318  avctx->sample_rate = m4ac.sample_rate;
319  skip_bits_long(&gb, 32); // sample rate already known
320  sconf->samples = get_bits_long(&gb, 32);
321  avctx->channels = m4ac.channels;
322  skip_bits(&gb, 16); // number of channels already known
323  skip_bits(&gb, 3); // skip file_type
324  sconf->resolution = get_bits(&gb, 3);
325  sconf->floating = get_bits1(&gb);
326  sconf->msb_first = get_bits1(&gb);
327  sconf->frame_length = get_bits(&gb, 16) + 1;
328  sconf->ra_distance = get_bits(&gb, 8);
329  sconf->ra_flag = get_bits(&gb, 2);
330  sconf->adapt_order = get_bits1(&gb);
331  sconf->coef_table = get_bits(&gb, 2);
332  sconf->long_term_prediction = get_bits1(&gb);
333  sconf->max_order = get_bits(&gb, 10);
334  sconf->block_switching = get_bits(&gb, 2);
335  sconf->bgmc = get_bits1(&gb);
336  sconf->sb_part = get_bits1(&gb);
337  sconf->joint_stereo = get_bits1(&gb);
338  sconf->mc_coding = get_bits1(&gb);
339  sconf->chan_config = get_bits1(&gb);
340  sconf->chan_sort = get_bits1(&gb);
341  sconf->crc_enabled = get_bits1(&gb);
342  sconf->rlslms = get_bits1(&gb);
343  skip_bits(&gb, 5); // skip 5 reserved bits
344  skip_bits1(&gb); // skip aux_data_enabled
345 
346 
347  // check for ALSSpecificConfig struct
348  if (als_id != MKBETAG('A','L','S','\0'))
349  return AVERROR_INVALIDDATA;
350 
351  if (avctx->channels > FF_SANE_NB_CHANNELS) {
352  avpriv_request_sample(avctx, "Huge number of channels\n");
353  return AVERROR_PATCHWELCOME;
354  }
355 
356  ctx->cur_frame_length = sconf->frame_length;
357 
358  // read channel config
359  if (sconf->chan_config)
360  sconf->chan_config_info = get_bits(&gb, 16);
361  // TODO: use this to set avctx->channel_layout
362 
363 
364  // read channel sorting
365  if (sconf->chan_sort && avctx->channels > 1) {
366  int chan_pos_bits = av_ceil_log2(avctx->channels);
367  int bits_needed = avctx->channels * chan_pos_bits + 7;
368  if (get_bits_left(&gb) < bits_needed)
369  return AVERROR_INVALIDDATA;
370 
371  if (!(sconf->chan_pos = av_malloc_array(avctx->channels, sizeof(*sconf->chan_pos))))
372  return AVERROR(ENOMEM);
373 
374  ctx->cs_switch = 1;
375 
376  for (i = 0; i < avctx->channels; i++) {
377  sconf->chan_pos[i] = -1;
378  }
379 
380  for (i = 0; i < avctx->channels; i++) {
381  int idx;
382 
383  idx = get_bits(&gb, chan_pos_bits);
384  if (idx >= avctx->channels || sconf->chan_pos[idx] != -1) {
385  av_log(avctx, AV_LOG_WARNING, "Invalid channel reordering.\n");
386  ctx->cs_switch = 0;
387  break;
388  }
389  sconf->chan_pos[idx] = i;
390  }
391 
392  align_get_bits(&gb);
393  }
394 
395 
396  // read fixed header and trailer sizes,
397  // if size = 0xFFFFFFFF then there is no data field!
398  if (get_bits_left(&gb) < 64)
399  return AVERROR_INVALIDDATA;
400 
401  header_size = get_bits_long(&gb, 32);
402  trailer_size = get_bits_long(&gb, 32);
403  if (header_size == 0xFFFFFFFF)
404  header_size = 0;
405  if (trailer_size == 0xFFFFFFFF)
406  trailer_size = 0;
407 
408  ht_size = ((int64_t)(header_size) + (int64_t)(trailer_size)) << 3;
409 
410 
411  // skip the header and trailer data
412  if (get_bits_left(&gb) < ht_size)
413  return AVERROR_INVALIDDATA;
414 
415  if (ht_size > INT32_MAX)
416  return AVERROR_PATCHWELCOME;
417 
418  skip_bits_long(&gb, ht_size);
419 
420 
421  // initialize CRC calculation
422  if (sconf->crc_enabled) {
423  if (get_bits_left(&gb) < 32)
424  return AVERROR_INVALIDDATA;
425 
428  ctx->crc = 0xFFFFFFFF;
429  ctx->crc_org = ~get_bits_long(&gb, 32);
430  } else
431  skip_bits_long(&gb, 32);
432  }
433 
434 
435  // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data)
436 
438 
439  return 0;
440 }
441 
442 
443 /** Check the ALSSpecificConfig for unsupported features.
444  */
446 {
447  ALSSpecificConfig *sconf = &ctx->sconf;
448  int error = 0;
449 
450  // report unsupported feature and set error value
451  #define MISSING_ERR(cond, str, errval) \
452  { \
453  if (cond) { \
454  avpriv_report_missing_feature(ctx->avctx, \
455  str); \
456  error = errval; \
457  } \
458  }
459 
460  MISSING_ERR(sconf->rlslms, "Adaptive RLS-LMS prediction", AVERROR_PATCHWELCOME);
461 
462  return error;
463 }
464 
465 
466 /** Parse the bs_info field to extract the block partitioning used in
467  * block switching mode, refer to ISO/IEC 14496-3, section 11.6.2.
468  */
469 static void parse_bs_info(const uint32_t bs_info, unsigned int n,
470  unsigned int div, unsigned int **div_blocks,
471  unsigned int *num_blocks)
472 {
473  if (n < 31 && ((bs_info << n) & 0x40000000)) {
474  // if the level is valid and the investigated bit n is set
475  // then recursively check both children at bits (2n+1) and (2n+2)
476  n *= 2;
477  div += 1;
478  parse_bs_info(bs_info, n + 1, div, div_blocks, num_blocks);
479  parse_bs_info(bs_info, n + 2, div, div_blocks, num_blocks);
480  } else {
481  // else the bit is not set or the last level has been reached
482  // (bit implicitly not set)
483  **div_blocks = div;
484  (*div_blocks)++;
485  (*num_blocks)++;
486  }
487 }
488 
489 
490 /** Read and decode a Rice codeword.
491  */
492 static int32_t decode_rice(GetBitContext *gb, unsigned int k)
493 {
494  int max = get_bits_left(gb) - k;
495  unsigned q = get_unary(gb, 0, max);
496  int r = k ? get_bits1(gb) : !(q & 1);
497 
498  if (k > 1) {
499  q <<= (k - 1);
500  q += get_bits_long(gb, k - 1);
501  } else if (!k) {
502  q >>= 1;
503  }
504  return r ? q : ~q;
505 }
506 
507 
508 /** Convert PARCOR coefficient k to direct filter coefficient.
509  */
510 static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
511 {
512  int i, j;
513 
514  for (i = 0, j = k - 1; i < j; i++, j--) {
515  unsigned tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
516  cof[j] += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);
517  cof[i] += tmp1;
518  }
519  if (i == j)
520  cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
521 
522  cof[k] = par[k];
523 }
524 
525 
526 /** Read block switching field if necessary and set actual block sizes.
527  * Also assure that the block sizes of the last frame correspond to the
528  * actual number of samples.
529  */
530 static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks,
531  uint32_t *bs_info)
532 {
533  ALSSpecificConfig *sconf = &ctx->sconf;
534  GetBitContext *gb = &ctx->gb;
535  unsigned int *ptr_div_blocks = div_blocks;
536  unsigned int b;
537 
538  if (sconf->block_switching) {
539  unsigned int bs_info_len = 1 << (sconf->block_switching + 2);
540  *bs_info = get_bits_long(gb, bs_info_len);
541  *bs_info <<= (32 - bs_info_len);
542  }
543 
544  ctx->num_blocks = 0;
545  parse_bs_info(*bs_info, 0, 0, &ptr_div_blocks, &ctx->num_blocks);
546 
547  // The last frame may have an overdetermined block structure given in
548  // the bitstream. In that case the defined block structure would need
549  // more samples than available to be consistent.
550  // The block structure is actually used but the block sizes are adapted
551  // to fit the actual number of available samples.
552  // Example: 5 samples, 2nd level block sizes: 2 2 2 2.
553  // This results in the actual block sizes: 2 2 1 0.
554  // This is not specified in 14496-3 but actually done by the reference
555  // codec RM22 revision 2.
556  // This appears to happen in case of an odd number of samples in the last
557  // frame which is actually not allowed by the block length switching part
558  // of 14496-3.
559  // The ALS conformance files feature an odd number of samples in the last
560  // frame.
561 
562  for (b = 0; b < ctx->num_blocks; b++)
563  div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b];
564 
565  if (ctx->cur_frame_length != ctx->sconf.frame_length) {
566  unsigned int remaining = ctx->cur_frame_length;
567 
568  for (b = 0; b < ctx->num_blocks; b++) {
569  if (remaining <= div_blocks[b]) {
570  div_blocks[b] = remaining;
571  ctx->num_blocks = b + 1;
572  break;
573  }
574 
575  remaining -= div_blocks[b];
576  }
577  }
578 }
579 
580 
581 /** Read the block data for a constant block
582  */
584 {
585  ALSSpecificConfig *sconf = &ctx->sconf;
586  AVCodecContext *avctx = ctx->avctx;
587  GetBitContext *gb = &ctx->gb;
588 
589  if (bd->block_length <= 0)
590  return AVERROR_INVALIDDATA;
591 
592  *bd->raw_samples = 0;
593  *bd->const_block = get_bits1(gb); // 1 = constant value, 0 = zero block (silence)
594  bd->js_blocks = get_bits1(gb);
595 
596  // skip 5 reserved bits
597  skip_bits(gb, 5);
598 
599  if (*bd->const_block) {
600  unsigned int const_val_bits = sconf->floating ? 24 : avctx->bits_per_raw_sample;
601  *bd->raw_samples = get_sbits_long(gb, const_val_bits);
602  }
603 
604  // ensure constant block decoding by reusing this field
605  *bd->const_block = 1;
606 
607  return 0;
608 }
609 
610 
611 /** Decode the block data for a constant block
612  */
614 {
615  int smp = bd->block_length - 1;
616  int32_t val = *bd->raw_samples;
617  int32_t *dst = bd->raw_samples + 1;
618 
619  // write raw samples into buffer
620  for (; smp; smp--)
621  *dst++ = val;
622 }
623 
624 
625 /** Read the block data for a non-constant block
626  */
628 {
629  ALSSpecificConfig *sconf = &ctx->sconf;
630  AVCodecContext *avctx = ctx->avctx;
631  GetBitContext *gb = &ctx->gb;
632  unsigned int k;
633  unsigned int s[8];
634  unsigned int sx[8];
635  unsigned int sub_blocks, log2_sub_blocks, sb_length;
636  unsigned int start = 0;
637  unsigned int opt_order;
638  int sb;
639  int32_t *quant_cof = bd->quant_cof;
640  int32_t *current_res;
641 
642 
643  // ensure variable block decoding by reusing this field
644  *bd->const_block = 0;
645 
646  *bd->opt_order = 1;
647  bd->js_blocks = get_bits1(gb);
648 
649  opt_order = *bd->opt_order;
650 
651  // determine the number of subblocks for entropy decoding
652  if (!sconf->bgmc && !sconf->sb_part) {
653  log2_sub_blocks = 0;
654  } else {
655  if (sconf->bgmc && sconf->sb_part)
656  log2_sub_blocks = get_bits(gb, 2);
657  else
658  log2_sub_blocks = 2 * get_bits1(gb);
659  }
660 
661  sub_blocks = 1 << log2_sub_blocks;
662 
663  // do not continue in case of a damaged stream since
664  // block_length must be evenly divisible by sub_blocks
665  if (bd->block_length & (sub_blocks - 1) || bd->block_length <= 0) {
666  av_log(avctx, AV_LOG_WARNING,
667  "Block length is not evenly divisible by the number of subblocks.\n");
668  return AVERROR_INVALIDDATA;
669  }
670 
671  sb_length = bd->block_length >> log2_sub_blocks;
672 
673  if (sconf->bgmc) {
674  s[0] = get_bits(gb, 8 + (sconf->resolution > 1));
675  for (k = 1; k < sub_blocks; k++)
676  s[k] = s[k - 1] + decode_rice(gb, 2);
677 
678  for (k = 0; k < sub_blocks; k++) {
679  sx[k] = s[k] & 0x0F;
680  s [k] >>= 4;
681  }
682  } else {
683  s[0] = get_bits(gb, 4 + (sconf->resolution > 1));
684  for (k = 1; k < sub_blocks; k++)
685  s[k] = s[k - 1] + decode_rice(gb, 0);
686  }
687  for (k = 1; k < sub_blocks; k++)
688  if (s[k] > 32) {
689  av_log(avctx, AV_LOG_ERROR, "k invalid for rice code.\n");
690  return AVERROR_INVALIDDATA;
691  }
692 
693  if (get_bits1(gb))
694  *bd->shift_lsbs = get_bits(gb, 4) + 1;
695 
696  *bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || *bd->shift_lsbs;
697 
698 
699  if (!sconf->rlslms) {
700  if (sconf->adapt_order && sconf->max_order) {
701  int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
702  2, sconf->max_order + 1));
703  *bd->opt_order = get_bits(gb, opt_order_length);
704  if (*bd->opt_order > sconf->max_order) {
705  *bd->opt_order = sconf->max_order;
706  av_log(avctx, AV_LOG_ERROR, "Predictor order too large.\n");
707  return AVERROR_INVALIDDATA;
708  }
709  } else {
710  *bd->opt_order = sconf->max_order;
711  }
712  opt_order = *bd->opt_order;
713 
714  if (opt_order) {
715  int add_base;
716 
717  if (sconf->coef_table == 3) {
718  add_base = 0x7F;
719 
720  // read coefficient 0
721  quant_cof[0] = 32 * parcor_scaled_values[get_bits(gb, 7)];
722 
723  // read coefficient 1
724  if (opt_order > 1)
725  quant_cof[1] = -32 * parcor_scaled_values[get_bits(gb, 7)];
726 
727  // read coefficients 2 to opt_order
728  for (k = 2; k < opt_order; k++)
729  quant_cof[k] = get_bits(gb, 7);
730  } else {
731  int k_max;
732  add_base = 1;
733 
734  // read coefficient 0 to 19
735  k_max = FFMIN(opt_order, 20);
736  for (k = 0; k < k_max; k++) {
737  int rice_param = parcor_rice_table[sconf->coef_table][k][1];
738  int offset = parcor_rice_table[sconf->coef_table][k][0];
739  quant_cof[k] = decode_rice(gb, rice_param) + offset;
740  if (quant_cof[k] < -64 || quant_cof[k] > 63) {
741  av_log(avctx, AV_LOG_ERROR,
742  "quant_cof %"PRId32" is out of range.\n",
743  quant_cof[k]);
744  return AVERROR_INVALIDDATA;
745  }
746  }
747 
748  // read coefficients 20 to 126
749  k_max = FFMIN(opt_order, 127);
750  for (; k < k_max; k++)
751  quant_cof[k] = decode_rice(gb, 2) + (k & 1);
752 
753  // read coefficients 127 to opt_order
754  for (; k < opt_order; k++)
755  quant_cof[k] = decode_rice(gb, 1);
756 
757  quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64];
758 
759  if (opt_order > 1)
760  quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64];
761  }
762 
763  for (k = 2; k < opt_order; k++)
764  quant_cof[k] = (quant_cof[k] * (1 << 14)) + (add_base << 13);
765  }
766  }
767 
768  // read LTP gain and lag values
769  if (sconf->long_term_prediction) {
770  *bd->use_ltp = get_bits1(gb);
771 
772  if (*bd->use_ltp) {
773  int r, c;
774 
775  bd->ltp_gain[0] = decode_rice(gb, 1) * 8;
776  bd->ltp_gain[1] = decode_rice(gb, 2) * 8;
777 
778  r = get_unary(gb, 0, 4);
779  c = get_bits(gb, 2);
780  if (r >= 4) {
781  av_log(avctx, AV_LOG_ERROR, "r overflow\n");
782  return AVERROR_INVALIDDATA;
783  }
784 
785  bd->ltp_gain[2] = ltp_gain_values[r][c];
786 
787  bd->ltp_gain[3] = decode_rice(gb, 2) * 8;
788  bd->ltp_gain[4] = decode_rice(gb, 1) * 8;
789 
790  *bd->ltp_lag = get_bits(gb, ctx->ltp_lag_length);
791  *bd->ltp_lag += FFMAX(4, opt_order + 1);
792  }
793  }
794 
795  // read first value and residuals in case of a random access block
796  if (bd->ra_block) {
797  start = FFMIN(opt_order, 3);
798  av_assert0(sb_length <= sconf->frame_length);
799  if (sb_length <= start) {
800  // opt_order or sb_length may be corrupted, either way this is unsupported and not well defined in the specification
801  av_log(avctx, AV_LOG_ERROR, "Sub block length smaller or equal start\n");
802  return AVERROR_PATCHWELCOME;
803  }
804 
805  if (opt_order)
806  bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);
807  if (opt_order > 1)
808  bd->raw_samples[1] = decode_rice(gb, FFMIN(s[0] + 3, ctx->s_max));
809  if (opt_order > 2)
810  bd->raw_samples[2] = decode_rice(gb, FFMIN(s[0] + 1, ctx->s_max));
811  }
812 
813  // read all residuals
814  if (sconf->bgmc) {
815  int delta[8];
816  unsigned int k [8];
817  unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);
818 
819  // read most significant bits
820  unsigned int high;
821  unsigned int low;
822  unsigned int value;
823 
824  int ret = ff_bgmc_decode_init(gb, &high, &low, &value);
825  if (ret < 0)
826  return ret;
827 
828  current_res = bd->raw_samples + start;
829 
830  for (sb = 0; sb < sub_blocks; sb++) {
831  unsigned int sb_len = sb_length - (sb ? 0 : start);
832 
833  k [sb] = s[sb] > b ? s[sb] - b : 0;
834  delta[sb] = 5 - s[sb] + k[sb];
835 
836  if (k[sb] >= 32)
837  return AVERROR_INVALIDDATA;
838 
839  ff_bgmc_decode(gb, sb_len, current_res,
840  delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
841 
842  current_res += sb_len;
843  }
844 
845  ff_bgmc_decode_end(gb);
846 
847 
848  // read least significant bits and tails
849  current_res = bd->raw_samples + start;
850 
851  for (sb = 0; sb < sub_blocks; sb++, start = 0) {
852  unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]];
853  unsigned int cur_k = k[sb];
854  unsigned int cur_s = s[sb];
855 
856  for (; start < sb_length; start++) {
857  int32_t res = *current_res;
858 
859  if (res == cur_tail_code) {
860  unsigned int max_msb = (2 + (sx[sb] > 2) + (sx[sb] > 10))
861  << (5 - delta[sb]);
862 
863  res = decode_rice(gb, cur_s);
864 
865  if (res >= 0) {
866  res += (max_msb ) << cur_k;
867  } else {
868  res -= (max_msb - 1) << cur_k;
869  }
870  } else {
871  if (res > cur_tail_code)
872  res--;
873 
874  if (res & 1)
875  res = -res;
876 
877  res >>= 1;
878 
879  if (cur_k) {
880  res *= 1U << cur_k;
881  res |= get_bits_long(gb, cur_k);
882  }
883  }
884 
885  *current_res++ = res;
886  }
887  }
888  } else {
889  current_res = bd->raw_samples + start;
890 
891  for (sb = 0; sb < sub_blocks; sb++, start = 0)
892  for (; start < sb_length; start++)
893  *current_res++ = decode_rice(gb, s[sb]);
894  }
895 
896  return 0;
897 }
898 
899 
900 /** Decode the block data for a non-constant block
901  */
903 {
904  ALSSpecificConfig *sconf = &ctx->sconf;
905  unsigned int block_length = bd->block_length;
906  unsigned int smp = 0;
907  unsigned int k;
908  int opt_order = *bd->opt_order;
909  int sb;
910  int64_t y;
911  int32_t *quant_cof = bd->quant_cof;
912  int32_t *lpc_cof = bd->lpc_cof;
913  int32_t *raw_samples = bd->raw_samples;
914  int32_t *raw_samples_end = bd->raw_samples + bd->block_length;
915  int32_t *lpc_cof_reversed = ctx->lpc_cof_reversed_buffer;
916 
917  // reverse long-term prediction
918  if (*bd->use_ltp) {
919  int ltp_smp;
920 
921  for (ltp_smp = FFMAX(*bd->ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) {
922  int center = ltp_smp - *bd->ltp_lag;
923  int begin = FFMAX(0, center - 2);
924  int end = center + 3;
925  int tab = 5 - (end - begin);
926  int base;
927 
928  y = 1 << 6;
929 
930  for (base = begin; base < end; base++, tab++)
931  y += (uint64_t)MUL64(bd->ltp_gain[tab], raw_samples[base]);
932 
933  raw_samples[ltp_smp] += y >> 7;
934  }
935  }
936 
937  // reconstruct all samples from residuals
938  if (bd->ra_block) {
939  for (smp = 0; smp < FFMIN(opt_order, block_length); smp++) {
940  y = 1 << 19;
941 
942  for (sb = 0; sb < smp; sb++)
943  y += (uint64_t)MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]);
944 
945  *raw_samples++ -= y >> 20;
946  parcor_to_lpc(smp, quant_cof, lpc_cof);
947  }
948  } else {
949  for (k = 0; k < opt_order; k++)
950  parcor_to_lpc(k, quant_cof, lpc_cof);
951 
952  // store previous samples in case that they have to be altered
953  if (*bd->store_prev_samples)
954  memcpy(bd->prev_raw_samples, raw_samples - sconf->max_order,
955  sizeof(*bd->prev_raw_samples) * sconf->max_order);
956 
957  // reconstruct difference signal for prediction (joint-stereo)
958  if (bd->js_blocks && bd->raw_other) {
959  uint32_t *left, *right;
960 
961  if (bd->raw_other > raw_samples) { // D = R - L
962  left = raw_samples;
963  right = bd->raw_other;
964  } else { // D = R - L
965  left = bd->raw_other;
966  right = raw_samples;
967  }
968 
969  for (sb = -1; sb >= -sconf->max_order; sb--)
970  raw_samples[sb] = right[sb] - left[sb];
971  }
972 
973  // reconstruct shifted signal
974  if (*bd->shift_lsbs)
975  for (sb = -1; sb >= -sconf->max_order; sb--)
976  raw_samples[sb] >>= *bd->shift_lsbs;
977  }
978 
979  // reverse linear prediction coefficients for efficiency
980  lpc_cof = lpc_cof + opt_order;
981 
982  for (sb = 0; sb < opt_order; sb++)
983  lpc_cof_reversed[sb] = lpc_cof[-(sb + 1)];
984 
985  // reconstruct raw samples
986  raw_samples = bd->raw_samples + smp;
987  lpc_cof = lpc_cof_reversed + opt_order;
988 
989  for (; raw_samples < raw_samples_end; raw_samples++) {
990  y = 1 << 19;
991 
992  for (sb = -opt_order; sb < 0; sb++)
993  y += (uint64_t)MUL64(lpc_cof[sb], raw_samples[sb]);
994 
995  *raw_samples -= y >> 20;
996  }
997 
998  raw_samples = bd->raw_samples;
999 
1000  // restore previous samples in case that they have been altered
1001  if (*bd->store_prev_samples)
1002  memcpy(raw_samples - sconf->max_order, bd->prev_raw_samples,
1003  sizeof(*raw_samples) * sconf->max_order);
1004 
1005  return 0;
1006 }
1007 
1008 
1009 /** Read the block data.
1010  */
1012 {
1013  int ret;
1014  GetBitContext *gb = &ctx->gb;
1015  ALSSpecificConfig *sconf = &ctx->sconf;
1016 
1017  *bd->shift_lsbs = 0;
1018  // read block type flag and read the samples accordingly
1019  if (get_bits1(gb)) {
1020  ret = read_var_block_data(ctx, bd);
1021  } else {
1022  ret = read_const_block_data(ctx, bd);
1023  }
1024 
1025  if (!sconf->mc_coding || ctx->js_switch)
1026  align_get_bits(gb);
1027 
1028  return ret;
1029 }
1030 
1031 
1032 /** Decode the block data.
1033  */
1035 {
1036  unsigned int smp;
1037  int ret = 0;
1038 
1039  // read block type flag and read the samples accordingly
1040  if (*bd->const_block)
1041  decode_const_block_data(ctx, bd);
1042  else
1043  ret = decode_var_block_data(ctx, bd); // always return 0
1044 
1045  if (ret < 0)
1046  return ret;
1047 
1048  // TODO: read RLSLMS extension data
1049 
1050  if (*bd->shift_lsbs)
1051  for (smp = 0; smp < bd->block_length; smp++)
1052  bd->raw_samples[smp] = (unsigned)bd->raw_samples[smp] << *bd->shift_lsbs;
1053 
1054  return 0;
1055 }
1056 
1057 
1058 /** Read and decode block data successively.
1059  */
1061 {
1062  int ret;
1063 
1064  if ((ret = read_block(ctx, bd)) < 0)
1065  return ret;
1066 
1067  return decode_block(ctx, bd);
1068 }
1069 
1070 
1071 /** Compute the number of samples left to decode for the current frame and
1072  * sets these samples to zero.
1073  */
1074 static void zero_remaining(unsigned int b, unsigned int b_max,
1075  const unsigned int *div_blocks, int32_t *buf)
1076 {
1077  unsigned int count = 0;
1078 
1079  while (b < b_max)
1080  count += div_blocks[b++];
1081 
1082  if (count)
1083  memset(buf, 0, sizeof(*buf) * count);
1084 }
1085 
1086 
1087 /** Decode blocks independently.
1088  */
1089 static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,
1090  unsigned int c, const unsigned int *div_blocks,
1091  unsigned int *js_blocks)
1092 {
1093  int ret;
1094  unsigned int b;
1095  ALSBlockData bd = { 0 };
1096 
1097  bd.ra_block = ra_frame;
1098  bd.const_block = ctx->const_block;
1099  bd.shift_lsbs = ctx->shift_lsbs;
1100  bd.opt_order = ctx->opt_order;
1102  bd.use_ltp = ctx->use_ltp;
1103  bd.ltp_lag = ctx->ltp_lag;
1104  bd.ltp_gain = ctx->ltp_gain[0];
1105  bd.quant_cof = ctx->quant_cof[0];
1106  bd.lpc_cof = ctx->lpc_cof[0];
1108  bd.raw_samples = ctx->raw_samples[c];
1109 
1110 
1111  for (b = 0; b < ctx->num_blocks; b++) {
1112  bd.block_length = div_blocks[b];
1113 
1114  if ((ret = read_decode_block(ctx, &bd)) < 0) {
1115  // damaged block, write zero for the rest of the frame
1116  zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples);
1117  return ret;
1118  }
1119  bd.raw_samples += div_blocks[b];
1120  bd.ra_block = 0;
1121  }
1122 
1123  return 0;
1124 }
1125 
1126 
1127 /** Decode blocks dependently.
1128  */
1129 static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame,
1130  unsigned int c, const unsigned int *div_blocks,
1131  unsigned int *js_blocks)
1132 {
1133  ALSSpecificConfig *sconf = &ctx->sconf;
1134  unsigned int offset = 0;
1135  unsigned int b;
1136  int ret;
1137  ALSBlockData bd[2] = { { 0 } };
1138 
1139  bd[0].ra_block = ra_frame;
1140  bd[0].const_block = ctx->const_block;
1141  bd[0].shift_lsbs = ctx->shift_lsbs;
1142  bd[0].opt_order = ctx->opt_order;
1144  bd[0].use_ltp = ctx->use_ltp;
1145  bd[0].ltp_lag = ctx->ltp_lag;
1146  bd[0].ltp_gain = ctx->ltp_gain[0];
1147  bd[0].quant_cof = ctx->quant_cof[0];
1148  bd[0].lpc_cof = ctx->lpc_cof[0];
1149  bd[0].prev_raw_samples = ctx->prev_raw_samples;
1150  bd[0].js_blocks = *js_blocks;
1151 
1152  bd[1].ra_block = ra_frame;
1153  bd[1].const_block = ctx->const_block;
1154  bd[1].shift_lsbs = ctx->shift_lsbs;
1155  bd[1].opt_order = ctx->opt_order;
1157  bd[1].use_ltp = ctx->use_ltp;
1158  bd[1].ltp_lag = ctx->ltp_lag;
1159  bd[1].ltp_gain = ctx->ltp_gain[0];
1160  bd[1].quant_cof = ctx->quant_cof[0];
1161  bd[1].lpc_cof = ctx->lpc_cof[0];
1162  bd[1].prev_raw_samples = ctx->prev_raw_samples;
1163  bd[1].js_blocks = *(js_blocks + 1);
1164 
1165  // decode all blocks
1166  for (b = 0; b < ctx->num_blocks; b++) {
1167  unsigned int s;
1168 
1169  bd[0].block_length = div_blocks[b];
1170  bd[1].block_length = div_blocks[b];
1171 
1172  bd[0].raw_samples = ctx->raw_samples[c ] + offset;
1173  bd[1].raw_samples = ctx->raw_samples[c + 1] + offset;
1174 
1175  bd[0].raw_other = bd[1].raw_samples;
1176  bd[1].raw_other = bd[0].raw_samples;
1177 
1178  if ((ret = read_decode_block(ctx, &bd[0])) < 0 ||
1179  (ret = read_decode_block(ctx, &bd[1])) < 0)
1180  goto fail;
1181 
1182  // reconstruct joint-stereo blocks
1183  if (bd[0].js_blocks) {
1184  if (bd[1].js_blocks)
1185  av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair.\n");
1186 
1187  for (s = 0; s < div_blocks[b]; s++)
1188  bd[0].raw_samples[s] = bd[1].raw_samples[s] - (unsigned)bd[0].raw_samples[s];
1189  } else if (bd[1].js_blocks) {
1190  for (s = 0; s < div_blocks[b]; s++)
1191  bd[1].raw_samples[s] = bd[1].raw_samples[s] + (unsigned)bd[0].raw_samples[s];
1192  }
1193 
1194  offset += div_blocks[b];
1195  bd[0].ra_block = 0;
1196  bd[1].ra_block = 0;
1197  }
1198 
1199  // store carryover raw samples,
1200  // the others channel raw samples are stored by the calling function.
1201  memmove(ctx->raw_samples[c] - sconf->max_order,
1202  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1203  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1204 
1205  return 0;
1206 fail:
1207  // damaged block, write zero for the rest of the frame
1208  zero_remaining(b, ctx->num_blocks, div_blocks, bd[0].raw_samples);
1209  zero_remaining(b, ctx->num_blocks, div_blocks, bd[1].raw_samples);
1210  return ret;
1211 }
1212 
1213 static inline int als_weighting(GetBitContext *gb, int k, int off)
1214 {
1215  int idx = av_clip(decode_rice(gb, k) + off,
1216  0, FF_ARRAY_ELEMS(mcc_weightings) - 1);
1217  return mcc_weightings[idx];
1218 }
1219 
1220 /** Read the channel data.
1221  */
1223 {
1224  GetBitContext *gb = &ctx->gb;
1225  ALSChannelData *current = cd;
1226  unsigned int channels = ctx->avctx->channels;
1227  int entries = 0;
1228 
1229  while (entries < channels && !(current->stop_flag = get_bits1(gb))) {
1230  current->master_channel = get_bits_long(gb, av_ceil_log2(channels));
1231 
1232  if (current->master_channel >= channels) {
1233  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid master channel.\n");
1234  return AVERROR_INVALIDDATA;
1235  }
1236 
1237  if (current->master_channel != c) {
1238  current->time_diff_flag = get_bits1(gb);
1239  current->weighting[0] = als_weighting(gb, 1, 16);
1240  current->weighting[1] = als_weighting(gb, 2, 14);
1241  current->weighting[2] = als_weighting(gb, 1, 16);
1242 
1243  if (current->time_diff_flag) {
1244  current->weighting[3] = als_weighting(gb, 1, 16);
1245  current->weighting[4] = als_weighting(gb, 1, 16);
1246  current->weighting[5] = als_weighting(gb, 1, 16);
1247 
1248  current->time_diff_sign = get_bits1(gb);
1249  current->time_diff_index = get_bits(gb, ctx->ltp_lag_length - 3) + 3;
1250  }
1251  }
1252 
1253  current++;
1254  entries++;
1255  }
1256 
1257  if (entries == channels) {
1258  av_log(ctx->avctx, AV_LOG_ERROR, "Damaged channel data.\n");
1259  return AVERROR_INVALIDDATA;
1260  }
1261 
1262  align_get_bits(gb);
1263  return 0;
1264 }
1265 
1266 
1267 /** Recursively reverts the inter-channel correlation for a block.
1268  */
1270  ALSChannelData **cd, int *reverted,
1271  unsigned int offset, int c)
1272 {
1273  ALSChannelData *ch = cd[c];
1274  unsigned int dep = 0;
1275  unsigned int channels = ctx->avctx->channels;
1276  unsigned int channel_size = ctx->sconf.frame_length + ctx->sconf.max_order;
1277 
1278  if (reverted[c])
1279  return 0;
1280 
1281  reverted[c] = 1;
1282 
1283  while (dep < channels && !ch[dep].stop_flag) {
1284  revert_channel_correlation(ctx, bd, cd, reverted, offset,
1285  ch[dep].master_channel);
1286 
1287  dep++;
1288  }
1289 
1290  if (dep == channels) {
1291  av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation.\n");
1292  return AVERROR_INVALIDDATA;
1293  }
1294 
1295  bd->const_block = ctx->const_block + c;
1296  bd->shift_lsbs = ctx->shift_lsbs + c;
1297  bd->opt_order = ctx->opt_order + c;
1299  bd->use_ltp = ctx->use_ltp + c;
1300  bd->ltp_lag = ctx->ltp_lag + c;
1301  bd->ltp_gain = ctx->ltp_gain[c];
1302  bd->lpc_cof = ctx->lpc_cof[c];
1303  bd->quant_cof = ctx->quant_cof[c];
1304  bd->raw_samples = ctx->raw_samples[c] + offset;
1305 
1306  for (dep = 0; !ch[dep].stop_flag; dep++) {
1307  ptrdiff_t smp;
1308  ptrdiff_t begin = 1;
1309  ptrdiff_t end = bd->block_length - 1;
1310  int64_t y;
1311  int32_t *master = ctx->raw_samples[ch[dep].master_channel] + offset;
1312 
1313  if (ch[dep].master_channel == c)
1314  continue;
1315 
1316  if (ch[dep].time_diff_flag) {
1317  int t = ch[dep].time_diff_index;
1318 
1319  if (ch[dep].time_diff_sign) {
1320  t = -t;
1321  if (begin < t) {
1322  av_log(ctx->avctx, AV_LOG_ERROR, "begin %"PTRDIFF_SPECIFIER" smaller than time diff index %d.\n", begin, t);
1323  return AVERROR_INVALIDDATA;
1324  }
1325  begin -= t;
1326  } else {
1327  if (end < t) {
1328  av_log(ctx->avctx, AV_LOG_ERROR, "end %"PTRDIFF_SPECIFIER" smaller than time diff index %d.\n", end, t);
1329  return AVERROR_INVALIDDATA;
1330  }
1331  end -= t;
1332  }
1333 
1334  if (FFMIN(begin - 1, begin - 1 + t) < ctx->raw_buffer - master ||
1335  FFMAX(end + 1, end + 1 + t) > ctx->raw_buffer + channels * channel_size - master) {
1336  av_log(ctx->avctx, AV_LOG_ERROR,
1337  "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
1338  master + FFMIN(begin - 1, begin - 1 + t), master + FFMAX(end + 1, end + 1 + t),
1339  ctx->raw_buffer, ctx->raw_buffer + channels * channel_size);
1340  return AVERROR_INVALIDDATA;
1341  }
1342 
1343  for (smp = begin; smp < end; smp++) {
1344  y = (1 << 6) +
1345  MUL64(ch[dep].weighting[0], master[smp - 1 ]) +
1346  MUL64(ch[dep].weighting[1], master[smp ]) +
1347  MUL64(ch[dep].weighting[2], master[smp + 1 ]) +
1348  MUL64(ch[dep].weighting[3], master[smp - 1 + t]) +
1349  MUL64(ch[dep].weighting[4], master[smp + t]) +
1350  MUL64(ch[dep].weighting[5], master[smp + 1 + t]);
1351 
1352  bd->raw_samples[smp] += y >> 7;
1353  }
1354  } else {
1355 
1356  if (begin - 1 < ctx->raw_buffer - master ||
1357  end + 1 > ctx->raw_buffer + channels * channel_size - master) {
1358  av_log(ctx->avctx, AV_LOG_ERROR,
1359  "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
1360  master + begin - 1, master + end + 1,
1361  ctx->raw_buffer, ctx->raw_buffer + channels * channel_size);
1362  return AVERROR_INVALIDDATA;
1363  }
1364 
1365  for (smp = begin; smp < end; smp++) {
1366  y = (1 << 6) +
1367  MUL64(ch[dep].weighting[0], master[smp - 1]) +
1368  MUL64(ch[dep].weighting[1], master[smp ]) +
1369  MUL64(ch[dep].weighting[2], master[smp + 1]);
1370 
1371  bd->raw_samples[smp] += y >> 7;
1372  }
1373  }
1374  }
1375 
1376  return 0;
1377 }
1378 
1379 
1380 /** multiply two softfloats and handle the rounding off
1381  */
1383  uint64_t mantissa_temp;
1384  uint64_t mask_64;
1385  int cutoff_bit_count;
1386  unsigned char last_2_bits;
1387  unsigned int mantissa;
1388  int32_t sign;
1389  uint32_t return_val = 0;
1390  int bit_count = 48;
1391 
1392  sign = a.sign ^ b.sign;
1393 
1394  // Multiply mantissa bits in a 64-bit register
1395  mantissa_temp = (uint64_t)a.mant * (uint64_t)b.mant;
1396  mask_64 = (uint64_t)0x1 << 47;
1397 
1398  if (!mantissa_temp)
1399  return FLOAT_0;
1400 
1401  // Count the valid bit count
1402  while (!(mantissa_temp & mask_64) && mask_64) {
1403  bit_count--;
1404  mask_64 >>= 1;
1405  }
1406 
1407  // Round off
1408  cutoff_bit_count = bit_count - 24;
1409  if (cutoff_bit_count > 0) {
1410  last_2_bits = (unsigned char)(((unsigned int)mantissa_temp >> (cutoff_bit_count - 1)) & 0x3 );
1411  if ((last_2_bits == 0x3) || ((last_2_bits == 0x1) && ((unsigned int)mantissa_temp & ((0x1UL << (cutoff_bit_count - 1)) - 1)))) {
1412  // Need to round up
1413  mantissa_temp += (uint64_t)0x1 << cutoff_bit_count;
1414  }
1415  }
1416 
1417  if (cutoff_bit_count >= 0) {
1418  mantissa = (unsigned int)(mantissa_temp >> cutoff_bit_count);
1419  } else {
1420  mantissa = (unsigned int)(mantissa_temp <<-cutoff_bit_count);
1421  }
1422 
1423  // Need one more shift?
1424  if (mantissa & 0x01000000ul) {
1425  bit_count++;
1426  mantissa >>= 1;
1427  }
1428 
1429  if (!sign) {
1430  return_val = 0x80000000U;
1431  }
1432 
1433  return_val |= ((unsigned)av_clip(a.exp + b.exp + bit_count - 47, -126, 127) << 23) & 0x7F800000;
1434  return_val |= mantissa;
1435  return av_bits2sf_ieee754(return_val);
1436 }
1437 
1438 
1439 /** Read and decode the floating point sample data
1440  */
1441 static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame) {
1442  AVCodecContext *avctx = ctx->avctx;
1443  GetBitContext *gb = &ctx->gb;
1444  SoftFloat_IEEE754 *acf = ctx->acf;
1445  int *shift_value = ctx->shift_value;
1446  int *last_shift_value = ctx->last_shift_value;
1447  int *last_acf_mantissa = ctx->last_acf_mantissa;
1448  int **raw_mantissa = ctx->raw_mantissa;
1449  int *nbits = ctx->nbits;
1450  unsigned char *larray = ctx->larray;
1451  int frame_length = ctx->cur_frame_length;
1452  SoftFloat_IEEE754 scale = av_int2sf_ieee754(0x1u, 23);
1453  unsigned int partA_flag;
1454  unsigned int highest_byte;
1455  unsigned int shift_amp;
1456  uint32_t tmp_32;
1457  int use_acf;
1458  int nchars;
1459  int i;
1460  int c;
1461  long k;
1462  long nbits_aligned;
1463  unsigned long acc;
1464  unsigned long j;
1465  uint32_t sign;
1466  uint32_t e;
1467  uint32_t mantissa;
1468 
1469  skip_bits_long(gb, 32); //num_bytes_diff_float
1470  use_acf = get_bits1(gb);
1471 
1472  if (ra_frame) {
1473  memset(last_acf_mantissa, 0, avctx->channels * sizeof(*last_acf_mantissa));
1474  memset(last_shift_value, 0, avctx->channels * sizeof(*last_shift_value) );
1475  ff_mlz_flush_dict(ctx->mlz);
1476  }
1477 
1478  if (avctx->channels * 8 > get_bits_left(gb))
1479  return AVERROR_INVALIDDATA;
1480 
1481  for (c = 0; c < avctx->channels; ++c) {
1482  if (use_acf) {
1483  //acf_flag
1484  if (get_bits1(gb)) {
1485  tmp_32 = get_bits(gb, 23);
1486  last_acf_mantissa[c] = tmp_32;
1487  } else {
1488  tmp_32 = last_acf_mantissa[c];
1489  }
1490  acf[c] = av_bits2sf_ieee754(tmp_32);
1491  } else {
1492  acf[c] = FLOAT_1;
1493  }
1494 
1495  highest_byte = get_bits(gb, 2);
1496  partA_flag = get_bits1(gb);
1497  shift_amp = get_bits1(gb);
1498 
1499  if (shift_amp) {
1500  shift_value[c] = get_bits(gb, 8);
1501  last_shift_value[c] = shift_value[c];
1502  } else {
1503  shift_value[c] = last_shift_value[c];
1504  }
1505 
1506  if (partA_flag) {
1507  if (!get_bits1(gb)) { //uncompressed
1508  for (i = 0; i < frame_length; ++i) {
1509  if (ctx->raw_samples[c][i] == 0) {
1510  ctx->raw_mantissa[c][i] = get_bits_long(gb, 32);
1511  }
1512  }
1513  } else { //compressed
1514  nchars = 0;
1515  for (i = 0; i < frame_length; ++i) {
1516  if (ctx->raw_samples[c][i] == 0) {
1517  nchars += 4;
1518  }
1519  }
1520 
1521  tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray);
1522  if(tmp_32 != nchars) {
1523  av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars);
1524  return AVERROR_INVALIDDATA;
1525  }
1526 
1527  for (i = 0; i < frame_length; ++i) {
1528  ctx->raw_mantissa[c][i] = AV_RB32(larray);
1529  }
1530  }
1531  }
1532 
1533  //decode part B
1534  if (highest_byte) {
1535  for (i = 0; i < frame_length; ++i) {
1536  if (ctx->raw_samples[c][i] != 0) {
1537  //The following logic is taken from Tabel 14.45 and 14.46 from the ISO spec
1538  if (av_cmp_sf_ieee754(acf[c], FLOAT_1)) {
1539  nbits[i] = 23 - av_log2(abs(ctx->raw_samples[c][i]));
1540  } else {
1541  nbits[i] = 23;
1542  }
1543  nbits[i] = FFMIN(nbits[i], highest_byte*8);
1544  }
1545  }
1546 
1547  if (!get_bits1(gb)) { //uncompressed
1548  for (i = 0; i < frame_length; ++i) {
1549  if (ctx->raw_samples[c][i] != 0) {
1550  raw_mantissa[c][i] = get_bitsz(gb, nbits[i]);
1551  }
1552  }
1553  } else { //compressed
1554  nchars = 0;
1555  for (i = 0; i < frame_length; ++i) {
1556  if (ctx->raw_samples[c][i]) {
1557  nchars += (int) nbits[i] / 8;
1558  if (nbits[i] & 7) {
1559  ++nchars;
1560  }
1561  }
1562  }
1563 
1564  tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray);
1565  if(tmp_32 != nchars) {
1566  av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars);
1567  return AVERROR_INVALIDDATA;
1568  }
1569 
1570  j = 0;
1571  for (i = 0; i < frame_length; ++i) {
1572  if (ctx->raw_samples[c][i]) {
1573  if (nbits[i] & 7) {
1574  nbits_aligned = 8 * ((unsigned int)(nbits[i] / 8) + 1);
1575  } else {
1576  nbits_aligned = nbits[i];
1577  }
1578  acc = 0;
1579  for (k = 0; k < nbits_aligned/8; ++k) {
1580  acc = (acc << 8) + larray[j++];
1581  }
1582  acc >>= (nbits_aligned - nbits[i]);
1583  raw_mantissa[c][i] = acc;
1584  }
1585  }
1586  }
1587  }
1588 
1589  for (i = 0; i < frame_length; ++i) {
1590  SoftFloat_IEEE754 pcm_sf = av_int2sf_ieee754(ctx->raw_samples[c][i], 0);
1591  pcm_sf = av_div_sf_ieee754(pcm_sf, scale);
1592 
1593  if (ctx->raw_samples[c][i] != 0) {
1594  if (!av_cmp_sf_ieee754(acf[c], FLOAT_1)) {
1595  pcm_sf = multiply(acf[c], pcm_sf);
1596  }
1597 
1598  sign = pcm_sf.sign;
1599  e = pcm_sf.exp;
1600  mantissa = (pcm_sf.mant | 0x800000) + raw_mantissa[c][i];
1601 
1602  while(mantissa >= 0x1000000) {
1603  e++;
1604  mantissa >>= 1;
1605  }
1606 
1607  if (mantissa) e += (shift_value[c] - 127);
1608  mantissa &= 0x007fffffUL;
1609 
1610  tmp_32 = (sign << 31) | ((e + EXP_BIAS) << 23) | (mantissa);
1611  ctx->raw_samples[c][i] = tmp_32;
1612  } else {
1613  ctx->raw_samples[c][i] = raw_mantissa[c][i] & 0x007fffffUL;
1614  }
1615  }
1616  align_get_bits(gb);
1617  }
1618  return 0;
1619 }
1620 
1621 
1622 /** Read the frame data.
1623  */
1624 static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
1625 {
1626  ALSSpecificConfig *sconf = &ctx->sconf;
1627  AVCodecContext *avctx = ctx->avctx;
1628  GetBitContext *gb = &ctx->gb;
1629  unsigned int div_blocks[32]; ///< block sizes.
1630  unsigned int c;
1631  unsigned int js_blocks[2];
1632  uint32_t bs_info = 0;
1633  int ret;
1634 
1635  // skip the size of the ra unit if present in the frame
1636  if (sconf->ra_flag == RA_FLAG_FRAMES && ra_frame)
1637  skip_bits_long(gb, 32);
1638 
1639  if (sconf->mc_coding && sconf->joint_stereo) {
1640  ctx->js_switch = get_bits1(gb);
1641  align_get_bits(gb);
1642  }
1643 
1644  if (!sconf->mc_coding || ctx->js_switch) {
1645  int independent_bs = !sconf->joint_stereo;
1646 
1647  for (c = 0; c < avctx->channels; c++) {
1648  js_blocks[0] = 0;
1649  js_blocks[1] = 0;
1650 
1651  get_block_sizes(ctx, div_blocks, &bs_info);
1652 
1653  // if joint_stereo and block_switching is set, independent decoding
1654  // is signaled via the first bit of bs_info
1655  if (sconf->joint_stereo && sconf->block_switching)
1656  if (bs_info >> 31)
1657  independent_bs = 2;
1658 
1659  // if this is the last channel, it has to be decoded independently
1660  if (c == avctx->channels - 1 || (c & 1))
1661  independent_bs = 1;
1662 
1663  if (independent_bs) {
1664  ret = decode_blocks_ind(ctx, ra_frame, c,
1665  div_blocks, js_blocks);
1666  if (ret < 0)
1667  return ret;
1668  independent_bs--;
1669  } else {
1670  ret = decode_blocks(ctx, ra_frame, c, div_blocks, js_blocks);
1671  if (ret < 0)
1672  return ret;
1673 
1674  c++;
1675  }
1676 
1677  // store carryover raw samples
1678  memmove(ctx->raw_samples[c] - sconf->max_order,
1679  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1680  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1681  }
1682  } else { // multi-channel coding
1683  ALSBlockData bd = { 0 };
1684  int b, ret;
1685  int *reverted_channels = ctx->reverted_channels;
1686  unsigned int offset = 0;
1687 
1688  for (c = 0; c < avctx->channels; c++)
1689  if (ctx->chan_data[c] < ctx->chan_data_buffer) {
1690  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid channel data.\n");
1691  return AVERROR_INVALIDDATA;
1692  }
1693 
1694  memset(reverted_channels, 0, sizeof(*reverted_channels) * avctx->channels);
1695 
1696  bd.ra_block = ra_frame;
1698 
1699  get_block_sizes(ctx, div_blocks, &bs_info);
1700 
1701  for (b = 0; b < ctx->num_blocks; b++) {
1702  bd.block_length = div_blocks[b];
1703  if (bd.block_length <= 0) {
1704  av_log(ctx->avctx, AV_LOG_WARNING,
1705  "Invalid block length %u in channel data!\n",
1706  bd.block_length);
1707  continue;
1708  }
1709 
1710  for (c = 0; c < avctx->channels; c++) {
1711  bd.const_block = ctx->const_block + c;
1712  bd.shift_lsbs = ctx->shift_lsbs + c;
1713  bd.opt_order = ctx->opt_order + c;
1715  bd.use_ltp = ctx->use_ltp + c;
1716  bd.ltp_lag = ctx->ltp_lag + c;
1717  bd.ltp_gain = ctx->ltp_gain[c];
1718  bd.lpc_cof = ctx->lpc_cof[c];
1719  bd.quant_cof = ctx->quant_cof[c];
1720  bd.raw_samples = ctx->raw_samples[c] + offset;
1721  bd.raw_other = NULL;
1722 
1723  if ((ret = read_block(ctx, &bd)) < 0)
1724  return ret;
1725  if ((ret = read_channel_data(ctx, ctx->chan_data[c], c)) < 0)
1726  return ret;
1727  }
1728 
1729  for (c = 0; c < avctx->channels; c++) {
1730  ret = revert_channel_correlation(ctx, &bd, ctx->chan_data,
1731  reverted_channels, offset, c);
1732  if (ret < 0)
1733  return ret;
1734  }
1735  for (c = 0; c < avctx->channels; c++) {
1736  bd.const_block = ctx->const_block + c;
1737  bd.shift_lsbs = ctx->shift_lsbs + c;
1738  bd.opt_order = ctx->opt_order + c;
1740  bd.use_ltp = ctx->use_ltp + c;
1741  bd.ltp_lag = ctx->ltp_lag + c;
1742  bd.ltp_gain = ctx->ltp_gain[c];
1743  bd.lpc_cof = ctx->lpc_cof[c];
1744  bd.quant_cof = ctx->quant_cof[c];
1745  bd.raw_samples = ctx->raw_samples[c] + offset;
1746 
1747  if ((ret = decode_block(ctx, &bd)) < 0)
1748  return ret;
1749  }
1750 
1751  memset(reverted_channels, 0, avctx->channels * sizeof(*reverted_channels));
1752  offset += div_blocks[b];
1753  bd.ra_block = 0;
1754  }
1755 
1756  // store carryover raw samples
1757  for (c = 0; c < avctx->channels; c++)
1758  memmove(ctx->raw_samples[c] - sconf->max_order,
1759  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1760  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1761  }
1762 
1763  if (sconf->floating) {
1764  read_diff_float_data(ctx, ra_frame);
1765  }
1766 
1767  if (get_bits_left(gb) < 0) {
1768  av_log(ctx->avctx, AV_LOG_ERROR, "Overread %d\n", -get_bits_left(gb));
1769  return AVERROR_INVALIDDATA;
1770  }
1771 
1772  return 0;
1773 }
1774 
1775 
1776 /** Decode an ALS frame.
1777  */
1778 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1779  AVPacket *avpkt)
1780 {
1781  ALSDecContext *ctx = avctx->priv_data;
1782  AVFrame *frame = data;
1783  ALSSpecificConfig *sconf = &ctx->sconf;
1784  const uint8_t *buffer = avpkt->data;
1785  int buffer_size = avpkt->size;
1786  int invalid_frame, ret;
1787  unsigned int c, sample, ra_frame, bytes_read, shift;
1788 
1789  if ((ret = init_get_bits8(&ctx->gb, buffer, buffer_size)) < 0)
1790  return ret;
1791 
1792  // In the case that the distance between random access frames is set to zero
1793  // (sconf->ra_distance == 0) no frame is treated as a random access frame.
1794  // For the first frame, if prediction is used, all samples used from the
1795  // previous frame are assumed to be zero.
1796  ra_frame = sconf->ra_distance && !(ctx->frame_id % sconf->ra_distance);
1797 
1798  // the last frame to decode might have a different length
1799  if (sconf->samples != 0xFFFFFFFF)
1800  ctx->cur_frame_length = FFMIN(sconf->samples - ctx->frame_id * (uint64_t) sconf->frame_length,
1801  sconf->frame_length);
1802  else
1803  ctx->cur_frame_length = sconf->frame_length;
1804 
1805  // decode the frame data
1806  if ((invalid_frame = read_frame_data(ctx, ra_frame)) < 0)
1807  av_log(ctx->avctx, AV_LOG_WARNING,
1808  "Reading frame data failed. Skipping RA unit.\n");
1809 
1810  ctx->frame_id++;
1811 
1812  /* get output buffer */
1813  frame->nb_samples = ctx->cur_frame_length;
1814  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1815  return ret;
1816 
1817  // transform decoded frame into output format
1818  #define INTERLEAVE_OUTPUT(bps) \
1819  { \
1820  int##bps##_t *dest = (int##bps##_t*)frame->data[0]; \
1821  int channels = avctx->channels; \
1822  int32_t **raw_samples = ctx->raw_samples; \
1823  shift = bps - ctx->avctx->bits_per_raw_sample; \
1824  if (!ctx->cs_switch) { \
1825  for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1826  for (c = 0; c < channels; c++) \
1827  *dest++ = raw_samples[c][sample] * (1U << shift); \
1828  } else { \
1829  for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1830  for (c = 0; c < channels; c++) \
1831  *dest++ = raw_samples[sconf->chan_pos[c]][sample] * (1U << shift);\
1832  } \
1833  }
1834 
1835  if (ctx->avctx->bits_per_raw_sample <= 16) {
1836  INTERLEAVE_OUTPUT(16)
1837  } else {
1838  INTERLEAVE_OUTPUT(32)
1839  }
1840 
1841  // update CRC
1842  if (sconf->crc_enabled && (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
1843  int swap = HAVE_BIGENDIAN != sconf->msb_first;
1844 
1845  if (ctx->avctx->bits_per_raw_sample == 24) {
1846  int32_t *src = (int32_t *)frame->data[0];
1847 
1848  for (sample = 0;
1849  sample < ctx->cur_frame_length * avctx->channels;
1850  sample++) {
1851  int32_t v;
1852 
1853  if (swap)
1854  v = av_bswap32(src[sample]);
1855  else
1856  v = src[sample];
1857  if (!HAVE_BIGENDIAN)
1858  v >>= 8;
1859 
1860  ctx->crc = av_crc(ctx->crc_table, ctx->crc, (uint8_t*)(&v), 3);
1861  }
1862  } else {
1863  uint8_t *crc_source;
1864 
1865  if (swap) {
1866  if (ctx->avctx->bits_per_raw_sample <= 16) {
1867  int16_t *src = (int16_t*) frame->data[0];
1868  int16_t *dest = (int16_t*) ctx->crc_buffer;
1869  for (sample = 0;
1870  sample < ctx->cur_frame_length * avctx->channels;
1871  sample++)
1872  *dest++ = av_bswap16(src[sample]);
1873  } else {
1874  ctx->bdsp.bswap_buf((uint32_t *) ctx->crc_buffer,
1875  (uint32_t *) frame->data[0],
1876  ctx->cur_frame_length * avctx->channels);
1877  }
1878  crc_source = ctx->crc_buffer;
1879  } else {
1880  crc_source = frame->data[0];
1881  }
1882 
1883  ctx->crc = av_crc(ctx->crc_table, ctx->crc, crc_source,
1884  ctx->cur_frame_length * avctx->channels *
1886  }
1887 
1888 
1889  // check CRC sums if this is the last frame
1890  if (ctx->cur_frame_length != sconf->frame_length &&
1891  ctx->crc_org != ctx->crc) {
1892  av_log(avctx, AV_LOG_ERROR, "CRC error.\n");
1893  if (avctx->err_recognition & AV_EF_EXPLODE)
1894  return AVERROR_INVALIDDATA;
1895  }
1896  }
1897 
1898  *got_frame_ptr = 1;
1899 
1900  bytes_read = invalid_frame ? buffer_size :
1901  (get_bits_count(&ctx->gb) + 7) >> 3;
1902 
1903  return bytes_read;
1904 }
1905 
1906 
1907 /** Uninitialize the ALS decoder.
1908  */
1910 {
1911  ALSDecContext *ctx = avctx->priv_data;
1912  int i;
1913 
1914  av_freep(&ctx->sconf.chan_pos);
1915 
1916  ff_bgmc_end(&ctx->bgmc_lut, &ctx->bgmc_lut_status);
1917 
1918  av_freep(&ctx->const_block);
1919  av_freep(&ctx->shift_lsbs);
1920  av_freep(&ctx->opt_order);
1922  av_freep(&ctx->use_ltp);
1923  av_freep(&ctx->ltp_lag);
1924  av_freep(&ctx->ltp_gain);
1925  av_freep(&ctx->ltp_gain_buffer);
1926  av_freep(&ctx->quant_cof);
1927  av_freep(&ctx->lpc_cof);
1928  av_freep(&ctx->quant_cof_buffer);
1929  av_freep(&ctx->lpc_cof_buffer);
1931  av_freep(&ctx->prev_raw_samples);
1932  av_freep(&ctx->raw_samples);
1933  av_freep(&ctx->raw_buffer);
1934  av_freep(&ctx->chan_data);
1935  av_freep(&ctx->chan_data_buffer);
1936  av_freep(&ctx->reverted_channels);
1937  av_freep(&ctx->crc_buffer);
1938  if (ctx->mlz) {
1939  av_freep(&ctx->mlz->dict);
1940  av_freep(&ctx->mlz);
1941  }
1942  av_freep(&ctx->acf);
1943  av_freep(&ctx->last_acf_mantissa);
1944  av_freep(&ctx->shift_value);
1945  av_freep(&ctx->last_shift_value);
1946  if (ctx->raw_mantissa) {
1947  for (i = 0; i < avctx->channels; i++) {
1948  av_freep(&ctx->raw_mantissa[i]);
1949  }
1950  av_freep(&ctx->raw_mantissa);
1951  }
1952  av_freep(&ctx->larray);
1953  av_freep(&ctx->nbits);
1954 
1955  return 0;
1956 }
1957 
1958 
1959 /** Initialize the ALS decoder.
1960  */
1962 {
1963  unsigned int c;
1964  unsigned int channel_size;
1965  int num_buffers, ret;
1966  ALSDecContext *ctx = avctx->priv_data;
1967  ALSSpecificConfig *sconf = &ctx->sconf;
1968  ctx->avctx = avctx;
1969 
1970  if (!avctx->extradata) {
1971  av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n");
1972  return AVERROR_INVALIDDATA;
1973  }
1974 
1975  if ((ret = read_specific_config(ctx)) < 0) {
1976  av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
1977  goto fail;
1978  }
1979 
1980  if ((ret = check_specific_config(ctx)) < 0) {
1981  goto fail;
1982  }
1983 
1984  if (sconf->bgmc) {
1985  ret = ff_bgmc_init(avctx, &ctx->bgmc_lut, &ctx->bgmc_lut_status);
1986  if (ret < 0)
1987  goto fail;
1988  }
1989  if (sconf->floating) {
1990  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1991  avctx->bits_per_raw_sample = 32;
1992  } else {
1993  avctx->sample_fmt = sconf->resolution > 1
1995  avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
1996  if (avctx->bits_per_raw_sample > 32) {
1997  av_log(avctx, AV_LOG_ERROR, "Bits per raw sample %d larger than 32.\n",
1998  avctx->bits_per_raw_sample);
1999  ret = AVERROR_INVALIDDATA;
2000  goto fail;
2001  }
2002  }
2003 
2004  // set maximum Rice parameter for progressive decoding based on resolution
2005  // This is not specified in 14496-3 but actually done by the reference
2006  // codec RM22 revision 2.
2007  ctx->s_max = sconf->resolution > 1 ? 31 : 15;
2008 
2009  // set lag value for long-term prediction
2010  ctx->ltp_lag_length = 8 + (avctx->sample_rate >= 96000) +
2011  (avctx->sample_rate >= 192000);
2012 
2013  // allocate quantized parcor coefficient buffer
2014  num_buffers = sconf->mc_coding ? avctx->channels : 1;
2015  if (num_buffers * (uint64_t)num_buffers > INT_MAX) // protect chan_data_buffer allocation
2016  return AVERROR_INVALIDDATA;
2017 
2018  ctx->quant_cof = av_malloc_array(num_buffers, sizeof(*ctx->quant_cof));
2019  ctx->lpc_cof = av_malloc_array(num_buffers, sizeof(*ctx->lpc_cof));
2020  ctx->quant_cof_buffer = av_malloc_array(num_buffers * sconf->max_order,
2021  sizeof(*ctx->quant_cof_buffer));
2022  ctx->lpc_cof_buffer = av_malloc_array(num_buffers * sconf->max_order,
2023  sizeof(*ctx->lpc_cof_buffer));
2025  sizeof(*ctx->lpc_cof_buffer));
2026 
2027  if (!ctx->quant_cof || !ctx->lpc_cof ||
2028  !ctx->quant_cof_buffer || !ctx->lpc_cof_buffer ||
2029  !ctx->lpc_cof_reversed_buffer) {
2030  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2031  ret = AVERROR(ENOMEM);
2032  goto fail;
2033  }
2034 
2035  // assign quantized parcor coefficient buffers
2036  for (c = 0; c < num_buffers; c++) {
2037  ctx->quant_cof[c] = ctx->quant_cof_buffer + c * sconf->max_order;
2038  ctx->lpc_cof[c] = ctx->lpc_cof_buffer + c * sconf->max_order;
2039  }
2040 
2041  // allocate and assign lag and gain data buffer for ltp mode
2042  ctx->const_block = av_malloc_array(num_buffers, sizeof(*ctx->const_block));
2043  ctx->shift_lsbs = av_malloc_array(num_buffers, sizeof(*ctx->shift_lsbs));
2044  ctx->opt_order = av_malloc_array(num_buffers, sizeof(*ctx->opt_order));
2045  ctx->store_prev_samples = av_malloc_array(num_buffers, sizeof(*ctx->store_prev_samples));
2046  ctx->use_ltp = av_mallocz_array(num_buffers, sizeof(*ctx->use_ltp));
2047  ctx->ltp_lag = av_malloc_array(num_buffers, sizeof(*ctx->ltp_lag));
2048  ctx->ltp_gain = av_malloc_array(num_buffers, sizeof(*ctx->ltp_gain));
2049  ctx->ltp_gain_buffer = av_malloc_array(num_buffers * 5, sizeof(*ctx->ltp_gain_buffer));
2050 
2051  if (!ctx->const_block || !ctx->shift_lsbs ||
2052  !ctx->opt_order || !ctx->store_prev_samples ||
2053  !ctx->use_ltp || !ctx->ltp_lag ||
2054  !ctx->ltp_gain || !ctx->ltp_gain_buffer) {
2055  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2056  ret = AVERROR(ENOMEM);
2057  goto fail;
2058  }
2059 
2060  for (c = 0; c < num_buffers; c++)
2061  ctx->ltp_gain[c] = ctx->ltp_gain_buffer + c * 5;
2062 
2063  // allocate and assign channel data buffer for mcc mode
2064  if (sconf->mc_coding) {
2065  ctx->chan_data_buffer = av_mallocz_array(num_buffers * num_buffers,
2066  sizeof(*ctx->chan_data_buffer));
2067  ctx->chan_data = av_mallocz_array(num_buffers,
2068  sizeof(*ctx->chan_data));
2069  ctx->reverted_channels = av_malloc_array(num_buffers,
2070  sizeof(*ctx->reverted_channels));
2071 
2072  if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) {
2073  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2074  ret = AVERROR(ENOMEM);
2075  goto fail;
2076  }
2077 
2078  for (c = 0; c < num_buffers; c++)
2079  ctx->chan_data[c] = ctx->chan_data_buffer + c * num_buffers;
2080  } else {
2081  ctx->chan_data = NULL;
2082  ctx->chan_data_buffer = NULL;
2083  ctx->reverted_channels = NULL;
2084  }
2085 
2086  channel_size = sconf->frame_length + sconf->max_order;
2087 
2088  ctx->prev_raw_samples = av_malloc_array(sconf->max_order, sizeof(*ctx->prev_raw_samples));
2089  ctx->raw_buffer = av_mallocz_array(avctx->channels * channel_size, sizeof(*ctx->raw_buffer));
2090  ctx->raw_samples = av_malloc_array(avctx->channels, sizeof(*ctx->raw_samples));
2091 
2092  if (sconf->floating) {
2093  ctx->acf = av_malloc_array(avctx->channels, sizeof(*ctx->acf));
2094  ctx->shift_value = av_malloc_array(avctx->channels, sizeof(*ctx->shift_value));
2095  ctx->last_shift_value = av_malloc_array(avctx->channels, sizeof(*ctx->last_shift_value));
2096  ctx->last_acf_mantissa = av_malloc_array(avctx->channels, sizeof(*ctx->last_acf_mantissa));
2097  ctx->raw_mantissa = av_mallocz_array(avctx->channels, sizeof(*ctx->raw_mantissa));
2098 
2099  ctx->larray = av_malloc_array(ctx->cur_frame_length * 4, sizeof(*ctx->larray));
2100  ctx->nbits = av_malloc_array(ctx->cur_frame_length, sizeof(*ctx->nbits));
2101  ctx->mlz = av_mallocz(sizeof(*ctx->mlz));
2102 
2103  if (!ctx->mlz || !ctx->acf || !ctx->shift_value || !ctx->last_shift_value
2104  || !ctx->last_acf_mantissa || !ctx->raw_mantissa) {
2105  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2106  ret = AVERROR(ENOMEM);
2107  goto fail;
2108  }
2109 
2110  ff_mlz_init_dict(avctx, ctx->mlz);
2111  ff_mlz_flush_dict(ctx->mlz);
2112 
2113  for (c = 0; c < avctx->channels; ++c) {
2114  ctx->raw_mantissa[c] = av_mallocz_array(ctx->cur_frame_length, sizeof(**ctx->raw_mantissa));
2115  }
2116  }
2117 
2118  // allocate previous raw sample buffer
2119  if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) {
2120  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2121  ret = AVERROR(ENOMEM);
2122  goto fail;
2123  }
2124 
2125  // assign raw samples buffers
2126  ctx->raw_samples[0] = ctx->raw_buffer + sconf->max_order;
2127  for (c = 1; c < avctx->channels; c++)
2128  ctx->raw_samples[c] = ctx->raw_samples[c - 1] + channel_size;
2129 
2130  // allocate crc buffer
2131  if (HAVE_BIGENDIAN != sconf->msb_first && sconf->crc_enabled &&
2134  avctx->channels *
2136  sizeof(*ctx->crc_buffer));
2137  if (!ctx->crc_buffer) {
2138  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2139  ret = AVERROR(ENOMEM);
2140  goto fail;
2141  }
2142  }
2143 
2144  ff_bswapdsp_init(&ctx->bdsp);
2145 
2146  return 0;
2147 
2148 fail:
2149  return ret;
2150 }
2151 
2152 
2153 /** Flush (reset) the frame ID after seeking.
2154  */
2155 static av_cold void flush(AVCodecContext *avctx)
2156 {
2157  ALSDecContext *ctx = avctx->priv_data;
2158 
2159  ctx->frame_id = 0;
2160 }
2161 
2162 
2164  .name = "als",
2165  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
2166  .type = AVMEDIA_TYPE_AUDIO,
2167  .id = AV_CODEC_ID_MP4ALS,
2168  .priv_data_size = sizeof(ALSDecContext),
2169  .init = decode_init,
2170  .close = decode_end,
2171  .decode = decode_frame,
2172  .flush = flush,
2173  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
2174  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2175 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define MUL64(a, b)
Definition: mathops.h:54
#define FF_SANE_NB_CHANNELS
Definition: internal.h:86
AVCodec ff_als_decoder
Definition: alsdec.c:2163
static int als_weighting(GetBitContext *gb, int k, int off)
Definition: alsdec.c:1213
static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a non-constant block.
Definition: alsdec.c:902
int msb_first
1 = original CRC calculated on big-endian system, 0 = little-endian
Definition: alsdec.c:162
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
unsigned char * larray
buffer to store the output of masked lz decompression
Definition: alsdec.c:237
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int shift(int a, int b)
Definition: sonic.c:82
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int * use_ltp
contains use_ltp flags for all channels
Definition: alsdec.c:215
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
av_cold void ff_bgmc_end(uint8_t **cf_lut, int **cf_lut_status)
Release the lookup table arrays.
Definition: bgmc.c:480
MLZ * mlz
masked lz decompression structure
Definition: alsdec.c:231
int32_t ** raw_samples
decoded raw samples for each channel
Definition: alsdec.c:228
uint8_t * crc_buffer
buffer of byte order corrected samples used for CRC check
Definition: alsdec.c:230
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static const int16_t mcc_weightings[]
Inter-channel weighting factors for multi-channel correlation.
Definition: alsdec.c:121
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int acc
Definition: yuv2rgb.c:554
#define avpriv_request_sample(...)
int block_switching
number of block switching levels
Definition: alsdec.c:170
int rlslms
use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
Definition: alsdec.c:177
channels
Definition: aptx.c:30
int size
Definition: avcodec.h:1481
static int check_specific_config(ALSDecContext *ctx)
Check the ALSSpecificConfig for unsupported features.
Definition: alsdec.c:445
#define av_bswap16
Definition: bswap.h:31
int av_log2(unsigned v)
Definition: intmath.c:26
int adapt_order
adaptive order: 1 = on, 0 = off
Definition: alsdec.c:166
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
Read the frame data.
Definition: alsdec.c:1624
int32_t * lpc_cof_reversed_buffer
temporary buffer to set up a reversed versio of lpc_cof_buffer
Definition: alsdec.c:223
GetBitContext gb
Definition: alsdec.c:197
Block Gilbert-Moore decoder header.
int * nbits
contains the number of bits to read for masked lz decompression for all samples
Definition: alsdec.c:238
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
const char * master
Definition: vf_curves.c:117
unsigned int js_switch
if true, joint-stereo decoding is enforced
Definition: alsdec.c:204
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2799
static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
Read and decode block data successively.
Definition: alsdec.c:1060
#define INTERLEAVE_OUTPUT(bps)
#define src
Definition: vp8dsp.c:254
#define sample
AVCodec.
Definition: avcodec.h:3492
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static int32_t decode_rice(GetBitContext *gb, unsigned int k)
Read and decode a Rice codeword.
Definition: alsdec.c:492
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:590
uint8_t base
Definition: vp3data.h:202
int * ltp_lag
contains ltp lag values for all channels
Definition: alsdec.c:216
int * const_block
contains const_block flags for all channels
Definition: alsdec.c:211
static const uint8_t ltp_gain_values[4][4]
Gain values of p(0) for long-term prediction.
Definition: alsdec.c:110
static const SoftFloat FLOAT_0
0.0
Definition: softfloat.h:39
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static av_cold int decode_init(AVCodecContext *avctx)
Initialize the ALS decoder.
Definition: alsdec.c:1961
BswapDSPContext bdsp
Definition: alsdec.c:198
int32_t * lpc_cof
coefficients of the direct form prediction
Definition: alsdec.c:254
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2236
uint8_t
#define av_cold
Definition: attributes.h:82
int avpriv_mpeg4audio_get_config2(MPEG4AudioConfig *c, const uint8_t *buf, int size, int sync_extension, void *logctx)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration. ...
Definition: mpeg4audio.c:177
static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a constant block.
Definition: alsdec.c:613
float delta
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int ** ltp_gain
gain values for ltp 5-tap filter for a channel
Definition: alsdec.c:217
static SoftFloat_IEEE754 av_bits2sf_ieee754(uint32_t n)
Make a softfloat out of the bitstream.
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1669
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
int chan_sort
channel rearrangement: 1 = on, 0 = off
Definition: alsdec.c:176
int joint_stereo
joint stereo: 1 = on, 0 = off
Definition: alsdec.c:173
Public header for CRC hash function implementation.
static SoftFloat_IEEE754 av_int2sf_ieee754(int64_t n, int e)
Convert integer to softfloat.
uint8_t * data
Definition: avcodec.h:1480
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define ff_dlog(a,...)
bitstream reader API header.
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:1089
unsigned int block_length
number of samples within the block
Definition: alsdec.c:243
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:1074
#define max(a, b)
Definition: cuda_runtime.h:33
int ra_distance
distance between RA frames (in frames, 0...255)
Definition: alsdec.c:164
int weighting[6]
Definition: alsdec.c:190
int32_t * quant_cof_buffer
contains all quantized parcor coefficients
Definition: alsdec.c:220
signed 32 bits
Definition: samplefmt.h:62
ALSChannelData * chan_data_buffer
contains channel data for all channels
Definition: alsdec.c:225
#define av_log(a,...)
int bgmc
"Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
Definition: alsdec.c:171
#define U(x)
Definition: vp56_arith.h:37
MLZDict * dict
Definition: mlz.h:54
unsigned int cs_switch
if true, channel rearrangement is done
Definition: alsdec.c:205
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
int * use_ltp
if true, long-term prediction is used
Definition: alsdec.c:250
enum RA_Flag ra_flag
indicates where the size of ra units is stored
Definition: alsdec.c:165
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ltp_lag_length
number of bits used for ltp lag value
Definition: alsdec.c:210
#define PTRDIFF_SPECIFIER
Definition: internal.h:261
static av_cold void dprint_specific_config(ALSDecContext *ctx)
Definition: alsdec.c:261
unsigned int * opt_order
prediction order of this block
Definition: alsdec.c:248
int * chan_pos
original channel positions
Definition: alsdec.c:179
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
AVCodecContext * avctx
Definition: alsdec.c:195
static const int16_t parcor_scaled_values[]
Scaled PARCOR values used for the first two PARCOR coefficients.
Definition: alsdec.c:71
static const SoftFloat FLOAT_1
1.0
Definition: softfloat.h:41
const char * r
Definition: vf_curves.c:114
static SoftFloat_IEEE754 multiply(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
multiply two softfloats and handle the rounding off
Definition: alsdec.c:1382
int32_t ** lpc_cof
coefficients of the direct form prediction filter for a channel
Definition: alsdec.c:221
static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame)
Read and decode the floating point sample data.
Definition: alsdec.c:1441
int chan_config_info
mapping of channels to loudspeaker locations. Unused until setting channel configuration is implement...
Definition: alsdec.c:178
unsigned int num_blocks
number of blocks used in the current frame
Definition: alsdec.c:206
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
int32_t * prev_raw_samples
contains unshifted raw samples from the previous block
Definition: alsdec.c:227
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:1129
void ff_bgmc_decode_end(GetBitContext *gb)
Finish decoding.
Definition: bgmc.c:503
const AVCRC * crc_table
Definition: alsdec.c:199
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:94
int * bgmc_lut_status
pointer at lookup table status flags used for BGMC
Definition: alsdec.c:209
#define fail()
Definition: checkasm.h:122
ALSSpecificConfig sconf
Definition: alsdec.c:196
int * store_prev_samples
if true, carryover samples have to be stored
Definition: alsdec.c:249
unsigned int * shift_lsbs
contains shift_lsbs flags for all channels
Definition: alsdec.c:212
#define b
Definition: input.c:41
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2697
#define FFMIN(a, b)
Definition: common.h:96
static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data for a non-constant block.
Definition: alsdec.c:627
int ff_mlz_decompression(MLZ *mlz, GetBitContext *gb, int size, unsigned char *buff)
Run mlz decompression on the next size bits and the output will be stored in buff.
Definition: mlz.c:123
int chan_config
indicates that a chan_config_info field is present
Definition: alsdec.c:175
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
#define EXP_BIAS
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:392
int * last_shift_value
contains last shift value for all channels
Definition: alsdec.c:235
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int av_cmp_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
Compare a with b strictly.
#define s(width, name)
Definition: cbs_vp9.c:257
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:510
static av_cold int decode_end(AVCodecContext *avctx)
Uninitialize the ALS decoder.
Definition: alsdec.c:1909
int * const_block
if true, this is a constant value block
Definition: alsdec.c:245
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2708
int n
Definition: avisynth_c.h:760
int floating
1 = IEEE 32-bit floating-point, 0 = integer
Definition: alsdec.c:161
int time_diff_flag
Definition: alsdec.c:187
SoftFloat_IEEE754 * acf
contains common multiplier for all channels
Definition: alsdec.c:232
int master_channel
Definition: alsdec.c:186
uint32_t crc
CRC value calculated from decoded data.
Definition: alsdec.c:201
int coef_table
table index of Rice code parameters
Definition: alsdec.c:167
static void error(const char *err)
static int read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data for a constant block.
Definition: alsdec.c:583
#define FF_ARRAY_ELEMS(a)
int sb_part
sub-block partition
Definition: alsdec.c:172
MLZ data strucure.
Definition: mlz.h:47
int32_t * raw_other
decoded raw samples of the other channel of a channel pair
Definition: alsdec.c:257
if(ret)
uint8_t * bgmc_lut
pointer at lookup tables used for BGMC
Definition: alsdec.c:208
av_cold void ff_mlz_init_dict(void *context, MLZ *mlz)
Initialize the dictionary.
Definition: mlz.c:23
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int * ltp_gain
gain values for ltp 5-tap filter
Definition: alsdec.c:252
int js_blocks
true if this block contains a difference signal
Definition: alsdec.c:246
#define av_bswap32
Definition: bswap.h:33
unsigned int ra_block
if true, this is a random access block
Definition: alsdec.c:244
Libavcodec external API header.
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:510
int * shift_value
value by which the binary point is to be shifted for all channels
Definition: alsdec.c:234
int sample_rate
samples per second
Definition: avcodec.h:2228
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
#define abs(x)
Definition: cuda_runtime.h:35
main external API structure.
Definition: avcodec.h:1568
ALSChannelData ** chan_data
channel data for multi-channel correlation
Definition: alsdec.c:224
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode an ALS frame.
Definition: alsdec.c:1778
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
#define MISSING_ERR(cond, str, errval)
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1670
#define AV_EF_CAREFUL
consider things that violate the spec, are fast to calculate and have not been seen in the wild as er...
Definition: avcodec.h:2711
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
unsigned int s_max
maximum Rice parameter allowed in entropy coding
Definition: alsdec.c:207
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: avcodec.h:1027
int * ltp_lag
lag value for long-term prediction
Definition: alsdec.c:251
int32_t * lpc_cof_buffer
contains all coefficients of the direct form prediction filter
Definition: alsdec.c:222
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:2705
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:50
RA_Flag
Definition: alsdec.c:151
static av_cold int read_specific_config(ALSDecContext *ctx)
Read an ALSSpecificConfig from a buffer into the output struct.
Definition: alsdec.c:291
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
int long_term_prediction
long term prediction (LTP): 1 = on, 0 = off
Definition: alsdec.c:168
int32_t * raw_samples
decoded raw samples / residuals for this block
Definition: alsdec.c:255
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
int * reverted_channels
stores a flag for each reverted channel
Definition: alsdec.c:226
int 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:488
int * last_acf_mantissa
contains the last acf mantissa data of common multiplier for all channels
Definition: alsdec.c:233
unsigned int * opt_order
contains opt_order flags for all channels
Definition: alsdec.c:213
int32_t * raw_buffer
contains all decoded raw samples including carryover samples
Definition: alsdec.c:229
int max_order
maximum prediction order (0..1023)
Definition: alsdec.c:169
uint32_t samples
number of samples, 0xFFFFFFFF if unknown
Definition: alsdec.c:159
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
int mc_coding
extended inter-channel coding (multi channel coding): 1 = on, 0 = off
Definition: alsdec.c:174
int
static const uint8_t tail_code[16][6]
Tail codes used in arithmetic coding using block Gilbert-Moore codes.
Definition: alsdec.c:131
common internal api header.
int32_t * prev_raw_samples
contains unshifted raw samples from the previous block
Definition: alsdec.c:256
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
av_cold void ff_mlz_flush_dict(MLZ *mlz)
Flush the dictionary.
Definition: mlz.c:35
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
Definition: alsdec.c:2155
signed 16 bits
Definition: samplefmt.h:61
int time_diff_index
Definition: alsdec.c:189
int * ltp_gain_buffer
contains all gain values for ltp 5-tap filter
Definition: alsdec.c:218
int32_t * quant_cof
quantized parcor coefficients
Definition: alsdec.c:253
#define MKBETAG(a, b, c, d)
Definition: common.h:367
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:469
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1595
int32_t ** quant_cof
quantized parcor coefficients for a channel
Definition: alsdec.c:219
int channels
number of audio channels
Definition: avcodec.h:2229
int crc_enabled
enable Cyclic Redundancy Checksum
Definition: alsdec.c:180
int ** raw_mantissa
decoded mantissa bits of the difference signal
Definition: alsdec.c:236
uint32_t crc_org
CRC value of the original input data.
Definition: alsdec.c:200
static int decode_block(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data.
Definition: alsdec.c:1034
static int read_block(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data.
Definition: alsdec.c:1011
int frame_length
frame length for each frame (last frame may differ)
Definition: alsdec.c:163
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
int stop_flag
Definition: alsdec.c:185
static const struct twinvq_data tab
unsigned int * shift_lsbs
shift of values for this block
Definition: alsdec.c:247
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
av_cold int ff_bgmc_init(AVCodecContext *avctx, uint8_t **cf_lut, int **cf_lut_status)
Initialize the lookup table arrays.
Definition: bgmc.c:460
#define av_malloc_array(a, b)
static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c)
Read the channel data.
Definition: alsdec.c:1222
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:530
int * store_prev_samples
contains store_prev_samples flags for all channels
Definition: alsdec.c:214
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame 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.Frame references ownership and permissions
static SoftFloat_IEEE754 av_div_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
Divide a by b.
unsigned int frame_id
the frame ID / number of the current frame
Definition: alsdec.c:203
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:1269
This structure stores compressed data.
Definition: avcodec.h:1457
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
uint32_t AVCRC
Definition: crc.h:47
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
for(j=16;j >0;--j)
unsigned int cur_frame_length
length of the current frame to decode
Definition: alsdec.c:202
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
GLuint buffer
Definition: opengl_enc.c:101
int resolution
000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
Definition: alsdec.c:160
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
int time_diff_sign
Definition: alsdec.c:188