FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
flacdec.c
Go to the documentation of this file.
1 /*
2  * FLAC (Free Lossless Audio Codec) decoder
3  * Copyright (c) 2003 Alex Beregszaszi
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  * FLAC (Free Lossless Audio Codec) decoder
25  * @author Alex Beregszaszi
26  * @see http://flac.sourceforge.net/
27  *
28  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
29  * through, starting from the initial 'fLaC' signature; or by passing the
30  * 34-byte streaminfo structure through avctx->extradata[_size] followed
31  * by data starting with the 0xFFF8 marker.
32  */
33 
34 #include <limits.h>
35 
36 #include "libavutil/avassert.h"
37 #include "libavutil/crc.h"
38 #include "libavutil/opt.h"
39 #include "avcodec.h"
40 #include "internal.h"
41 #include "get_bits.h"
42 #include "bytestream.h"
43 #include "golomb.h"
44 #include "flac.h"
45 #include "flacdata.h"
46 #include "flacdsp.h"
47 #include "thread.h"
48 #include "unary.h"
49 
50 
51 typedef struct FLACContext {
52  AVClass *class;
54 
55  AVCodecContext *avctx; ///< parent AVCodecContext
56  GetBitContext gb; ///< GetBitContext initialized to start at the current frame
57 
58  int blocksize; ///< number of samples in the current frame
59  int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
60  int ch_mode; ///< channel decorrelation type in the current frame
61  int got_streaminfo; ///< indicates if the STREAMINFO has been read
62 
63  int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
65  unsigned int decoded_buffer_size;
66  int buggy_lpc; ///< use workaround for old lavc encoded files
67 
69 } FLACContext;
70 
71 static int allocate_buffers(FLACContext *s);
72 
73 static void flac_set_bps(FLACContext *s)
74 {
76  int need32 = s->flac_stream_info.bps > 16;
77  int want32 = av_get_bytes_per_sample(req) > 2;
78  int planar = av_sample_fmt_is_planar(req);
79 
80  if (need32 || want32) {
81  if (planar)
83  else
85  s->sample_shift = 32 - s->flac_stream_info.bps;
86  } else {
87  if (planar)
89  else
91  s->sample_shift = 16 - s->flac_stream_info.bps;
92  }
93 }
94 
96 {
97  enum FLACExtradataFormat format;
98  uint8_t *streaminfo;
99  int ret;
100  FLACContext *s = avctx->priv_data;
101  s->avctx = avctx;
102 
103  /* for now, the raw FLAC header is allowed to be passed to the decoder as
104  frame data instead of extradata. */
105  if (!avctx->extradata)
106  return 0;
107 
108  if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
109  return AVERROR_INVALIDDATA;
110 
111  /* initialize based on the demuxer-supplied streamdata header */
112  ff_flac_parse_streaminfo(avctx, &s->flac_stream_info, streaminfo);
113  ret = allocate_buffers(s);
114  if (ret < 0)
115  return ret;
116  flac_set_bps(s);
117  ff_flacdsp_init(&s->dsp, avctx->sample_fmt,
118  s->flac_stream_info.channels, s->flac_stream_info.bps);
119  s->got_streaminfo = 1;
120 
121  return 0;
122 }
123 
125 {
126  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
127  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
128  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
129  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
130  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
131 }
132 
134 {
135  int buf_size;
136  int ret;
137 
138  av_assert0(s->flac_stream_info.max_blocksize);
139 
140  buf_size = av_samples_get_buffer_size(NULL, s->flac_stream_info.channels,
141  s->flac_stream_info.max_blocksize,
142  AV_SAMPLE_FMT_S32P, 0);
143  if (buf_size < 0)
144  return buf_size;
145 
147  if (!s->decoded_buffer)
148  return AVERROR(ENOMEM);
149 
151  s->decoded_buffer,
152  s->flac_stream_info.channels,
153  s->flac_stream_info.max_blocksize,
154  AV_SAMPLE_FMT_S32P, 0);
155  return ret < 0 ? ret : 0;
156 }
157 
158 /**
159  * Parse the STREAMINFO from an inline header.
160  * @param s the flac decoding context
161  * @param buf input buffer, starting with the "fLaC" marker
162  * @param buf_size buffer size
163  * @return non-zero if metadata is invalid
164  */
165 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
166 {
167  int metadata_type, metadata_size, ret;
168 
169  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
170  /* need more data */
171  return 0;
172  }
173  flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
174  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
175  metadata_size != FLAC_STREAMINFO_SIZE) {
176  return AVERROR_INVALIDDATA;
177  }
179  ret = allocate_buffers(s);
180  if (ret < 0)
181  return ret;
182  flac_set_bps(s);
184  s->flac_stream_info.channels, s->flac_stream_info.bps);
185  s->got_streaminfo = 1;
186 
187  return 0;
188 }
189 
190 /**
191  * Determine the size of an inline header.
192  * @param buf input buffer, starting with the "fLaC" marker
193  * @param buf_size buffer size
194  * @return number of bytes in the header, or 0 if more data is needed
195  */
196 static int get_metadata_size(const uint8_t *buf, int buf_size)
197 {
198  int metadata_last, metadata_size;
199  const uint8_t *buf_end = buf + buf_size;
200 
201  buf += 4;
202  do {
203  if (buf_end - buf < 4)
204  return 0;
205  flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
206  buf += 4;
207  if (buf_end - buf < metadata_size) {
208  /* need more data in order to read the complete header */
209  return 0;
210  }
211  buf += metadata_size;
212  } while (!metadata_last);
213 
214  return buf_size - (buf_end - buf);
215 }
216 
217 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
218 {
219  int i, tmp, partition, method_type, rice_order;
220  int rice_bits, rice_esc;
221  int samples;
222 
223  method_type = get_bits(&s->gb, 2);
224  if (method_type > 1) {
225  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
226  method_type);
227  return AVERROR_INVALIDDATA;
228  }
229 
230  rice_order = get_bits(&s->gb, 4);
231 
232  samples= s->blocksize >> rice_order;
233  if (samples << rice_order != s->blocksize) {
234  av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
235  rice_order, s->blocksize);
236  return AVERROR_INVALIDDATA;
237  }
238 
239  if (pred_order > samples) {
240  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
241  pred_order, samples);
242  return AVERROR_INVALIDDATA;
243  }
244 
245  rice_bits = 4 + method_type;
246  rice_esc = (1 << rice_bits) - 1;
247 
248  decoded += pred_order;
249  i= pred_order;
250  for (partition = 0; partition < (1 << rice_order); partition++) {
251  tmp = get_bits(&s->gb, rice_bits);
252  if (tmp == rice_esc) {
253  tmp = get_bits(&s->gb, 5);
254  for (; i < samples; i++)
255  *decoded++ = get_sbits_long(&s->gb, tmp);
256  } else {
257  for (; i < samples; i++) {
258  *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
259  }
260  }
261  i= 0;
262  }
263 
264  return 0;
265 }
266 
268  int pred_order, int bps)
269 {
270  const int blocksize = s->blocksize;
271  int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
272  int ret;
273 
274  /* warm up samples */
275  for (i = 0; i < pred_order; i++) {
276  decoded[i] = get_sbits_long(&s->gb, bps);
277  }
278 
279  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
280  return ret;
281 
282  if (pred_order > 0)
283  a = decoded[pred_order-1];
284  if (pred_order > 1)
285  b = a - decoded[pred_order-2];
286  if (pred_order > 2)
287  c = b - decoded[pred_order-2] + decoded[pred_order-3];
288  if (pred_order > 3)
289  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
290 
291  switch (pred_order) {
292  case 0:
293  break;
294  case 1:
295  for (i = pred_order; i < blocksize; i++)
296  decoded[i] = a += decoded[i];
297  break;
298  case 2:
299  for (i = pred_order; i < blocksize; i++)
300  decoded[i] = a += b += decoded[i];
301  break;
302  case 3:
303  for (i = pred_order; i < blocksize; i++)
304  decoded[i] = a += b += c += decoded[i];
305  break;
306  case 4:
307  for (i = pred_order; i < blocksize; i++)
308  decoded[i] = a += b += c += d += decoded[i];
309  break;
310  default:
311  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
312  return AVERROR_INVALIDDATA;
313  }
314 
315  return 0;
316 }
317 
318 static void lpc_analyze_remodulate(int32_t *decoded, const int coeffs[32],
319  int order, int qlevel, int len, int bps)
320 {
321  int i, j;
322  int ebps = 1 << (bps-1);
323  unsigned sigma = 0;
324 
325  for (i = order; i < len; i++)
326  sigma |= decoded[i] + ebps;
327 
328  if (sigma < 2*ebps)
329  return;
330 
331  for (i = len - 1; i >= order; i--) {
332  int64_t p = 0;
333  for (j = 0; j < order; j++)
334  p += coeffs[j] * (int64_t)decoded[i-order+j];
335  decoded[i] -= p >> qlevel;
336  }
337  for (i = order; i < len; i++, decoded++) {
338  int32_t p = 0;
339  for (j = 0; j < order; j++)
340  p += coeffs[j] * (uint32_t)decoded[j];
341  decoded[j] += p >> qlevel;
342  }
343 }
344 
345 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
346  int bps)
347 {
348  int i, ret;
349  int coeff_prec, qlevel;
350  int coeffs[32];
351 
352  /* warm up samples */
353  for (i = 0; i < pred_order; i++) {
354  decoded[i] = get_sbits_long(&s->gb, bps);
355  }
356 
357  coeff_prec = get_bits(&s->gb, 4) + 1;
358  if (coeff_prec == 16) {
359  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
360  return AVERROR_INVALIDDATA;
361  }
362  qlevel = get_sbits(&s->gb, 5);
363  if (qlevel < 0) {
364  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
365  qlevel);
366  return AVERROR_INVALIDDATA;
367  }
368 
369  for (i = 0; i < pred_order; i++) {
370  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
371  }
372 
373  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
374  return ret;
375 
376  if ( ( s->buggy_lpc && s->flac_stream_info.bps <= 16)
377  || ( !s->buggy_lpc && bps <= 16
378  && bps + coeff_prec + av_log2(pred_order) <= 32)) {
379  s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
380  } else {
381  s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
382  if (s->flac_stream_info.bps <= 16)
383  lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
384  }
385 
386  return 0;
387 }
388 
389 static inline int decode_subframe(FLACContext *s, int channel)
390 {
391  int32_t *decoded = s->decoded[channel];
392  int type, wasted = 0;
393  int bps = s->flac_stream_info.bps;
394  int i, tmp, ret;
395 
396  if (channel == 0) {
398  bps++;
399  } else {
401  bps++;
402  }
403 
404  if (get_bits1(&s->gb)) {
405  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
406  return AVERROR_INVALIDDATA;
407  }
408  type = get_bits(&s->gb, 6);
409 
410  if (get_bits1(&s->gb)) {
411  int left = get_bits_left(&s->gb);
412  if ( left <= 0 ||
413  (left < bps && !show_bits_long(&s->gb, left)) ||
414  !show_bits_long(&s->gb, bps)) {
416  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
417  bps, left);
418  return AVERROR_INVALIDDATA;
419  }
420  wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
421  bps -= wasted;
422  }
423  if (bps > 32) {
424  avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
425  return AVERROR_PATCHWELCOME;
426  }
427 
428 //FIXME use av_log2 for types
429  if (type == 0) {
430  tmp = get_sbits_long(&s->gb, bps);
431  for (i = 0; i < s->blocksize; i++)
432  decoded[i] = tmp;
433  } else if (type == 1) {
434  for (i = 0; i < s->blocksize; i++)
435  decoded[i] = get_sbits_long(&s->gb, bps);
436  } else if ((type >= 8) && (type <= 12)) {
437  if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
438  return ret;
439  } else if (type >= 32) {
440  if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
441  return ret;
442  } else {
443  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
444  return AVERROR_INVALIDDATA;
445  }
446 
447  if (wasted) {
448  int i;
449  for (i = 0; i < s->blocksize; i++)
450  decoded[i] <<= wasted;
451  }
452 
453  return 0;
454 }
455 
457 {
458  int i, ret;
459  GetBitContext *gb = &s->gb;
461 
462  if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
463  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
464  return ret;
465  }
466 
467  if ( s->flac_stream_info.channels
468  && fi.channels != s->flac_stream_info.channels
469  && s->got_streaminfo) {
470  s->flac_stream_info.channels = s->avctx->channels = fi.channels;
472  ret = allocate_buffers(s);
473  if (ret < 0)
474  return ret;
475  }
476  s->flac_stream_info.channels = s->avctx->channels = fi.channels;
477  if (!s->avctx->channel_layout)
479  s->ch_mode = fi.ch_mode;
480 
481  if (!s->flac_stream_info.bps && !fi.bps) {
482  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
483  return AVERROR_INVALIDDATA;
484  }
485  if (!fi.bps) {
486  fi.bps = s->flac_stream_info.bps;
487  } else if (s->flac_stream_info.bps && fi.bps != s->flac_stream_info.bps) {
488  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
489  "supported\n");
490  return AVERROR_INVALIDDATA;
491  }
492 
493  if (!s->flac_stream_info.bps) {
494  s->flac_stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
495  flac_set_bps(s);
496  }
497 
498  if (!s->flac_stream_info.max_blocksize)
499  s->flac_stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
500  if (fi.blocksize > s->flac_stream_info.max_blocksize) {
501  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
502  s->flac_stream_info.max_blocksize);
503  return AVERROR_INVALIDDATA;
504  }
505  s->blocksize = fi.blocksize;
506 
507  if (!s->flac_stream_info.samplerate && !fi.samplerate) {
508  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
509  " or frame header\n");
510  return AVERROR_INVALIDDATA;
511  }
512  if (fi.samplerate == 0)
513  fi.samplerate = s->flac_stream_info.samplerate;
514  s->flac_stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
515 
516  if (!s->got_streaminfo) {
517  ret = allocate_buffers(s);
518  if (ret < 0)
519  return ret;
520  s->got_streaminfo = 1;
522  }
524  s->flac_stream_info.channels, s->flac_stream_info.bps);
525 
526 // dump_headers(s->avctx, &s->flac_stream_info);
527 
528  /* subframes */
529  for (i = 0; i < s->flac_stream_info.channels; i++) {
530  if ((ret = decode_subframe(s, i)) < 0)
531  return ret;
532  }
533 
534  align_get_bits(gb);
535 
536  /* frame footer */
537  skip_bits(gb, 16); /* data crc */
538 
539  return 0;
540 }
541 
542 static int flac_decode_frame(AVCodecContext *avctx, void *data,
543  int *got_frame_ptr, AVPacket *avpkt)
544 {
545  AVFrame *frame = data;
546  ThreadFrame tframe = { .f = data };
547  const uint8_t *buf = avpkt->data;
548  int buf_size = avpkt->size;
549  FLACContext *s = avctx->priv_data;
550  int bytes_read = 0;
551  int ret;
552 
553  *got_frame_ptr = 0;
554 
555  if (s->flac_stream_info.max_framesize == 0) {
556  s->flac_stream_info.max_framesize =
558  FLAC_MAX_CHANNELS, 32);
559  }
560 
561  if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
562  av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
563  return buf_size;
564  }
565 
566  if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
567  av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
568  return buf_size;
569  }
570 
571  /* check that there is at least the smallest decodable amount of data.
572  this amount corresponds to the smallest valid FLAC frame possible.
573  FF F8 69 02 00 00 9A 00 00 34 46 */
574  if (buf_size < FLAC_MIN_FRAME_SIZE)
575  return buf_size;
576 
577  /* check for inline header */
578  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
579  if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
580  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
581  return ret;
582  }
583  return get_metadata_size(buf, buf_size);
584  }
585 
586  /* decode frame */
587  if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
588  return ret;
589  if ((ret = decode_frame(s)) < 0) {
590  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
591  return ret;
592  }
593  bytes_read = get_bits_count(&s->gb)/8;
594 
597  0, buf, bytes_read)) {
598  av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
600  return AVERROR_INVALIDDATA;
601  }
602 
603  /* get output buffer */
604  frame->nb_samples = s->blocksize;
605  if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
606  return ret;
607 
608  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
609  s->flac_stream_info.channels,
610  s->blocksize, s->sample_shift);
611 
612  if (bytes_read > buf_size) {
613  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
614  return AVERROR_INVALIDDATA;
615  }
616  if (bytes_read < buf_size) {
617  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
618  buf_size - bytes_read, buf_size);
619  }
620 
621  *got_frame_ptr = 1;
622 
623  return bytes_read;
624 }
625 
627 {
628  FLACContext *s = avctx->priv_data;
629  s->decoded_buffer = NULL;
630  s->decoded_buffer_size = 0;
631  s->avctx = avctx;
632  if (s->flac_stream_info.max_blocksize)
633  return allocate_buffers(s);
634  return 0;
635 }
636 
638 {
639  FLACContext *s = avctx->priv_data;
640 
642 
643  return 0;
644 }
645 
646 static const AVOption options[] = {
647 { "use_buggy_lpc", "emulate old buggy lavc behavior", offsetof(FLACContext, buggy_lpc), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
648 { NULL },
649 };
650 
651 static const AVClass flac_decoder_class = {
652  "FLAC decoder",
654  options,
656 };
657 
659  .name = "flac",
660  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
661  .type = AVMEDIA_TYPE_AUDIO,
662  .id = AV_CODEC_ID_FLAC,
663  .priv_data_size = sizeof(FLACContext),
665  .close = flac_decode_close,
668  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
669  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
674  .priv_class = &flac_decoder_class,
675 };
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:383
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:377
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:631
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
AVOption.
Definition: opt.h:255
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
AVFrame * f
Definition: thread.h:36
#define LIBAVUTIL_VERSION_INT
Definition: version.h:62
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int allocate_buffers(FLACContext *s)
Definition: flacdec.c:133
int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
Calculate an estimate for the maximum frame size based on verbatim mode.
Definition: flac.c:148
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:290
int size
Definition: avcodec.h:1174
const char * b
Definition: vf_curves.c:109
AVCodecContext * avctx
parent AVCodecContext
Definition: flacdec.c:55
#define FLAC_MAX_BLOCKSIZE
Definition: flac.h:37
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2753
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
Definition: flacdec.c:217
AVCodec.
Definition: avcodec.h:3206
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:86
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:245
int ff_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flac.c:169
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:375
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void(* lpc32)(int32_t *samples, const int coeffs[32], int order, int qlevel, int len)
Definition: flacdsp.h:30
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2018
uint8_t
#define av_cold
Definition: attributes.h:74
FLACDSPContext dsp
Definition: flacdec.c:68
static const AVClass flac_decoder_class
Definition: flacdec.c:651
AVOptions.
Multithreading support functions.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1366
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:85
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:794
static AVFrame * frame
static void flac_set_bps(FLACContext *s)
Definition: flacdec.c:73
uint8_t * decoded_buffer
Definition: flacdec.c:64
uint8_t * data
Definition: avcodec.h:1173
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
bitstream reader API header.
unsigned int decoded_buffer_size
Definition: flacdec.c:65
signed 32 bits
Definition: samplefmt.h:63
#define av_log(a,...)
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:110
FLACExtradataFormat
Definition: flac.h:58
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:588
AVS_FilterInfo ** fi
Definition: avisynth_c.h:594
int32_t * decoded[FLAC_MAX_CHANNELS]
decoded samples
Definition: flacdec.c:63
int ch_mode
channel decorrelation mode
Definition: flac.h:87
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2649
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
enum AVSampleFormat request_sample_fmt
desired sample format
Definition: avcodec.h:2093
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:345
simple assert() macros that are a bit more flexible than ISO C assert().
static int get_metadata_size(const uint8_t *buf, int buf_size)
Determine the size of an inline header.
Definition: flacdec.c:196
GetBitContext gb
GetBitContext initialized to start at the current frame.
Definition: flacdec.c:56
const char * name
Name of the codec implementation.
Definition: avcodec.h:3213
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
Definition: flacdec.c:124
int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, FLACFrameInfo *fi, int log_level_offset)
Validate and decode a frame header.
Definition: flac.c:50
Libavcodec external API header.
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:267
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2071
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:214
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2638
signed 32 bits, planar
Definition: samplefmt.h:69
int buggy_lpc
use workaround for old lavc encoded files
Definition: flacdec.c:66
int got_streaminfo
indicates if the STREAMINFO has been read
Definition: flacdec.c:61
ret
Definition: avfilter.c:974
int32_t
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:356
static void lpc_analyze_remodulate(int32_t *decoded, const int coeffs[32], int order, int qlevel, int len, int bps)
Definition: flacdec.c:318
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
int sample_shift
shift required to make output samples 16-bit or 32-bit
Definition: flacdec.c:59
AVCodec ff_flac_decoder
Definition: flacdec.c:658
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:59
int sample_rate
samples per second
Definition: avcodec.h:2010
static const AVOption options[]
Definition: flacdec.c:646
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:441
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
static int decode_frame(FLACContext *s)
Definition: flacdec.c:456
main external API structure.
Definition: avcodec.h:1252
void * buf
Definition: avisynth_c.h:553
GLint GLenum type
Definition: opengl_enc.c:105
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:196
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:204
Describe the class of an AVClass context structure.
Definition: log.h:67
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int channels, int bps)
Definition: flacdsp.c:88
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:297
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:117
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:286
static av_always_inline void flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)
Parse the metadata block parameters from the header.
Definition: flac.h:151
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
Parse the STREAMINFO from an inline header.
Definition: flacdec.c:165
struct FLACStreaminfo flac_stream_info
Definition: flacdec.c:53
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:104
int blocksize
number of samples in the current frame
Definition: flacdec.c:58
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:342
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:522
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:389
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:513
void(* lpc16)(int32_t *samples, const int coeffs[32], int order, int qlevel, int len)
Definition: flacdsp.h:28
common internal api header.
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:871
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:33
signed 16 bits
Definition: samplefmt.h:62
static double c[64]
#define FLAC_MIN_FRAME_SIZE
Definition: flac.h:38
unsigned bps
Definition: movenc.c:1334
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:2646
#define MKBETAG(a, b, c, d)
Definition: common.h:316
void * priv_data
Definition: avcodec.h:1294
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, const uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Fill plane data pointers and linesize for samples with sample format sample_fmt.
Definition: samplefmt.c:149
int len
int channels
number of audio channels
Definition: avcodec.h:2011
#define av_log2
Definition: intmath.h:105
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2653
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:449
#define av_uninit(x)
Definition: attributes.h:141
static av_cold int flac_decode_init(AVCodecContext *avctx)
Definition: flacdec.c:95
#define av_freep(p)
signed 16 bits, planar
Definition: samplefmt.h:68
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:1150
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:225
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1166
void(* decorrelate[4])(uint8_t **out, int32_t **in, int channels, int len, int shift)
Definition: flacdsp.h:26
static int init_thread_copy(AVCodecContext *avctx)
Definition: flacdec.c:626
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:637
int ch_mode
channel decorrelation type in the current frame
Definition: flacdec.c:60
static int flac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: flacdec.c:542