FFmpeg
 All Data Structures 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"
38 #include "libavutil/crc.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 
48 typedef struct FLACContext {
50 
51  AVCodecContext *avctx; ///< parent AVCodecContext
52  GetBitContext gb; ///< GetBitContext initialized to start at the current frame
53 
54  int blocksize; ///< number of samples in the current frame
55  int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
56  int ch_mode; ///< channel decorrelation type in the current frame
57  int got_streaminfo; ///< indicates if the STREAMINFO has been read
58 
59  int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
61  unsigned int decoded_buffer_size;
62 
64 } FLACContext;
65 
66 static int allocate_buffers(FLACContext *s);
67 
68 static void flac_set_bps(FLACContext *s)
69 {
71  int need32 = s->bps > 16;
72  int want32 = av_get_bytes_per_sample(req) > 2;
73  int planar = av_sample_fmt_is_planar(req);
74 
75  if (need32 || want32) {
76  if (planar)
78  else
80  s->sample_shift = 32 - s->bps;
81  } else {
82  if (planar)
84  else
86  s->sample_shift = 16 - s->bps;
87  }
88 }
89 
91 {
92  enum FLACExtradataFormat format;
93  uint8_t *streaminfo;
94  int ret;
95  FLACContext *s = avctx->priv_data;
96  s->avctx = avctx;
97 
98  /* for now, the raw FLAC header is allowed to be passed to the decoder as
99  frame data instead of extradata. */
100  if (!avctx->extradata)
101  return 0;
102 
103  if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
104  return -1;
105 
106  /* initialize based on the demuxer-supplied streamdata header */
107  avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
108  ret = allocate_buffers(s);
109  if (ret < 0)
110  return ret;
111  flac_set_bps(s);
112  ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
113  s->got_streaminfo = 1;
114 
115  return 0;
116 }
117 
119 {
120  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
121  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
122  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
123  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
124  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
125 }
126 
128 {
129  int buf_size;
130 
131  av_assert0(s->max_blocksize);
132 
133  buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
134  AV_SAMPLE_FMT_S32P, 0);
135  if (buf_size < 0)
136  return buf_size;
137 
139  if (!s->decoded_buffer)
140  return AVERROR(ENOMEM);
141 
143  s->decoded_buffer, s->channels,
144  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
145 }
146 
147 /**
148  * Parse the STREAMINFO from an inline header.
149  * @param s the flac decoding context
150  * @param buf input buffer, starting with the "fLaC" marker
151  * @param buf_size buffer size
152  * @return non-zero if metadata is invalid
153  */
154 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
155 {
156  int metadata_type, metadata_size, ret;
157 
158  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
159  /* need more data */
160  return 0;
161  }
162  avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
163  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
164  metadata_size != FLAC_STREAMINFO_SIZE) {
165  return AVERROR_INVALIDDATA;
166  }
168  ret = allocate_buffers(s);
169  if (ret < 0)
170  return ret;
171  flac_set_bps(s);
172  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
173  s->got_streaminfo = 1;
174 
175  return 0;
176 }
177 
178 /**
179  * Determine the size of an inline header.
180  * @param buf input buffer, starting with the "fLaC" marker
181  * @param buf_size buffer size
182  * @return number of bytes in the header, or 0 if more data is needed
183  */
184 static int get_metadata_size(const uint8_t *buf, int buf_size)
185 {
186  int metadata_last, metadata_size;
187  const uint8_t *buf_end = buf + buf_size;
188 
189  buf += 4;
190  do {
191  if (buf_end - buf < 4)
192  return 0;
193  avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
194  buf += 4;
195  if (buf_end - buf < metadata_size) {
196  /* need more data in order to read the complete header */
197  return 0;
198  }
199  buf += metadata_size;
200  } while (!metadata_last);
201 
202  return buf_size - (buf_end - buf);
203 }
204 
205 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
206 {
207  int i, tmp, partition, method_type, rice_order;
208  int rice_bits, rice_esc;
209  int samples;
210 
211  method_type = get_bits(&s->gb, 2);
212  if (method_type > 1) {
213  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
214  method_type);
215  return -1;
216  }
217 
218  rice_order = get_bits(&s->gb, 4);
219 
220  samples= s->blocksize >> rice_order;
221  if (pred_order > samples) {
222  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
223  pred_order, samples);
224  return -1;
225  }
226 
227  rice_bits = 4 + method_type;
228  rice_esc = (1 << rice_bits) - 1;
229 
230  decoded += pred_order;
231  i= pred_order;
232  for (partition = 0; partition < (1 << rice_order); partition++) {
233  tmp = get_bits(&s->gb, rice_bits);
234  if (tmp == rice_esc) {
235  tmp = get_bits(&s->gb, 5);
236  for (; i < samples; i++)
237  *decoded++ = get_sbits_long(&s->gb, tmp);
238  } else {
239  for (; i < samples; i++) {
240  *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
241  }
242  }
243  i= 0;
244  }
245 
246  return 0;
247 }
248 
249 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
250  int pred_order, int bps)
251 {
252  const int blocksize = s->blocksize;
253  int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
254 
255  /* warm up samples */
256  for (i = 0; i < pred_order; i++) {
257  decoded[i] = get_sbits_long(&s->gb, bps);
258  }
259 
260  if (decode_residuals(s, decoded, pred_order) < 0)
261  return -1;
262 
263  if (pred_order > 0)
264  a = decoded[pred_order-1];
265  if (pred_order > 1)
266  b = a - decoded[pred_order-2];
267  if (pred_order > 2)
268  c = b - decoded[pred_order-2] + decoded[pred_order-3];
269  if (pred_order > 3)
270  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
271 
272  switch (pred_order) {
273  case 0:
274  break;
275  case 1:
276  for (i = pred_order; i < blocksize; i++)
277  decoded[i] = a += decoded[i];
278  break;
279  case 2:
280  for (i = pred_order; i < blocksize; i++)
281  decoded[i] = a += b += decoded[i];
282  break;
283  case 3:
284  for (i = pred_order; i < blocksize; i++)
285  decoded[i] = a += b += c += decoded[i];
286  break;
287  case 4:
288  for (i = pred_order; i < blocksize; i++)
289  decoded[i] = a += b += c += d += decoded[i];
290  break;
291  default:
292  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
293  return -1;
294  }
295 
296  return 0;
297 }
298 
299 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
300  int bps)
301 {
302  int i;
303  int coeff_prec, qlevel;
304  int coeffs[32];
305 
306  /* warm up samples */
307  for (i = 0; i < pred_order; i++) {
308  decoded[i] = get_sbits_long(&s->gb, bps);
309  }
310 
311  coeff_prec = get_bits(&s->gb, 4) + 1;
312  if (coeff_prec == 16) {
313  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
314  return -1;
315  }
316  qlevel = get_sbits(&s->gb, 5);
317  if (qlevel < 0) {
318  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
319  qlevel);
320  return -1;
321  }
322 
323  for (i = 0; i < pred_order; i++) {
324  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
325  }
326 
327  if (decode_residuals(s, decoded, pred_order) < 0)
328  return -1;
329 
330  s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
331 
332  return 0;
333 }
334 
335 static inline int decode_subframe(FLACContext *s, int channel)
336 {
337  int32_t *decoded = s->decoded[channel];
338  int type, wasted = 0;
339  int bps = s->bps;
340  int i, tmp;
341 
342  if (channel == 0) {
344  bps++;
345  } else {
347  bps++;
348  }
349 
350  if (get_bits1(&s->gb)) {
351  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
352  return -1;
353  }
354  type = get_bits(&s->gb, 6);
355 
356  if (get_bits1(&s->gb)) {
357  int left = get_bits_left(&s->gb);
358  wasted = 1;
359  if ( left < 0 ||
360  (left < bps && !show_bits_long(&s->gb, left)) ||
361  !show_bits_long(&s->gb, bps)) {
363  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
364  bps, left);
365  return AVERROR_INVALIDDATA;
366  }
367  while (!get_bits1(&s->gb))
368  wasted++;
369  bps -= wasted;
370  }
371  if (bps > 32) {
372  av_log_missing_feature(s->avctx, "Decorrelated bit depth > 32", 0);
373  return AVERROR_PATCHWELCOME;
374  }
375 
376 //FIXME use av_log2 for types
377  if (type == 0) {
378  tmp = get_sbits_long(&s->gb, bps);
379  for (i = 0; i < s->blocksize; i++)
380  decoded[i] = tmp;
381  } else if (type == 1) {
382  for (i = 0; i < s->blocksize; i++)
383  decoded[i] = get_sbits_long(&s->gb, bps);
384  } else if ((type >= 8) && (type <= 12)) {
385  if (decode_subframe_fixed(s, decoded, type & ~0x8, bps) < 0)
386  return -1;
387  } else if (type >= 32) {
388  if (decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps) < 0)
389  return -1;
390  } else {
391  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
392  return -1;
393  }
394 
395  if (wasted) {
396  int i;
397  for (i = 0; i < s->blocksize; i++)
398  decoded[i] <<= wasted;
399  }
400 
401  return 0;
402 }
403 
404 static int decode_frame(FLACContext *s)
405 {
406  int i, ret;
407  GetBitContext *gb = &s->gb;
408  FLACFrameInfo fi;
409 
410  if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
411  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
412  return -1;
413  }
414 
415  if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
416  s->channels = s->avctx->channels = fi.channels;
418  ret = allocate_buffers(s);
419  if (ret < 0)
420  return ret;
421  }
422  s->channels = s->avctx->channels = fi.channels;
423  if (!s->avctx->channel_layout)
425  s->ch_mode = fi.ch_mode;
426 
427  if (!s->bps && !fi.bps) {
428  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
429  return -1;
430  }
431  if (!fi.bps) {
432  fi.bps = s->bps;
433  } else if (s->bps && fi.bps != s->bps) {
434  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
435  "supported\n");
436  return -1;
437  }
438 
439  if (!s->bps) {
440  s->bps = s->avctx->bits_per_raw_sample = fi.bps;
441  flac_set_bps(s);
442  }
443 
444  if (!s->max_blocksize)
445  s->max_blocksize = FLAC_MAX_BLOCKSIZE;
446  if (fi.blocksize > s->max_blocksize) {
447  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
448  s->max_blocksize);
449  return -1;
450  }
451  s->blocksize = fi.blocksize;
452 
453  if (!s->samplerate && !fi.samplerate) {
454  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
455  " or frame header\n");
456  return -1;
457  }
458  if (fi.samplerate == 0)
459  fi.samplerate = s->samplerate;
460  s->samplerate = s->avctx->sample_rate = fi.samplerate;
461 
462  if (!s->got_streaminfo) {
463  ret = allocate_buffers(s);
464  if (ret < 0)
465  return ret;
466  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
467  s->got_streaminfo = 1;
469  }
470 
471 // dump_headers(s->avctx, (FLACStreaminfo *)s);
472 
473  /* subframes */
474  for (i = 0; i < s->channels; i++) {
475  if (decode_subframe(s, i) < 0)
476  return -1;
477  }
478 
479  align_get_bits(gb);
480 
481  /* frame footer */
482  skip_bits(gb, 16); /* data crc */
483 
484  return 0;
485 }
486 
487 static int flac_decode_frame(AVCodecContext *avctx, void *data,
488  int *got_frame_ptr, AVPacket *avpkt)
489 {
490  AVFrame *frame = data;
491  const uint8_t *buf = avpkt->data;
492  int buf_size = avpkt->size;
493  FLACContext *s = avctx->priv_data;
494  int bytes_read = 0;
495  int ret;
496 
497  *got_frame_ptr = 0;
498 
499  if (s->max_framesize == 0) {
500  s->max_framesize =
501  ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
502  FLAC_MAX_CHANNELS, 32);
503  }
504 
505  if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
506  av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
507  return buf_size;
508  }
509 
510  if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
511  av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
512  return buf_size;
513  }
514 
515  /* check that there is at least the smallest decodable amount of data.
516  this amount corresponds to the smallest valid FLAC frame possible.
517  FF F8 69 02 00 00 9A 00 00 34 46 */
518  if (buf_size < FLAC_MIN_FRAME_SIZE)
519  return buf_size;
520 
521  /* check for inline header */
522  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
523  if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
524  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
525  return -1;
526  }
527  return get_metadata_size(buf, buf_size);
528  }
529 
530  /* decode frame */
531  init_get_bits(&s->gb, buf, buf_size*8);
532  if (decode_frame(s) < 0) {
533  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
534  return -1;
535  }
536  bytes_read = get_bits_count(&s->gb)/8;
537 
538  if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
540  0, buf, bytes_read)) {
541  av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
543  return AVERROR_INVALIDDATA;
544  }
545 
546  /* get output buffer */
547  frame->nb_samples = s->blocksize;
548  if ((ret = ff_get_buffer(avctx, frame)) < 0) {
549  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
550  return ret;
551  }
552 
553  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
554  s->blocksize, s->sample_shift);
555 
556  if (bytes_read > buf_size) {
557  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
558  return -1;
559  }
560  if (bytes_read < buf_size) {
561  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
562  buf_size - bytes_read, buf_size);
563  }
564 
565  *got_frame_ptr = 1;
566 
567  return bytes_read;
568 }
569 
571 {
572  FLACContext *s = avctx->priv_data;
573 
575 
576  return 0;
577 }
578 
580  .name = "flac",
581  .type = AVMEDIA_TYPE_AUDIO,
582  .id = AV_CODEC_ID_FLAC,
583  .priv_data_size = sizeof(FLACContext),
587  .capabilities = CODEC_CAP_DR1,
588  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
589  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
594 };