FFmpeg  4.4
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 {
75  enum AVSampleFormat req = s->avctx->request_sample_fmt;
76  int need32 = s->flac_stream_info.bps > 16;
77  int want32 = av_get_bytes_per_sample(req) > 2;
79 
80  if (need32 || want32) {
81  if (planar)
82  s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
83  else
84  s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
85  s->sample_shift = 32 - s->flac_stream_info.bps;
86  } else {
87  if (planar)
88  s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
89  else
90  s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
91  s->sample_shift = 16 - s->flac_stream_info.bps;
92  }
93 }
94 
96 {
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  ret = ff_flac_parse_streaminfo(avctx, &s->flac_stream_info, streaminfo);
113  if (ret < 0)
114  return ret;
115  ret = allocate_buffers(s);
116  if (ret < 0)
117  return ret;
118  flac_set_bps(s);
119  ff_flacdsp_init(&s->dsp, avctx->sample_fmt,
120  s->flac_stream_info.channels, s->flac_stream_info.bps);
121  s->got_streaminfo = 1;
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 buf_size;
138  int ret;
139 
140  av_assert0(s->flac_stream_info.max_blocksize);
141 
142  buf_size = av_samples_get_buffer_size(NULL, s->flac_stream_info.channels,
143  s->flac_stream_info.max_blocksize,
144  AV_SAMPLE_FMT_S32P, 0);
145  if (buf_size < 0)
146  return buf_size;
147 
148  av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
149  if (!s->decoded_buffer)
150  return AVERROR(ENOMEM);
151 
152  ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
153  s->decoded_buffer,
154  s->flac_stream_info.channels,
155  s->flac_stream_info.max_blocksize,
156  AV_SAMPLE_FMT_S32P, 0);
157  return ret < 0 ? ret : 0;
158 }
159 
160 /**
161  * Parse the STREAMINFO from an inline header.
162  * @param s the flac decoding context
163  * @param buf input buffer, starting with the "fLaC" marker
164  * @param buf_size buffer size
165  * @return non-zero if metadata is invalid
166  */
167 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
168 {
169  int metadata_type, metadata_size, ret;
170 
171  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
172  /* need more data */
173  return 0;
174  }
175  flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
176  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
177  metadata_size != FLAC_STREAMINFO_SIZE) {
178  return AVERROR_INVALIDDATA;
179  }
180  ret = ff_flac_parse_streaminfo(s->avctx, &s->flac_stream_info, &buf[8]);
181  if (ret < 0)
182  return ret;
183  ret = allocate_buffers(s);
184  if (ret < 0)
185  return ret;
186  flac_set_bps(s);
187  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
188  s->flac_stream_info.channels, s->flac_stream_info.bps);
189  s->got_streaminfo = 1;
190 
191  return 0;
192 }
193 
194 /**
195  * Determine the size of an inline header.
196  * @param buf input buffer, starting with the "fLaC" marker
197  * @param buf_size buffer size
198  * @return number of bytes in the header, or 0 if more data is needed
199  */
200 static int get_metadata_size(const uint8_t *buf, int buf_size)
201 {
202  int metadata_last, metadata_size;
203  const uint8_t *buf_end = buf + buf_size;
204 
205  buf += 4;
206  do {
207  if (buf_end - buf < 4)
208  return AVERROR_INVALIDDATA;
209  flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
210  buf += 4;
211  if (buf_end - buf < metadata_size) {
212  /* need more data in order to read the complete header */
213  return AVERROR_INVALIDDATA;
214  }
215  buf += metadata_size;
216  } while (!metadata_last);
217 
218  return buf_size - (buf_end - buf);
219 }
220 
221 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
222 {
223  GetBitContext gb = s->gb;
224  int i, tmp, partition, method_type, rice_order;
225  int rice_bits, rice_esc;
226  int samples;
227 
228  method_type = get_bits(&gb, 2);
229  rice_order = get_bits(&gb, 4);
230 
231  samples = s->blocksize >> rice_order;
232  rice_bits = 4 + method_type;
233  rice_esc = (1 << rice_bits) - 1;
234 
235  decoded += pred_order;
236  i = pred_order;
237 
238  if (method_type > 1) {
239  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
240  method_type);
241  return AVERROR_INVALIDDATA;
242  }
243 
244  if (samples << rice_order != s->blocksize) {
245  av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
246  rice_order, s->blocksize);
247  return AVERROR_INVALIDDATA;
248  }
249 
250  if (pred_order > samples) {
251  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
252  pred_order, samples);
253  return AVERROR_INVALIDDATA;
254  }
255 
256  for (partition = 0; partition < (1 << rice_order); partition++) {
257  tmp = get_bits(&gb, rice_bits);
258  if (tmp == rice_esc) {
259  tmp = get_bits(&gb, 5);
260  for (; i < samples; i++)
261  *decoded++ = get_sbits_long(&gb, tmp);
262  } else {
263  int real_limit = tmp ? (INT_MAX >> tmp) + 2 : INT_MAX;
264  for (; i < samples; i++) {
265  int v = get_sr_golomb_flac(&gb, tmp, real_limit, 1);
266  if (v == 0x80000000){
267  av_log(s->avctx, AV_LOG_ERROR, "invalid residual\n");
268  return AVERROR_INVALIDDATA;
269  }
270 
271  *decoded++ = v;
272  }
273  }
274  i= 0;
275  }
276 
277  s->gb = gb;
278 
279  return 0;
280 }
281 
283  int pred_order, int bps)
284 {
285  const int blocksize = s->blocksize;
286  unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
287  int i;
288  int ret;
289 
290  /* warm up samples */
291  for (i = 0; i < pred_order; i++) {
292  decoded[i] = get_sbits_long(&s->gb, bps);
293  }
294 
295  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
296  return ret;
297 
298  if (pred_order > 0)
299  a = decoded[pred_order-1];
300  if (pred_order > 1)
301  b = a - decoded[pred_order-2];
302  if (pred_order > 2)
303  c = b - decoded[pred_order-2] + decoded[pred_order-3];
304  if (pred_order > 3)
305  d = c - decoded[pred_order-2] + 2U*decoded[pred_order-3] - decoded[pred_order-4];
306 
307  switch (pred_order) {
308  case 0:
309  break;
310  case 1:
311  for (i = pred_order; i < blocksize; i++)
312  decoded[i] = a += decoded[i];
313  break;
314  case 2:
315  for (i = pred_order; i < blocksize; i++)
316  decoded[i] = a += b += decoded[i];
317  break;
318  case 3:
319  for (i = pred_order; i < blocksize; i++)
320  decoded[i] = a += b += c += decoded[i];
321  break;
322  case 4:
323  for (i = pred_order; i < blocksize; i++)
324  decoded[i] = a += b += c += d += decoded[i];
325  break;
326  default:
327  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
328  return AVERROR_INVALIDDATA;
329  }
330 
331  return 0;
332 }
333 
334 static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32],
335  int order, int qlevel, int len, int bps)
336 {
337  int i, j;
338  int ebps = 1 << (bps-1);
339  unsigned sigma = 0;
340 
341  for (i = order; i < len; i++)
342  sigma |= decoded[i] + ebps;
343 
344  if (sigma < 2*ebps)
345  return;
346 
347  for (i = len - 1; i >= order; i--) {
348  int64_t p = 0;
349  for (j = 0; j < order; j++)
350  p += coeffs[j] * (int64_t)(int32_t)decoded[i-order+j];
351  decoded[i] -= p >> qlevel;
352  }
353  for (i = order; i < len; i++, decoded++) {
354  int32_t p = 0;
355  for (j = 0; j < order; j++)
356  p += coeffs[j] * (uint32_t)decoded[j];
357  decoded[j] += p >> qlevel;
358  }
359 }
360 
361 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
362  int bps)
363 {
364  int i, ret;
365  int coeff_prec, qlevel;
366  int coeffs[32];
367 
368  /* warm up samples */
369  for (i = 0; i < pred_order; i++) {
370  decoded[i] = get_sbits_long(&s->gb, bps);
371  }
372 
373  coeff_prec = get_bits(&s->gb, 4) + 1;
374  if (coeff_prec == 16) {
375  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
376  return AVERROR_INVALIDDATA;
377  }
378  qlevel = get_sbits(&s->gb, 5);
379  if (qlevel < 0) {
380  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
381  qlevel);
382  return AVERROR_INVALIDDATA;
383  }
384 
385  for (i = 0; i < pred_order; i++) {
386  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
387  }
388 
389  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
390  return ret;
391 
392  if ( ( s->buggy_lpc && s->flac_stream_info.bps <= 16)
393  || ( !s->buggy_lpc && bps <= 16
394  && bps + coeff_prec + av_log2(pred_order) <= 32)) {
395  s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
396  } else {
397  s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
398  if (s->flac_stream_info.bps <= 16)
399  lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
400  }
401 
402  return 0;
403 }
404 
405 static inline int decode_subframe(FLACContext *s, int channel)
406 {
407  int32_t *decoded = s->decoded[channel];
408  int type, wasted = 0;
409  int bps = s->flac_stream_info.bps;
410  int i, tmp, ret;
411 
412  if (channel == 0) {
413  if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
414  bps++;
415  } else {
416  if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
417  bps++;
418  }
419 
420  if (get_bits1(&s->gb)) {
421  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
422  return AVERROR_INVALIDDATA;
423  }
424  type = get_bits(&s->gb, 6);
425 
426  if (get_bits1(&s->gb)) {
427  int left = get_bits_left(&s->gb);
428  if ( left <= 0 ||
429  (left < bps && !show_bits_long(&s->gb, left)) ||
430  !show_bits_long(&s->gb, bps)) {
431  av_log(s->avctx, AV_LOG_ERROR,
432  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
433  bps, left);
434  return AVERROR_INVALIDDATA;
435  }
436  wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
437  bps -= wasted;
438  }
439  if (bps > 32) {
440  avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
441  return AVERROR_PATCHWELCOME;
442  }
443 
444 //FIXME use av_log2 for types
445  if (type == 0) {
446  tmp = get_sbits_long(&s->gb, bps);
447  for (i = 0; i < s->blocksize; i++)
448  decoded[i] = tmp;
449  } else if (type == 1) {
450  for (i = 0; i < s->blocksize; i++)
451  decoded[i] = get_sbits_long(&s->gb, bps);
452  } else if ((type >= 8) && (type <= 12)) {
453  if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
454  return ret;
455  } else if (type >= 32) {
456  if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
457  return ret;
458  } else {
459  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
460  return AVERROR_INVALIDDATA;
461  }
462 
463  if (wasted && wasted < 32) {
464  int i;
465  for (i = 0; i < s->blocksize; i++)
466  decoded[i] = (unsigned)decoded[i] << wasted;
467  }
468 
469  return 0;
470 }
471 
473 {
474  int i, ret;
475  GetBitContext *gb = &s->gb;
476  FLACFrameInfo fi;
477 
478  if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
479  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
480  return ret;
481  }
482 
483  if ( s->flac_stream_info.channels
484  && fi.channels != s->flac_stream_info.channels
485  && s->got_streaminfo) {
486  s->flac_stream_info.channels = s->avctx->channels = fi.channels;
488  ret = allocate_buffers(s);
489  if (ret < 0)
490  return ret;
491  }
492  s->flac_stream_info.channels = s->avctx->channels = fi.channels;
493  if (!s->avctx->channel_layout)
495  s->ch_mode = fi.ch_mode;
496 
497  if (!s->flac_stream_info.bps && !fi.bps) {
498  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
499  return AVERROR_INVALIDDATA;
500  }
501  if (!fi.bps) {
502  fi.bps = s->flac_stream_info.bps;
503  } else if (s->flac_stream_info.bps && fi.bps != s->flac_stream_info.bps) {
504  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
505  "supported\n");
506  return AVERROR_INVALIDDATA;
507  }
508 
509  if (!s->flac_stream_info.bps) {
510  s->flac_stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
511  flac_set_bps(s);
512  }
513 
514  if (!s->flac_stream_info.max_blocksize)
515  s->flac_stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
516  if (fi.blocksize > s->flac_stream_info.max_blocksize) {
517  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
518  s->flac_stream_info.max_blocksize);
519  return AVERROR_INVALIDDATA;
520  }
521  s->blocksize = fi.blocksize;
522 
523  if (!s->flac_stream_info.samplerate && !fi.samplerate) {
524  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
525  " or frame header\n");
526  return AVERROR_INVALIDDATA;
527  }
528  if (fi.samplerate == 0)
529  fi.samplerate = s->flac_stream_info.samplerate;
530  s->flac_stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
531 
532  if (!s->got_streaminfo) {
533  ret = allocate_buffers(s);
534  if (ret < 0)
535  return ret;
536  s->got_streaminfo = 1;
537  dump_headers(s->avctx, &s->flac_stream_info);
538  }
539  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
540  s->flac_stream_info.channels, s->flac_stream_info.bps);
541 
542 // dump_headers(s->avctx, &s->flac_stream_info);
543 
544  /* subframes */
545  for (i = 0; i < s->flac_stream_info.channels; i++) {
546  if ((ret = decode_subframe(s, i)) < 0)
547  return ret;
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  AVFrame *frame = data;
562  ThreadFrame tframe = { .f = data };
563  const uint8_t *buf = avpkt->data;
564  int buf_size = avpkt->size;
565  FLACContext *s = avctx->priv_data;
566  int bytes_read = 0;
567  int ret;
568 
569  *got_frame_ptr = 0;
570 
571  if (s->flac_stream_info.max_framesize == 0) {
572  s->flac_stream_info.max_framesize =
573  ff_flac_get_max_frame_size(s->flac_stream_info.max_blocksize ? s->flac_stream_info.max_blocksize : FLAC_MAX_BLOCKSIZE,
574  FLAC_MAX_CHANNELS, 32);
575  }
576 
577  if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
578  av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
579  return buf_size;
580  }
581 
582  if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
583  av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
584  return buf_size;
585  }
586 
587  /* check that there is at least the smallest decodable amount of data.
588  this amount corresponds to the smallest valid FLAC frame possible.
589  FF F8 69 02 00 00 9A 00 00 34 46 */
590  if (buf_size < FLAC_MIN_FRAME_SIZE)
591  return buf_size;
592 
593  /* check for inline header */
594  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
595  if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
596  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
597  return ret;
598  }
599  return get_metadata_size(buf, buf_size);
600  }
601 
602  /* decode frame */
603  if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
604  return ret;
605  if ((ret = decode_frame(s)) < 0) {
606  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
607  return ret;
608  }
609  bytes_read = get_bits_count(&s->gb)/8;
610 
611  if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
613  0, buf, bytes_read)) {
614  av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
615  if (s->avctx->err_recognition & AV_EF_EXPLODE)
616  return AVERROR_INVALIDDATA;
617  }
618 
619  /* get output buffer */
620  frame->nb_samples = s->blocksize;
621  if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
622  return ret;
623 
624  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
625  s->flac_stream_info.channels,
626  s->blocksize, s->sample_shift);
627 
628  if (bytes_read > buf_size) {
629  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
630  return AVERROR_INVALIDDATA;
631  }
632  if (bytes_read < buf_size) {
633  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
634  buf_size - bytes_read, buf_size);
635  }
636 
637  *got_frame_ptr = 1;
638 
639  return bytes_read;
640 }
641 
643 {
644  FLACContext *s = avctx->priv_data;
645 
646  av_freep(&s->decoded_buffer);
647 
648  return 0;
649 }
650 
651 static const AVOption options[] = {
652 { "use_buggy_lpc", "emulate old buggy lavc behavior", offsetof(FLACContext, buggy_lpc), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
653 { NULL },
654 };
655 
656 static const AVClass flac_decoder_class = {
657  .class_name = "FLAC decoder",
658  .item_name = av_default_item_name,
659  .option = options,
660  .version = LIBAVUTIL_VERSION_INT,
661 };
662 
664  .name = "flac",
665  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
666  .type = AVMEDIA_TYPE_AUDIO,
667  .id = AV_CODEC_ID_FLAC,
668  .priv_data_size = sizeof(FLACContext),
670  .close = flac_decode_close,
672  .capabilities = AV_CODEC_CAP_CHANNEL_CONF |
675  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
680  .priv_class = &flac_decoder_class,
681 };
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:925
static const char *const format[]
Definition: af_aiir.c:456
#define av_uninit(x)
Definition: attributes.h:154
#define av_cold
Definition: attributes.h:88
uint8_t
int32_t
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: avcodec.h:1653
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1660
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
#define AV_RB32
Definition: intreadwrite.h:130
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define s(width, name)
Definition: cbs_vp9.c:257
#define MKBETAG(a, b, c, d)
Definition: common.h:479
#define NULL
Definition: coverity.c:32
Public header for CRC hash function implementation.
#define SUINT32
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
int ff_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flac.c:169
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 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
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:196
int ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:204
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
#define FLAC_MIN_FRAME_SIZE
Definition: flac.h:38
#define FLAC_MAX_BLOCKSIZE
Definition: flac.h:37
FLACExtradataFormat
Definition: flac.h:58
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:145
@ FLAC_CHMODE_RIGHT_SIDE
Definition: flac.h:43
@ FLAC_CHMODE_MID_SIDE
Definition: flac.h:44
@ FLAC_CHMODE_LEFT_SIDE
Definition: flac.h:42
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
@ FLAC_METADATA_TYPE_VORBIS_COMMENT
Definition: flac.h:52
@ FLAC_METADATA_TYPE_STREAMINFO
Definition: flac.h:48
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
bitstream reader API header.
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:590
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
exp golomb vlc stuff
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:541
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:436
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
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:392
@ AV_CRC_16_ANSI
Definition: crc.h:51
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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:502
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
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:119
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
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:151
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
cl_device_type type
int i
Definition: input.c:407
#define av_log2
Definition: intmath.h:83
static int flac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: flacdec.c:558
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:361
static int decode_frame(FLACContext *s)
Definition: flacdec.c:472
static const AVOption options[]
Definition: flacdec.c:651
static const AVClass flac_decoder_class
Definition: flacdec.c:656
static av_cold int flac_decode_init(AVCodecContext *avctx)
Definition: flacdec.c:95
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
Definition: flacdec.c:221
static int allocate_buffers(FLACContext *s)
Definition: flacdec.c:135
AVCodec ff_flac_decoder
Definition: flacdec.c:663
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:642
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
Definition: flacdec.c:126
static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32], int order, int qlevel, int len, int bps)
Definition: flacdec.c:334
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:282
static void flac_set_bps(FLACContext *s)
Definition: flacdec.c:73
static int get_metadata_size(const uint8_t *buf, int buf_size)
Determine the size of an inline header.
Definition: flacdec.c:200
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
Parse the STREAMINFO from an inline header.
Definition: flacdec.c:167
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:405
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int channels, int bps)
Definition: flacdsp.c:88
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
unsigned bps
Definition: movenc.c:1601
const char data[16]
Definition: mxf.c:142
AVOptions.
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:280
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:279
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Describe the class of an AVClass context structure.
Definition: log.h:67
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
main external API structure.
Definition: avcodec.h:536
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
int blocksize
number of samples in the current frame
Definition: flacdec.c:58
struct FLACStreaminfo flac_stream_info
Definition: flacdec.c:53
AVCodecContext * avctx
parent AVCodecContext
Definition: flacdec.c:55
unsigned int decoded_buffer_size
Definition: flacdec.c:65
GetBitContext gb
GetBitContext initialized to start at the current frame.
Definition: flacdec.c:56
int32_t * decoded[FLAC_MAX_CHANNELS]
decoded samples
Definition: flacdec.c:63
int ch_mode
channel decorrelation type in the current frame
Definition: flacdec.c:60
int buggy_lpc
use workaround for old lavc encoded files
Definition: flacdec.c:66
uint8_t * decoded_buffer
Definition: flacdec.c:64
FLACDSPContext dsp
Definition: flacdec.c:68
int got_streaminfo
indicates if the STREAMINFO has been read
Definition: flacdec.c:61
int sample_shift
shift required to make output samples 16-bit or 32-bit
Definition: flacdec.c:59
int ch_mode
channel decorrelation mode
Definition: flac.h:87
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:86
AVFrame * f
Definition: thread.h:35
#define av_freep(p)
#define av_log(a,...)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
const char * b
Definition: vf_curves.c:118
int len
static double c[64]