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