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