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