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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
34 #include <limits.h>
35 
36 #include "libavutil/crc.h"
37 #include "avcodec.h"
38 #include "internal.h"
39 #include "get_bits.h"
40 #include "bytestream.h"
41 #include "golomb.h"
42 #include "flac.h"
43 #include "flacdata.h"
44 
45 #undef NDEBUG
46 #include <assert.h>
47 
48 typedef struct FLACContext {
50 
54 
55  int blocksize;
56  int curr_bps;
58  int is32;
59  int ch_mode;
61 
63 } FLACContext;
64 
65 static void allocate_buffers(FLACContext *s);
66 
68  enum FLACExtradataFormat *format,
69  uint8_t **streaminfo_start)
70 {
71  if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
72  av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
73  return 0;
74  }
75  if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
76  /* extradata contains STREAMINFO only */
77  if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
78  av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
80  }
82  *streaminfo_start = avctx->extradata;
83  } else {
84  if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
85  av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
86  return 0;
87  }
89  *streaminfo_start = &avctx->extradata[8];
90  }
91  return 1;
92 }
93 
95 {
96  enum FLACExtradataFormat format;
97  uint8_t *streaminfo;
98  FLACContext *s = avctx->priv_data;
99  s->avctx = avctx;
100 
101  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
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 (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
109  return -1;
110 
111  /* initialize based on the demuxer-supplied streamdata header */
112  avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
113  if (s->bps > 16)
114  avctx->sample_fmt = AV_SAMPLE_FMT_S32;
115  else
116  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
117  allocate_buffers(s);
118  s->got_streaminfo = 1;
119 
121  avctx->coded_frame = &s->frame;
122 
123  return 0;
124 }
125 
127 {
128  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
129  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
130  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
131  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
132  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
133 }
134 
136 {
137  int i;
138 
139  assert(s->max_blocksize);
140 
141  for (i = 0; i < s->channels; i++) {
142  s->decoded[i] = av_realloc(s->decoded[i],
143  sizeof(int32_t)*s->max_blocksize);
144  }
145 }
146 
148  const uint8_t *buffer)
149 {
150  GetBitContext gb;
151  init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
152 
153  skip_bits(&gb, 16); /* skip min blocksize */
154  s->max_blocksize = get_bits(&gb, 16);
155  if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
156  av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
157  s->max_blocksize);
158  s->max_blocksize = 16;
159  }
160 
161  skip_bits(&gb, 24); /* skip min frame size */
162  s->max_framesize = get_bits_long(&gb, 24);
163 
164  s->samplerate = get_bits_long(&gb, 20);
165  s->channels = get_bits(&gb, 3) + 1;
166  s->bps = get_bits(&gb, 5) + 1;
167 
168  avctx->channels = s->channels;
169  avctx->sample_rate = s->samplerate;
170  avctx->bits_per_raw_sample = s->bps;
171 
172  s->samples = get_bits_long(&gb, 32) << 4;
173  s->samples |= get_bits(&gb, 4);
174 
175  skip_bits_long(&gb, 64); /* md5 sum */
176  skip_bits_long(&gb, 64); /* md5 sum */
177 
178  dump_headers(avctx, s);
179 }
180 
181 void avpriv_flac_parse_block_header(const uint8_t *block_header,
182  int *last, int *type, int *size)
183 {
184  int tmp = bytestream_get_byte(&block_header);
185  if (last)
186  *last = tmp & 0x80;
187  if (type)
188  *type = tmp & 0x7F;
189  if (size)
190  *size = bytestream_get_be24(&block_header);
191 }
192 
200 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
201 {
202  int metadata_type, metadata_size;
203 
204  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
205  /* need more data */
206  return 0;
207  }
208  avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
209  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
210  metadata_size != FLAC_STREAMINFO_SIZE) {
211  return AVERROR_INVALIDDATA;
212  }
214  allocate_buffers(s);
215  s->got_streaminfo = 1;
216 
217  return 0;
218 }
219 
226 static int get_metadata_size(const uint8_t *buf, int buf_size)
227 {
228  int metadata_last, metadata_size;
229  const uint8_t *buf_end = buf + buf_size;
230 
231  buf += 4;
232  do {
233  if (buf_end - buf < 4)
234  return 0;
235  avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
236  buf += 4;
237  if (buf_end - buf < metadata_size) {
238  /* need more data in order to read the complete header */
239  return 0;
240  }
241  buf += metadata_size;
242  } while (!metadata_last);
243 
244  return buf_size - (buf_end - buf);
245 }
246 
247 static int decode_residuals(FLACContext *s, int channel, int pred_order)
248 {
249  int i, tmp, partition, method_type, rice_order;
250  int sample = 0, samples;
251 
252  method_type = get_bits(&s->gb, 2);
253  if (method_type > 1) {
254  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
255  method_type);
256  return -1;
257  }
258 
259  rice_order = get_bits(&s->gb, 4);
260 
261  samples= s->blocksize >> rice_order;
262  if (pred_order > samples) {
263  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
264  pred_order, samples);
265  return -1;
266  }
267 
268  sample=
269  i= pred_order;
270  for (partition = 0; partition < (1 << rice_order); partition++) {
271  tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
272  if (tmp == (method_type == 0 ? 15 : 31)) {
273  tmp = get_bits(&s->gb, 5);
274  for (; i < samples; i++, sample++)
275  s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
276  } else {
277  for (; i < samples; i++, sample++) {
278  s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
279  }
280  }
281  i= 0;
282  }
283 
284  return 0;
285 }
286 
287 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
288 {
289  const int blocksize = s->blocksize;
290  int32_t *decoded = s->decoded[channel];
291  int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
292 
293  /* warm up samples */
294  for (i = 0; i < pred_order; i++) {
295  decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
296  }
297 
298  if (decode_residuals(s, channel, pred_order) < 0)
299  return -1;
300 
301  if (pred_order > 0)
302  a = decoded[pred_order-1];
303  if (pred_order > 1)
304  b = a - decoded[pred_order-2];
305  if (pred_order > 2)
306  c = b - decoded[pred_order-2] + decoded[pred_order-3];
307  if (pred_order > 3)
308  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
309 
310  switch (pred_order) {
311  case 0:
312  break;
313  case 1:
314  for (i = pred_order; i < blocksize; i++)
315  decoded[i] = a += decoded[i];
316  break;
317  case 2:
318  for (i = pred_order; i < blocksize; i++)
319  decoded[i] = a += b += decoded[i];
320  break;
321  case 3:
322  for (i = pred_order; i < blocksize; i++)
323  decoded[i] = a += b += c += decoded[i];
324  break;
325  case 4:
326  for (i = pred_order; i < blocksize; i++)
327  decoded[i] = a += b += c += d += decoded[i];
328  break;
329  default:
330  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
331  return -1;
332  }
333 
334  return 0;
335 }
336 
337 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
338 {
339  int i, j;
340  int coeff_prec, qlevel;
341  int coeffs[32];
342  int32_t *decoded = s->decoded[channel];
343 
344  /* warm up samples */
345  for (i = 0; i < pred_order; i++) {
346  decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
347  }
348 
349  coeff_prec = get_bits(&s->gb, 4) + 1;
350  if (coeff_prec == 16) {
351  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
352  return -1;
353  }
354  qlevel = get_sbits(&s->gb, 5);
355  if (qlevel < 0) {
356  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
357  qlevel);
358  return -1;
359  }
360 
361  for (i = 0; i < pred_order; i++) {
362  coeffs[i] = get_sbits(&s->gb, coeff_prec);
363  }
364 
365  if (decode_residuals(s, channel, pred_order) < 0)
366  return -1;
367 
368  if (s->bps > 16) {
369  int64_t sum;
370  for (i = pred_order; i < s->blocksize; i++) {
371  sum = 0;
372  for (j = 0; j < pred_order; j++)
373  sum += (int64_t)coeffs[j] * decoded[i-j-1];
374  decoded[i] += sum >> qlevel;
375  }
376  } else {
377  for (i = pred_order; i < s->blocksize-1; i += 2) {
378  int c;
379  int d = decoded[i-pred_order];
380  int s0 = 0, s1 = 0;
381  for (j = pred_order-1; j > 0; j--) {
382  c = coeffs[j];
383  s0 += c*d;
384  d = decoded[i-j];
385  s1 += c*d;
386  }
387  c = coeffs[0];
388  s0 += c*d;
389  d = decoded[i] += s0 >> qlevel;
390  s1 += c*d;
391  decoded[i+1] += s1 >> qlevel;
392  }
393  if (i < s->blocksize) {
394  int sum = 0;
395  for (j = 0; j < pred_order; j++)
396  sum += coeffs[j] * decoded[i-j-1];
397  decoded[i] += sum >> qlevel;
398  }
399  }
400 
401  return 0;
402 }
403 
404 static inline int decode_subframe(FLACContext *s, int channel)
405 {
406  int type, wasted = 0;
407  int i, tmp;
408 
409  s->curr_bps = s->bps;
410  if (channel == 0) {
412  s->curr_bps++;
413  } else {
415  s->curr_bps++;
416  }
417 
418  if (get_bits1(&s->gb)) {
419  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
420  return -1;
421  }
422  type = get_bits(&s->gb, 6);
423 
424  if (get_bits1(&s->gb)) {
425  int left = get_bits_left(&s->gb);
426  wasted = 1;
427  if ( left < 0 ||
428  (left < s->curr_bps && !show_bits_long(&s->gb, left)) ||
429  !show_bits_long(&s->gb, s->curr_bps)) {
431  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
432  s->curr_bps, left);
433  return AVERROR_INVALIDDATA;
434  }
435  while (!get_bits1(&s->gb))
436  wasted++;
437  s->curr_bps -= wasted;
438  }
439  if (s->curr_bps > 32) {
440  av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
441  return -1;
442  }
443 
444 //FIXME use av_log2 for types
445  if (type == 0) {
446  tmp = get_sbits_long(&s->gb, s->curr_bps);
447  for (i = 0; i < s->blocksize; i++)
448  s->decoded[channel][i] = tmp;
449  } else if (type == 1) {
450  for (i = 0; i < s->blocksize; i++)
451  s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
452  } else if ((type >= 8) && (type <= 12)) {
453  if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
454  return -1;
455  } else if (type >= 32) {
456  if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
457  return -1;
458  } else {
459  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
460  return -1;
461  }
462 
463  if (wasted) {
464  int i;
465  for (i = 0; i < s->blocksize; i++)
466  s->decoded[channel][i] <<= wasted;
467  }
468 
469  return 0;
470 }
471 
472 static int decode_frame(FLACContext *s)
473 {
474  int i;
475  GetBitContext *gb = &s->gb;
476  FLACFrameInfo fi;
477 
478  if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
479  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
480  return -1;
481  }
482 
483  if (s->channels && fi.channels != s->channels) {
484  av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
485  "is not supported\n");
486  return -1;
487  }
488  s->channels = s->avctx->channels = fi.channels;
489  s->ch_mode = fi.ch_mode;
490 
491  if (!s->bps && !fi.bps) {
492  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
493  return -1;
494  }
495  if (!fi.bps) {
496  fi.bps = s->bps;
497  } else if (s->bps && fi.bps != s->bps) {
498  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
499  "supported\n");
500  return -1;
501  }
502  s->bps = s->avctx->bits_per_raw_sample = fi.bps;
503 
504  if (s->bps > 16) {
506  s->sample_shift = 32 - s->bps;
507  s->is32 = 1;
508  } else {
510  s->sample_shift = 16 - s->bps;
511  s->is32 = 0;
512  }
513 
514  if (!s->max_blocksize)
515  s->max_blocksize = FLAC_MAX_BLOCKSIZE;
516  if (fi.blocksize > s->max_blocksize) {
517  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
518  s->max_blocksize);
519  return -1;
520  }
521  s->blocksize = fi.blocksize;
522 
523  if (!s->samplerate && !fi.samplerate) {
524  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
525  " or frame header\n");
526  return -1;
527  }
528  if (fi.samplerate == 0) {
529  fi.samplerate = s->samplerate;
530  } else if (s->samplerate && fi.samplerate != s->samplerate) {
531  av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
532  s->samplerate, fi.samplerate);
533  }
534  s->samplerate = s->avctx->sample_rate = fi.samplerate;
535 
536  if (!s->got_streaminfo) {
537  allocate_buffers(s);
538  s->got_streaminfo = 1;
540  }
541 
542 // dump_headers(s->avctx, (FLACStreaminfo *)s);
543 
544  /* subframes */
545  for (i = 0; i < s->channels; i++) {
546  if (decode_subframe(s, i) < 0)
547  return -1;
548  }
549 
550  align_get_bits(gb);
551 
552  /* frame footer */
553  skip_bits(gb, 16); /* data crc */
554 
555  return 0;
556 }
557 
558 static int flac_decode_frame(AVCodecContext *avctx, void *data,
559  int *got_frame_ptr, AVPacket *avpkt)
560 {
561  const uint8_t *buf = avpkt->data;
562  int buf_size = avpkt->size;
563  FLACContext *s = avctx->priv_data;
564  int i, j = 0, bytes_read = 0;
565  int16_t *samples_16;
566  int32_t *samples_32;
567  int ret;
568 
569  *got_frame_ptr = 0;
570 
571  if (s->max_framesize == 0) {
572  s->max_framesize =
573  ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
574  FLAC_MAX_CHANNELS, 32);
575  }
576 
577  /* check that there is at least the smallest decodable amount of data.
578  this amount corresponds to the smallest valid FLAC frame possible.
579  FF F8 69 02 00 00 9A 00 00 34 46 */
580  if (buf_size < FLAC_MIN_FRAME_SIZE)
581  return buf_size;
582 
583  /* check for inline header */
584  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
585  if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
586  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
587  return -1;
588  }
589  return get_metadata_size(buf, buf_size);
590  }
591 
592  /* decode frame */
593  init_get_bits(&s->gb, buf, buf_size*8);
594  if (decode_frame(s) < 0) {
595  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
596  return -1;
597  }
598  bytes_read = (get_bits_count(&s->gb)+7)/8;
599 
600  /* get output buffer */
601  s->frame.nb_samples = s->blocksize;
602  if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
603  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
604  return ret;
605  }
606  samples_16 = (int16_t *)s->frame.data[0];
607  samples_32 = (int32_t *)s->frame.data[0];
608 
609 #define DECORRELATE(left, right)\
610  assert(s->channels == 2);\
611  for (i = 0; i < s->blocksize; i++) {\
612  int a= s->decoded[0][i];\
613  int b= s->decoded[1][i];\
614  if (s->is32) {\
615  *samples_32++ = (left) << s->sample_shift;\
616  *samples_32++ = (right) << s->sample_shift;\
617  } else {\
618  *samples_16++ = (left) << s->sample_shift;\
619  *samples_16++ = (right) << s->sample_shift;\
620  }\
621  }\
622  break;
623 
624  switch (s->ch_mode) {
626  for (j = 0; j < s->blocksize; j++) {
627  for (i = 0; i < s->channels; i++) {
628  if (s->is32)
629  *samples_32++ = s->decoded[i][j] << s->sample_shift;
630  else
631  *samples_16++ = s->decoded[i][j] << s->sample_shift;
632  }
633  }
634  break;
636  DECORRELATE(a,a-b)
638  DECORRELATE(a+b,b)
640  DECORRELATE( (a-=b>>1) + b, a)
641  }
642 
643  if (bytes_read > buf_size) {
644  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
645  return -1;
646  }
647  if (bytes_read < buf_size) {
648  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
649  buf_size - bytes_read, buf_size);
650  }
651 
652  *got_frame_ptr = 1;
653  *(AVFrame *)data = s->frame;
654 
655  return bytes_read;
656 }
657 
659 {
660  FLACContext *s = avctx->priv_data;
661  int i;
662 
663  for (i = 0; i < s->channels; i++) {
664  av_freep(&s->decoded[i]);
665  }
666 
667  return 0;
668 }
669 
671  .name = "flac",
672  .type = AVMEDIA_TYPE_AUDIO,
673  .id = CODEC_ID_FLAC,
674  .priv_data_size = sizeof(FLACContext),
678  .capabilities = CODEC_CAP_DR1,
679  .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
680 };
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:327
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:347
static const int16_t coeffs[28]
int is32
flag to indicate if output should be 32-bit instead of 16-bit
Definition: flacdec.c:58
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
int size
Audio Video Frame.
Definition: avcodec.h:985
static short * samples
Definition: ffmpeg.c:233
AV_WL32 AV_WL24 AV_WL16 AV_RB32
Definition: bytestream.h:89
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
struct FLACContext FLACContext
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
Definition: flacdec.c:287
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:197
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2000
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:117
static void align_get_bits(GetBitContext *s)
Definition: get_bits.h:378
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:132
int size
Definition: avcodec.h:909
#define b
Definition: swscale.c:1335
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:117
#define FLAC_MAX_BLOCKSIZE
Definition: flac.h:36
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2863
signed 16 bits
Definition: samplefmt.h:30
AVCodec.
Definition: avcodec.h:3189
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:85
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:223
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:319
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:147
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1464
#define av_cold
Definition: attributes.h:71
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1387
const char data[16]
Definition: mxf.c:60
uint8_t * data
Definition: avcodec.h:908
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
bitstream reader API header.
void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flacdec.c:147
#define FLAC_MIN_BLOCKSIZE
Definition: flac.h:35
#define DECORRELATE(left, right)
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:336
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:719
FLACExtradataFormat
Definition: flac.h:57
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:513
int32_t * decoded[FLAC_MAX_CHANNELS]
decoded samples
Definition: flacdec.c:62
int ch_mode
channel decorrelation mode
Definition: flac.h:86
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:191
AV_RL32
Definition: bytestream.h:89
#define s0
Definition: regdef.h:37
static int get_metadata_size(const uint8_t *buf, int buf_size)
Determine the size of an inline header.
Definition: flacdec.c:226
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:140
GetBitContext gb
GetBitContext initialized to start at the current frame.
Definition: flacdec.c:53
const char * name
Name of the codec implementation.
Definition: avcodec.h:3196
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
Definition: flacdec.c:126
#define FLACSTREAMINFO
Data needed from the Streaminfo header for use by the raw FLAC demuxer and/or the FLAC decoder...
Definition: flac.h:72
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:35
signed 32 bits
Definition: samplefmt.h:31
int avpriv_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flacdec.c:67
int got_streaminfo
indicates if the STREAMINFO has been read
Definition: flacdec.c:60
void avpriv_flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)
Parse the metadata block parameters from the header.
Definition: flacdec.c:181
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Definition: utils.c:1867
static void allocate_buffers(FLACContext *s)
Definition: flacdec.c:135
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:33
static char buffer[20]
Definition: seek-test.c:34
int sample_shift
shift required to make output samples 16-bit or 32-bit
Definition: flacdec.c:57
AVCodec ff_flac_decoder
Definition: flacdec.c:670
NULL
Definition: eval.c:50
AVFrame frame
Definition: flacdec.c:52
external API header
int sample_rate
samples per second
Definition: avcodec.h:1456
static int decode_frame(FLACContext *s)
Definition: flacdec.c:472
main external API structure.
Definition: avcodec.h:1329
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:327
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:111
int extradata_size
Definition: avcodec.h:1388
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:354
#define s1
Definition: regdef.h:38
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:301
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
Parse the STREAMINFO from an inline header.
Definition: flacdec.c:200
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
Definition: flacdec.c:337
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
int blocksize
number of samples in the current frame
Definition: flacdec.c:55
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:404
FLACSTREAMINFO AVCodecContext * avctx
parent AVCodecContext
Definition: flacdec.c:51
common internal api header.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:125
#define FLAC_MIN_FRAME_SIZE
Definition: flac.h:37
#define MKBETAG(a, b, c, d)
Definition: common.h:232
void * priv_data
Definition: avcodec.h:1531
int channels
number of audio channels
Definition: avcodec.h:1457
#define av_uninit(x)
Definition: attributes.h:124
int curr_bps
bps for current subframe, adjusted for channel correlation and wasted bits
Definition: flacdec.c:56
static av_cold int flac_decode_init(AVCodecContext *avctx)
Definition: flacdec.c:94
void avcodec_get_frame_defaults(AVFrame *pic)
Set the fields of the given AVFrame to default values.
Definition: utils.c:609
static int decode_residuals(FLACContext *s, int channel, int pred_order)
Definition: flacdec.c:247
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:1714
#define MKTAG(a, b, c, d)
Definition: common.h:231
exp golomb vlc stuff
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1265
#define FLAC_MAX_CHANNELS
Definition: flac.h:34
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:658
int ch_mode
channel decorrelation type in the current frame
Definition: flacdec.c:59
static int flac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: flacdec.c:558