FFmpeg
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;
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;
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;
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;
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) {
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 
642 #if HAVE_THREADS
643 static int init_thread_copy(AVCodecContext *avctx)
644 {
645  FLACContext *s = avctx->priv_data;
646  s->decoded_buffer = NULL;
647  s->decoded_buffer_size = 0;
648  s->avctx = avctx;
649  if (s->flac_stream_info.max_blocksize)
650  return allocate_buffers(s);
651  return 0;
652 }
653 #endif
654 
656 {
657  FLACContext *s = avctx->priv_data;
658 
659  av_freep(&s->decoded_buffer);
660 
661  return 0;
662 }
663 
664 static const AVOption options[] = {
665 { "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 },
666 { NULL },
667 };
668 
669 static const AVClass flac_decoder_class = {
670  "FLAC decoder",
672  options,
674 };
675 
677  .name = "flac",
678  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
679  .type = AVMEDIA_TYPE_AUDIO,
680  .id = AV_CODEC_ID_FLAC,
681  .priv_data_size = sizeof(FLACContext),
683  .close = flac_decode_close,
687  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
692  .priv_class = &flac_decoder_class,
693 };
decode_residuals
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
Definition: flacdec.c:221
AVCodec
AVCodec.
Definition: avcodec.h:3481
FLAC_CHMODE_MID_SIDE
@ FLAC_CHMODE_MID_SIDE
Definition: flac.h:44
flac_decode_close
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:655
FLACContext::decoded_buffer_size
unsigned int decoded_buffer_size
Definition: flacdec.c:65
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
allocate_buffers
static int allocate_buffers(FLACContext *s)
Definition: flacdec.c:135
av_samples_fill_arrays
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
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
FLACContext::ch_mode
int ch_mode
channel decorrelation type in the current frame
Definition: flacdec.c:60
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
ff_flacdsp_init
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int channels, int bps)
Definition: flacdsp.c:88
AVOption
AVOption.
Definition: opt.h:246
b
#define b
Definition: input.c:41
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
FLACContext::dsp
FLACDSPContext dsp
Definition: flacdec.c:68
data
const char data[16]
Definition: mxf.c:91
ff_flac_parse_streaminfo
int ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:204
ff_flac_decode_frame_header
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
flac_decode_frame
static int flac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: flacdec.c:558
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2709
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: avcodec.h:576
flacdsp.h
thread.h
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
FLACContext::sample_shift
int sample_shift
shift required to make output samples 16-bit or 32-bit
Definition: flacdec.c:59
flac_decoder_class
static const AVClass flac_decoder_class
Definition: flacdec.c:669
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
U
#define U(x)
Definition: vp56_arith.h:37
GetBitContext
Definition: get_bits.h:61
SUINT32
#define SUINT32
Definition: dct32_template.c:31
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
decode_subframe_lpc
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:361
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
FLACContext::flac_stream_info
struct FLACStreaminfo flac_stream_info
Definition: flacdec.c:53
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
FLACStreaminfo
Definition: flac.h:80
planar
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_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/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_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 *(INT64_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 *(INT64_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 &&1) 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 const uint8_t **in ch off *out planar
Definition: audioconvert.c:226
FLACContext::gb
GetBitContext gb
GetBitContext initialized to start at the current frame.
Definition: flacdec.c:56
s
#define s(width, name)
Definition: cbs_vp9.c:257
flac_set_bps
static void flac_set_bps(FLACContext *s)
Definition: flacdec.c:73
ff_flac_get_max_frame_size
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
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
dump_headers
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
Definition: flacdec.c:126
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
get_bits.h
limits.h
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
int32_t
int32_t
Definition: audio_convert.c:194
FLACExtradataFormat
FLACExtradataFormat
Definition: flac.h:58
FLAC_METADATA_TYPE_STREAMINFO
@ FLAC_METADATA_TYPE_STREAMINFO
Definition: flac.h:48
AV_CRC_16_ANSI
@ AV_CRC_16_ANSI
Definition: crc.h:51
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
get_sr_golomb_flac
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:539
flac_parse_block_header
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
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
ff_flac_set_channel_layout
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:196
FLACContext::decoded
int32_t * decoded[FLAC_MAX_CHANNELS]
decoded samples
Definition: flacdec.c:63
FLAC_STREAMINFO_SIZE
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
FLAC_CHMODE_RIGHT_SIDE
@ FLAC_CHMODE_RIGHT_SIDE
Definition: flac.h:43
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:227
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:964
FLACFrameInfo
Definition: flac.h:84
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2705
decode_frame
static int decode_frame(FLACContext *s)
Definition: flacdec.c:472
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
ff_flac_is_extradata_valid
int ff_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flac.c:169
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
AVPacket::size
int size
Definition: avcodec.h:1478
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
get_metadata_size
static int get_metadata_size(const uint8_t *buf, int buf_size)
Determine the size of an inline header.
Definition: flacdec.c:200
bps
unsigned bps
Definition: movenc.c:1497
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
init_thread_copy
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have add an init_thread_copy() which re-allocates them for other threads. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. If there are inter-frame dependencies
flacdata.h
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:92
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:367
FLACContext::buggy_lpc
int buggy_lpc
use workaround for old lavc encoded files
Definition: flacdec.c:66
fi
AVS_FilterInfo ** fi
Definition: avisynth_c.h:807
decode_subframe_fixed
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:282
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
decode_subframe
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:405
ff_flac_decoder
AVCodec ff_flac_decoder
Definition: flacdec.c:676
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
unary.h
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
FLACContext
Definition: flacdec.c:51
FLACContext::got_streaminfo
int got_streaminfo
indicates if the STREAMINFO has been read
Definition: flacdec.c:61
parse_streaminfo
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
Parse the STREAMINFO from an inline header.
Definition: flacdec.c:167
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
options
static const AVOption options[]
Definition: flacdec.c:664
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
uint8_t
uint8_t
Definition: audio_convert.c:194
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
len
int len
Definition: vorbis_enc_data.h:452
av_samples_get_buffer_size
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
avcodec.h
lpc_analyze_remodulate
static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32], int order, int qlevel, int len, int bps)
Definition: flacdec.c:334
av_uninit
#define av_uninit(x)
Definition: attributes.h:148
FLACContext::avctx
AVCodecContext * avctx
parent AVCodecContext
Definition: flacdec.c:55
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
FLAC_METADATA_TYPE_VORBIS_COMMENT
@ FLAC_METADATA_TYPE_VORBIS_COMMENT
Definition: flac.h:52
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: avcodec.h:2702
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
FLAC_MIN_FRAME_SIZE
#define FLAC_MIN_FRAME_SIZE
Definition: flac.h:38
FLACContext::decoded_buffer
uint8_t * decoded_buffer
Definition: flacdec.c:64
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
FLAC_MAX_CHANNELS
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
ThreadFrame
Definition: thread.h:34
av_crc
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
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
flac_decode_init
static av_cold int flac_decode_init(AVCodecContext *avctx)
Definition: flacdec.c:95
FLAC_MAX_BLOCKSIZE
#define FLAC_MAX_BLOCKSIZE
Definition: flac.h:37
FLACContext::blocksize
int blocksize
number of samples in the current frame
Definition: flacdec.c:58
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
FLAC_CHMODE_LEFT_SIDE
@ FLAC_CHMODE_LEFT_SIDE
Definition: flac.h:42
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_fast_malloc
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:500
bytestream.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
flac.h
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:590
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
FLACDSPContext
Definition: flacdsp.h:26
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
channel
channel
Definition: ebur128.h:39