FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules 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 AVERROR_INVALIDDATA;
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 AVERROR_INVALIDDATA;
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  unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
272  int i;
273  int ret;
274 
275  /* warm up samples */
276  for (i = 0; i < pred_order; i++) {
277  decoded[i] = get_sbits_long(&s->gb, bps);
278  }
279 
280  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
281  return ret;
282 
283  if (pred_order > 0)
284  a = decoded[pred_order-1];
285  if (pred_order > 1)
286  b = a - decoded[pred_order-2];
287  if (pred_order > 2)
288  c = b - decoded[pred_order-2] + decoded[pred_order-3];
289  if (pred_order > 3)
290  d = c - decoded[pred_order-2] + 2U*decoded[pred_order-3] - decoded[pred_order-4];
291 
292  switch (pred_order) {
293  case 0:
294  break;
295  case 1:
296  for (i = pred_order; i < blocksize; i++)
297  decoded[i] = a += decoded[i];
298  break;
299  case 2:
300  for (i = pred_order; i < blocksize; i++)
301  decoded[i] = a += b += decoded[i];
302  break;
303  case 3:
304  for (i = pred_order; i < blocksize; i++)
305  decoded[i] = a += b += c += decoded[i];
306  break;
307  case 4:
308  for (i = pred_order; i < blocksize; i++)
309  decoded[i] = a += b += c += d += decoded[i];
310  break;
311  default:
312  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
313  return AVERROR_INVALIDDATA;
314  }
315 
316  return 0;
317 }
318 
319 static void lpc_analyze_remodulate(int32_t *decoded, const int coeffs[32],
320  int order, int qlevel, int len, int bps)
321 {
322  int i, j;
323  int ebps = 1 << (bps-1);
324  unsigned sigma = 0;
325 
326  for (i = order; i < len; i++)
327  sigma |= decoded[i] + ebps;
328 
329  if (sigma < 2*ebps)
330  return;
331 
332  for (i = len - 1; i >= order; i--) {
333  int64_t p = 0;
334  for (j = 0; j < order; j++)
335  p += coeffs[j] * (int64_t)decoded[i-order+j];
336  decoded[i] -= p >> qlevel;
337  }
338  for (i = order; i < len; i++, decoded++) {
339  int32_t p = 0;
340  for (j = 0; j < order; j++)
341  p += coeffs[j] * (uint32_t)decoded[j];
342  decoded[j] += p >> qlevel;
343  }
344 }
345 
346 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
347  int bps)
348 {
349  int i, ret;
350  int coeff_prec, qlevel;
351  int coeffs[32];
352 
353  /* warm up samples */
354  for (i = 0; i < pred_order; i++) {
355  decoded[i] = get_sbits_long(&s->gb, bps);
356  }
357 
358  coeff_prec = get_bits(&s->gb, 4) + 1;
359  if (coeff_prec == 16) {
360  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
361  return AVERROR_INVALIDDATA;
362  }
363  qlevel = get_sbits(&s->gb, 5);
364  if (qlevel < 0) {
365  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
366  qlevel);
367  return AVERROR_INVALIDDATA;
368  }
369 
370  for (i = 0; i < pred_order; i++) {
371  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
372  }
373 
374  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
375  return ret;
376 
377  if ( ( s->buggy_lpc && s->flac_stream_info.bps <= 16)
378  || ( !s->buggy_lpc && bps <= 16
379  && bps + coeff_prec + av_log2(pred_order) <= 32)) {
380  s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
381  } else {
382  s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
383  if (s->flac_stream_info.bps <= 16)
384  lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
385  }
386 
387  return 0;
388 }
389 
390 static inline int decode_subframe(FLACContext *s, int channel)
391 {
392  int32_t *decoded = s->decoded[channel];
393  int type, wasted = 0;
394  int bps = s->flac_stream_info.bps;
395  int i, tmp, ret;
396 
397  if (channel == 0) {
399  bps++;
400  } else {
402  bps++;
403  }
404 
405  if (get_bits1(&s->gb)) {
406  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
407  return AVERROR_INVALIDDATA;
408  }
409  type = get_bits(&s->gb, 6);
410 
411  if (get_bits1(&s->gb)) {
412  int left = get_bits_left(&s->gb);
413  if ( left <= 0 ||
414  (left < bps && !show_bits_long(&s->gb, left)) ||
415  !show_bits_long(&s->gb, bps)) {
417  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
418  bps, left);
419  return AVERROR_INVALIDDATA;
420  }
421  wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
422  bps -= wasted;
423  }
424  if (bps > 32) {
425  avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
426  return AVERROR_PATCHWELCOME;
427  }
428 
429 //FIXME use av_log2 for types
430  if (type == 0) {
431  tmp = get_sbits_long(&s->gb, bps);
432  for (i = 0; i < s->blocksize; i++)
433  decoded[i] = tmp;
434  } else if (type == 1) {
435  for (i = 0; i < s->blocksize; i++)
436  decoded[i] = get_sbits_long(&s->gb, bps);
437  } else if ((type >= 8) && (type <= 12)) {
438  if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
439  return ret;
440  } else if (type >= 32) {
441  if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
442  return ret;
443  } else {
444  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
445  return AVERROR_INVALIDDATA;
446  }
447 
448  if (wasted && wasted < 32) {
449  int i;
450  for (i = 0; i < s->blocksize; i++)
451  decoded[i] = (unsigned)decoded[i] << wasted;
452  }
453 
454  return 0;
455 }
456 
458 {
459  int i, ret;
460  GetBitContext *gb = &s->gb;
462 
463  if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
464  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
465  return ret;
466  }
467 
468  if ( s->flac_stream_info.channels
469  && fi.channels != s->flac_stream_info.channels
470  && s->got_streaminfo) {
471  s->flac_stream_info.channels = s->avctx->channels = fi.channels;
473  ret = allocate_buffers(s);
474  if (ret < 0)
475  return ret;
476  }
477  s->flac_stream_info.channels = s->avctx->channels = fi.channels;
478  if (!s->avctx->channel_layout)
480  s->ch_mode = fi.ch_mode;
481 
482  if (!s->flac_stream_info.bps && !fi.bps) {
483  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
484  return AVERROR_INVALIDDATA;
485  }
486  if (!fi.bps) {
487  fi.bps = s->flac_stream_info.bps;
488  } else if (s->flac_stream_info.bps && fi.bps != s->flac_stream_info.bps) {
489  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
490  "supported\n");
491  return AVERROR_INVALIDDATA;
492  }
493 
494  if (!s->flac_stream_info.bps) {
495  s->flac_stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
496  flac_set_bps(s);
497  }
498 
499  if (!s->flac_stream_info.max_blocksize)
500  s->flac_stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
501  if (fi.blocksize > s->flac_stream_info.max_blocksize) {
502  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
503  s->flac_stream_info.max_blocksize);
504  return AVERROR_INVALIDDATA;
505  }
506  s->blocksize = fi.blocksize;
507 
508  if (!s->flac_stream_info.samplerate && !fi.samplerate) {
509  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
510  " or frame header\n");
511  return AVERROR_INVALIDDATA;
512  }
513  if (fi.samplerate == 0)
514  fi.samplerate = s->flac_stream_info.samplerate;
515  s->flac_stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
516 
517  if (!s->got_streaminfo) {
518  ret = allocate_buffers(s);
519  if (ret < 0)
520  return ret;
521  s->got_streaminfo = 1;
523  }
525  s->flac_stream_info.channels, s->flac_stream_info.bps);
526 
527 // dump_headers(s->avctx, &s->flac_stream_info);
528 
529  /* subframes */
530  for (i = 0; i < s->flac_stream_info.channels; i++) {
531  if ((ret = decode_subframe(s, i)) < 0)
532  return ret;
533  }
534 
535  align_get_bits(gb);
536 
537  /* frame footer */
538  skip_bits(gb, 16); /* data crc */
539 
540  return 0;
541 }
542 
543 static int flac_decode_frame(AVCodecContext *avctx, void *data,
544  int *got_frame_ptr, AVPacket *avpkt)
545 {
546  AVFrame *frame = data;
547  ThreadFrame tframe = { .f = data };
548  const uint8_t *buf = avpkt->data;
549  int buf_size = avpkt->size;
550  FLACContext *s = avctx->priv_data;
551  int bytes_read = 0;
552  int ret;
553 
554  *got_frame_ptr = 0;
555 
556  if (s->flac_stream_info.max_framesize == 0) {
557  s->flac_stream_info.max_framesize =
559  FLAC_MAX_CHANNELS, 32);
560  }
561 
562  if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
563  av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
564  return buf_size;
565  }
566 
567  if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
568  av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
569  return buf_size;
570  }
571 
572  /* check that there is at least the smallest decodable amount of data.
573  this amount corresponds to the smallest valid FLAC frame possible.
574  FF F8 69 02 00 00 9A 00 00 34 46 */
575  if (buf_size < FLAC_MIN_FRAME_SIZE)
576  return buf_size;
577 
578  /* check for inline header */
579  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
580  if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
581  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
582  return ret;
583  }
584  return get_metadata_size(buf, buf_size);
585  }
586 
587  /* decode frame */
588  if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
589  return ret;
590  if ((ret = decode_frame(s)) < 0) {
591  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
592  return ret;
593  }
594  bytes_read = get_bits_count(&s->gb)/8;
595 
598  0, buf, bytes_read)) {
599  av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
601  return AVERROR_INVALIDDATA;
602  }
603 
604  /* get output buffer */
605  frame->nb_samples = s->blocksize;
606  if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
607  return ret;
608 
609  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
610  s->flac_stream_info.channels,
611  s->blocksize, s->sample_shift);
612 
613  if (bytes_read > buf_size) {
614  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
615  return AVERROR_INVALIDDATA;
616  }
617  if (bytes_read < buf_size) {
618  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
619  buf_size - bytes_read, buf_size);
620  }
621 
622  *got_frame_ptr = 1;
623 
624  return bytes_read;
625 }
626 
628 {
629  FLACContext *s = avctx->priv_data;
630  s->decoded_buffer = NULL;
631  s->decoded_buffer_size = 0;
632  s->avctx = avctx;
633  if (s->flac_stream_info.max_blocksize)
634  return allocate_buffers(s);
635  return 0;
636 }
637 
639 {
640  FLACContext *s = avctx->priv_data;
641 
643 
644  return 0;
645 }
646 
647 static const AVOption options[] = {
648 { "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 },
649 { NULL },
650 };
651 
652 static const AVClass flac_decoder_class = {
653  "FLAC decoder",
655  options,
657 };
658 
660  .name = "flac",
661  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
662  .type = AVMEDIA_TYPE_AUDIO,
663  .id = AV_CODEC_ID_FLAC,
664  .priv_data_size = sizeof(FLACContext),
666  .close = flac_decode_close,
670  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
675  .priv_class = &flac_decoder_class,
676 };
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:388
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:261
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:1434
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:3013
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
Definition: flacdec.c:217
AVCodec.
Definition: avcodec.h:3482
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:86
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:246
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:376
#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:2280
uint8_t
#define av_cold
Definition: attributes.h:74
FLACDSPContext dsp
Definition: flacdec.c:68
static const AVClass flac_decoder_class
Definition: flacdec.c:652
AVOptions.
#define AV_RB32
Definition: intreadwrite.h:130
Multithreading support functions.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1627
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:1433
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:213
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
#define U(x)
Definition: vp56_arith.h:37
FLACExtradataFormat
Definition: flac.h:58
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:594
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:2911
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:2355
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:178
#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:346
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:3489
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.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:920
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:2333
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:217
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2900
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
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:319
#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:659
#define av_log2
Definition: intmath.h:100
#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:2272
static const AVOption options[]
Definition: flacdec.c:647
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:446
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:457
main external API structure.
Definition: avcodec.h:1512
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:305
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:298
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:521
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:390
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:511
void(* lpc16)(int32_t *samples, const int coeffs[32], int order, int qlevel, int len)
Definition: flacdsp.h:28
common internal api header.
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
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:1340
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:2908
#define MKBETAG(a, b, c, d)
Definition: common.h:342
void * priv_data
Definition: avcodec.h:1554
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
static const int16_t coeffs[]
int len
int channels
number of audio channels
Definition: avcodec.h:2273
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2915
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:454
#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:1410
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:225
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:857
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1426
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:627
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:638
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:543