avcodec/flacdec: make while get_bits loop more robust by checking bits left
[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 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/channel_layout.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 #include "thread.h"
48
49 typedef struct FLACContext {
50     FLACSTREAMINFO
51
52     AVCodecContext *avctx;                  ///< parent AVCodecContext
53     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
54
55     int blocksize;                          ///< number of samples in the current frame
56     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
57     int ch_mode;                            ///< channel decorrelation type in the current frame
58     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
59
60     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
61     uint8_t *decoded_buffer;
62     unsigned int decoded_buffer_size;
63
64     FLACDSPContext dsp;
65 } FLACContext;
66
67 static int allocate_buffers(FLACContext *s);
68
69 static void flac_set_bps(FLACContext *s)
70 {
71     enum AVSampleFormat req = s->avctx->request_sample_fmt;
72     int need32 = s->bps > 16;
73     int want32 = av_get_bytes_per_sample(req) > 2;
74     int planar = av_sample_fmt_is_planar(req);
75
76     if (need32 || want32) {
77         if (planar)
78             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
79         else
80             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
81         s->sample_shift = 32 - s->bps;
82     } else {
83         if (planar)
84             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
85         else
86             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
87         s->sample_shift = 16 - s->bps;
88     }
89 }
90
91 static av_cold int flac_decode_init(AVCodecContext *avctx)
92 {
93     enum FLACExtradataFormat format;
94     uint8_t *streaminfo;
95     int ret;
96     FLACContext *s = avctx->priv_data;
97     s->avctx = avctx;
98
99     /* for now, the raw FLAC header is allowed to be passed to the decoder as
100        frame data instead of extradata. */
101     if (!avctx->extradata)
102         return 0;
103
104     if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
105         return AVERROR_INVALIDDATA;
106
107     /* initialize based on the demuxer-supplied streamdata header */
108     avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
109     ret = allocate_buffers(s);
110     if (ret < 0)
111         return ret;
112     flac_set_bps(s);
113     ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
114     s->got_streaminfo = 1;
115
116     return 0;
117 }
118
119 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
120 {
121     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
122     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
123     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
124     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
125     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
126 }
127
128 static int allocate_buffers(FLACContext *s)
129 {
130     int buf_size;
131
132     av_assert0(s->max_blocksize);
133
134     buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
135                                           AV_SAMPLE_FMT_S32P, 0);
136     if (buf_size < 0)
137         return buf_size;
138
139     av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
140     if (!s->decoded_buffer)
141         return AVERROR(ENOMEM);
142
143     return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
144                                   s->decoded_buffer, s->channels,
145                                   s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
146 }
147
148 /**
149  * Parse the STREAMINFO from an inline header.
150  * @param s the flac decoding context
151  * @param buf input buffer, starting with the "fLaC" marker
152  * @param buf_size buffer size
153  * @return non-zero if metadata is invalid
154  */
155 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
156 {
157     int metadata_type, metadata_size, ret;
158
159     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
160         /* need more data */
161         return 0;
162     }
163     avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
164     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
165         metadata_size != FLAC_STREAMINFO_SIZE) {
166         return AVERROR_INVALIDDATA;
167     }
168     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
169     ret = allocate_buffers(s);
170     if (ret < 0)
171         return ret;
172     flac_set_bps(s);
173     ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
174     s->got_streaminfo = 1;
175
176     return 0;
177 }
178
179 /**
180  * Determine the size of an inline header.
181  * @param buf input buffer, starting with the "fLaC" marker
182  * @param buf_size buffer size
183  * @return number of bytes in the header, or 0 if more data is needed
184  */
185 static int get_metadata_size(const uint8_t *buf, int buf_size)
186 {
187     int metadata_last, metadata_size;
188     const uint8_t *buf_end = buf + buf_size;
189
190     buf += 4;
191     do {
192         if (buf_end - buf < 4)
193             return 0;
194         avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
195         buf += 4;
196         if (buf_end - buf < metadata_size) {
197             /* need more data in order to read the complete header */
198             return 0;
199         }
200         buf += metadata_size;
201     } while (!metadata_last);
202
203     return buf_size - (buf_end - buf);
204 }
205
206 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
207 {
208     int i, tmp, partition, method_type, rice_order;
209     int rice_bits, rice_esc;
210     int 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 AVERROR_INVALIDDATA;
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 AVERROR_INVALIDDATA;
226     }
227
228     rice_bits = 4 + method_type;
229     rice_esc  = (1 << rice_bits) - 1;
230
231     decoded += pred_order;
232     i= pred_order;
233     for (partition = 0; partition < (1 << rice_order); partition++) {
234         tmp = get_bits(&s->gb, rice_bits);
235         if (tmp == rice_esc) {
236             tmp = get_bits(&s->gb, 5);
237             for (; i < samples; i++)
238                 *decoded++ = get_sbits_long(&s->gb, tmp);
239         } else {
240             for (; i < samples; i++) {
241                 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
242             }
243         }
244         i= 0;
245     }
246
247     return 0;
248 }
249
250 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
251                                  int pred_order, int bps)
252 {
253     const int blocksize = s->blocksize;
254     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
255     int ret;
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 ((ret = decode_residuals(s, decoded, pred_order)) < 0)
263         return ret;
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 AVERROR_INVALIDDATA;
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, ret;
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 AVERROR_INVALIDDATA;
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 AVERROR_INVALIDDATA;
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 ((ret = decode_residuals(s, decoded, pred_order)) < 0)
330         return ret;
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, ret;
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 AVERROR_INVALIDDATA;
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             if (get_bits_left(&s->gb) <= 0)
372                 return AVERROR_INVALIDDATA;
373         }
374         bps -= wasted;
375     }
376     if (bps > 32) {
377         avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
378         return AVERROR_PATCHWELCOME;
379     }
380
381 //FIXME use av_log2 for types
382     if (type == 0) {
383         tmp = get_sbits_long(&s->gb, bps);
384         for (i = 0; i < s->blocksize; i++)
385             decoded[i] = tmp;
386     } else if (type == 1) {
387         for (i = 0; i < s->blocksize; i++)
388             decoded[i] = get_sbits_long(&s->gb, bps);
389     } else if ((type >= 8) && (type <= 12)) {
390         if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
391             return ret;
392     } else if (type >= 32) {
393         if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
394             return ret;
395     } else {
396         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
397         return AVERROR_INVALIDDATA;
398     }
399
400     if (wasted) {
401         int i;
402         for (i = 0; i < s->blocksize; i++)
403             decoded[i] <<= wasted;
404     }
405
406     return 0;
407 }
408
409 static int decode_frame(FLACContext *s)
410 {
411     int i, ret;
412     GetBitContext *gb = &s->gb;
413     FLACFrameInfo fi;
414
415     if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
416         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
417         return ret;
418     }
419
420     if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
421         s->channels = s->avctx->channels = fi.channels;
422         ff_flac_set_channel_layout(s->avctx);
423         ret = allocate_buffers(s);
424         if (ret < 0)
425             return ret;
426     }
427     s->channels = s->avctx->channels = fi.channels;
428     if (!s->avctx->channel_layout)
429         ff_flac_set_channel_layout(s->avctx);
430     s->ch_mode = fi.ch_mode;
431
432     if (!s->bps && !fi.bps) {
433         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
434         return AVERROR_INVALIDDATA;
435     }
436     if (!fi.bps) {
437         fi.bps = s->bps;
438     } else if (s->bps && fi.bps != s->bps) {
439         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
440                                        "supported\n");
441         return AVERROR_INVALIDDATA;
442     }
443
444     if (!s->bps) {
445         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
446         flac_set_bps(s);
447     }
448
449     if (!s->max_blocksize)
450         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
451     if (fi.blocksize > s->max_blocksize) {
452         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
453                s->max_blocksize);
454         return AVERROR_INVALIDDATA;
455     }
456     s->blocksize = fi.blocksize;
457
458     if (!s->samplerate && !fi.samplerate) {
459         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
460                                         " or frame header\n");
461         return AVERROR_INVALIDDATA;
462     }
463     if (fi.samplerate == 0)
464         fi.samplerate = s->samplerate;
465     s->samplerate = s->avctx->sample_rate = fi.samplerate;
466
467     if (!s->got_streaminfo) {
468         ret = allocate_buffers(s);
469         if (ret < 0)
470             return ret;
471         ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
472         s->got_streaminfo = 1;
473         dump_headers(s->avctx, (FLACStreaminfo *)s);
474     }
475
476 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
477
478     /* subframes */
479     for (i = 0; i < s->channels; i++) {
480         if ((ret = decode_subframe(s, i)) < 0)
481             return ret;
482     }
483
484     align_get_bits(gb);
485
486     /* frame footer */
487     skip_bits(gb, 16); /* data crc */
488
489     return 0;
490 }
491
492 static int flac_decode_frame(AVCodecContext *avctx, void *data,
493                              int *got_frame_ptr, AVPacket *avpkt)
494 {
495     AVFrame *frame     = data;
496     ThreadFrame tframe = { .f = data };
497     const uint8_t *buf = avpkt->data;
498     int buf_size = avpkt->size;
499     FLACContext *s = avctx->priv_data;
500     int bytes_read = 0;
501     int ret;
502
503     *got_frame_ptr = 0;
504
505     if (s->max_framesize == 0) {
506         s->max_framesize =
507             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
508                                        FLAC_MAX_CHANNELS, 32);
509     }
510
511     if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
512         av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
513         return buf_size;
514     }
515
516     if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
517         av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
518         return buf_size;
519     }
520
521     /* check that there is at least the smallest decodable amount of data.
522        this amount corresponds to the smallest valid FLAC frame possible.
523        FF F8 69 02 00 00 9A 00 00 34 46 */
524     if (buf_size < FLAC_MIN_FRAME_SIZE)
525         return buf_size;
526
527     /* check for inline header */
528     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
529         if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
530             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
531             return ret;
532         }
533         return get_metadata_size(buf, buf_size);
534     }
535
536     /* decode frame */
537     if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
538         return ret;
539     if ((ret = decode_frame(s)) < 0) {
540         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
541         return ret;
542     }
543     bytes_read = get_bits_count(&s->gb)/8;
544
545     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
546         av_crc(av_crc_get_table(AV_CRC_16_ANSI),
547                0, buf, bytes_read)) {
548         av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
549         if (s->avctx->err_recognition & AV_EF_EXPLODE)
550             return AVERROR_INVALIDDATA;
551     }
552
553     /* get output buffer */
554     frame->nb_samples = s->blocksize;
555     if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
556         return ret;
557
558     s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
559                                    s->blocksize, s->sample_shift);
560
561     if (bytes_read > buf_size) {
562         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
563         return AVERROR_INVALIDDATA;
564     }
565     if (bytes_read < buf_size) {
566         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
567                buf_size - bytes_read, buf_size);
568     }
569
570     *got_frame_ptr = 1;
571
572     return bytes_read;
573 }
574
575 static int init_thread_copy(AVCodecContext *avctx)
576 {
577     FLACContext *s = avctx->priv_data;
578     s->decoded_buffer = NULL;
579     s->decoded_buffer_size = 0;
580     s->avctx = avctx;
581     if (s->max_blocksize)
582         return allocate_buffers(s);
583     return 0;
584 }
585
586 static av_cold int flac_decode_close(AVCodecContext *avctx)
587 {
588     FLACContext *s = avctx->priv_data;
589
590     av_freep(&s->decoded_buffer);
591
592     return 0;
593 }
594
595 AVCodec ff_flac_decoder = {
596     .name           = "flac",
597     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
598     .type           = AVMEDIA_TYPE_AUDIO,
599     .id             = AV_CODEC_ID_FLAC,
600     .priv_data_size = sizeof(FLACContext),
601     .init           = flac_decode_init,
602     .close          = flac_decode_close,
603     .decode         = flac_decode_frame,
604     .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
605     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
606     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
607                                                       AV_SAMPLE_FMT_S16P,
608                                                       AV_SAMPLE_FMT_S32,
609                                                       AV_SAMPLE_FMT_S32P,
610                                                       AV_SAMPLE_FMT_NONE },
611 };