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/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
  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     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 -1;
 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     avcodec_get_frame_defaults(&s->frame);
 117     avctx->coded_frame = &s->frame;
 118
 119     return 0;
 120 }
 121
 122 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
 123 {
 124     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
 125     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
 126     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 127     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 128     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
 129 }
 130
 131 static int allocate_buffers(FLACContext *s)
 132 {
 133     int buf_size;
 134
 135     av_assert0(s->max_blocksize);
 136
 137     buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
 138                                           AV_SAMPLE_FMT_S32P, 0);
 139     if (buf_size < 0)
 140         return buf_size;
 141
 142     av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
 143     if (!s->decoded_buffer)
 144         return AVERROR(ENOMEM);
 145
 146     return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
 147                                   s->decoded_buffer, s->channels,
 148                                   s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
 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, ret;
 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     ret = allocate_buffers(s);
 173     if (ret < 0)
 174         return ret;
 175     flac_set_bps(s);
 176     ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
 177     s->got_streaminfo = 1;
 178
 179     return 0;
 180 }
 181
 182 /**
 183  * Determine the size of an inline header.
 184  * @param buf input buffer, starting with the "fLaC" marker
 185  * @param buf_size buffer size
 186  * @return number of bytes in the header, or 0 if more data is needed
 187  */
 188 static int get_metadata_size(const uint8_t *buf, int buf_size)
 189 {
 190     int metadata_last, metadata_size;
 191     const uint8_t *buf_end = buf + buf_size;
 192
 193     buf += 4;
 194     do {
 195         if (buf_end - buf < 4)
 196             return 0;
 197         avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 198         buf += 4;
 199         if (buf_end - buf < metadata_size) {
 200             /* need more data in order to read the complete header */
 201             return 0;
 202         }
 203         buf += metadata_size;
 204     } while (!metadata_last);
 205
 206     return buf_size - (buf_end - buf);
 207 }
 208
 209 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
 210 {
 211     int i, tmp, partition, method_type, rice_order;
 212     int rice_bits, rice_esc;
 213     int samples;
 214
 215     method_type = get_bits(&s->gb, 2);
 216     if (method_type > 1) {
 217         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 218                method_type);
 219         return -1;
 220     }
 221
 222     rice_order = get_bits(&s->gb, 4);
 223
 224     samples= s->blocksize >> rice_order;
 225     if (pred_order > samples) {
 226         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 227                pred_order, samples);
 228         return -1;
 229     }
 230
 231     rice_bits = 4 + method_type;
 232     rice_esc  = (1 << rice_bits) - 1;
 233
 234     decoded += pred_order;
 235     i= pred_order;
 236     for (partition = 0; partition < (1 << rice_order); partition++) {
 237         tmp = get_bits(&s->gb, rice_bits);
 238         if (tmp == rice_esc) {
 239             tmp = get_bits(&s->gb, 5);
 240             for (; i < samples; i++)
 241                 *decoded++ = get_sbits_long(&s->gb, tmp);
 242         } else {
 243             for (; i < samples; i++) {
 244                 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 245             }
 246         }
 247         i= 0;
 248     }
 249
 250     return 0;
 251 }
 252
 253 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
 254                                  int pred_order, int bps)
 255 {
 256     const int blocksize = s->blocksize;
 257     int a, b, c, d, i;
 258
 259     /* warm up samples */
 260     for (i = 0; i < pred_order; i++) {
 261         decoded[i] = get_sbits_long(&s->gb, bps);
 262     }
 263
 264     if (decode_residuals(s, decoded, pred_order) < 0)
 265         return -1;
 266
 267     if (pred_order > 0)
 268         a = decoded[pred_order-1];
 269     if (pred_order > 1)
 270         b = a - decoded[pred_order-2];
 271     if (pred_order > 2)
 272         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 273     if (pred_order > 3)
 274         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 275
 276     switch (pred_order) {
 277     case 0:
 278         break;
 279     case 1:
 280         for (i = pred_order; i < blocksize; i++)
 281             decoded[i] = a += decoded[i];
 282         break;
 283     case 2:
 284         for (i = pred_order; i < blocksize; i++)
 285             decoded[i] = a += b += decoded[i];
 286         break;
 287     case 3:
 288         for (i = pred_order; i < blocksize; i++)
 289             decoded[i] = a += b += c += decoded[i];
 290         break;
 291     case 4:
 292         for (i = pred_order; i < blocksize; i++)
 293             decoded[i] = a += b += c += d += decoded[i];
 294         break;
 295     default:
 296         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 297         return -1;
 298     }
 299
 300     return 0;
 301 }
 302
 303 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
 304                                int bps)
 305 {
 306     int i;
 307     int coeff_prec, qlevel;
 308     int coeffs[32];
 309
 310     /* warm up samples */
 311     for (i = 0; i < pred_order; i++) {
 312         decoded[i] = get_sbits_long(&s->gb, bps);
 313     }
 314
 315     coeff_prec = get_bits(&s->gb, 4) + 1;
 316     if (coeff_prec == 16) {
 317         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 318         return -1;
 319     }
 320     qlevel = get_sbits(&s->gb, 5);
 321     if (qlevel < 0) {
 322         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 323                qlevel);
 324         return -1;
 325     }
 326
 327     for (i = 0; i < pred_order; i++) {
 328         coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
 329     }
 330
 331     if (decode_residuals(s, decoded, pred_order) < 0)
 332         return -1;
 333
 334     s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
 335
 336     return 0;
 337 }
 338
 339 static inline int decode_subframe(FLACContext *s, int channel)
 340 {
 341     int32_t *decoded = s->decoded[channel];
 342     int type, wasted = 0;
 343     int bps = s->bps;
 344     int i, tmp;
 345
 346     if (channel == 0) {
 347         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
 348             bps++;
 349     } else {
 350         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
 351             bps++;
 352     }
 353
 354     if (get_bits1(&s->gb)) {
 355         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 356         return -1;
 357     }
 358     type = get_bits(&s->gb, 6);
 359
 360     if (get_bits1(&s->gb)) {
 361         int left = get_bits_left(&s->gb);
 362         wasted = 1;
 363         if ( left < 0 ||
 364             (left < bps && !show_bits_long(&s->gb, left)) ||
 365                            !show_bits_long(&s->gb, bps)) {
 366             av_log(s->avctx, AV_LOG_ERROR,
 367                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
 368                    bps, left);
 369             return AVERROR_INVALIDDATA;
 370         }
 371         while (!get_bits1(&s->gb))
 372             wasted++;
 373         bps -= wasted;
 374     }
 375     if (bps > 32) {
 376         av_log_missing_feature(s->avctx, "Decorrelated bit depth > 32", 0);
 377         return AVERROR_PATCHWELCOME;
 378     }
 379
 380 //FIXME use av_log2 for types
 381     if (type == 0) {
 382         tmp = get_sbits_long(&s->gb, bps);
 383         for (i = 0; i < s->blocksize; i++)
 384             decoded[i] = tmp;
 385     } else if (type == 1) {
 386         for (i = 0; i < s->blocksize; i++)
 387             decoded[i] = get_sbits_long(&s->gb, bps);
 388     } else if ((type >= 8) && (type <= 12)) {
 389         if (decode_subframe_fixed(s, decoded, type & ~0x8, bps) < 0)
 390             return -1;
 391     } else if (type >= 32) {
 392         if (decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps) < 0)
 393             return -1;
 394     } else {
 395         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 396         return -1;
 397     }
 398
 399     if (wasted) {
 400         int i;
 401         for (i = 0; i < s->blocksize; i++)
 402             decoded[i] <<= wasted;
 403     }
 404
 405     return 0;
 406 }
 407
 408 static int decode_frame(FLACContext *s)
 409 {
 410     int i, ret;
 411     GetBitContext *gb = &s->gb;
 412     FLACFrameInfo fi;
 413
 414     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
 415         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
 416         return -1;
 417     }
 418
 419     if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
 420         s->channels = s->avctx->channels = fi.channels;
 421         ff_flac_set_channel_layout(s->avctx);
 422         ret = allocate_buffers(s);
 423         if (ret < 0)
 424             return ret;
 425     }
 426     s->channels = s->avctx->channels = fi.channels;
 427     ff_flac_set_channel_layout(s->avctx);
 428     s->ch_mode = fi.ch_mode;
 429
 430     if (!s->bps && !fi.bps) {
 431         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 432         return -1;
 433     }
 434     if (!fi.bps) {
 435         fi.bps = s->bps;
 436     } else if (s->bps && fi.bps != s->bps) {
 437         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 438                                        "supported\n");
 439         return -1;
 440     }
 441
 442     if (!s->bps) {
 443         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 444         flac_set_bps(s);
 445     }
 446
 447     if (!s->max_blocksize)
 448         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 449     if (fi.blocksize > s->max_blocksize) {
 450         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
 451                s->max_blocksize);
 452         return -1;
 453     }
 454     s->blocksize = fi.blocksize;
 455
 456     if (!s->samplerate && !fi.samplerate) {
 457         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 458                                         " or frame header\n");
 459         return -1;
 460     }
 461     if (fi.samplerate == 0)
 462         fi.samplerate = s->samplerate;
 463     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 464
 465     if (!s->got_streaminfo) {
 466         ret = allocate_buffers(s);
 467         if (ret < 0)
 468             return ret;
 469         ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
 470         s->got_streaminfo = 1;
 471         dump_headers(s->avctx, (FLACStreaminfo *)s);
 472     }
 473
 474 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
 475
 476     /* subframes */
 477     for (i = 0; i < s->channels; i++) {
 478         if (decode_subframe(s, i) < 0)
 479             return -1;
 480     }
 481
 482     align_get_bits(gb);
 483
 484     /* frame footer */
 485     skip_bits(gb, 16); /* data crc */
 486
 487     return 0;
 488 }
 489
 490 static int flac_decode_frame(AVCodecContext *avctx, void *data,
 491                              int *got_frame_ptr, AVPacket *avpkt)
 492 {
 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     s->frame.nb_samples = s->blocksize;
 532     if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
 533         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 534         return ret;
 535     }
 536
 537     s->dsp.decorrelate[s->ch_mode](s->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     *(AVFrame *)data = s->frame;
 551
 552     return bytes_read;
 553 }
 554
 555 static av_cold int flac_decode_close(AVCodecContext *avctx)
 556 {
 557     FLACContext *s = avctx->priv_data;
 558
 559     av_freep(&s->decoded_buffer);
 560
 561     return 0;
 562 }
 563
 564 AVCodec ff_flac_decoder = {
 565     .name           = "flac",
 566     .type           = AVMEDIA_TYPE_AUDIO,
 567     .id             = AV_CODEC_ID_FLAC,
 568     .priv_data_size = sizeof(FLACContext),
 569     .init           = flac_decode_init,
 570     .close          = flac_decode_close,
 571     .decode         = flac_decode_frame,
 572     .capabilities   = CODEC_CAP_DR1,
 573     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 574     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
 575                                                       AV_SAMPLE_FMT_S16P,
 576                                                       AV_SAMPLE_FMT_S32,
 577                                                       AV_SAMPLE_FMT_S32P,
 578                                                       AV_SAMPLE_FMT_NONE },
 579 };