flacdec.c
Go to the documentation of this file.
1 /*
2  * FLAC (Free Lossless Audio Codec) decoder
3  * Copyright (c) 2003 Alex Beregszaszi
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
34 #include <limits.h>
35 
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 
47 #undef NDEBUG
48 #include <assert.h>
49 
50 typedef struct FLACContext {
52 
56 
57  int blocksize;
59  int ch_mode;
61 
64  unsigned int decoded_buffer_size;
65 
67 } FLACContext;
68 
69 static int allocate_buffers(FLACContext *s);
70 
71 static void flac_set_bps(FLACContext *s)
72 {
74  int need32 = s->bps > 16;
75  int want32 = av_get_bytes_per_sample(req) > 2;
76  int planar = av_sample_fmt_is_planar(req);
77 
78  if (need32 || want32) {
79  if (planar)
81  else
83  s->sample_shift = 32 - s->bps;
84  } else {
85  if (planar)
87  else
89  s->sample_shift = 16 - s->bps;
90  }
91 }
92 
94 {
95  enum FLACExtradataFormat format;
96  uint8_t *streaminfo;
97  int ret;
98  FLACContext *s = avctx->priv_data;
99  s->avctx = avctx;
100 
101  /* for now, the raw FLAC header is allowed to be passed to the decoder as
102  frame data instead of extradata. */
103  if (!avctx->extradata)
104  return 0;
105 
106  if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
107  return -1;
108 
109  /* initialize based on the demuxer-supplied streamdata header */
110  avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
111  ret = allocate_buffers(s);
112  if (ret < 0)
113  return ret;
114  flac_set_bps(s);
115  ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
116  s->got_streaminfo = 1;
117 
119  avctx->coded_frame = &s->frame;
120 
121  return 0;
122 }
123 
125 {
126  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
127  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
128  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
129  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
130  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
131 }
132 
134 {
135  int buf_size;
136 
137  assert(s->max_blocksize);
138 
139  buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
140  AV_SAMPLE_FMT_S32P, 0);
141  if (buf_size < 0)
142  return buf_size;
143 
145  if (!s->decoded_buffer)
146  return AVERROR(ENOMEM);
147 
149  s->decoded_buffer, s->channels,
150  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
151 }
152 
160 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
161 {
162  int metadata_type, metadata_size, ret;
163 
164  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
165  /* need more data */
166  return 0;
167  }
168  avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
169  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
170  metadata_size != FLAC_STREAMINFO_SIZE) {
171  return AVERROR_INVALIDDATA;
172  }
174  ret = allocate_buffers(s);
175  if (ret < 0)
176  return ret;
177  flac_set_bps(s);
178  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
179  s->got_streaminfo = 1;
180 
181  return 0;
182 }
183 
190 static int get_metadata_size(const uint8_t *buf, int buf_size)
191 {
192  int metadata_last, metadata_size;
193  const uint8_t *buf_end = buf + buf_size;
194 
195  buf += 4;
196  do {
197  if (buf_end - buf < 4)
198  return 0;
199  avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
200  buf += 4;
201  if (buf_end - buf < metadata_size) {
202  /* need more data in order to read the complete header */
203  return 0;
204  }
205  buf += metadata_size;
206  } while (!metadata_last);
207 
208  return buf_size - (buf_end - buf);
209 }
210 
211 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
212 {
213  int i, tmp, partition, method_type, rice_order;
214  int rice_bits, rice_esc;
215  int samples;
216 
217  method_type = get_bits(&s->gb, 2);
218  if (method_type > 1) {
219  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
220  method_type);
221  return -1;
222  }
223 
224  rice_order = get_bits(&s->gb, 4);
225 
226  samples= s->blocksize >> rice_order;
227  if (pred_order > samples) {
228  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
229  pred_order, samples);
230  return -1;
231  }
232 
233  rice_bits = 4 + method_type;
234  rice_esc = (1 << rice_bits) - 1;
235 
236  decoded += pred_order;
237  i= pred_order;
238  for (partition = 0; partition < (1 << rice_order); partition++) {
239  tmp = get_bits(&s->gb, rice_bits);
240  if (tmp == rice_esc) {
241  tmp = get_bits(&s->gb, 5);
242  for (; i < samples; i++)
243  *decoded++ = get_sbits_long(&s->gb, tmp);
244  } else {
245  for (; i < samples; i++) {
246  *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
247  }
248  }
249  i= 0;
250  }
251 
252  return 0;
253 }
254 
255 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
256  int pred_order, int bps)
257 {
258  const int blocksize = s->blocksize;
259  int a, b, c, d, i;
260 
261  /* warm up samples */
262  for (i = 0; i < pred_order; i++) {
263  decoded[i] = get_sbits_long(&s->gb, bps);
264  }
265 
266  if (decode_residuals(s, decoded, pred_order) < 0)
267  return -1;
268 
269  if (pred_order > 0)
270  a = decoded[pred_order-1];
271  if (pred_order > 1)
272  b = a - decoded[pred_order-2];
273  if (pred_order > 2)
274  c = b - decoded[pred_order-2] + decoded[pred_order-3];
275  if (pred_order > 3)
276  d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
277 
278  switch (pred_order) {
279  case 0:
280  break;
281  case 1:
282  for (i = pred_order; i < blocksize; i++)
283  decoded[i] = a += decoded[i];
284  break;
285  case 2:
286  for (i = pred_order; i < blocksize; i++)
287  decoded[i] = a += b += decoded[i];
288  break;
289  case 3:
290  for (i = pred_order; i < blocksize; i++)
291  decoded[i] = a += b += c += decoded[i];
292  break;
293  case 4:
294  for (i = pred_order; i < blocksize; i++)
295  decoded[i] = a += b += c += d += decoded[i];
296  break;
297  default:
298  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
299  return -1;
300  }
301 
302  return 0;
303 }
304 
305 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
306  int bps)
307 {
308  int i;
309  int coeff_prec, qlevel;
310  int coeffs[32];
311 
312  /* warm up samples */
313  for (i = 0; i < pred_order; i++) {
314  decoded[i] = get_sbits_long(&s->gb, bps);
315  }
316 
317  coeff_prec = get_bits(&s->gb, 4) + 1;
318  if (coeff_prec == 16) {
319  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
320  return -1;
321  }
322  qlevel = get_sbits(&s->gb, 5);
323  if (qlevel < 0) {
324  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
325  qlevel);
326  return -1;
327  }
328 
329  for (i = 0; i < pred_order; i++) {
330  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
331  }
332 
333  if (decode_residuals(s, decoded, pred_order) < 0)
334  return -1;
335 
336  s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
337 
338  return 0;
339 }
340 
341 static inline int decode_subframe(FLACContext *s, int channel)
342 {
343  int32_t *decoded = s->decoded[channel];
344  int type, wasted = 0;
345  int bps = s->bps;
346  int i, tmp;
347 
348  if (channel == 0) {
350  bps++;
351  } else {
353  bps++;
354  }
355 
356  if (get_bits1(&s->gb)) {
357  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
358  return -1;
359  }
360  type = get_bits(&s->gb, 6);
361 
362  if (get_bits1(&s->gb)) {
363  int left = get_bits_left(&s->gb);
364  wasted = 1;
365  if ( left < 0 ||
366  (left < bps && !show_bits_long(&s->gb, left)) ||
367  !show_bits_long(&s->gb, bps)) {
369  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
370  bps, left);
371  return AVERROR_INVALIDDATA;
372  }
373  while (!get_bits1(&s->gb))
374  wasted++;
375  bps -= wasted;
376  }
377  if (bps > 32) {
378  av_log_missing_feature(s->avctx, "Decorrelated bit depth > 32", 0);
379  return AVERROR_PATCHWELCOME;
380  }
381 
382 //FIXME use av_log2 for types
383  if (type == 0) {
384  tmp = get_sbits_long(&s->gb, bps);
385  for (i = 0; i < s->blocksize; i++)
386  decoded[i] = tmp;
387  } else if (type == 1) {
388  for (i = 0; i < s->blocksize; i++)
389  decoded[i] = get_sbits_long(&s->gb, bps);
390  } else if ((type >= 8) && (type <= 12)) {
391  if (decode_subframe_fixed(s, decoded, type & ~0x8, bps) < 0)
392  return -1;
393  } else if (type >= 32) {
394  if (decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps) < 0)
395  return -1;
396  } else {
397  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
398  return -1;
399  }
400 
401  if (wasted) {
402  int i;
403  for (i = 0; i < s->blocksize; i++)
404  decoded[i] <<= wasted;
405  }
406 
407  return 0;
408 }
409 
410 static int decode_frame(FLACContext *s)
411 {
412  int i, ret;
413  GetBitContext *gb = &s->gb;
414  FLACFrameInfo fi;
415 
416  if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
417  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
418  return -1;
419  }
420 
421  if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
422  s->channels = s->avctx->channels = fi.channels;
424  ret = allocate_buffers(s);
425  if (ret < 0)
426  return ret;
427  }
428  s->channels = s->avctx->channels = fi.channels;
429  if (!s->avctx->channel_layout && s->channels <= 6)
431  s->ch_mode = fi.ch_mode;
432 
433  if (!s->bps && !fi.bps) {
434  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
435  return -1;
436  }
437  if (!fi.bps) {
438  fi.bps = s->bps;
439  } else if (s->bps && fi.bps != s->bps) {
440  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
441  "supported\n");
442  return -1;
443  }
444 
445  if (!s->bps) {
446  s->bps = s->avctx->bits_per_raw_sample = fi.bps;
447  flac_set_bps(s);
448  }
449 
450  if (!s->max_blocksize)
451  s->max_blocksize = FLAC_MAX_BLOCKSIZE;
452  if (fi.blocksize > s->max_blocksize) {
453  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
454  s->max_blocksize);
455  return -1;
456  }
457  s->blocksize = fi.blocksize;
458 
459  if (!s->samplerate && !fi.samplerate) {
460  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
461  " or frame header\n");
462  return -1;
463  }
464  if (fi.samplerate == 0)
465  fi.samplerate = s->samplerate;
466  s->samplerate = s->avctx->sample_rate = fi.samplerate;
467 
468  if (!s->got_streaminfo) {
469  ret = allocate_buffers(s);
470  if (ret < 0)
471  return ret;
472  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
473  s->got_streaminfo = 1;
475  }
476 
477 // dump_headers(s->avctx, (FLACStreaminfo *)s);
478 
479  /* subframes */
480  for (i = 0; i < s->channels; i++) {
481  if (decode_subframe(s, i) < 0)
482  return -1;
483  }
484 
485  align_get_bits(gb);
486 
487  /* frame footer */
488  skip_bits(gb, 16); /* data crc */
489 
490  return 0;
491 }
492 
493 static int flac_decode_frame(AVCodecContext *avctx, void *data,
494  int *got_frame_ptr, AVPacket *avpkt)
495 {
496  const uint8_t *buf = avpkt->data;
497  int buf_size = avpkt->size;
498  FLACContext *s = avctx->priv_data;
499  int bytes_read = 0;
500  int ret;
501 
502  *got_frame_ptr = 0;
503 
504  if (s->max_framesize == 0) {
505  s->max_framesize =
506  ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
507  FLAC_MAX_CHANNELS, 32);
508  }
509 
510  /* check that there is at least the smallest decodable amount of data.
511  this amount corresponds to the smallest valid FLAC frame possible.
512  FF F8 69 02 00 00 9A 00 00 34 46 */
513  if (buf_size < FLAC_MIN_FRAME_SIZE)
514  return buf_size;
515 
516  /* check for inline header */
517  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
518  if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
519  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
520  return -1;
521  }
522  return get_metadata_size(buf, buf_size);
523  }
524 
525  /* decode frame */
526  init_get_bits(&s->gb, buf, buf_size*8);
527  if (decode_frame(s) < 0) {
528  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
529  return -1;
530  }
531  bytes_read = (get_bits_count(&s->gb)+7)/8;
532 
533  /* get output buffer */
534  s->frame.nb_samples = s->blocksize;
535  if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
536  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
537  return ret;
538  }
539 
540  s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
541  s->blocksize, s->sample_shift);
542 
543  if (bytes_read > buf_size) {
544  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
545  return -1;
546  }
547  if (bytes_read < buf_size) {
548  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
549  buf_size - bytes_read, buf_size);
550  }
551 
552  *got_frame_ptr = 1;
553  *(AVFrame *)data = s->frame;
554 
555  return bytes_read;
556 }
557 
559 {
560  FLACContext *s = avctx->priv_data;
561 
563 
564  return 0;
565 }
566 
568  .name = "flac",
569  .type = AVMEDIA_TYPE_AUDIO,
570  .id = AV_CODEC_ID_FLAC,
571  .priv_data_size = sizeof(FLACContext),
575  .capabilities = CODEC_CAP_DR1,
576  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
577  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
581  -1 },
582 };