flac: Move flac functions shared between libraries to flac common code
[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/audioconvert.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     AVFrame frame;
55     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
56
57     int blocksize;                          ///< number of samples in the current frame
58     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
59     int ch_mode;                            ///< channel decorrelation type in the current frame
60     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
61
62     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
63
64     FLACDSPContext dsp;
65 } FLACContext;
66
67 static const int64_t flac_channel_layouts[6] = {
68     AV_CH_LAYOUT_MONO,
69     AV_CH_LAYOUT_STEREO,
70     AV_CH_LAYOUT_SURROUND,
71     AV_CH_LAYOUT_QUAD,
72     AV_CH_LAYOUT_5POINT0,
73     AV_CH_LAYOUT_5POINT1
74 };
75
76 static void allocate_buffers(FLACContext *s);
77
78 static void flac_set_bps(FLACContext *s)
79 {
80     enum AVSampleFormat req = s->avctx->request_sample_fmt;
81     int need32 = s->bps > 16;
82     int want32 = av_get_bytes_per_sample(req) > 2;
83     int planar = av_sample_fmt_is_planar(req);
84
85     if (need32 || want32) {
86         if (planar)
87             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
88         else
89             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
90         s->sample_shift = 32 - s->bps;
91     } else {
92         if (planar)
93             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
94         else
95             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
96         s->sample_shift = 16 - s->bps;
97     }
98 }
99
100 static av_cold int flac_decode_init(AVCodecContext *avctx)
101 {
102     enum FLACExtradataFormat format;
103     uint8_t *streaminfo;
104     FLACContext *s = avctx->priv_data;
105     s->avctx = avctx;
106
107     /* for now, the raw FLAC header is allowed to be passed to the decoder as
108        frame data instead of extradata. */
109     if (!avctx->extradata)
110         return 0;
111
112     if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
113         return -1;
114
115     /* initialize based on the demuxer-supplied streamdata header */
116     avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
117     allocate_buffers(s);
118     flac_set_bps(s);
119     ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
120     s->got_streaminfo = 1;
121
122     avcodec_get_frame_defaults(&s->frame);
123     avctx->coded_frame = &s->frame;
124
125     if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
126         avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
127
128     return 0;
129 }
130
131 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
132 {
133     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
134     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
135     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
136     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
137     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
138 }
139
140 static void allocate_buffers(FLACContext *s)
141 {
142     int i;
143
144     assert(s->max_blocksize);
145
146     for (i = 0; i < s->channels; i++) {
147         s->decoded[i] = av_malloc(sizeof(int32_t)*s->max_blocksize);
148     }
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;
161
162     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
163         /* need more data */
164         return 0;
165     }
166     avpriv_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     }
171     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
172     allocate_buffers(s);
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, int channel, int pred_order)
208 {
209     int i, tmp, partition, method_type, rice_order;
210     int sample = 0, samples;
211
212     method_type = get_bits(&s->gb, 2);
213     if (method_type > 1) {
214         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
215                method_type);
216         return -1;
217     }
218
219     rice_order = get_bits(&s->gb, 4);
220
221     samples= s->blocksize >> rice_order;
222     if (pred_order > samples) {
223         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
224                pred_order, samples);
225         return -1;
226     }
227
228     sample=
229     i= pred_order;
230     for (partition = 0; partition < (1 << rice_order); partition++) {
231         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
232         if (tmp == (method_type == 0 ? 15 : 31)) {
233             tmp = get_bits(&s->gb, 5);
234             for (; i < samples; i++, sample++)
235                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
236         } else {
237             for (; i < samples; i++, sample++) {
238                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
239             }
240         }
241         i= 0;
242     }
243
244     return 0;
245 }
246
247 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order,
248                                  int bps)
249 {
250     const int blocksize = s->blocksize;
251     int32_t *decoded = s->decoded[channel];
252     int a, b, c, d, i;
253
254     /* warm up samples */
255     for (i = 0; i < pred_order; i++) {
256         decoded[i] = get_sbits_long(&s->gb, bps);
257     }
258
259     if (decode_residuals(s, channel, pred_order) < 0)
260         return -1;
261
262     if (pred_order > 0)
263         a = decoded[pred_order-1];
264     if (pred_order > 1)
265         b = a - decoded[pred_order-2];
266     if (pred_order > 2)
267         c = b - decoded[pred_order-2] + decoded[pred_order-3];
268     if (pred_order > 3)
269         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
270
271     switch (pred_order) {
272     case 0:
273         break;
274     case 1:
275         for (i = pred_order; i < blocksize; i++)
276             decoded[i] = a += decoded[i];
277         break;
278     case 2:
279         for (i = pred_order; i < blocksize; i++)
280             decoded[i] = a += b += decoded[i];
281         break;
282     case 3:
283         for (i = pred_order; i < blocksize; i++)
284             decoded[i] = a += b += c += decoded[i];
285         break;
286     case 4:
287         for (i = pred_order; i < blocksize; i++)
288             decoded[i] = a += b += c += d += decoded[i];
289         break;
290     default:
291         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
292         return -1;
293     }
294
295     return 0;
296 }
297
298 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order,
299                                int bps)
300 {
301     int i;
302     int coeff_prec, qlevel;
303     int coeffs[32];
304     int32_t *decoded = s->decoded[channel];
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[i] = get_sbits(&s->gb, coeff_prec);
325     }
326
327     if (decode_residuals(s, channel, 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     int type, wasted = 0;
338     int bps = s->bps;
339     int i, tmp;
340
341     if (channel == 0) {
342         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
343             bps++;
344     } else {
345         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
346             bps++;
347     }
348
349     if (get_bits1(&s->gb)) {
350         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
351         return -1;
352     }
353     type = get_bits(&s->gb, 6);
354
355     if (get_bits1(&s->gb)) {
356         int left = get_bits_left(&s->gb);
357         wasted = 1;
358         if ( left < 0 ||
359             (left < bps && !show_bits_long(&s->gb, left)) ||
360                            !show_bits_long(&s->gb, bps)) {
361             av_log(s->avctx, AV_LOG_ERROR,
362                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
363                    bps, left);
364             return AVERROR_INVALIDDATA;
365         }
366         while (!get_bits1(&s->gb))
367             wasted++;
368         bps -= wasted;
369     }
370     if (bps > 32) {
371         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
372         return -1;
373     }
374
375 //FIXME use av_log2 for types
376     if (type == 0) {
377         tmp = get_sbits_long(&s->gb, bps);
378         for (i = 0; i < s->blocksize; i++)
379             s->decoded[channel][i] = tmp;
380     } else if (type == 1) {
381         for (i = 0; i < s->blocksize; i++)
382             s->decoded[channel][i] = get_sbits_long(&s->gb, bps);
383     } else if ((type >= 8) && (type <= 12)) {
384         if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0)
385             return -1;
386     } else if (type >= 32) {
387         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0)
388             return -1;
389     } else {
390         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
391         return -1;
392     }
393
394     if (wasted) {
395         int i;
396         for (i = 0; i < s->blocksize; i++)
397             s->decoded[channel][i] <<= wasted;
398     }
399
400     return 0;
401 }
402
403 static int decode_frame(FLACContext *s)
404 {
405     int i;
406     GetBitContext *gb = &s->gb;
407     FLACFrameInfo fi;
408
409     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
410         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
411         return -1;
412     }
413
414     if (s->channels && fi.channels != s->channels) {
415         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
416                                        "is not supported\n");
417         return -1;
418     }
419     s->channels = s->avctx->channels = fi.channels;
420     s->ch_mode = fi.ch_mode;
421
422     if (!s->bps && !fi.bps) {
423         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
424         return -1;
425     }
426     if (!fi.bps) {
427         fi.bps = s->bps;
428     } else if (s->bps && fi.bps != s->bps) {
429         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
430                                        "supported\n");
431         return -1;
432     }
433
434     if (!s->bps) {
435         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
436         flac_set_bps(s);
437     }
438
439     if (!s->max_blocksize)
440         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
441     if (fi.blocksize > s->max_blocksize) {
442         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
443                s->max_blocksize);
444         return -1;
445     }
446     s->blocksize = fi.blocksize;
447
448     if (!s->samplerate && !fi.samplerate) {
449         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
450                                         " or frame header\n");
451         return -1;
452     }
453     if (fi.samplerate == 0) {
454         fi.samplerate = s->samplerate;
455     } else if (s->samplerate && fi.samplerate != s->samplerate) {
456         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
457                s->samplerate, fi.samplerate);
458     }
459     s->samplerate = s->avctx->sample_rate = fi.samplerate;
460
461     if (!s->got_streaminfo) {
462         allocate_buffers(s);
463         ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
464         s->got_streaminfo = 1;
465         dump_headers(s->avctx, (FLACStreaminfo *)s);
466     }
467
468 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
469
470     /* subframes */
471     for (i = 0; i < s->channels; i++) {
472         if (decode_subframe(s, i) < 0)
473             return -1;
474     }
475
476     align_get_bits(gb);
477
478     /* frame footer */
479     skip_bits(gb, 16); /* data crc */
480
481     return 0;
482 }
483
484 static int flac_decode_frame(AVCodecContext *avctx, void *data,
485                              int *got_frame_ptr, AVPacket *avpkt)
486 {
487     const uint8_t *buf = avpkt->data;
488     int buf_size = avpkt->size;
489     FLACContext *s = avctx->priv_data;
490     int bytes_read = 0;
491     int ret;
492
493     *got_frame_ptr = 0;
494
495     if (s->max_framesize == 0) {
496         s->max_framesize =
497             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
498                                        FLAC_MAX_CHANNELS, 32);
499     }
500
501     /* check that there is at least the smallest decodable amount of data.
502        this amount corresponds to the smallest valid FLAC frame possible.
503        FF F8 69 02 00 00 9A 00 00 34 46 */
504     if (buf_size < FLAC_MIN_FRAME_SIZE)
505         return buf_size;
506
507     /* check for inline header */
508     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
509         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
510             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
511             return -1;
512         }
513         return get_metadata_size(buf, buf_size);
514     }
515
516     /* decode frame */
517     init_get_bits(&s->gb, buf, buf_size*8);
518     if (decode_frame(s) < 0) {
519         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
520         return -1;
521     }
522     bytes_read = (get_bits_count(&s->gb)+7)/8;
523
524     /* get output buffer */
525     s->frame.nb_samples = s->blocksize;
526     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
527         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
528         return ret;
529     }
530
531     s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
532                                    s->blocksize, s->sample_shift);
533
534     if (bytes_read > buf_size) {
535         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
536         return -1;
537     }
538     if (bytes_read < buf_size) {
539         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
540                buf_size - bytes_read, buf_size);
541     }
542
543     *got_frame_ptr   = 1;
544     *(AVFrame *)data = s->frame;
545
546     return bytes_read;
547 }
548
549 static av_cold int flac_decode_close(AVCodecContext *avctx)
550 {
551     FLACContext *s = avctx->priv_data;
552     int i;
553
554     for (i = 0; i < s->channels; i++) {
555         av_freep(&s->decoded[i]);
556     }
557
558     return 0;
559 }
560
561 AVCodec ff_flac_decoder = {
562     .name           = "flac",
563     .type           = AVMEDIA_TYPE_AUDIO,
564     .id             = CODEC_ID_FLAC,
565     .priv_data_size = sizeof(FLACContext),
566     .init           = flac_decode_init,
567     .close          = flac_decode_close,
568     .decode         = flac_decode_frame,
569     .capabilities   = CODEC_CAP_DR1,
570     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
571     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
572                                                       AV_SAMPLE_FMT_S16P,
573                                                       AV_SAMPLE_FMT_S32,
574                                                       AV_SAMPLE_FMT_S32P,
575                                                       -1 },
576 };