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/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[pred_order - i - 1] = 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 };