FFmpeg
alac.c
Go to the documentation of this file.
1 /*
2  * ALAC (Apple Lossless Audio Codec) decoder
3  * Copyright (c) 2005 David Hammerton
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  * ALAC (Apple Lossless Audio Codec) decoder
25  * @author 2005 David Hammerton
26  * @see http://crazney.net/programs/itunes/alac.html
27  *
28  * Note: This decoder expects a 36-byte QuickTime atom to be
29  * passed through the extradata[_size] fields. This atom is tacked onto
30  * the end of an 'alac' stsd atom and has the following format:
31  *
32  * 32 bits atom size
33  * 32 bits tag ("alac")
34  * 32 bits tag version (0)
35  * 32 bits samples per frame (used when not set explicitly in the frames)
36  * 8 bits compatible version (0)
37  * 8 bits sample size
38  * 8 bits history mult (40)
39  * 8 bits initial history (10)
40  * 8 bits rice param limit (14)
41  * 8 bits channels
42  * 16 bits maxRun (255)
43  * 32 bits max coded frame size (0 means unknown)
44  * 32 bits average bitrate (0 means unknown)
45  * 32 bits samplerate
46  */
47 
48 #include <inttypes.h>
49 
51 #include "libavutil/opt.h"
52 #include "avcodec.h"
53 #include "get_bits.h"
54 #include "bytestream.h"
55 #include "codec_internal.h"
56 #include "thread.h"
57 #include "unary.h"
58 #include "mathops.h"
59 #include "alac_data.h"
60 #include "alacdsp.h"
61 
62 #define ALAC_EXTRADATA_SIZE 36
63 
64 typedef struct ALACContext {
65  AVClass *class;
68  int channels;
69 
73 
75  uint8_t sample_size;
78  uint8_t rice_limit;
80 
81  int extra_bits; /**< number of extra bits beyond 16-bit */
82  int nb_samples; /**< number of samples in the current frame */
83 
86 
88 } ALACContext;
89 
90 static inline unsigned int decode_scalar(GetBitContext *gb, int k, int bps)
91 {
92  unsigned int x = get_unary_0_9(gb);
93 
94  if (x > 8) { /* RICE THRESHOLD */
95  /* use alternative encoding */
96  x = get_bits_long(gb, bps);
97  } else if (k != 1) {
98  int extrabits = show_bits(gb, k);
99 
100  /* multiply x by 2^k - 1, as part of their strange algorithm */
101  x = (x << k) - x;
102 
103  if (extrabits > 1) {
104  x += extrabits - 1;
105  skip_bits(gb, k);
106  } else
107  skip_bits(gb, k - 1);
108  }
109  return x;
110 }
111 
112 static int rice_decompress(ALACContext *alac, int32_t *output_buffer,
113  int nb_samples, int bps, int rice_history_mult)
114 {
115  GetBitContext *gb = &alac->gb;
116  int i;
117  unsigned int history = alac->rice_initial_history;
118  int sign_modifier = 0;
119 
120  for (i = 0; i < nb_samples; i++) {
121  int k;
122  unsigned int x;
123 
124  if (get_bits_left(gb) <= 0)
125  return AVERROR_INVALIDDATA;
126 
127  /* calculate rice param and decode next value */
128  k = av_log2((history >> 9) + 3);
129  k = FFMIN(k, alac->rice_limit);
130  x = decode_scalar(gb, k, bps);
131  x += sign_modifier;
132  sign_modifier = 0;
133  output_buffer[i] = (x >> 1) ^ -(x & 1);
134 
135  /* update the history */
136  if (x > 0xffff)
137  history = 0xffff;
138  else
139  history += x * rice_history_mult -
140  ((history * rice_history_mult) >> 9);
141 
142  /* special case: there may be compressed blocks of 0 */
143  if ((history < 128) && (i + 1 < nb_samples)) {
144  int block_size;
145 
146  /* calculate rice param and decode block size */
147  k = 7 - av_log2(history) + ((history + 16) >> 6);
148  k = FFMIN(k, alac->rice_limit);
149  block_size = decode_scalar(gb, k, 16);
150 
151  if (block_size > 0) {
152  if (block_size >= nb_samples - i) {
153  av_log(alac->avctx, AV_LOG_ERROR,
154  "invalid zero block size of %d %d %d\n", block_size,
155  nb_samples, i);
156  block_size = nb_samples - i - 1;
157  }
158  memset(&output_buffer[i + 1], 0,
159  block_size * sizeof(*output_buffer));
160  i += block_size;
161  }
162  if (block_size <= 0xffff)
163  sign_modifier = 1;
164  history = 0;
165  }
166  }
167  return 0;
168 }
169 
170 static inline int sign_only(int v)
171 {
172  return FFDIFFSIGN(v, 0);
173 }
174 
175 static void lpc_prediction(int32_t *error_buffer, uint32_t *buffer_out,
176  int nb_samples, int bps, int16_t *lpc_coefs,
177  int lpc_order, int lpc_quant)
178 {
179  int i;
180  uint32_t *pred = buffer_out;
181 
182  /* first sample always copies */
183  *buffer_out = *error_buffer;
184 
185  if (nb_samples <= 1)
186  return;
187 
188  if (!lpc_order) {
189  memcpy(&buffer_out[1], &error_buffer[1],
190  (nb_samples - 1) * sizeof(*buffer_out));
191  return;
192  }
193 
194  if (lpc_order == 31) {
195  /* simple 1st-order prediction */
196  for (i = 1; i < nb_samples; i++) {
197  buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i],
198  bps);
199  }
200  return;
201  }
202 
203  /* read warm-up samples */
204  for (i = 1; i <= lpc_order && i < nb_samples; i++)
205  buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i], bps);
206 
207  /* NOTE: 4 and 8 are very common cases that could be optimized. */
208 
209  for (; i < nb_samples; i++) {
210  int j;
211  int val = 0;
212  unsigned error_val = error_buffer[i];
213  int error_sign;
214  int d = *pred++;
215 
216  /* LPC prediction */
217  for (j = 0; j < lpc_order; j++)
218  val += (pred[j] - d) * lpc_coefs[j];
219  val = (val + (1LL << (lpc_quant - 1))) >> lpc_quant;
220  val += d + error_val;
221  buffer_out[i] = sign_extend(val, bps);
222 
223  /* adapt LPC coefficients */
224  error_sign = sign_only(error_val);
225  if (error_sign) {
226  for (j = 0; j < lpc_order && (int)(error_val * error_sign) > 0; j++) {
227  int sign;
228  val = d - pred[j];
229  sign = sign_only(val) * error_sign;
230  lpc_coefs[j] -= sign;
231  val *= (unsigned)sign;
232  error_val -= (val >> lpc_quant) * (j + 1U);
233  }
234  }
235  }
236 }
237 
238 static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,
239  int channels)
240 {
241  ALACContext *alac = avctx->priv_data;
242  int has_size, bps, is_compressed, decorr_shift, decorr_left_weight, ret;
243  GetBitContext *gb = &alac->gb;
244  uint32_t output_samples;
245  int i, ch;
246 
247  skip_bits(gb, 4); /* element instance tag */
248  skip_bits(gb, 12); /* unused header bits */
249 
250  /* the number of output samples is stored in the frame */
251  has_size = get_bits1(gb);
252 
253  alac->extra_bits = get_bits(gb, 2) << 3;
254  bps = alac->sample_size - alac->extra_bits + channels - 1;
255  if (bps > 32) {
256  avpriv_report_missing_feature(avctx, "bps %d", bps);
257  return AVERROR_PATCHWELCOME;
258  }
259  if (bps < 1)
260  return AVERROR_INVALIDDATA;
261 
262  /* whether the frame is compressed */
263  is_compressed = !get_bits1(gb);
264 
265  if (has_size)
266  output_samples = get_bits_long(gb, 32);
267  else
268  output_samples = alac->max_samples_per_frame;
269  if (!output_samples || output_samples > alac->max_samples_per_frame) {
270  av_log(avctx, AV_LOG_ERROR, "invalid samples per frame: %"PRIu32"\n",
271  output_samples);
272  return AVERROR_INVALIDDATA;
273  }
274  if (!alac->nb_samples) {
275  /* get output buffer */
276  frame->nb_samples = output_samples;
277  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
278  return ret;
279  } else if (output_samples != alac->nb_samples) {
280  av_log(avctx, AV_LOG_ERROR, "sample count mismatch: %"PRIu32" != %d\n",
281  output_samples, alac->nb_samples);
282  return AVERROR_INVALIDDATA;
283  }
284  alac->nb_samples = output_samples;
285  if (alac->direct_output) {
286  for (ch = 0; ch < channels; ch++)
287  alac->output_samples_buffer[ch] = (int32_t *)frame->extended_data[ch_index + ch];
288  }
289 
290  if (is_compressed) {
291  int16_t lpc_coefs[2][32];
292  int lpc_order[2];
293  int prediction_type[2];
294  int lpc_quant[2];
295  int rice_history_mult[2];
296 
297  if (!alac->rice_limit) {
299  "Compression with rice limit 0");
300  return AVERROR(ENOSYS);
301  }
302 
303  decorr_shift = get_bits(gb, 8);
304  decorr_left_weight = get_bits(gb, 8);
305 
306  if (channels == 2 && decorr_left_weight && decorr_shift > 31)
307  return AVERROR_INVALIDDATA;
308 
309  for (ch = 0; ch < channels; ch++) {
310  prediction_type[ch] = get_bits(gb, 4);
311  lpc_quant[ch] = get_bits(gb, 4);
312  rice_history_mult[ch] = get_bits(gb, 3);
313  lpc_order[ch] = get_bits(gb, 5);
314 
315  if (lpc_order[ch] >= alac->max_samples_per_frame || !lpc_quant[ch])
316  return AVERROR_INVALIDDATA;
317 
318  /* read the predictor table */
319  for (i = lpc_order[ch] - 1; i >= 0; i--)
320  lpc_coefs[ch][i] = get_sbits(gb, 16);
321  }
322 
323  if (alac->extra_bits) {
324  const int extra_bits = alac->extra_bits;
325  if (get_bits_left(gb) < (int64_t)alac->nb_samples * channels * extra_bits)
326  return AVERROR_INVALIDDATA;
327  for (i = 0; i < alac->nb_samples; i++) {
328  for (ch = 0; ch < channels; ch++)
329  alac->extra_bits_buffer[ch][i] = get_bits(gb, extra_bits);
330  }
331  }
332  for (ch = 0; ch < channels; ch++) {
333  int ret = rice_decompress(alac, alac->predict_error_buffer[ch],
334  alac->nb_samples, bps,
335  rice_history_mult[ch] * alac->rice_history_mult / 4);
336  if (ret < 0)
337  return ret;
338 
339  /* adaptive FIR filter */
340  if (prediction_type[ch] == 15) {
341  /* Prediction type 15 runs the adaptive FIR twice.
342  * The first pass uses the special-case coef_num = 31, while
343  * the second pass uses the coefs from the bitstream.
344  *
345  * However, this prediction type is not currently used by the
346  * reference encoder.
347  */
349  alac->predict_error_buffer[ch],
350  alac->nb_samples, bps, NULL, 31, 0);
351  } else if (prediction_type[ch] > 0) {
352  av_log(avctx, AV_LOG_WARNING, "unknown prediction type: %i\n",
353  prediction_type[ch]);
354  }
356  alac->output_samples_buffer[ch], alac->nb_samples,
357  bps, lpc_coefs[ch], lpc_order[ch], lpc_quant[ch]);
358  }
359  } else {
360  const int sample_size = alac->sample_size;
361  /* not compressed, easy case */
362  if (get_bits_left(gb) < (int64_t)alac->nb_samples * channels * sample_size)
363  return AVERROR_INVALIDDATA;
364  for (i = 0; i < alac->nb_samples; i++) {
365  for (ch = 0; ch < channels; ch++) {
366  alac->output_samples_buffer[ch][i] =
367  get_sbits_long(gb, sample_size);
368  }
369  }
370  alac->extra_bits = 0;
371  decorr_shift = 0;
372  decorr_left_weight = 0;
373  }
374 
375  if (channels == 2) {
376  if (alac->extra_bits && alac->extra_bit_bug) {
378  alac->extra_bits, channels, alac->nb_samples);
379  }
380 
381  if (decorr_left_weight) {
383  decorr_shift, decorr_left_weight);
384  }
385 
386  if (alac->extra_bits && !alac->extra_bit_bug) {
388  alac->extra_bits, channels, alac->nb_samples);
389  }
390  } else if (alac->extra_bits) {
392  alac->extra_bits, channels, alac->nb_samples);
393  }
394 
395  switch(alac->sample_size) {
396  case 16: {
397  for (ch = 0; ch < channels; ch++) {
398  int16_t *outbuffer = (int16_t *)frame->extended_data[ch_index + ch];
399  for (i = 0; i < alac->nb_samples; i++)
400  *outbuffer++ = alac->output_samples_buffer[ch][i];
401  }}
402  break;
403  case 20: {
404  for (ch = 0; ch < channels; ch++) {
405  for (i = 0; i < alac->nb_samples; i++)
406  alac->output_samples_buffer[ch][i] *= 1U << 12;
407  }}
408  break;
409  case 24: {
410  for (ch = 0; ch < channels; ch++) {
411  for (i = 0; i < alac->nb_samples; i++)
412  alac->output_samples_buffer[ch][i] *= 1U << 8;
413  }}
414  break;
415  }
416 
417  return 0;
418 }
419 
421  int *got_frame_ptr, AVPacket *avpkt)
422 {
423  ALACContext *alac = avctx->priv_data;
424  enum AlacRawDataBlockType element;
425  int channels;
426  int ch, ret, got_end;
427 
428  if ((ret = init_get_bits8(&alac->gb, avpkt->data, avpkt->size)) < 0)
429  return ret;
430 
431  got_end = 0;
432  alac->nb_samples = 0;
433  ch = 0;
434  while (get_bits_left(&alac->gb) >= 3) {
435  element = get_bits(&alac->gb, 3);
436  if (element == TYPE_END) {
437  got_end = 1;
438  break;
439  }
440  if (element > TYPE_CPE && element != TYPE_LFE) {
441  avpriv_report_missing_feature(avctx, "Syntax element %d", element);
442  return AVERROR_PATCHWELCOME;
443  }
444 
445  channels = (element == TYPE_CPE) ? 2 : 1;
446  if (ch + channels > alac->channels ||
447  ff_alac_channel_layout_offsets[alac->channels - 1][ch] + channels > alac->channels) {
448  av_log(avctx, AV_LOG_ERROR, "invalid element channel count\n");
449  return AVERROR_INVALIDDATA;
450  }
451 
452  ret = decode_element(avctx, frame,
454  channels);
455  if (ret < 0 && get_bits_left(&alac->gb))
456  return ret;
457 
458  ch += channels;
459  }
460  if (!got_end) {
461  av_log(avctx, AV_LOG_ERROR, "no end tag found. incomplete packet.\n");
462  return AVERROR_INVALIDDATA;
463  }
464 
465  if (avpkt->size * 8 - get_bits_count(&alac->gb) > 8) {
466  av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n",
467  avpkt->size * 8 - get_bits_count(&alac->gb));
468  }
469 
470  if (alac->channels == ch && alac->nb_samples)
471  *got_frame_ptr = 1;
472  else
473  av_log(avctx, AV_LOG_WARNING, "Failed to decode all channels\n");
474 
475  return avpkt->size;
476 }
477 
479 {
480  ALACContext *alac = avctx->priv_data;
481 
482  int ch;
483  for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {
484  av_freep(&alac->predict_error_buffer[ch]);
485  if (!alac->direct_output)
486  av_freep(&alac->output_samples_buffer[ch]);
487  av_freep(&alac->extra_bits_buffer[ch]);
488  }
489 
490  return 0;
491 }
492 
493 static int allocate_buffers(ALACContext *alac)
494 {
495  int ch;
496  unsigned buf_size = alac->max_samples_per_frame * sizeof(int32_t);
497  unsigned extra_buf_size = buf_size + AV_INPUT_BUFFER_PADDING_SIZE;
498 
499  for (ch = 0; ch < 2; ch++) {
500  alac->predict_error_buffer[ch] = NULL;
501  alac->output_samples_buffer[ch] = NULL;
502  alac->extra_bits_buffer[ch] = NULL;
503  }
504 
505  for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {
506  if (!(alac->predict_error_buffer[ch] = av_malloc(buf_size)))
507  return AVERROR(ENOMEM);
508 
509  alac->direct_output = alac->sample_size > 16;
510  if (!alac->direct_output) {
511  if (!(alac->output_samples_buffer[ch] = av_malloc(extra_buf_size)))
512  return AVERROR(ENOMEM);
513  }
514 
515  if (!(alac->extra_bits_buffer[ch] = av_malloc(extra_buf_size)))
516  return AVERROR(ENOMEM);
517  }
518  return 0;
519 }
520 
521 static int alac_set_info(ALACContext *alac)
522 {
523  GetByteContext gb;
524 
525  bytestream2_init(&gb, alac->avctx->extradata,
526  alac->avctx->extradata_size);
527 
528  bytestream2_skipu(&gb, 12); // size:4, alac:4, version:4
529 
530  alac->max_samples_per_frame = bytestream2_get_be32u(&gb);
531  if (!alac->max_samples_per_frame ||
532  alac->max_samples_per_frame > 4096 * 4096) {
533  av_log(alac->avctx, AV_LOG_ERROR,
534  "max samples per frame invalid: %"PRIu32"\n",
535  alac->max_samples_per_frame);
536  return AVERROR_INVALIDDATA;
537  }
538  bytestream2_skipu(&gb, 1); // compatible version
539  alac->sample_size = bytestream2_get_byteu(&gb);
540  alac->rice_history_mult = bytestream2_get_byteu(&gb);
541  alac->rice_initial_history = bytestream2_get_byteu(&gb);
542  alac->rice_limit = bytestream2_get_byteu(&gb);
543  alac->channels = bytestream2_get_byteu(&gb);
544  bytestream2_get_be16u(&gb); // maxRun
545  bytestream2_get_be32u(&gb); // max coded frame size
546  bytestream2_get_be32u(&gb); // average bitrate
547  alac->sample_rate = bytestream2_get_be32u(&gb);
548 
549  return 0;
550 }
551 
553 {
554  int ret;
555  ALACContext *alac = avctx->priv_data;
556  alac->avctx = avctx;
557 
558  /* initialize from the extradata */
560  av_log(avctx, AV_LOG_ERROR, "extradata is too small\n");
561  return AVERROR_INVALIDDATA;
562  }
563  if ((ret = alac_set_info(alac)) < 0) {
564  av_log(avctx, AV_LOG_ERROR, "set_info failed\n");
565  return ret;
566  }
567 
568  switch (alac->sample_size) {
569  case 16: avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
570  break;
571  case 20:
572  case 24:
573  case 32: avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
574  break;
575  default: avpriv_request_sample(avctx, "Sample depth %d", alac->sample_size);
576  return AVERROR_PATCHWELCOME;
577  }
578  avctx->bits_per_raw_sample = alac->sample_size;
579  avctx->sample_rate = alac->sample_rate;
580 
581  if (alac->channels < 1) {
582  av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n");
583  if (avctx->ch_layout.nb_channels < 1)
584  return AVERROR(EINVAL);
585  alac->channels = avctx->ch_layout.nb_channels;
586  }
587  if (alac->channels > ALAC_MAX_CHANNELS) {
588  avpriv_report_missing_feature(avctx, "Channel count %d",
589  alac->channels);
590  return AVERROR_PATCHWELCOME;
591  }
593  avctx->ch_layout = ff_alac_ch_layouts[alac->channels - 1];
594 
595  if ((ret = allocate_buffers(alac)) < 0) {
596  av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n");
597  return ret;
598  }
599 
600  ff_alacdsp_init(&alac->dsp);
601 
602  return 0;
603 }
604 
605 static const AVOption options[] = {
606  { "extra_bits_bug", "Force non-standard decoding process",
607  offsetof(ALACContext, extra_bit_bug), AV_OPT_TYPE_BOOL, { .i64 = 0 },
609  { NULL },
610 };
611 
612 static const AVClass alac_class = {
613  .class_name = "alac",
614  .item_name = av_default_item_name,
615  .option = options,
616  .version = LIBAVUTIL_VERSION_INT,
617 };
618 
620  .p.name = "alac",
621  CODEC_LONG_NAME("ALAC (Apple Lossless Audio Codec)"),
622  .p.type = AVMEDIA_TYPE_AUDIO,
623  .p.id = AV_CODEC_ID_ALAC,
624  .priv_data_size = sizeof(ALACContext),
626  .close = alac_decode_close,
629  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
630  .p.priv_class = &alac_class
631 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_alacdsp_init
av_cold void ff_alacdsp_init(ALACDSPContext *c)
Definition: alacdsp.c:55
extra_bits
#define extra_bits(eb)
Definition: intrax8.c:119
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
ff_alac_decoder
const FFCodec ff_alac_decoder
Definition: alac.c:619
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
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
opt.h
ALACDSPContext::decorrelate_stereo
void(* decorrelate_stereo)(int32_t *buffer[2], int nb_samples, int decorr_shift, int decorr_left_weight)
Definition: alacdsp.h:25
get_unary_0_9
static int get_unary_0_9(GetBitContext *gb)
Definition: unary.h:64
alac_data.h
lpc_prediction
static void lpc_prediction(int32_t *error_buffer, uint32_t *buffer_out, int nb_samples, int bps, int16_t *lpc_coefs, int lpc_order, int lpc_quant)
Definition: alac.c:175
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1068
decode_scalar
static unsigned int decode_scalar(GetBitContext *gb, int k, int bps)
Definition: alac.c:90
GetByteContext
Definition: bytestream.h:33
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
ALACContext::extra_bits
int extra_bits
number of extra bits beyond 16-bit
Definition: alac.c:81
alac_decode_close
static av_cold int alac_decode_close(AVCodecContext *avctx)
Definition: alac.c:478
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:251
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
AV_CODEC_ID_ALAC
@ AV_CODEC_ID_ALAC
Definition: codec_id.h:459
FFCodec
Definition: codec_internal.h:127
ALACContext::rice_history_mult
uint8_t rice_history_mult
Definition: alac.c:76
rice_decompress
static int rice_decompress(ALACContext *alac, int32_t *output_buffer, int nb_samples, int bps, int rice_history_mult)
Definition: alac.c:112
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:323
thread.h
alacdsp.h
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in FFCodec caps_internal and use ff_thread_get_buffer() to allocate frames. Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
sign_only
static int sign_only(int v)
Definition: alac.c:170
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2111
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:44
GetBitContext
Definition: get_bits.h:108
val
static double val(void *priv, double ch)
Definition: aeval.c:78
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
alac_decode_frame
static int alac_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: alac.c:420
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:547
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ALACContext::channels
int channels
Definition: alac.c:68
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1521
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:320
channels
channels
Definition: aptx.h:31
get_bits.h
ALACContext::predict_error_buffer
int32_t * predict_error_buffer[2]
Definition: alac.c:70
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:283
frame
static AVFrame * frame
Definition: demux_decode.c:54
decode_element
static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index, int channels)
Definition: alac.c:238
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
ALACContext::dsp
ALACDSPContext dsp
Definition: alac.c:87
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
options
static const AVOption options[]
Definition: alac.c:605
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
mathops.h
ALACDSPContext
Definition: alacdsp.h:24
ALACContext::nb_samples
int nb_samples
number of samples in the current frame
Definition: alac.c:82
ALACContext::max_samples_per_frame
uint32_t max_samples_per_frame
Definition: alac.c:74
ALACContext::rice_initial_history
uint8_t rice_initial_history
Definition: alac.c:77
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:106
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
alac_decode_init
static av_cold int alac_decode_init(AVCodecContext *avctx)
Definition: alac.c:552
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
AVPacket::size
int size
Definition: packet.h:523
codec_internal.h
TYPE_END
@ TYPE_END
Definition: aac.h:50
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
bps
unsigned bps
Definition: movenc.c:1787
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1084
ALACContext::output_samples_buffer
int32_t * output_samples_buffer[2]
Definition: alac.c:71
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
ALACContext
Definition: alac.c:64
ALACContext::direct_output
int direct_output
Definition: alac.c:84
ALACContext::rice_limit
uint8_t rice_limit
Definition: alac.c:78
ALAC_MAX_CHANNELS
#define ALAC_MAX_CHANNELS
Definition: alac_data.h:40
unary.h
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
ff_alac_channel_layout_offsets
const uint8_t ff_alac_channel_layout_offsets[ALAC_MAX_CHANNELS][ALAC_MAX_CHANNELS]
Definition: alac_data.c:24
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:546
ff_alac_ch_layouts
const AVChannelLayout ff_alac_ch_layouts[ALAC_MAX_CHANNELS+1]
Definition: alac_data.c:35
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
alac_class
static const AVClass alac_class
Definition: alac.c:612
ALACContext::avctx
AVCodecContext * avctx
Definition: alac.c:66
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:282
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
TYPE_LFE
@ TYPE_LFE
Definition: aac.h:46
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ALACContext::extra_bit_bug
int extra_bit_bug
Definition: alac.c:85
avcodec.h
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
ALACContext::sample_size
uint8_t sample_size
Definition: alac.c:75
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
U
#define U(x)
Definition: vpx_arith.h:37
ALACContext::sample_rate
int sample_rate
Definition: alac.c:79
AVCodecContext
main external API structure.
Definition: avcodec.h:445
channel_layout.h
allocate_buffers
static int allocate_buffers(ALACContext *alac)
Definition: alac.c:493
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:662
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
alac_set_info
static int alac_set_info(ALACContext *alac)
Definition: alac.c:521
AlacRawDataBlockType
AlacRawDataBlockType
Definition: alac_data.h:28
ALACDSPContext::append_extra_bits
void(* append_extra_bits[2])(int32_t *buffer[2], int32_t *extra_bits_buffer[2], int extra_bits, int channels, int nb_samples)
Definition: alacdsp.h:27
ALACContext::extra_bits_buffer
int32_t * extra_bits_buffer[2]
Definition: alac.c:72
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
d
d
Definition: ffmpeg_filter.c:424
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:471
int
int
Definition: ffmpeg_filter.c:424
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ALACContext::gb
GetBitContext gb
Definition: alac.c:67
ALAC_EXTRADATA_SIZE
#define ALAC_EXTRADATA_SIZE
Definition: alac.c:62