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_config(&m4ac, avctx->extradata,
306  avctx->extradata_size * 8, 1);
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  ctx->cur_frame_length = sconf->frame_length;
352 
353  // read channel config
354  if (sconf->chan_config)
355  sconf->chan_config_info = get_bits(&gb, 16);
356  // TODO: use this to set avctx->channel_layout
357 
358 
359  // read channel sorting
360  if (sconf->chan_sort && avctx->channels > 1) {
361  int chan_pos_bits = av_ceil_log2(avctx->channels);
362  int bits_needed = avctx->channels * chan_pos_bits + 7;
363  if (get_bits_left(&gb) < bits_needed)
364  return AVERROR_INVALIDDATA;
365 
366  if (!(sconf->chan_pos = av_malloc_array(avctx->channels, sizeof(*sconf->chan_pos))))
367  return AVERROR(ENOMEM);
368 
369  ctx->cs_switch = 1;
370 
371  for (i = 0; i < avctx->channels; i++) {
372  sconf->chan_pos[i] = -1;
373  }
374 
375  for (i = 0; i < avctx->channels; i++) {
376  int idx;
377 
378  idx = get_bits(&gb, chan_pos_bits);
379  if (idx >= avctx->channels || sconf->chan_pos[idx] != -1) {
380  av_log(avctx, AV_LOG_WARNING, "Invalid channel reordering.\n");
381  ctx->cs_switch = 0;
382  break;
383  }
384  sconf->chan_pos[idx] = i;
385  }
386 
387  align_get_bits(&gb);
388  }
389 
390 
391  // read fixed header and trailer sizes,
392  // if size = 0xFFFFFFFF then there is no data field!
393  if (get_bits_left(&gb) < 64)
394  return AVERROR_INVALIDDATA;
395 
396  header_size = get_bits_long(&gb, 32);
397  trailer_size = get_bits_long(&gb, 32);
398  if (header_size == 0xFFFFFFFF)
399  header_size = 0;
400  if (trailer_size == 0xFFFFFFFF)
401  trailer_size = 0;
402 
403  ht_size = ((int64_t)(header_size) + (int64_t)(trailer_size)) << 3;
404 
405 
406  // skip the header and trailer data
407  if (get_bits_left(&gb) < ht_size)
408  return AVERROR_INVALIDDATA;
409 
410  if (ht_size > INT32_MAX)
411  return AVERROR_PATCHWELCOME;
412 
413  skip_bits_long(&gb, ht_size);
414 
415 
416  // initialize CRC calculation
417  if (sconf->crc_enabled) {
418  if (get_bits_left(&gb) < 32)
419  return AVERROR_INVALIDDATA;
420 
423  ctx->crc = 0xFFFFFFFF;
424  ctx->crc_org = ~get_bits_long(&gb, 32);
425  } else
426  skip_bits_long(&gb, 32);
427  }
428 
429 
430  // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data)
431 
433 
434  return 0;
435 }
436 
437 
438 /** Check the ALSSpecificConfig for unsupported features.
439  */
441 {
442  ALSSpecificConfig *sconf = &ctx->sconf;
443  int error = 0;
444 
445  // report unsupported feature and set error value
446  #define MISSING_ERR(cond, str, errval) \
447  { \
448  if (cond) { \
449  avpriv_report_missing_feature(ctx->avctx, \
450  str); \
451  error = errval; \
452  } \
453  }
454 
455  MISSING_ERR(sconf->rlslms, "Adaptive RLS-LMS prediction", AVERROR_PATCHWELCOME);
456 
457  return error;
458 }
459 
460 
461 /** Parse the bs_info field to extract the block partitioning used in
462  * block switching mode, refer to ISO/IEC 14496-3, section 11.6.2.
463  */
464 static void parse_bs_info(const uint32_t bs_info, unsigned int n,
465  unsigned int div, unsigned int **div_blocks,
466  unsigned int *num_blocks)
467 {
468  if (n < 31 && ((bs_info << n) & 0x40000000)) {
469  // if the level is valid and the investigated bit n is set
470  // then recursively check both children at bits (2n+1) and (2n+2)
471  n *= 2;
472  div += 1;
473  parse_bs_info(bs_info, n + 1, div, div_blocks, num_blocks);
474  parse_bs_info(bs_info, n + 2, div, div_blocks, num_blocks);
475  } else {
476  // else the bit is not set or the last level has been reached
477  // (bit implicitly not set)
478  **div_blocks = div;
479  (*div_blocks)++;
480  (*num_blocks)++;
481  }
482 }
483 
484 
485 /** Read and decode a Rice codeword.
486  */
487 static int32_t decode_rice(GetBitContext *gb, unsigned int k)
488 {
489  int max = get_bits_left(gb) - k;
490  unsigned q = get_unary(gb, 0, max);
491  int r = k ? get_bits1(gb) : !(q & 1);
492 
493  if (k > 1) {
494  q <<= (k - 1);
495  q += get_bits_long(gb, k - 1);
496  } else if (!k) {
497  q >>= 1;
498  }
499  return r ? q : ~q;
500 }
501 
502 
503 /** Convert PARCOR coefficient k to direct filter coefficient.
504  */
505 static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
506 {
507  int i, j;
508 
509  for (i = 0, j = k - 1; i < j; i++, j--) {
510  int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
511  cof[j] += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);
512  cof[i] += tmp1;
513  }
514  if (i == j)
515  cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
516 
517  cof[k] = par[k];
518 }
519 
520 
521 /** Read block switching field if necessary and set actual block sizes.
522  * Also assure that the block sizes of the last frame correspond to the
523  * actual number of samples.
524  */
525 static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks,
526  uint32_t *bs_info)
527 {
528  ALSSpecificConfig *sconf = &ctx->sconf;
529  GetBitContext *gb = &ctx->gb;
530  unsigned int *ptr_div_blocks = div_blocks;
531  unsigned int b;
532 
533  if (sconf->block_switching) {
534  unsigned int bs_info_len = 1 << (sconf->block_switching + 2);
535  *bs_info = get_bits_long(gb, bs_info_len);
536  *bs_info <<= (32 - bs_info_len);
537  }
538 
539  ctx->num_blocks = 0;
540  parse_bs_info(*bs_info, 0, 0, &ptr_div_blocks, &ctx->num_blocks);
541 
542  // The last frame may have an overdetermined block structure given in
543  // the bitstream. In that case the defined block structure would need
544  // more samples than available to be consistent.
545  // The block structure is actually used but the block sizes are adapted
546  // to fit the actual number of available samples.
547  // Example: 5 samples, 2nd level block sizes: 2 2 2 2.
548  // This results in the actual block sizes: 2 2 1 0.
549  // This is not specified in 14496-3 but actually done by the reference
550  // codec RM22 revision 2.
551  // This appears to happen in case of an odd number of samples in the last
552  // frame which is actually not allowed by the block length switching part
553  // of 14496-3.
554  // The ALS conformance files feature an odd number of samples in the last
555  // frame.
556 
557  for (b = 0; b < ctx->num_blocks; b++)
558  div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b];
559 
560  if (ctx->cur_frame_length != ctx->sconf.frame_length) {
561  unsigned int remaining = ctx->cur_frame_length;
562 
563  for (b = 0; b < ctx->num_blocks; b++) {
564  if (remaining <= div_blocks[b]) {
565  div_blocks[b] = remaining;
566  ctx->num_blocks = b + 1;
567  break;
568  }
569 
570  remaining -= div_blocks[b];
571  }
572  }
573 }
574 
575 
576 /** Read the block data for a constant block
577  */
579 {
580  ALSSpecificConfig *sconf = &ctx->sconf;
581  AVCodecContext *avctx = ctx->avctx;
582  GetBitContext *gb = &ctx->gb;
583 
584  if (bd->block_length <= 0)
585  return AVERROR_INVALIDDATA;
586 
587  *bd->raw_samples = 0;
588  *bd->const_block = get_bits1(gb); // 1 = constant value, 0 = zero block (silence)
589  bd->js_blocks = get_bits1(gb);
590 
591  // skip 5 reserved bits
592  skip_bits(gb, 5);
593 
594  if (*bd->const_block) {
595  unsigned int const_val_bits = sconf->floating ? 24 : avctx->bits_per_raw_sample;
596  *bd->raw_samples = get_sbits_long(gb, const_val_bits);
597  }
598 
599  // ensure constant block decoding by reusing this field
600  *bd->const_block = 1;
601 
602  return 0;
603 }
604 
605 
606 /** Decode the block data for a constant block
607  */
609 {
610  int smp = bd->block_length - 1;
611  int32_t val = *bd->raw_samples;
612  int32_t *dst = bd->raw_samples + 1;
613 
614  // write raw samples into buffer
615  for (; smp; smp--)
616  *dst++ = val;
617 }
618 
619 
620 /** Read the block data for a non-constant block
621  */
623 {
624  ALSSpecificConfig *sconf = &ctx->sconf;
625  AVCodecContext *avctx = ctx->avctx;
626  GetBitContext *gb = &ctx->gb;
627  unsigned int k;
628  unsigned int s[8];
629  unsigned int sx[8];
630  unsigned int sub_blocks, log2_sub_blocks, sb_length;
631  unsigned int start = 0;
632  unsigned int opt_order;
633  int sb;
634  int32_t *quant_cof = bd->quant_cof;
635  int32_t *current_res;
636 
637 
638  // ensure variable block decoding by reusing this field
639  *bd->const_block = 0;
640 
641  *bd->opt_order = 1;
642  bd->js_blocks = get_bits1(gb);
643 
644  opt_order = *bd->opt_order;
645 
646  // determine the number of subblocks for entropy decoding
647  if (!sconf->bgmc && !sconf->sb_part) {
648  log2_sub_blocks = 0;
649  } else {
650  if (sconf->bgmc && sconf->sb_part)
651  log2_sub_blocks = get_bits(gb, 2);
652  else
653  log2_sub_blocks = 2 * get_bits1(gb);
654  }
655 
656  sub_blocks = 1 << log2_sub_blocks;
657 
658  // do not continue in case of a damaged stream since
659  // block_length must be evenly divisible by sub_blocks
660  if (bd->block_length & (sub_blocks - 1)) {
661  av_log(avctx, AV_LOG_WARNING,
662  "Block length is not evenly divisible by the number of subblocks.\n");
663  return AVERROR_INVALIDDATA;
664  }
665 
666  sb_length = bd->block_length >> log2_sub_blocks;
667 
668  if (sconf->bgmc) {
669  s[0] = get_bits(gb, 8 + (sconf->resolution > 1));
670  for (k = 1; k < sub_blocks; k++)
671  s[k] = s[k - 1] + decode_rice(gb, 2);
672 
673  for (k = 0; k < sub_blocks; k++) {
674  sx[k] = s[k] & 0x0F;
675  s [k] >>= 4;
676  }
677  } else {
678  s[0] = get_bits(gb, 4 + (sconf->resolution > 1));
679  for (k = 1; k < sub_blocks; k++)
680  s[k] = s[k - 1] + decode_rice(gb, 0);
681  }
682  for (k = 1; k < sub_blocks; k++)
683  if (s[k] > 32) {
684  av_log(avctx, AV_LOG_ERROR, "k invalid for rice code.\n");
685  return AVERROR_INVALIDDATA;
686  }
687 
688  if (get_bits1(gb))
689  *bd->shift_lsbs = get_bits(gb, 4) + 1;
690 
691  *bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || *bd->shift_lsbs;
692 
693 
694  if (!sconf->rlslms) {
695  if (sconf->adapt_order && sconf->max_order) {
696  int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
697  2, sconf->max_order + 1));
698  *bd->opt_order = get_bits(gb, opt_order_length);
699  if (*bd->opt_order > sconf->max_order) {
700  *bd->opt_order = sconf->max_order;
701  av_log(avctx, AV_LOG_ERROR, "Predictor order too large.\n");
702  return AVERROR_INVALIDDATA;
703  }
704  } else {
705  *bd->opt_order = sconf->max_order;
706  }
707  opt_order = *bd->opt_order;
708 
709  if (opt_order) {
710  int add_base;
711 
712  if (sconf->coef_table == 3) {
713  add_base = 0x7F;
714 
715  // read coefficient 0
716  quant_cof[0] = 32 * parcor_scaled_values[get_bits(gb, 7)];
717 
718  // read coefficient 1
719  if (opt_order > 1)
720  quant_cof[1] = -32 * parcor_scaled_values[get_bits(gb, 7)];
721 
722  // read coefficients 2 to opt_order
723  for (k = 2; k < opt_order; k++)
724  quant_cof[k] = get_bits(gb, 7);
725  } else {
726  int k_max;
727  add_base = 1;
728 
729  // read coefficient 0 to 19
730  k_max = FFMIN(opt_order, 20);
731  for (k = 0; k < k_max; k++) {
732  int rice_param = parcor_rice_table[sconf->coef_table][k][1];
733  int offset = parcor_rice_table[sconf->coef_table][k][0];
734  quant_cof[k] = decode_rice(gb, rice_param) + offset;
735  if (quant_cof[k] < -64 || quant_cof[k] > 63) {
736  av_log(avctx, AV_LOG_ERROR,
737  "quant_cof %"PRId32" is out of range.\n",
738  quant_cof[k]);
739  return AVERROR_INVALIDDATA;
740  }
741  }
742 
743  // read coefficients 20 to 126
744  k_max = FFMIN(opt_order, 127);
745  for (; k < k_max; k++)
746  quant_cof[k] = decode_rice(gb, 2) + (k & 1);
747 
748  // read coefficients 127 to opt_order
749  for (; k < opt_order; k++)
750  quant_cof[k] = decode_rice(gb, 1);
751 
752  quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64];
753 
754  if (opt_order > 1)
755  quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64];
756  }
757 
758  for (k = 2; k < opt_order; k++)
759  quant_cof[k] = (quant_cof[k] * (1 << 14)) + (add_base << 13);
760  }
761  }
762 
763  // read LTP gain and lag values
764  if (sconf->long_term_prediction) {
765  *bd->use_ltp = get_bits1(gb);
766 
767  if (*bd->use_ltp) {
768  int r, c;
769 
770  bd->ltp_gain[0] = decode_rice(gb, 1) * 8;
771  bd->ltp_gain[1] = decode_rice(gb, 2) * 8;
772 
773  r = get_unary(gb, 0, 4);
774  c = get_bits(gb, 2);
775  if (r >= 4) {
776  av_log(avctx, AV_LOG_ERROR, "r overflow\n");
777  return AVERROR_INVALIDDATA;
778  }
779 
780  bd->ltp_gain[2] = ltp_gain_values[r][c];
781 
782  bd->ltp_gain[3] = decode_rice(gb, 2) * 8;
783  bd->ltp_gain[4] = decode_rice(gb, 1) * 8;
784 
785  *bd->ltp_lag = get_bits(gb, ctx->ltp_lag_length);
786  *bd->ltp_lag += FFMAX(4, opt_order + 1);
787  }
788  }
789 
790  // read first value and residuals in case of a random access block
791  if (bd->ra_block) {
792  start = FFMIN(opt_order, 3);
793  av_assert0(sb_length <= sconf->frame_length);
794  if (sb_length <= start) {
795  // opt_order or sb_length may be corrupted, either way this is unsupported and not well defined in the specification
796  av_log(avctx, AV_LOG_ERROR, "Sub block length smaller or equal start\n");
797  return AVERROR_PATCHWELCOME;
798  }
799 
800  if (opt_order)
801  bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);
802  if (opt_order > 1)
803  bd->raw_samples[1] = decode_rice(gb, FFMIN(s[0] + 3, ctx->s_max));
804  if (opt_order > 2)
805  bd->raw_samples[2] = decode_rice(gb, FFMIN(s[0] + 1, ctx->s_max));
806  }
807 
808  // read all residuals
809  if (sconf->bgmc) {
810  int delta[8];
811  unsigned int k [8];
812  unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);
813 
814  // read most significant bits
815  unsigned int high;
816  unsigned int low;
817  unsigned int value;
818 
819  ff_bgmc_decode_init(gb, &high, &low, &value);
820 
821  current_res = bd->raw_samples + start;
822 
823  for (sb = 0; sb < sub_blocks; sb++) {
824  unsigned int sb_len = sb_length - (sb ? 0 : start);
825 
826  k [sb] = s[sb] > b ? s[sb] - b : 0;
827  delta[sb] = 5 - s[sb] + k[sb];
828 
829  ff_bgmc_decode(gb, sb_len, current_res,
830  delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
831 
832  current_res += sb_len;
833  }
834 
835  ff_bgmc_decode_end(gb);
836 
837 
838  // read least significant bits and tails
839  current_res = bd->raw_samples + start;
840 
841  for (sb = 0; sb < sub_blocks; sb++, start = 0) {
842  unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]];
843  unsigned int cur_k = k[sb];
844  unsigned int cur_s = s[sb];
845 
846  for (; start < sb_length; start++) {
847  int32_t res = *current_res;
848 
849  if (res == cur_tail_code) {
850  unsigned int max_msb = (2 + (sx[sb] > 2) + (sx[sb] > 10))
851  << (5 - delta[sb]);
852 
853  res = decode_rice(gb, cur_s);
854 
855  if (res >= 0) {
856  res += (max_msb ) << cur_k;
857  } else {
858  res -= (max_msb - 1) << cur_k;
859  }
860  } else {
861  if (res > cur_tail_code)
862  res--;
863 
864  if (res & 1)
865  res = -res;
866 
867  res >>= 1;
868 
869  if (cur_k) {
870  res *= 1U << cur_k;
871  res |= get_bits_long(gb, cur_k);
872  }
873  }
874 
875  *current_res++ = res;
876  }
877  }
878  } else {
879  current_res = bd->raw_samples + start;
880 
881  for (sb = 0; sb < sub_blocks; sb++, start = 0)
882  for (; start < sb_length; start++)
883  *current_res++ = decode_rice(gb, s[sb]);
884  }
885 
886  return 0;
887 }
888 
889 
890 /** Decode the block data for a non-constant block
891  */
893 {
894  ALSSpecificConfig *sconf = &ctx->sconf;
895  unsigned int block_length = bd->block_length;
896  unsigned int smp = 0;
897  unsigned int k;
898  int opt_order = *bd->opt_order;
899  int sb;
900  int64_t y;
901  int32_t *quant_cof = bd->quant_cof;
902  int32_t *lpc_cof = bd->lpc_cof;
903  int32_t *raw_samples = bd->raw_samples;
904  int32_t *raw_samples_end = bd->raw_samples + bd->block_length;
905  int32_t *lpc_cof_reversed = ctx->lpc_cof_reversed_buffer;
906 
907  // reverse long-term prediction
908  if (*bd->use_ltp) {
909  int ltp_smp;
910 
911  for (ltp_smp = FFMAX(*bd->ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) {
912  int center = ltp_smp - *bd->ltp_lag;
913  int begin = FFMAX(0, center - 2);
914  int end = center + 3;
915  int tab = 5 - (end - begin);
916  int base;
917 
918  y = 1 << 6;
919 
920  for (base = begin; base < end; base++, tab++)
921  y += MUL64(bd->ltp_gain[tab], raw_samples[base]);
922 
923  raw_samples[ltp_smp] += y >> 7;
924  }
925  }
926 
927  // reconstruct all samples from residuals
928  if (bd->ra_block) {
929  for (smp = 0; smp < FFMIN(opt_order, block_length); smp++) {
930  y = 1 << 19;
931 
932  for (sb = 0; sb < smp; sb++)
933  y += MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]);
934 
935  *raw_samples++ -= y >> 20;
936  parcor_to_lpc(smp, quant_cof, lpc_cof);
937  }
938  } else {
939  for (k = 0; k < opt_order; k++)
940  parcor_to_lpc(k, quant_cof, lpc_cof);
941 
942  // store previous samples in case that they have to be altered
943  if (*bd->store_prev_samples)
944  memcpy(bd->prev_raw_samples, raw_samples - sconf->max_order,
945  sizeof(*bd->prev_raw_samples) * sconf->max_order);
946 
947  // reconstruct difference signal for prediction (joint-stereo)
948  if (bd->js_blocks && bd->raw_other) {
949  int32_t *left, *right;
950 
951  if (bd->raw_other > raw_samples) { // D = R - L
952  left = raw_samples;
953  right = bd->raw_other;
954  } else { // D = R - L
955  left = bd->raw_other;
956  right = raw_samples;
957  }
958 
959  for (sb = -1; sb >= -sconf->max_order; sb--)
960  raw_samples[sb] = right[sb] - left[sb];
961  }
962 
963  // reconstruct shifted signal
964  if (*bd->shift_lsbs)
965  for (sb = -1; sb >= -sconf->max_order; sb--)
966  raw_samples[sb] >>= *bd->shift_lsbs;
967  }
968 
969  // reverse linear prediction coefficients for efficiency
970  lpc_cof = lpc_cof + opt_order;
971 
972  for (sb = 0; sb < opt_order; sb++)
973  lpc_cof_reversed[sb] = lpc_cof[-(sb + 1)];
974 
975  // reconstruct raw samples
976  raw_samples = bd->raw_samples + smp;
977  lpc_cof = lpc_cof_reversed + opt_order;
978 
979  for (; raw_samples < raw_samples_end; raw_samples++) {
980  y = 1 << 19;
981 
982  for (sb = -opt_order; sb < 0; sb++)
983  y += MUL64(lpc_cof[sb], raw_samples[sb]);
984 
985  *raw_samples -= y >> 20;
986  }
987 
988  raw_samples = bd->raw_samples;
989 
990  // restore previous samples in case that they have been altered
991  if (*bd->store_prev_samples)
992  memcpy(raw_samples - sconf->max_order, bd->prev_raw_samples,
993  sizeof(*raw_samples) * sconf->max_order);
994 
995  return 0;
996 }
997 
998 
999 /** Read the block data.
1000  */
1002 {
1003  int ret;
1004  GetBitContext *gb = &ctx->gb;
1005  ALSSpecificConfig *sconf = &ctx->sconf;
1006 
1007  *bd->shift_lsbs = 0;
1008  // read block type flag and read the samples accordingly
1009  if (get_bits1(gb)) {
1010  ret = read_var_block_data(ctx, bd);
1011  } else {
1012  ret = read_const_block_data(ctx, bd);
1013  }
1014 
1015  if (!sconf->mc_coding || ctx->js_switch)
1016  align_get_bits(gb);
1017 
1018  return ret;
1019 }
1020 
1021 
1022 /** Decode the block data.
1023  */
1025 {
1026  unsigned int smp;
1027  int ret = 0;
1028 
1029  // read block type flag and read the samples accordingly
1030  if (*bd->const_block)
1031  decode_const_block_data(ctx, bd);
1032  else
1033  ret = decode_var_block_data(ctx, bd); // always return 0
1034 
1035  if (ret < 0)
1036  return ret;
1037 
1038  // TODO: read RLSLMS extension data
1039 
1040  if (*bd->shift_lsbs)
1041  for (smp = 0; smp < bd->block_length; smp++)
1042  bd->raw_samples[smp] = (unsigned)bd->raw_samples[smp] << *bd->shift_lsbs;
1043 
1044  return 0;
1045 }
1046 
1047 
1048 /** Read and decode block data successively.
1049  */
1051 {
1052  int ret;
1053 
1054  if ((ret = read_block(ctx, bd)) < 0)
1055  return ret;
1056 
1057  return decode_block(ctx, bd);
1058 }
1059 
1060 
1061 /** Compute the number of samples left to decode for the current frame and
1062  * sets these samples to zero.
1063  */
1064 static void zero_remaining(unsigned int b, unsigned int b_max,
1065  const unsigned int *div_blocks, int32_t *buf)
1066 {
1067  unsigned int count = 0;
1068 
1069  while (b < b_max)
1070  count += div_blocks[b++];
1071 
1072  if (count)
1073  memset(buf, 0, sizeof(*buf) * count);
1074 }
1075 
1076 
1077 /** Decode blocks independently.
1078  */
1079 static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,
1080  unsigned int c, const unsigned int *div_blocks,
1081  unsigned int *js_blocks)
1082 {
1083  int ret;
1084  unsigned int b;
1085  ALSBlockData bd = { 0 };
1086 
1087  bd.ra_block = ra_frame;
1088  bd.const_block = ctx->const_block;
1089  bd.shift_lsbs = ctx->shift_lsbs;
1090  bd.opt_order = ctx->opt_order;
1092  bd.use_ltp = ctx->use_ltp;
1093  bd.ltp_lag = ctx->ltp_lag;
1094  bd.ltp_gain = ctx->ltp_gain[0];
1095  bd.quant_cof = ctx->quant_cof[0];
1096  bd.lpc_cof = ctx->lpc_cof[0];
1098  bd.raw_samples = ctx->raw_samples[c];
1099 
1100 
1101  for (b = 0; b < ctx->num_blocks; b++) {
1102  bd.block_length = div_blocks[b];
1103 
1104  if ((ret = read_decode_block(ctx, &bd)) < 0) {
1105  // damaged block, write zero for the rest of the frame
1106  zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples);
1107  return ret;
1108  }
1109  bd.raw_samples += div_blocks[b];
1110  bd.ra_block = 0;
1111  }
1112 
1113  return 0;
1114 }
1115 
1116 
1117 /** Decode blocks dependently.
1118  */
1119 static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame,
1120  unsigned int c, const unsigned int *div_blocks,
1121  unsigned int *js_blocks)
1122 {
1123  ALSSpecificConfig *sconf = &ctx->sconf;
1124  unsigned int offset = 0;
1125  unsigned int b;
1126  int ret;
1127  ALSBlockData bd[2] = { { 0 } };
1128 
1129  bd[0].ra_block = ra_frame;
1130  bd[0].const_block = ctx->const_block;
1131  bd[0].shift_lsbs = ctx->shift_lsbs;
1132  bd[0].opt_order = ctx->opt_order;
1134  bd[0].use_ltp = ctx->use_ltp;
1135  bd[0].ltp_lag = ctx->ltp_lag;
1136  bd[0].ltp_gain = ctx->ltp_gain[0];
1137  bd[0].quant_cof = ctx->quant_cof[0];
1138  bd[0].lpc_cof = ctx->lpc_cof[0];
1139  bd[0].prev_raw_samples = ctx->prev_raw_samples;
1140  bd[0].js_blocks = *js_blocks;
1141 
1142  bd[1].ra_block = ra_frame;
1143  bd[1].const_block = ctx->const_block;
1144  bd[1].shift_lsbs = ctx->shift_lsbs;
1145  bd[1].opt_order = ctx->opt_order;
1147  bd[1].use_ltp = ctx->use_ltp;
1148  bd[1].ltp_lag = ctx->ltp_lag;
1149  bd[1].ltp_gain = ctx->ltp_gain[0];
1150  bd[1].quant_cof = ctx->quant_cof[0];
1151  bd[1].lpc_cof = ctx->lpc_cof[0];
1152  bd[1].prev_raw_samples = ctx->prev_raw_samples;
1153  bd[1].js_blocks = *(js_blocks + 1);
1154 
1155  // decode all blocks
1156  for (b = 0; b < ctx->num_blocks; b++) {
1157  unsigned int s;
1158 
1159  bd[0].block_length = div_blocks[b];
1160  bd[1].block_length = div_blocks[b];
1161 
1162  bd[0].raw_samples = ctx->raw_samples[c ] + offset;
1163  bd[1].raw_samples = ctx->raw_samples[c + 1] + offset;
1164 
1165  bd[0].raw_other = bd[1].raw_samples;
1166  bd[1].raw_other = bd[0].raw_samples;
1167 
1168  if ((ret = read_decode_block(ctx, &bd[0])) < 0 ||
1169  (ret = read_decode_block(ctx, &bd[1])) < 0)
1170  goto fail;
1171 
1172  // reconstruct joint-stereo blocks
1173  if (bd[0].js_blocks) {
1174  if (bd[1].js_blocks)
1175  av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair.\n");
1176 
1177  for (s = 0; s < div_blocks[b]; s++)
1178  bd[0].raw_samples[s] = bd[1].raw_samples[s] - bd[0].raw_samples[s];
1179  } else if (bd[1].js_blocks) {
1180  for (s = 0; s < div_blocks[b]; s++)
1181  bd[1].raw_samples[s] = bd[1].raw_samples[s] + bd[0].raw_samples[s];
1182  }
1183 
1184  offset += div_blocks[b];
1185  bd[0].ra_block = 0;
1186  bd[1].ra_block = 0;
1187  }
1188 
1189  // store carryover raw samples,
1190  // the others channel raw samples are stored by the calling function.
1191  memmove(ctx->raw_samples[c] - sconf->max_order,
1192  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1193  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1194 
1195  return 0;
1196 fail:
1197  // damaged block, write zero for the rest of the frame
1198  zero_remaining(b, ctx->num_blocks, div_blocks, bd[0].raw_samples);
1199  zero_remaining(b, ctx->num_blocks, div_blocks, bd[1].raw_samples);
1200  return ret;
1201 }
1202 
1203 static inline int als_weighting(GetBitContext *gb, int k, int off)
1204 {
1205  int idx = av_clip(decode_rice(gb, k) + off,
1206  0, FF_ARRAY_ELEMS(mcc_weightings) - 1);
1207  return mcc_weightings[idx];
1208 }
1209 
1210 /** Read the channel data.
1211  */
1213 {
1214  GetBitContext *gb = &ctx->gb;
1215  ALSChannelData *current = cd;
1216  unsigned int channels = ctx->avctx->channels;
1217  int entries = 0;
1218 
1219  while (entries < channels && !(current->stop_flag = get_bits1(gb))) {
1220  current->master_channel = get_bits_long(gb, av_ceil_log2(channels));
1221 
1222  if (current->master_channel >= channels) {
1223  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid master channel.\n");
1224  return AVERROR_INVALIDDATA;
1225  }
1226 
1227  if (current->master_channel != c) {
1228  current->time_diff_flag = get_bits1(gb);
1229  current->weighting[0] = als_weighting(gb, 1, 16);
1230  current->weighting[1] = als_weighting(gb, 2, 14);
1231  current->weighting[2] = als_weighting(gb, 1, 16);
1232 
1233  if (current->time_diff_flag) {
1234  current->weighting[3] = als_weighting(gb, 1, 16);
1235  current->weighting[4] = als_weighting(gb, 1, 16);
1236  current->weighting[5] = als_weighting(gb, 1, 16);
1237 
1238  current->time_diff_sign = get_bits1(gb);
1239  current->time_diff_index = get_bits(gb, ctx->ltp_lag_length - 3) + 3;
1240  }
1241  }
1242 
1243  current++;
1244  entries++;
1245  }
1246 
1247  if (entries == channels) {
1248  av_log(ctx->avctx, AV_LOG_ERROR, "Damaged channel data.\n");
1249  return AVERROR_INVALIDDATA;
1250  }
1251 
1252  align_get_bits(gb);
1253  return 0;
1254 }
1255 
1256 
1257 /** Recursively reverts the inter-channel correlation for a block.
1258  */
1260  ALSChannelData **cd, int *reverted,
1261  unsigned int offset, int c)
1262 {
1263  ALSChannelData *ch = cd[c];
1264  unsigned int dep = 0;
1265  unsigned int channels = ctx->avctx->channels;
1266  unsigned int channel_size = ctx->sconf.frame_length + ctx->sconf.max_order;
1267 
1268  if (reverted[c])
1269  return 0;
1270 
1271  reverted[c] = 1;
1272 
1273  while (dep < channels && !ch[dep].stop_flag) {
1274  revert_channel_correlation(ctx, bd, cd, reverted, offset,
1275  ch[dep].master_channel);
1276 
1277  dep++;
1278  }
1279 
1280  if (dep == channels) {
1281  av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation.\n");
1282  return AVERROR_INVALIDDATA;
1283  }
1284 
1285  bd->const_block = ctx->const_block + c;
1286  bd->shift_lsbs = ctx->shift_lsbs + c;
1287  bd->opt_order = ctx->opt_order + c;
1289  bd->use_ltp = ctx->use_ltp + c;
1290  bd->ltp_lag = ctx->ltp_lag + c;
1291  bd->ltp_gain = ctx->ltp_gain[c];
1292  bd->lpc_cof = ctx->lpc_cof[c];
1293  bd->quant_cof = ctx->quant_cof[c];
1294  bd->raw_samples = ctx->raw_samples[c] + offset;
1295 
1296  for (dep = 0; !ch[dep].stop_flag; dep++) {
1297  ptrdiff_t smp;
1298  ptrdiff_t begin = 1;
1299  ptrdiff_t end = bd->block_length - 1;
1300  int64_t y;
1301  int32_t *master = ctx->raw_samples[ch[dep].master_channel] + offset;
1302 
1303  if (ch[dep].master_channel == c)
1304  continue;
1305 
1306  if (ch[dep].time_diff_flag) {
1307  int t = ch[dep].time_diff_index;
1308 
1309  if (ch[dep].time_diff_sign) {
1310  t = -t;
1311  if (begin < t) {
1312  av_log(ctx->avctx, AV_LOG_ERROR, "begin %"PTRDIFF_SPECIFIER" smaller than time diff index %d.\n", begin, t);
1313  return AVERROR_INVALIDDATA;
1314  }
1315  begin -= t;
1316  } else {
1317  if (end < t) {
1318  av_log(ctx->avctx, AV_LOG_ERROR, "end %"PTRDIFF_SPECIFIER" smaller than time diff index %d.\n", end, t);
1319  return AVERROR_INVALIDDATA;
1320  }
1321  end -= t;
1322  }
1323 
1324  if (FFMIN(begin - 1, begin - 1 + t) < ctx->raw_buffer - master ||
1325  FFMAX(end + 1, end + 1 + t) > ctx->raw_buffer + channels * channel_size - master) {
1326  av_log(ctx->avctx, AV_LOG_ERROR,
1327  "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
1328  master + FFMIN(begin - 1, begin - 1 + t), master + FFMAX(end + 1, end + 1 + t),
1329  ctx->raw_buffer, ctx->raw_buffer + channels * channel_size);
1330  return AVERROR_INVALIDDATA;
1331  }
1332 
1333  for (smp = begin; smp < end; smp++) {
1334  y = (1 << 6) +
1335  MUL64(ch[dep].weighting[0], master[smp - 1 ]) +
1336  MUL64(ch[dep].weighting[1], master[smp ]) +
1337  MUL64(ch[dep].weighting[2], master[smp + 1 ]) +
1338  MUL64(ch[dep].weighting[3], master[smp - 1 + t]) +
1339  MUL64(ch[dep].weighting[4], master[smp + t]) +
1340  MUL64(ch[dep].weighting[5], master[smp + 1 + t]);
1341 
1342  bd->raw_samples[smp] += y >> 7;
1343  }
1344  } else {
1345 
1346  if (begin - 1 < ctx->raw_buffer - master ||
1347  end + 1 > ctx->raw_buffer + channels * channel_size - master) {
1348  av_log(ctx->avctx, AV_LOG_ERROR,
1349  "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
1350  master + begin - 1, master + end + 1,
1351  ctx->raw_buffer, ctx->raw_buffer + channels * channel_size);
1352  return AVERROR_INVALIDDATA;
1353  }
1354 
1355  for (smp = begin; smp < end; smp++) {
1356  y = (1 << 6) +
1357  MUL64(ch[dep].weighting[0], master[smp - 1]) +
1358  MUL64(ch[dep].weighting[1], master[smp ]) +
1359  MUL64(ch[dep].weighting[2], master[smp + 1]);
1360 
1361  bd->raw_samples[smp] += y >> 7;
1362  }
1363  }
1364  }
1365 
1366  return 0;
1367 }
1368 
1369 
1370 /** multiply two softfloats and handle the rounding off
1371  */
1373  uint64_t mantissa_temp;
1374  uint64_t mask_64;
1375  int cutoff_bit_count;
1376  unsigned char last_2_bits;
1377  unsigned int mantissa;
1378  int32_t sign;
1379  uint32_t return_val = 0;
1380  int bit_count = 48;
1381 
1382  sign = a.sign ^ b.sign;
1383 
1384  // Multiply mantissa bits in a 64-bit register
1385  mantissa_temp = (uint64_t)a.mant * (uint64_t)b.mant;
1386  mask_64 = (uint64_t)0x1 << 47;
1387 
1388  if (!mantissa_temp)
1389  return FLOAT_0;
1390 
1391  // Count the valid bit count
1392  while (!(mantissa_temp & mask_64) && mask_64) {
1393  bit_count--;
1394  mask_64 >>= 1;
1395  }
1396 
1397  // Round off
1398  cutoff_bit_count = bit_count - 24;
1399  if (cutoff_bit_count > 0) {
1400  last_2_bits = (unsigned char)(((unsigned int)mantissa_temp >> (cutoff_bit_count - 1)) & 0x3 );
1401  if ((last_2_bits == 0x3) || ((last_2_bits == 0x1) && ((unsigned int)mantissa_temp & ((0x1UL << (cutoff_bit_count - 1)) - 1)))) {
1402  // Need to round up
1403  mantissa_temp += (uint64_t)0x1 << cutoff_bit_count;
1404  }
1405  }
1406 
1407  mantissa = (unsigned int)(mantissa_temp >> cutoff_bit_count);
1408 
1409  // Need one more shift?
1410  if (mantissa & 0x01000000ul) {
1411  bit_count++;
1412  mantissa >>= 1;
1413  }
1414 
1415  if (!sign) {
1416  return_val = 0x80000000U;
1417  }
1418 
1419  return_val |= (a.exp + b.exp + bit_count - 47) << 23;
1420  return_val |= mantissa;
1421  return av_bits2sf_ieee754(return_val);
1422 }
1423 
1424 
1425 /** Read and decode the floating point sample data
1426  */
1427 static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame) {
1428  AVCodecContext *avctx = ctx->avctx;
1429  GetBitContext *gb = &ctx->gb;
1430  SoftFloat_IEEE754 *acf = ctx->acf;
1431  int *shift_value = ctx->shift_value;
1432  int *last_shift_value = ctx->last_shift_value;
1433  int *last_acf_mantissa = ctx->last_acf_mantissa;
1434  int **raw_mantissa = ctx->raw_mantissa;
1435  int *nbits = ctx->nbits;
1436  unsigned char *larray = ctx->larray;
1437  int frame_length = ctx->cur_frame_length;
1438  SoftFloat_IEEE754 scale = av_int2sf_ieee754(0x1u, 23);
1439  unsigned int partA_flag;
1440  unsigned int highest_byte;
1441  unsigned int shift_amp;
1442  uint32_t tmp_32;
1443  int use_acf;
1444  int nchars;
1445  int i;
1446  int c;
1447  long k;
1448  long nbits_aligned;
1449  unsigned long acc;
1450  unsigned long j;
1451  uint32_t sign;
1452  uint32_t e;
1453  uint32_t mantissa;
1454 
1455  skip_bits_long(gb, 32); //num_bytes_diff_float
1456  use_acf = get_bits1(gb);
1457 
1458  if (ra_frame) {
1459  memset(last_acf_mantissa, 0, avctx->channels * sizeof(*last_acf_mantissa));
1460  memset(last_shift_value, 0, avctx->channels * sizeof(*last_shift_value) );
1461  ff_mlz_flush_dict(ctx->mlz);
1462  }
1463 
1464  for (c = 0; c < avctx->channels; ++c) {
1465  if (use_acf) {
1466  //acf_flag
1467  if (get_bits1(gb)) {
1468  tmp_32 = get_bits(gb, 23);
1469  last_acf_mantissa[c] = tmp_32;
1470  } else {
1471  tmp_32 = last_acf_mantissa[c];
1472  }
1473  acf[c] = av_bits2sf_ieee754(tmp_32);
1474  } else {
1475  acf[c] = FLOAT_1;
1476  }
1477 
1478  highest_byte = get_bits(gb, 2);
1479  partA_flag = get_bits1(gb);
1480  shift_amp = get_bits1(gb);
1481 
1482  if (shift_amp) {
1483  shift_value[c] = get_bits(gb, 8);
1484  last_shift_value[c] = shift_value[c];
1485  } else {
1486  shift_value[c] = last_shift_value[c];
1487  }
1488 
1489  if (partA_flag) {
1490  if (!get_bits1(gb)) { //uncompressed
1491  for (i = 0; i < frame_length; ++i) {
1492  if (ctx->raw_samples[c][i] == 0) {
1493  ctx->raw_mantissa[c][i] = get_bits_long(gb, 32);
1494  }
1495  }
1496  } else { //compressed
1497  nchars = 0;
1498  for (i = 0; i < frame_length; ++i) {
1499  if (ctx->raw_samples[c][i] == 0) {
1500  nchars += 4;
1501  }
1502  }
1503 
1504  tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray);
1505  if(tmp_32 != nchars) {
1506  av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars);
1507  return AVERROR_INVALIDDATA;
1508  }
1509 
1510  for (i = 0; i < frame_length; ++i) {
1511  ctx->raw_mantissa[c][i] = AV_RB32(larray);
1512  }
1513  }
1514  }
1515 
1516  //decode part B
1517  if (highest_byte) {
1518  for (i = 0; i < frame_length; ++i) {
1519  if (ctx->raw_samples[c][i] != 0) {
1520  //The following logic is taken from Tabel 14.45 and 14.46 from the ISO spec
1521  if (av_cmp_sf_ieee754(acf[c], FLOAT_1)) {
1522  nbits[i] = 23 - av_log2(abs(ctx->raw_samples[c][i]));
1523  } else {
1524  nbits[i] = 23;
1525  }
1526  nbits[i] = FFMIN(nbits[i], highest_byte*8);
1527  }
1528  }
1529 
1530  if (!get_bits1(gb)) { //uncompressed
1531  for (i = 0; i < frame_length; ++i) {
1532  if (ctx->raw_samples[c][i] != 0) {
1533  raw_mantissa[c][i] = get_bitsz(gb, nbits[i]);
1534  }
1535  }
1536  } else { //compressed
1537  nchars = 0;
1538  for (i = 0; i < frame_length; ++i) {
1539  if (ctx->raw_samples[c][i]) {
1540  nchars += (int) nbits[i] / 8;
1541  if (nbits[i] & 7) {
1542  ++nchars;
1543  }
1544  }
1545  }
1546 
1547  tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray);
1548  if(tmp_32 != nchars) {
1549  av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars);
1550  return AVERROR_INVALIDDATA;
1551  }
1552 
1553  j = 0;
1554  for (i = 0; i < frame_length; ++i) {
1555  if (ctx->raw_samples[c][i]) {
1556  if (nbits[i] & 7) {
1557  nbits_aligned = 8 * ((unsigned int)(nbits[i] / 8) + 1);
1558  } else {
1559  nbits_aligned = nbits[i];
1560  }
1561  acc = 0;
1562  for (k = 0; k < nbits_aligned/8; ++k) {
1563  acc = (acc << 8) + larray[j++];
1564  }
1565  acc >>= (nbits_aligned - nbits[i]);
1566  raw_mantissa[c][i] = acc;
1567  }
1568  }
1569  }
1570  }
1571 
1572  for (i = 0; i < frame_length; ++i) {
1573  SoftFloat_IEEE754 pcm_sf = av_int2sf_ieee754(ctx->raw_samples[c][i], 0);
1574  pcm_sf = av_div_sf_ieee754(pcm_sf, scale);
1575 
1576  if (ctx->raw_samples[c][i] != 0) {
1577  if (!av_cmp_sf_ieee754(acf[c], FLOAT_1)) {
1578  pcm_sf = multiply(acf[c], pcm_sf);
1579  }
1580 
1581  sign = pcm_sf.sign;
1582  e = pcm_sf.exp;
1583  mantissa = (pcm_sf.mant | 0x800000) + raw_mantissa[c][i];
1584 
1585  while(mantissa >= 0x1000000) {
1586  e++;
1587  mantissa >>= 1;
1588  }
1589 
1590  if (mantissa) e += (shift_value[c] - 127);
1591  mantissa &= 0x007fffffUL;
1592 
1593  tmp_32 = (sign << 31) | ((e + EXP_BIAS) << 23) | (mantissa);
1594  ctx->raw_samples[c][i] = tmp_32;
1595  } else {
1596  ctx->raw_samples[c][i] = raw_mantissa[c][i] & 0x007fffffUL;
1597  }
1598  }
1599  align_get_bits(gb);
1600  }
1601  return 0;
1602 }
1603 
1604 
1605 /** Read the frame data.
1606  */
1607 static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
1608 {
1609  ALSSpecificConfig *sconf = &ctx->sconf;
1610  AVCodecContext *avctx = ctx->avctx;
1611  GetBitContext *gb = &ctx->gb;
1612  unsigned int div_blocks[32]; ///< block sizes.
1613  unsigned int c;
1614  unsigned int js_blocks[2];
1615  uint32_t bs_info = 0;
1616  int ret;
1617 
1618  // skip the size of the ra unit if present in the frame
1619  if (sconf->ra_flag == RA_FLAG_FRAMES && ra_frame)
1620  skip_bits_long(gb, 32);
1621 
1622  if (sconf->mc_coding && sconf->joint_stereo) {
1623  ctx->js_switch = get_bits1(gb);
1624  align_get_bits(gb);
1625  }
1626 
1627  if (!sconf->mc_coding || ctx->js_switch) {
1628  int independent_bs = !sconf->joint_stereo;
1629 
1630  for (c = 0; c < avctx->channels; c++) {
1631  js_blocks[0] = 0;
1632  js_blocks[1] = 0;
1633 
1634  get_block_sizes(ctx, div_blocks, &bs_info);
1635 
1636  // if joint_stereo and block_switching is set, independent decoding
1637  // is signaled via the first bit of bs_info
1638  if (sconf->joint_stereo && sconf->block_switching)
1639  if (bs_info >> 31)
1640  independent_bs = 2;
1641 
1642  // if this is the last channel, it has to be decoded independently
1643  if (c == avctx->channels - 1 || (c & 1))
1644  independent_bs = 1;
1645 
1646  if (independent_bs) {
1647  ret = decode_blocks_ind(ctx, ra_frame, c,
1648  div_blocks, js_blocks);
1649  if (ret < 0)
1650  return ret;
1651  independent_bs--;
1652  } else {
1653  ret = decode_blocks(ctx, ra_frame, c, div_blocks, js_blocks);
1654  if (ret < 0)
1655  return ret;
1656 
1657  c++;
1658  }
1659 
1660  // store carryover raw samples
1661  memmove(ctx->raw_samples[c] - sconf->max_order,
1662  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1663  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1664  }
1665  } else { // multi-channel coding
1666  ALSBlockData bd = { 0 };
1667  int b, ret;
1668  int *reverted_channels = ctx->reverted_channels;
1669  unsigned int offset = 0;
1670 
1671  for (c = 0; c < avctx->channels; c++)
1672  if (ctx->chan_data[c] < ctx->chan_data_buffer) {
1673  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid channel data.\n");
1674  return AVERROR_INVALIDDATA;
1675  }
1676 
1677  memset(reverted_channels, 0, sizeof(*reverted_channels) * avctx->channels);
1678 
1679  bd.ra_block = ra_frame;
1681 
1682  get_block_sizes(ctx, div_blocks, &bs_info);
1683 
1684  for (b = 0; b < ctx->num_blocks; b++) {
1685  bd.block_length = div_blocks[b];
1686  if (bd.block_length <= 0) {
1687  av_log(ctx->avctx, AV_LOG_WARNING,
1688  "Invalid block length %u in channel data!\n",
1689  bd.block_length);
1690  continue;
1691  }
1692 
1693  for (c = 0; c < avctx->channels; c++) {
1694  bd.const_block = ctx->const_block + c;
1695  bd.shift_lsbs = ctx->shift_lsbs + c;
1696  bd.opt_order = ctx->opt_order + c;
1698  bd.use_ltp = ctx->use_ltp + c;
1699  bd.ltp_lag = ctx->ltp_lag + c;
1700  bd.ltp_gain = ctx->ltp_gain[c];
1701  bd.lpc_cof = ctx->lpc_cof[c];
1702  bd.quant_cof = ctx->quant_cof[c];
1703  bd.raw_samples = ctx->raw_samples[c] + offset;
1704  bd.raw_other = NULL;
1705 
1706  if ((ret = read_block(ctx, &bd)) < 0)
1707  return ret;
1708  if ((ret = read_channel_data(ctx, ctx->chan_data[c], c)) < 0)
1709  return ret;
1710  }
1711 
1712  for (c = 0; c < avctx->channels; c++) {
1713  ret = revert_channel_correlation(ctx, &bd, ctx->chan_data,
1714  reverted_channels, offset, c);
1715  if (ret < 0)
1716  return ret;
1717  }
1718  for (c = 0; c < avctx->channels; c++) {
1719  bd.const_block = ctx->const_block + c;
1720  bd.shift_lsbs = ctx->shift_lsbs + c;
1721  bd.opt_order = ctx->opt_order + c;
1723  bd.use_ltp = ctx->use_ltp + c;
1724  bd.ltp_lag = ctx->ltp_lag + c;
1725  bd.ltp_gain = ctx->ltp_gain[c];
1726  bd.lpc_cof = ctx->lpc_cof[c];
1727  bd.quant_cof = ctx->quant_cof[c];
1728  bd.raw_samples = ctx->raw_samples[c] + offset;
1729 
1730  if ((ret = decode_block(ctx, &bd)) < 0)
1731  return ret;
1732  }
1733 
1734  memset(reverted_channels, 0, avctx->channels * sizeof(*reverted_channels));
1735  offset += div_blocks[b];
1736  bd.ra_block = 0;
1737  }
1738 
1739  // store carryover raw samples
1740  for (c = 0; c < avctx->channels; c++)
1741  memmove(ctx->raw_samples[c] - sconf->max_order,
1742  ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1743  sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1744  }
1745 
1746  if (sconf->floating) {
1747  read_diff_float_data(ctx, ra_frame);
1748  }
1749 
1750  if (get_bits_left(gb) < 0) {
1751  av_log(ctx->avctx, AV_LOG_ERROR, "Overread %d\n", -get_bits_left(gb));
1752  return AVERROR_INVALIDDATA;
1753  }
1754 
1755  return 0;
1756 }
1757 
1758 
1759 /** Decode an ALS frame.
1760  */
1761 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1762  AVPacket *avpkt)
1763 {
1764  ALSDecContext *ctx = avctx->priv_data;
1765  AVFrame *frame = data;
1766  ALSSpecificConfig *sconf = &ctx->sconf;
1767  const uint8_t *buffer = avpkt->data;
1768  int buffer_size = avpkt->size;
1769  int invalid_frame, ret;
1770  unsigned int c, sample, ra_frame, bytes_read, shift;
1771 
1772  if ((ret = init_get_bits8(&ctx->gb, buffer, buffer_size)) < 0)
1773  return ret;
1774 
1775  // In the case that the distance between random access frames is set to zero
1776  // (sconf->ra_distance == 0) no frame is treated as a random access frame.
1777  // For the first frame, if prediction is used, all samples used from the
1778  // previous frame are assumed to be zero.
1779  ra_frame = sconf->ra_distance && !(ctx->frame_id % sconf->ra_distance);
1780 
1781  // the last frame to decode might have a different length
1782  if (sconf->samples != 0xFFFFFFFF)
1783  ctx->cur_frame_length = FFMIN(sconf->samples - ctx->frame_id * (uint64_t) sconf->frame_length,
1784  sconf->frame_length);
1785  else
1786  ctx->cur_frame_length = sconf->frame_length;
1787 
1788  // decode the frame data
1789  if ((invalid_frame = read_frame_data(ctx, ra_frame)) < 0)
1790  av_log(ctx->avctx, AV_LOG_WARNING,
1791  "Reading frame data failed. Skipping RA unit.\n");
1792 
1793  ctx->frame_id++;
1794 
1795  /* get output buffer */
1796  frame->nb_samples = ctx->cur_frame_length;
1797  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1798  return ret;
1799 
1800  // transform decoded frame into output format
1801  #define INTERLEAVE_OUTPUT(bps) \
1802  { \
1803  int##bps##_t *dest = (int##bps##_t*)frame->data[0]; \
1804  shift = bps - ctx->avctx->bits_per_raw_sample; \
1805  if (!ctx->cs_switch) { \
1806  for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1807  for (c = 0; c < avctx->channels; c++) \
1808  *dest++ = ctx->raw_samples[c][sample] * (1U << shift); \
1809  } else { \
1810  for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1811  for (c = 0; c < avctx->channels; c++) \
1812  *dest++ = ctx->raw_samples[sconf->chan_pos[c]][sample] * (1U << shift); \
1813  } \
1814  }
1815 
1816  if (ctx->avctx->bits_per_raw_sample <= 16) {
1817  INTERLEAVE_OUTPUT(16)
1818  } else {
1819  INTERLEAVE_OUTPUT(32)
1820  }
1821 
1822  // update CRC
1823  if (sconf->crc_enabled && (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
1824  int swap = HAVE_BIGENDIAN != sconf->msb_first;
1825 
1826  if (ctx->avctx->bits_per_raw_sample == 24) {
1827  int32_t *src = (int32_t *)frame->data[0];
1828 
1829  for (sample = 0;
1830  sample < ctx->cur_frame_length * avctx->channels;
1831  sample++) {
1832  int32_t v;
1833 
1834  if (swap)
1835  v = av_bswap32(src[sample]);
1836  else
1837  v = src[sample];
1838  if (!HAVE_BIGENDIAN)
1839  v >>= 8;
1840 
1841  ctx->crc = av_crc(ctx->crc_table, ctx->crc, (uint8_t*)(&v), 3);
1842  }
1843  } else {
1844  uint8_t *crc_source;
1845 
1846  if (swap) {
1847  if (ctx->avctx->bits_per_raw_sample <= 16) {
1848  int16_t *src = (int16_t*) frame->data[0];
1849  int16_t *dest = (int16_t*) ctx->crc_buffer;
1850  for (sample = 0;
1851  sample < ctx->cur_frame_length * avctx->channels;
1852  sample++)
1853  *dest++ = av_bswap16(src[sample]);
1854  } else {
1855  ctx->bdsp.bswap_buf((uint32_t *) ctx->crc_buffer,
1856  (uint32_t *) frame->data[0],
1857  ctx->cur_frame_length * avctx->channels);
1858  }
1859  crc_source = ctx->crc_buffer;
1860  } else {
1861  crc_source = frame->data[0];
1862  }
1863 
1864  ctx->crc = av_crc(ctx->crc_table, ctx->crc, crc_source,
1865  ctx->cur_frame_length * avctx->channels *
1867  }
1868 
1869 
1870  // check CRC sums if this is the last frame
1871  if (ctx->cur_frame_length != sconf->frame_length &&
1872  ctx->crc_org != ctx->crc) {
1873  av_log(avctx, AV_LOG_ERROR, "CRC error.\n");
1874  if (avctx->err_recognition & AV_EF_EXPLODE)
1875  return AVERROR_INVALIDDATA;
1876  }
1877  }
1878 
1879  *got_frame_ptr = 1;
1880 
1881  bytes_read = invalid_frame ? buffer_size :
1882  (get_bits_count(&ctx->gb) + 7) >> 3;
1883 
1884  return bytes_read;
1885 }
1886 
1887 
1888 /** Uninitialize the ALS decoder.
1889  */
1891 {
1892  ALSDecContext *ctx = avctx->priv_data;
1893  int i;
1894 
1895  av_freep(&ctx->sconf.chan_pos);
1896 
1897  ff_bgmc_end(&ctx->bgmc_lut, &ctx->bgmc_lut_status);
1898 
1899  av_freep(&ctx->const_block);
1900  av_freep(&ctx->shift_lsbs);
1901  av_freep(&ctx->opt_order);
1903  av_freep(&ctx->use_ltp);
1904  av_freep(&ctx->ltp_lag);
1905  av_freep(&ctx->ltp_gain);
1906  av_freep(&ctx->ltp_gain_buffer);
1907  av_freep(&ctx->quant_cof);
1908  av_freep(&ctx->lpc_cof);
1909  av_freep(&ctx->quant_cof_buffer);
1910  av_freep(&ctx->lpc_cof_buffer);
1912  av_freep(&ctx->prev_raw_samples);
1913  av_freep(&ctx->raw_samples);
1914  av_freep(&ctx->raw_buffer);
1915  av_freep(&ctx->chan_data);
1916  av_freep(&ctx->chan_data_buffer);
1917  av_freep(&ctx->reverted_channels);
1918  av_freep(&ctx->crc_buffer);
1919  if (ctx->mlz) {
1920  av_freep(&ctx->mlz->dict);
1921  av_freep(&ctx->mlz);
1922  }
1923  av_freep(&ctx->acf);
1924  av_freep(&ctx->last_acf_mantissa);
1925  av_freep(&ctx->shift_value);
1926  av_freep(&ctx->last_shift_value);
1927  if (ctx->raw_mantissa) {
1928  for (i = 0; i < avctx->channels; i++) {
1929  av_freep(&ctx->raw_mantissa[i]);
1930  }
1931  av_freep(&ctx->raw_mantissa);
1932  }
1933  av_freep(&ctx->larray);
1934  av_freep(&ctx->nbits);
1935 
1936  return 0;
1937 }
1938 
1939 
1940 /** Initialize the ALS decoder.
1941  */
1943 {
1944  unsigned int c;
1945  unsigned int channel_size;
1946  int num_buffers, ret;
1947  ALSDecContext *ctx = avctx->priv_data;
1948  ALSSpecificConfig *sconf = &ctx->sconf;
1949  ctx->avctx = avctx;
1950 
1951  if (!avctx->extradata) {
1952  av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n");
1953  return AVERROR_INVALIDDATA;
1954  }
1955 
1956  if ((ret = read_specific_config(ctx)) < 0) {
1957  av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
1958  goto fail;
1959  }
1960 
1961  if ((ret = check_specific_config(ctx)) < 0) {
1962  goto fail;
1963  }
1964 
1965  if (sconf->bgmc) {
1966  ret = ff_bgmc_init(avctx, &ctx->bgmc_lut, &ctx->bgmc_lut_status);
1967  if (ret < 0)
1968  goto fail;
1969  }
1970  if (sconf->floating) {
1971  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1972  avctx->bits_per_raw_sample = 32;
1973  } else {
1974  avctx->sample_fmt = sconf->resolution > 1
1976  avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
1977  if (avctx->bits_per_raw_sample > 32) {
1978  av_log(avctx, AV_LOG_ERROR, "Bits per raw sample %d larger than 32.\n",
1979  avctx->bits_per_raw_sample);
1980  ret = AVERROR_INVALIDDATA;
1981  goto fail;
1982  }
1983  }
1984 
1985  // set maximum Rice parameter for progressive decoding based on resolution
1986  // This is not specified in 14496-3 but actually done by the reference
1987  // codec RM22 revision 2.
1988  ctx->s_max = sconf->resolution > 1 ? 31 : 15;
1989 
1990  // set lag value for long-term prediction
1991  ctx->ltp_lag_length = 8 + (avctx->sample_rate >= 96000) +
1992  (avctx->sample_rate >= 192000);
1993 
1994  // allocate quantized parcor coefficient buffer
1995  num_buffers = sconf->mc_coding ? avctx->channels : 1;
1996  if (num_buffers * (uint64_t)num_buffers > INT_MAX) // protect chan_data_buffer allocation
1997  return AVERROR_INVALIDDATA;
1998 
1999  ctx->quant_cof = av_malloc_array(num_buffers, sizeof(*ctx->quant_cof));
2000  ctx->lpc_cof = av_malloc_array(num_buffers, sizeof(*ctx->lpc_cof));
2001  ctx->quant_cof_buffer = av_malloc_array(num_buffers * sconf->max_order,
2002  sizeof(*ctx->quant_cof_buffer));
2003  ctx->lpc_cof_buffer = av_malloc_array(num_buffers * sconf->max_order,
2004  sizeof(*ctx->lpc_cof_buffer));
2006  sizeof(*ctx->lpc_cof_buffer));
2007 
2008  if (!ctx->quant_cof || !ctx->lpc_cof ||
2009  !ctx->quant_cof_buffer || !ctx->lpc_cof_buffer ||
2010  !ctx->lpc_cof_reversed_buffer) {
2011  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2012  ret = AVERROR(ENOMEM);
2013  goto fail;
2014  }
2015 
2016  // assign quantized parcor coefficient buffers
2017  for (c = 0; c < num_buffers; c++) {
2018  ctx->quant_cof[c] = ctx->quant_cof_buffer + c * sconf->max_order;
2019  ctx->lpc_cof[c] = ctx->lpc_cof_buffer + c * sconf->max_order;
2020  }
2021 
2022  // allocate and assign lag and gain data buffer for ltp mode
2023  ctx->const_block = av_malloc_array(num_buffers, sizeof(*ctx->const_block));
2024  ctx->shift_lsbs = av_malloc_array(num_buffers, sizeof(*ctx->shift_lsbs));
2025  ctx->opt_order = av_malloc_array(num_buffers, sizeof(*ctx->opt_order));
2026  ctx->store_prev_samples = av_malloc_array(num_buffers, sizeof(*ctx->store_prev_samples));
2027  ctx->use_ltp = av_mallocz_array(num_buffers, sizeof(*ctx->use_ltp));
2028  ctx->ltp_lag = av_malloc_array(num_buffers, sizeof(*ctx->ltp_lag));
2029  ctx->ltp_gain = av_malloc_array(num_buffers, sizeof(*ctx->ltp_gain));
2030  ctx->ltp_gain_buffer = av_malloc_array(num_buffers * 5, sizeof(*ctx->ltp_gain_buffer));
2031 
2032  if (!ctx->const_block || !ctx->shift_lsbs ||
2033  !ctx->opt_order || !ctx->store_prev_samples ||
2034  !ctx->use_ltp || !ctx->ltp_lag ||
2035  !ctx->ltp_gain || !ctx->ltp_gain_buffer) {
2036  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2037  ret = AVERROR(ENOMEM);
2038  goto fail;
2039  }
2040 
2041  for (c = 0; c < num_buffers; c++)
2042  ctx->ltp_gain[c] = ctx->ltp_gain_buffer + c * 5;
2043 
2044  // allocate and assign channel data buffer for mcc mode
2045  if (sconf->mc_coding) {
2046  ctx->chan_data_buffer = av_mallocz_array(num_buffers * num_buffers,
2047  sizeof(*ctx->chan_data_buffer));
2048  ctx->chan_data = av_mallocz_array(num_buffers,
2049  sizeof(*ctx->chan_data));
2050  ctx->reverted_channels = av_malloc_array(num_buffers,
2051  sizeof(*ctx->reverted_channels));
2052 
2053  if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) {
2054  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2055  ret = AVERROR(ENOMEM);
2056  goto fail;
2057  }
2058 
2059  for (c = 0; c < num_buffers; c++)
2060  ctx->chan_data[c] = ctx->chan_data_buffer + c * num_buffers;
2061  } else {
2062  ctx->chan_data = NULL;
2063  ctx->chan_data_buffer = NULL;
2064  ctx->reverted_channels = NULL;
2065  }
2066 
2067  channel_size = sconf->frame_length + sconf->max_order;
2068 
2069  ctx->prev_raw_samples = av_malloc_array(sconf->max_order, sizeof(*ctx->prev_raw_samples));
2070  ctx->raw_buffer = av_mallocz_array(avctx->channels * channel_size, sizeof(*ctx->raw_buffer));
2071  ctx->raw_samples = av_malloc_array(avctx->channels, sizeof(*ctx->raw_samples));
2072 
2073  if (sconf->floating) {
2074  ctx->acf = av_malloc_array(avctx->channels, sizeof(*ctx->acf));
2075  ctx->shift_value = av_malloc_array(avctx->channels, sizeof(*ctx->shift_value));
2076  ctx->last_shift_value = av_malloc_array(avctx->channels, sizeof(*ctx->last_shift_value));
2077  ctx->last_acf_mantissa = av_malloc_array(avctx->channels, sizeof(*ctx->last_acf_mantissa));
2078  ctx->raw_mantissa = av_mallocz_array(avctx->channels, sizeof(*ctx->raw_mantissa));
2079 
2080  ctx->larray = av_malloc_array(ctx->cur_frame_length * 4, sizeof(*ctx->larray));
2081  ctx->nbits = av_malloc_array(ctx->cur_frame_length, sizeof(*ctx->nbits));
2082  ctx->mlz = av_mallocz(sizeof(*ctx->mlz));
2083 
2084  if (!ctx->mlz || !ctx->acf || !ctx->shift_value || !ctx->last_shift_value
2085  || !ctx->last_acf_mantissa || !ctx->raw_mantissa) {
2086  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2087  ret = AVERROR(ENOMEM);
2088  goto fail;
2089  }
2090 
2091  ff_mlz_init_dict(avctx, ctx->mlz);
2092  ff_mlz_flush_dict(ctx->mlz);
2093 
2094  for (c = 0; c < avctx->channels; ++c) {
2095  ctx->raw_mantissa[c] = av_mallocz_array(ctx->cur_frame_length, sizeof(**ctx->raw_mantissa));
2096  }
2097  }
2098 
2099  // allocate previous raw sample buffer
2100  if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) {
2101  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2102  ret = AVERROR(ENOMEM);
2103  goto fail;
2104  }
2105 
2106  // assign raw samples buffers
2107  ctx->raw_samples[0] = ctx->raw_buffer + sconf->max_order;
2108  for (c = 1; c < avctx->channels; c++)
2109  ctx->raw_samples[c] = ctx->raw_samples[c - 1] + channel_size;
2110 
2111  // allocate crc buffer
2112  if (HAVE_BIGENDIAN != sconf->msb_first && sconf->crc_enabled &&
2115  avctx->channels *
2117  sizeof(*ctx->crc_buffer));
2118  if (!ctx->crc_buffer) {
2119  av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
2120  ret = AVERROR(ENOMEM);
2121  goto fail;
2122  }
2123  }
2124 
2125  ff_bswapdsp_init(&ctx->bdsp);
2126 
2127  return 0;
2128 
2129 fail:
2130  return ret;
2131 }
2132 
2133 
2134 /** Flush (reset) the frame ID after seeking.
2135  */
2136 static av_cold void flush(AVCodecContext *avctx)
2137 {
2138  ALSDecContext *ctx = avctx->priv_data;
2139 
2140  ctx->frame_id = 0;
2141 }
2142 
2143 
2145  .name = "als",
2146  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
2147  .type = AVMEDIA_TYPE_AUDIO,
2148  .id = AV_CODEC_ID_MP4ALS,
2149  .priv_data_size = sizeof(ALSDecContext),
2150  .init = decode_init,
2151  .close = decode_end,
2152  .decode = decode_frame,
2153  .flush = flush,
2154  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
2155  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2156 };
#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
AVCodec ff_als_decoder
Definition: alsdec.c:2144
static int als_weighting(GetBitContext *gb, int k, int off)
Definition: alsdec.c:1203
static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a non-constant block.
Definition: alsdec.c:892
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
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:1478
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/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_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 *(INT64_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 *(INT64_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
static int check_specific_config(ALSDecContext *ctx)
Check the ALSSpecificConfig for unsupported features.
Definition: alsdec.c:440
#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:1607
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:2792
static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
Read and decode block data successively.
Definition: alsdec.c:1050
#define INTERLEAVE_OUTPUT(bps)
#define src
Definition: vp8dsp.c:254
#define sample
AVCodec.
Definition: avcodec.h:3477
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
static int32_t decode_rice(GetBitContext *gb, unsigned int k)
Read and decode a Rice codeword.
Definition: alsdec.c:487
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:1942
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:2229
uint8_t
#define av_cold
Definition: attributes.h:82
static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
Decode the block data for a constant block.
Definition: alsdec.c:608
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:1666
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:1477
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:1079
void ff_bgmc_decode_init(GetBitContext *gb, unsigned int *h, unsigned int *l, unsigned int *v)
Initialize decoding and reads the first value.
Definition: bgmc.c:488
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:1064
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:1372
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:1427
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:3484
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:1119
void ff_bgmc_decode_end(GetBitContext *gb)
Finish decoding.
Definition: bgmc.c:498
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:120
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:2690
#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:622
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:505
static av_cold int decode_end(AVCodecContext *avctx)
Uninitialize the ALS decoder.
Definition: alsdec.c:1890
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:2701
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:578
#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:505
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:2221
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:1565
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:1761
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
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:1667
#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:2704
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:1024
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:2698
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
int * reverted_channels
stores a flag for each reverted channel
Definition: alsdec.c:226
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:2136
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
int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf, int bit_size, int sync_extension)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration. ...
Definition: mpeg4audio.c:155
#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:464
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1592
int32_t ** quant_cof
quantized parcor coefficients for a channel
Definition: alsdec.c:219
int channels
number of audio channels
Definition: avcodec.h:2222
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:1024
static int read_block(ALSDecContext *ctx, ALSBlockData *bd)
Read the block data.
Definition: alsdec.c:1001
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:1212
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:525
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:1259
This structure stores compressed data.
Definition: avcodec.h:1454
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:981
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