FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
flacdec.c
Go to the documentation of this file.
1 /*
2  * FLAC (Free Lossless Audio Codec) decoder
3  * Copyright (c) 2003 Alex Beregszaszi
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * FLAC (Free Lossless Audio Codec) decoder
25  * @author Alex Beregszaszi
26  * @see http://flac.sourceforge.net/
27  *
28  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
29  * through, starting from the initial 'fLaC' signature; or by passing the
30  * 34-byte streaminfo structure through avctx->extradata[_size] followed
31  * by data starting with the 0xFFF8 marker.
32  */
33 
34 #include <limits.h>
35 
36 #include "libavutil/avassert.h"
37 #include "libavutil/crc.h"
38 #include "avcodec.h"
39 #include "internal.h"
40 #include "get_bits.h"
41 #include "bytestream.h"
42 #include "golomb.h"
43 #include "flac.h"
44 #include "flacdata.h"
45 #include "flacdsp.h"
46 #include "thread.h"
47 #include "unary.h"
48 
49 
50 typedef struct FLACContext {
52 
53  AVCodecContext *avctx; ///< parent AVCodecContext
54  GetBitContext gb; ///< GetBitContext initialized to start at the current frame
55 
56  int blocksize; ///< number of samples in the current frame
57  int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
58  int ch_mode; ///< channel decorrelation type in the current frame
59  int got_streaminfo; ///< indicates if the STREAMINFO has been read
60 
61  int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
63  unsigned int decoded_buffer_size;
64 
66 } FLACContext;
67 
68 static int allocate_buffers(FLACContext *s);
69 
70 static void flac_set_bps(FLACContext *s)
71 {
73  int need32 = s->bps > 16;
74  int want32 = av_get_bytes_per_sample(req) > 2;
75  int planar = av_sample_fmt_is_planar(req);
76 
77  if (need32 || want32) {
78  if (planar)
80  else
82  s->sample_shift = 32 - s->bps;
83  } else {
84  if (planar)
86  else
88  s->sample_shift = 16 - s->bps;
89  }
90 }
91 
93 {
94  enum FLACExtradataFormat format;
95  uint8_t *streaminfo;
96  int ret;
97  FLACContext *s = avctx->priv_data;
98  s->avctx = avctx;
99 
100  /* for now, the raw FLAC header is allowed to be passed to the decoder as
101  frame data instead of extradata. */
102  if (!avctx->extradata)
103  return 0;
104 
105  if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
106  return AVERROR_INVALIDDATA;
107 
108  /* initialize based on the demuxer-supplied streamdata header */
109  avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
110  ret = allocate_buffers(s);
111  if (ret < 0)
112  return ret;
113  flac_set_bps(s);
114  ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
115  s->got_streaminfo = 1;
116 
117  return 0;
118 }
119 
121 {
122  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
123  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
124  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
125  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
126  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
127 }
128 
130 {
131  int buf_size;
132  int ret;
133 
134  av_assert0(s->max_blocksize);
135 
136  buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
137  AV_SAMPLE_FMT_S32P, 0);
138  if (buf_size < 0)
139  return buf_size;
140 
142  if (!s->decoded_buffer)
143  return AVERROR(ENOMEM);
144 
145  ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
146  s->decoded_buffer, s->channels,
147  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
148  return ret < 0 ? ret : 0;
149 }
150 
151 /**
152  * Parse the STREAMINFO from an inline header.
153  * @param s the flac decoding context
154  * @param buf input buffer, starting with the "fLaC" marker
155  * @param buf_size buffer size
156  * @return non-zero if metadata is invalid
157  */
158 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
159 {
160  int metadata_type, metadata_size, ret;
161 
162  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
163  /* need more data */
164  return 0;
165  }
166  flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
167  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
168  metadata_size != FLAC_STREAMINFO_SIZE) {
169  return AVERROR_INVALIDDATA;
170  }
172  ret = allocate_buffers(s);
173  if (ret < 0)
174  return ret;
175  flac_set_bps(s);
176  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
177  s->got_streaminfo = 1;
178 
179  return 0;
180 }
181 
182 /**
183  * Determine the size of an inline header.
184  * @param buf input buffer, starting with the "fLaC" marker
185  * @param buf_size buffer size
186  * @return number of bytes in the header, or 0 if more data is needed
187  */
188 static int get_metadata_size(const uint8_t *buf, int buf_size)
189 {
190  int metadata_last, metadata_size;
191  const uint8_t *buf_end = buf + buf_size;
192 
193  buf += 4;
194  do {
195  if (buf_end - buf < 4)
196  return 0;
197  flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
198  buf += 4;
199  if (buf_end - buf < metadata_size) {
200  /* need more data in order to read the complete header */
201  return 0;
202  }
203  buf += metadata_size;
204  } while (!metadata_last);
205 
206  return buf_size - (buf_end - buf);
207 }
208 
209 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
210 {
211  int i, tmp, partition, method_type, rice_order;
212  int rice_bits, rice_esc;
213  int samples;
214 
215  method_type = get_bits(&s->gb, 2);
216  if (method_type > 1) {
217  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
218  method_type);
219  return AVERROR_INVALIDDATA;
220  }
221 
222  rice_order = get_bits(&s->gb, 4);
223 
224  samples= s->blocksize >> rice_order;
225  if (samples << rice_order != s->blocksize) {
226  av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
227  rice_order, s->blocksize);
228  return AVERROR_INVALIDDATA;
229  }
230 
231  if (pred_order > samples) {
232  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
233  pred_order, samples);
234  return AVERROR_INVALIDDATA;
235  }
236 
237  rice_bits = 4 + method_type;
238  rice_esc = (1 << rice_bits) - 1;
239 
240  decoded += pred_order;
241  i= pred_order;
242  for (partition = 0; partition < (1 << rice_order); partition++) {
243  tmp = get_bits(&s->gb, rice_bits);
244  if (tmp == rice_esc) {
245  tmp = get_bits(&s->gb, 5);
246  for (; i < samples; i++)
247  *decoded++ = get_sbits_long(&s->gb, tmp);
248  } else {
249  for (; i < samples; i++) {
250  *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
251  }
252  }
253  i= 0;
254  }
255 
256  return 0;
257 }
258 
260  int pred_order, int bps)
261 {
262  const int blocksize = s->blocksize;
263  int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
264  int ret;
265 
266  /* warm up samples */
267  for (i = 0; i < pred_order; i++) {
268  decoded[i] = get_sbits_long(&s->gb, bps);
269  }
270 
271  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
272  return ret;
273 
274  if (pred_order > 0)
275  a = decoded[pred_order-1];
276  if (pred_order > 1)
277  b = a - decoded[pred_order-2];
278  if (pred_order > 2)
279  c = b - decoded[pred_order-2] + decoded[pred_order-3];
280  if (pred_order > 3)
281  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
282 
283  switch (pred_order) {
284  case 0:
285  break;
286  case 1:
287  for (i = pred_order; i < blocksize; i++)
288  decoded[i] = a += decoded[i];
289  break;
290  case 2:
291  for (i = pred_order; i < blocksize; i++)
292  decoded[i] = a += b += decoded[i];
293  break;
294  case 3:
295  for (i = pred_order; i < blocksize; i++)
296  decoded[i] = a += b += c += decoded[i];
297  break;
298  case 4:
299  for (i = pred_order; i < blocksize; i++)
300  decoded[i] = a += b += c += d += decoded[i];
301  break;
302  default:
303  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
304  return AVERROR_INVALIDDATA;
305  }
306 
307  return 0;
308 }
309 
310 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
311  int bps)
312 {
313  int i, ret;
314  int coeff_prec, qlevel;
315  int coeffs[32];
316 
317  /* warm up samples */
318  for (i = 0; i < pred_order; i++) {
319  decoded[i] = get_sbits_long(&s->gb, bps);
320  }
321 
322  coeff_prec = get_bits(&s->gb, 4) + 1;
323  if (coeff_prec == 16) {
324  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
325  return AVERROR_INVALIDDATA;
326  }
327  qlevel = get_sbits(&s->gb, 5);
328  if (qlevel < 0) {
329  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
330  qlevel);
331  return AVERROR_INVALIDDATA;
332  }
333 
334  for (i = 0; i < pred_order; i++) {
335  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
336  }
337 
338  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
339  return ret;
340 
341  s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
342 
343  return 0;
344 }
345 
346 static inline int decode_subframe(FLACContext *s, int channel)
347 {
348  int32_t *decoded = s->decoded[channel];
349  int type, wasted = 0;
350  int bps = s->bps;
351  int i, tmp, ret;
352 
353  if (channel == 0) {
355  bps++;
356  } else {
358  bps++;
359  }
360 
361  if (get_bits1(&s->gb)) {
362  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
363  return AVERROR_INVALIDDATA;
364  }
365  type = get_bits(&s->gb, 6);
366 
367  if (get_bits1(&s->gb)) {
368  int left = get_bits_left(&s->gb);
369  if ( left < 0 ||
370  (left < bps && !show_bits_long(&s->gb, left)) ||
371  !show_bits_long(&s->gb, bps)) {
373  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
374  bps, left);
375  return AVERROR_INVALIDDATA;
376  }
377  wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
378  bps -= wasted;
379  }
380  if (bps > 32) {
381  avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
382  return AVERROR_PATCHWELCOME;
383  }
384 
385 //FIXME use av_log2 for types
386  if (type == 0) {
387  tmp = get_sbits_long(&s->gb, bps);
388  for (i = 0; i < s->blocksize; i++)
389  decoded[i] = tmp;
390  } else if (type == 1) {
391  for (i = 0; i < s->blocksize; i++)
392  decoded[i] = get_sbits_long(&s->gb, bps);
393  } else if ((type >= 8) && (type <= 12)) {
394  if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
395  return ret;
396  } else if (type >= 32) {
397  if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
398  return ret;
399  } else {
400  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
401  return AVERROR_INVALIDDATA;
402  }
403 
404  if (wasted) {
405  int i;
406  for (i = 0; i < s->blocksize; i++)
407  decoded[i] <<= wasted;
408  }
409 
410  return 0;
411 }
412 
414 {
415  int i, ret;
416  GetBitContext *gb = &s->gb;
418 
419  if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
420  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
421  return ret;
422  }
423 
424  if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
425  s->channels = s->avctx->channels = fi.channels;
427  ret = allocate_buffers(s);
428  if (ret < 0)
429  return ret;
430  }
431  s->channels = s->avctx->channels = fi.channels;
432  if (!s->avctx->channel_layout)
434  s->ch_mode = fi.ch_mode;
435 
436  if (!s->bps && !fi.bps) {
437  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
438  return AVERROR_INVALIDDATA;
439  }
440  if (!fi.bps) {
441  fi.bps = s->bps;
442  } else if (s->bps && fi.bps != s->bps) {
443  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
444  "supported\n");
445  return AVERROR_INVALIDDATA;
446  }
447 
448  if (!s->bps) {
449  s->bps = s->avctx->bits_per_raw_sample = fi.bps;
450  flac_set_bps(s);
451  }
452 
453  if (!s->max_blocksize)
454  s->max_blocksize = FLAC_MAX_BLOCKSIZE;
455  if (fi.blocksize > s->max_blocksize) {
456  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
457  s->max_blocksize);
458  return AVERROR_INVALIDDATA;
459  }
460  s->blocksize = fi.blocksize;
461 
462  if (!s->samplerate && !fi.samplerate) {
463  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
464  " or frame header\n");
465  return AVERROR_INVALIDDATA;
466  }
467  if (fi.samplerate == 0)
468  fi.samplerate = s->samplerate;
469  s->samplerate = s->avctx->sample_rate = fi.samplerate;
470 
471  if (!s->got_streaminfo) {
472  ret = allocate_buffers(s);
473  if (ret < 0)
474  return ret;
475  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
476  s->got_streaminfo = 1;
478  }
479 
480 // dump_headers(s->avctx, (FLACStreaminfo *)s);
481 
482  /* subframes */
483  for (i = 0; i < s->channels; i++) {
484  if ((ret = decode_subframe(s, i)) < 0)
485  return ret;
486  }
487 
488  align_get_bits(gb);
489 
490  /* frame footer */
491  skip_bits(gb, 16); /* data crc */
492 
493  return 0;
494 }
495 
496 static int flac_decode_frame(AVCodecContext *avctx, void *data,
497  int *got_frame_ptr, AVPacket *avpkt)
498 {
499  AVFrame *frame = data;
500  ThreadFrame tframe = { .f = data };
501  const uint8_t *buf = avpkt->data;
502  int buf_size = avpkt->size;
503  FLACContext *s = avctx->priv_data;
504  int bytes_read = 0;
505  int ret;
506 
507  *got_frame_ptr = 0;
508 
509  if (s->max_framesize == 0) {
510  s->max_framesize =
511  ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
512  FLAC_MAX_CHANNELS, 32);
513  }
514 
515  if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
516  av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
517  return buf_size;
518  }
519 
520  if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
521  av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
522  return buf_size;
523  }
524 
525  /* check that there is at least the smallest decodable amount of data.
526  this amount corresponds to the smallest valid FLAC frame possible.
527  FF F8 69 02 00 00 9A 00 00 34 46 */
528  if (buf_size < FLAC_MIN_FRAME_SIZE)
529  return buf_size;
530 
531  /* check for inline header */
532  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
533  if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
534  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
535  return ret;
536  }
537  return get_metadata_size(buf, buf_size);
538  }
539 
540  /* decode frame */
541  if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
542  return ret;
543  if ((ret = decode_frame(s)) < 0) {
544  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
545  return ret;
546  }
547  bytes_read = get_bits_count(&s->gb)/8;
548 
551  0, buf, bytes_read)) {
552  av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
554  return AVERROR_INVALIDDATA;
555  }
556 
557  /* get output buffer */
558  frame->nb_samples = s->blocksize;
559  if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
560  return ret;
561 
562  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
563  s->blocksize, s->sample_shift);
564 
565  if (bytes_read > buf_size) {
566  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
567  return AVERROR_INVALIDDATA;
568  }
569  if (bytes_read < buf_size) {
570  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
571  buf_size - bytes_read, buf_size);
572  }
573 
574  *got_frame_ptr = 1;
575 
576  return bytes_read;
577 }
578 
580 {
581  FLACContext *s = avctx->priv_data;
582  s->decoded_buffer = NULL;
583  s->decoded_buffer_size = 0;
584  s->avctx = avctx;
585  if (s->max_blocksize)
586  return allocate_buffers(s);
587  return 0;
588 }
589 
591 {
592  FLACContext *s = avctx->priv_data;
593 
595 
596  return 0;
597 }
598 
600  .name = "flac",
601  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
602  .type = AVMEDIA_TYPE_AUDIO,
603  .id = AV_CODEC_ID_FLAC,
604  .priv_data_size = sizeof(FLACContext),
609  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
610  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
615 };