Libav
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 "avcodec.h"
37 #include "internal.h"
38 #include "get_bits.h"
39 #include "bytestream.h"
40 #include "golomb.h"
41 #include "flac.h"
42 #include "flacdata.h"
43 #include "flacdsp.h"
44 
45 typedef struct FLACContext {
47 
50 
51  int blocksize;
53  int ch_mode;
55 
58  unsigned int decoded_buffer_size;
59 
61 } FLACContext;
62 
63 static int allocate_buffers(FLACContext *s);
64 
65 static void flac_set_bps(FLACContext *s)
66 {
68  int need32 = s->bps > 16;
69  int want32 = av_get_bytes_per_sample(req) > 2;
70  int planar = av_sample_fmt_is_planar(req);
71 
72  if (need32 || want32) {
73  if (planar)
75  else
77  s->sample_shift = 32 - s->bps;
78  } else {
79  if (planar)
81  else
83  s->sample_shift = 16 - s->bps;
84  }
85 }
86 
88 {
90  uint8_t *streaminfo;
91  int ret;
92  FLACContext *s = avctx->priv_data;
93  s->avctx = avctx;
94 
95  /* for now, the raw FLAC header is allowed to be passed to the decoder as
96  frame data instead of extradata. */
97  if (!avctx->extradata)
98  return 0;
99 
100  if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
101  return AVERROR_INVALIDDATA;
102 
103  /* initialize based on the demuxer-supplied streamdata header */
104  ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
105  ret = allocate_buffers(s);
106  if (ret < 0)
107  return ret;
108  flac_set_bps(s);
109  ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
110  s->got_streaminfo = 1;
111 
112  return 0;
113 }
114 
116 {
117  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
118  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
119  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
120  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
121  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
122 }
123 
125 {
126  int buf_size;
127 
128  buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
129  AV_SAMPLE_FMT_S32P, 0);
130  if (buf_size < 0)
131  return buf_size;
132 
134  if (!s->decoded_buffer)
135  return AVERROR(ENOMEM);
136 
138  s->decoded_buffer, s->channels,
139  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
140 }
141 
149 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
150 {
151  int metadata_type, metadata_size, ret;
152 
153  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
154  /* need more data */
155  return 0;
156  }
157  flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
158  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
159  metadata_size != FLAC_STREAMINFO_SIZE) {
160  return AVERROR_INVALIDDATA;
161  }
162  ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
163  ret = allocate_buffers(s);
164  if (ret < 0)
165  return ret;
166  flac_set_bps(s);
167  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
168  s->got_streaminfo = 1;
169 
170  return 0;
171 }
172 
179 static int get_metadata_size(const uint8_t *buf, int buf_size)
180 {
181  int metadata_last, metadata_size;
182  const uint8_t *buf_end = buf + buf_size;
183 
184  buf += 4;
185  do {
186  if (buf_end - buf < 4)
187  return 0;
188  flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
189  buf += 4;
190  if (buf_end - buf < metadata_size) {
191  /* need more data in order to read the complete header */
192  return 0;
193  }
194  buf += metadata_size;
195  } while (!metadata_last);
196 
197  return buf_size - (buf_end - buf);
198 }
199 
200 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
201 {
202  int i, tmp, partition, method_type, rice_order;
203  int rice_bits, rice_esc;
204  int samples;
205 
206  method_type = get_bits(&s->gb, 2);
207  if (method_type > 1) {
208  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
209  method_type);
210  return AVERROR_INVALIDDATA;
211  }
212 
213  rice_order = get_bits(&s->gb, 4);
214 
215  samples= s->blocksize >> rice_order;
216  if (pred_order > samples) {
217  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
218  pred_order, samples);
219  return AVERROR_INVALIDDATA;
220  }
221 
222  rice_bits = 4 + method_type;
223  rice_esc = (1 << rice_bits) - 1;
224 
225  decoded += pred_order;
226  i= pred_order;
227  for (partition = 0; partition < (1 << rice_order); partition++) {
228  tmp = get_bits(&s->gb, rice_bits);
229  if (tmp == rice_esc) {
230  tmp = get_bits(&s->gb, 5);
231  for (; i < samples; i++)
232  *decoded++ = get_sbits_long(&s->gb, tmp);
233  } else {
234  for (; i < samples; i++) {
235  *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
236  }
237  }
238  i= 0;
239  }
240 
241  return 0;
242 }
243 
245  int pred_order, int bps)
246 {
247  const int blocksize = s->blocksize;
248  int a, b, c, d, i, ret;
249 
250  /* warm up samples */
251  for (i = 0; i < pred_order; i++) {
252  decoded[i] = get_sbits_long(&s->gb, bps);
253  }
254 
255  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
256  return ret;
257 
258  if (pred_order > 0)
259  a = decoded[pred_order-1];
260  if (pred_order > 1)
261  b = a - decoded[pred_order-2];
262  if (pred_order > 2)
263  c = b - decoded[pred_order-2] + decoded[pred_order-3];
264  if (pred_order > 3)
265  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
266 
267  switch (pred_order) {
268  case 0:
269  break;
270  case 1:
271  for (i = pred_order; i < blocksize; i++)
272  decoded[i] = a += decoded[i];
273  break;
274  case 2:
275  for (i = pred_order; i < blocksize; i++)
276  decoded[i] = a += b += decoded[i];
277  break;
278  case 3:
279  for (i = pred_order; i < blocksize; i++)
280  decoded[i] = a += b += c += decoded[i];
281  break;
282  case 4:
283  for (i = pred_order; i < blocksize; i++)
284  decoded[i] = a += b += c += d += decoded[i];
285  break;
286  default:
287  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
288  return AVERROR_INVALIDDATA;
289  }
290 
291  return 0;
292 }
293 
294 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
295  int bps)
296 {
297  int i, ret;
298  int coeff_prec, qlevel;
299  int coeffs[32];
300 
301  /* warm up samples */
302  for (i = 0; i < pred_order; i++) {
303  decoded[i] = get_sbits_long(&s->gb, bps);
304  }
305 
306  coeff_prec = get_bits(&s->gb, 4) + 1;
307  if (coeff_prec == 16) {
308  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
309  return AVERROR_INVALIDDATA;
310  }
311  qlevel = get_sbits(&s->gb, 5);
312  if (qlevel < 0) {
313  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
314  qlevel);
315  return AVERROR_INVALIDDATA;
316  }
317 
318  for (i = 0; i < pred_order; i++) {
319  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
320  }
321 
322  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
323  return ret;
324 
325  s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
326 
327  return 0;
328 }
329 
330 static inline int decode_subframe(FLACContext *s, int channel)
331 {
332  int32_t *decoded = s->decoded[channel];
333  int type, wasted = 0;
334  int bps = s->bps;
335  int i, tmp, ret;
336 
337  if (channel == 0) {
339  bps++;
340  } else {
342  bps++;
343  }
344 
345  if (get_bits1(&s->gb)) {
346  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
347  return AVERROR_INVALIDDATA;
348  }
349  type = get_bits(&s->gb, 6);
350 
351  if (get_bits1(&s->gb)) {
352  int left = get_bits_left(&s->gb);
353  wasted = 1;
354  if ( left < 0 ||
355  (left < bps && !show_bits_long(&s->gb, left)) ||
356  !show_bits_long(&s->gb, bps)) {
358  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
359  bps, left);
360  return AVERROR_INVALIDDATA;
361  }
362  while (!get_bits1(&s->gb))
363  wasted++;
364  bps -= wasted;
365  }
366  if (bps > 32) {
367  avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
368  return AVERROR_PATCHWELCOME;
369  }
370 
371 //FIXME use av_log2 for types
372  if (type == 0) {
373  tmp = get_sbits_long(&s->gb, bps);
374  for (i = 0; i < s->blocksize; i++)
375  decoded[i] = tmp;
376  } else if (type == 1) {
377  for (i = 0; i < s->blocksize; i++)
378  decoded[i] = get_sbits_long(&s->gb, bps);
379  } else if ((type >= 8) && (type <= 12)) {
380  if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
381  return ret;
382  } else if (type >= 32) {
383  if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
384  return ret;
385  } else {
386  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
387  return AVERROR_INVALIDDATA;
388  }
389 
390  if (wasted) {
391  int i;
392  for (i = 0; i < s->blocksize; i++)
393  decoded[i] <<= wasted;
394  }
395 
396  return 0;
397 }
398 
399 static int decode_frame(FLACContext *s)
400 {
401  int i, ret;
402  GetBitContext *gb = &s->gb;
403  FLACFrameInfo fi;
404 
405  if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
406  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
407  return ret;
408  }
409 
410  if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
411  s->channels = s->avctx->channels = fi.channels;
413  ret = allocate_buffers(s);
414  if (ret < 0)
415  return ret;
416  }
417  s->channels = s->avctx->channels = fi.channels;
418  if (!s->avctx->channel_layout)
420  s->ch_mode = fi.ch_mode;
421 
422  if (!s->bps && !fi.bps) {
423  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
424  return AVERROR_INVALIDDATA;
425  }
426  if (!fi.bps) {
427  fi.bps = s->bps;
428  } else if (s->bps && fi.bps != s->bps) {
429  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
430  "supported\n");
431  return AVERROR_INVALIDDATA;
432  }
433 
434  if (!s->bps) {
435  s->bps = s->avctx->bits_per_raw_sample = fi.bps;
436  flac_set_bps(s);
437  }
438 
439  if (!s->max_blocksize)
440  s->max_blocksize = FLAC_MAX_BLOCKSIZE;
441  if (fi.blocksize > s->max_blocksize) {
442  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
443  s->max_blocksize);
444  return AVERROR_INVALIDDATA;
445  }
446  s->blocksize = fi.blocksize;
447 
448  if (!s->samplerate && !fi.samplerate) {
449  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
450  " or frame header\n");
451  return AVERROR_INVALIDDATA;
452  }
453  if (fi.samplerate == 0)
454  fi.samplerate = s->samplerate;
455  s->samplerate = s->avctx->sample_rate = fi.samplerate;
456 
457  if (!s->got_streaminfo) {
458  ret = allocate_buffers(s);
459  if (ret < 0)
460  return ret;
461  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
462  s->got_streaminfo = 1;
464  }
465 
466 // dump_headers(s->avctx, (FLACStreaminfo *)s);
467 
468  /* subframes */
469  for (i = 0; i < s->channels; i++) {
470  if ((ret = decode_subframe(s, i)) < 0)
471  return ret;
472  }
473 
474  align_get_bits(gb);
475 
476  /* frame footer */
477  skip_bits(gb, 16); /* data crc */
478 
479  return 0;
480 }
481 
483  int *got_frame_ptr, AVPacket *avpkt)
484 {
485  AVFrame *frame = data;
486  const uint8_t *buf = avpkt->data;
487  int buf_size = avpkt->size;
488  FLACContext *s = avctx->priv_data;
489  int bytes_read = 0;
490  int ret;
491 
492  *got_frame_ptr = 0;
493 
494  if (s->max_framesize == 0) {
495  s->max_framesize =
496  ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
497  FLAC_MAX_CHANNELS, 32);
498  }
499 
500  /* check that there is at least the smallest decodable amount of data.
501  this amount corresponds to the smallest valid FLAC frame possible.
502  FF F8 69 02 00 00 9A 00 00 34 46 */
503  if (buf_size < FLAC_MIN_FRAME_SIZE)
504  return buf_size;
505 
506  /* check for inline header */
507  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
508  if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
509  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
510  return ret;
511  }
512  return get_metadata_size(buf, buf_size);
513  }
514 
515  /* decode frame */
516  init_get_bits(&s->gb, buf, buf_size*8);
517  if ((ret = decode_frame(s)) < 0) {
518  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
519  return ret;
520  }
521  bytes_read = (get_bits_count(&s->gb)+7)/8;
522 
523  /* get output buffer */
524  frame->nb_samples = s->blocksize;
525  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
526  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
527  return ret;
528  }
529 
530  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
531  s->blocksize, s->sample_shift);
532 
533  if (bytes_read > buf_size) {
534  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
535  return AVERROR_INVALIDDATA;
536  }
537  if (bytes_read < buf_size) {
538  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
539  buf_size - bytes_read, buf_size);
540  }
541 
542  *got_frame_ptr = 1;
543 
544  return bytes_read;
545 }
546 
548 {
549  FLACContext *s = avctx->priv_data;
550 
552 
553  return 0;
554 }
555 
557  .name = "flac",
558  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
559  .type = AVMEDIA_TYPE_AUDIO,
560  .id = AV_CODEC_ID_FLAC,
561  .priv_data_size = sizeof(FLACContext),
563  .close = flac_decode_close,
565  .capabilities = AV_CODEC_CAP_DR1,
566  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
570  -1 },
571 };
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:344
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:378
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:228
static int allocate_buffers(FLACContext *s)
Definition: flacdec.c:124
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int bps)
Definition: flacdsp.c:88
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
int size
Definition: avcodec.h:1347
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
void(* lpc)(int32_t *samples, const int coeffs[32], int order, int qlevel, int len)
Definition: flacdsp.h:28
#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:2776
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
Definition: flacdec.c:200
AVCodec.
Definition: avcodec.h:3120
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:86
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:214
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:336
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:202
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2160
uint8_t
#define av_cold
Definition: attributes.h:66
FLACDSPContext dsp
Definition: flacdec.c:60
#define AV_RB32
Definition: intreadwrite.h:130
#define b
Definition: input.c:52
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1523
static void flac_set_bps(FLACContext *s)
Definition: flacdec.c:65
uint8_t * decoded_buffer
Definition: flacdec.c:57
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:1346
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:182
bitstream reader API header.
unsigned int decoded_buffer_size
Definition: flacdec.c:58
signed 32 bits
Definition: samplefmt.h:64
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:101
FLACExtradataFormat
Definition: flac.h:58
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:526
int32_t * decoded[FLAC_MAX_CHANNELS]
decoded samples
Definition: flacdec.c:56
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:124
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
#define AVERROR(e)
Definition: error.h:43
enum AVSampleFormat request_sample_fmt
Used to request a sample format from the decoder.
Definition: avcodec.h:2224
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:145
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:294
static int get_metadata_size(const uint8_t *buf, int buf_size)
Determine the size of an inline header.
Definition: flacdec.c:179
GetBitContext gb
GetBitContext initialized to start at the current frame.
Definition: flacdec.c:49
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
Definition: flacdec.c:115
#define FLACSTREAMINFO
Data needed from the Streaminfo header for use by the raw FLAC demuxer and/or the FLAC decoder...
Definition: flac.h:73
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
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:244
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2203
signed 32 bits, planar
Definition: samplefmt.h:70
int got_streaminfo
indicates if the STREAMINFO has been read
Definition: flacdec.c:54
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: avconv.c:1288
int32_t
#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:52
AVCodec ff_flac_decoder
Definition: flacdec.c:556
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
NULL
Definition: eval.c:55
Libavcodec external API header.
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:60
int sample_rate
samples per second
Definition: avcodec.h:2152
static int decode_frame(FLACContext *s)
Definition: flacdec.c:399
main external API structure.
Definition: avcodec.h:1409
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:589
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:196
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:267
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:204
const char * format
Definition: movenc.c:47
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:259
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:108
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:362
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:149
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:146
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:95
int blocksize
number of samples in the current frame
Definition: flacdec.c:51
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:330
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:394
FLACSTREAMINFO AVCodecContext * avctx
parent AVCodecContext
Definition: flacdec.c:48
common internal api header.
signed 16 bits
Definition: samplefmt.h:63
#define FLAC_MIN_FRAME_SIZE
Definition: flac.h:38
unsigned bps
Definition: movenc.c:855
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
#define MKBETAG(a, b, c, d)
Definition: common.h:257
void * priv_data
Definition: avcodec.h:1451
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 channel data pointers and linesize for samples with sample format sample_fmt.
Definition: samplefmt.c:140
int channels
number of audio channels
Definition: avcodec.h:2153
static uint8_t tmp[8]
Definition: des.c:38
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:403
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:700
static av_cold int flac_decode_init(AVCodecContext *avctx)
Definition: flacdec.c:87
signed 16 bits, planar
Definition: samplefmt.h:69
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:1323
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:184
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:838
void(* decorrelate[4])(uint8_t **out, int32_t **in, int channels, int len, int shift)
Definition: flacdsp.h:26
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:547
int ch_mode
channel decorrelation type in the current frame
Definition: flacdec.c:53
static int flac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: flacdec.c:482