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 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 "avcodec.h"
  37 #include "internal.h"
  38 #include "get_bits.h"
  39 #include "bytestream.h"
  40 #include "golomb.h"
  41 #include "flac.h"
  42 #include "flacdata.h"
  43 #include "flacdsp.h"
  44
  45 typedef struct FLACContext {
  46     FLACSTREAMINFO
  47
  48     AVCodecContext *avctx;                  ///< parent AVCodecContext
  49     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
  50
  51     int blocksize;                          ///< number of samples in the current frame
  52     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
  53     int ch_mode;                            ///< channel decorrelation type in the current frame
  54     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
  55
  56     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
  57     uint8_t *decoded_buffer;
  58     unsigned int decoded_buffer_size;
  59
  60     FLACDSPContext dsp;
  61 } FLACContext;
  62
  63 static int allocate_buffers(FLACContext *s);
  64
  65 static void flac_set_bps(FLACContext *s)
  66 {
  67     enum AVSampleFormat req = s->avctx->request_sample_fmt;
  68     int need32 = s->bps > 16;
  69     int want32 = av_get_bytes_per_sample(req) > 2;
  70     int planar = av_sample_fmt_is_planar(req);
  71
  72     if (need32 || want32) {
  73         if (planar)
  74             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
  75         else
  76             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
  77         s->sample_shift = 32 - s->bps;
  78     } else {
  79         if (planar)
  80             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  81         else
  82             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
  83         s->sample_shift = 16 - s->bps;
  84     }
  85 }
  86
  87 static av_cold int flac_decode_init(AVCodecContext *avctx)
  88 {
  89     enum FLACExtradataFormat format;
  90     uint8_t *streaminfo;
  91     int ret;
  92     FLACContext *s = avctx->priv_data;
  93     s->avctx = avctx;
  94
  95     /* for now, the raw FLAC header is allowed to be passed to the decoder as
  96        frame data instead of extradata. */
  97     if (!avctx->extradata)
  98         return 0;
  99
 100     if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
 101         return AVERROR_INVALIDDATA;
 102
 103     /* initialize based on the demuxer-supplied streamdata header */
 104     ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
 105     ret = allocate_buffers(s);
 106     if (ret < 0)
 107         return ret;
 108     flac_set_bps(s);
 109     ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
 110     s->got_streaminfo = 1;
 111
 112     return 0;
 113 }
 114
 115 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
 116 {
 117     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
 118     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
 119     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 120     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 121     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
 122 }
 123
 124 static int allocate_buffers(FLACContext *s)
 125 {
 126     int buf_size;
 127
 128     buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
 129                                           AV_SAMPLE_FMT_S32P, 0);
 130     if (buf_size < 0)
 131         return buf_size;
 132
 133     av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
 134     if (!s->decoded_buffer)
 135         return AVERROR(ENOMEM);
 136
 137     return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
 138                                   s->decoded_buffer, s->channels,
 139                                   s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
 140 }
 141
 142 /**
 143  * Parse the STREAMINFO from an inline header.
 144  * @param s the flac decoding context
 145  * @param buf input buffer, starting with the "fLaC" marker
 146  * @param buf_size buffer size
 147  * @return non-zero if metadata is invalid
 148  */
 149 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
 150 {
 151     int metadata_type, metadata_size, ret;
 152
 153     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
 154         /* need more data */
 155         return 0;
 156     }
 157     flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
 158     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
 159         metadata_size != FLAC_STREAMINFO_SIZE) {
 160         return AVERROR_INVALIDDATA;
 161     }
 162     ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
 163     ret = allocate_buffers(s);
 164     if (ret < 0)
 165         return ret;
 166     flac_set_bps(s);
 167     ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
 168     s->got_streaminfo = 1;
 169
 170     return 0;
 171 }
 172
 173 /**
 174  * Determine the size of an inline header.
 175  * @param buf input buffer, starting with the "fLaC" marker
 176  * @param buf_size buffer size
 177  * @return number of bytes in the header, or 0 if more data is needed
 178  */
 179 static int get_metadata_size(const uint8_t *buf, int buf_size)
 180 {
 181     int metadata_last, metadata_size;
 182     const uint8_t *buf_end = buf + buf_size;
 183
 184     buf += 4;
 185     do {
 186         if (buf_end - buf < 4)
 187             return 0;
 188         flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 189         buf += 4;
 190         if (buf_end - buf < metadata_size) {
 191             /* need more data in order to read the complete header */
 192             return 0;
 193         }
 194         buf += metadata_size;
 195     } while (!metadata_last);
 196
 197     return buf_size - (buf_end - buf);
 198 }
 199
 200 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
 201 {
 202     int i, tmp, partition, method_type, rice_order;
 203     int rice_bits, rice_esc;
 204     int samples;
 205
 206     method_type = get_bits(&s->gb, 2);
 207     if (method_type > 1) {
 208         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 209                method_type);
 210         return AVERROR_INVALIDDATA;
 211     }
 212
 213     rice_order = get_bits(&s->gb, 4);
 214
 215     samples= s->blocksize >> rice_order;
 216     if (pred_order > samples) {
 217         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 218                pred_order, samples);
 219         return AVERROR_INVALIDDATA;
 220     }
 221
 222     rice_bits = 4 + method_type;
 223     rice_esc  = (1 << rice_bits) - 1;
 224
 225     decoded += pred_order;
 226     i= pred_order;
 227     for (partition = 0; partition < (1 << rice_order); partition++) {
 228         tmp = get_bits(&s->gb, rice_bits);
 229         if (tmp == rice_esc) {
 230             tmp = get_bits(&s->gb, 5);
 231             for (; i < samples; i++)
 232                 *decoded++ = get_sbits_long(&s->gb, tmp);
 233         } else {
 234             for (; i < samples; i++) {
 235                 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 236             }
 237         }
 238         i= 0;
 239     }
 240
 241     return 0;
 242 }
 243
 244 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
 245                                  int pred_order, int bps)
 246 {
 247     const int blocksize = s->blocksize;
 248     int a, b, c, d, i, ret;
 249
 250     /* warm up samples */
 251     for (i = 0; i < pred_order; i++) {
 252         decoded[i] = get_sbits_long(&s->gb, bps);
 253     }
 254
 255     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 256         return ret;
 257
 258     if (pred_order > 0)
 259         a = decoded[pred_order-1];
 260     if (pred_order > 1)
 261         b = a - decoded[pred_order-2];
 262     if (pred_order > 2)
 263         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 264     if (pred_order > 3)
 265         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 266
 267     switch (pred_order) {
 268     case 0:
 269         break;
 270     case 1:
 271         for (i = pred_order; i < blocksize; i++)
 272             decoded[i] = a += decoded[i];
 273         break;
 274     case 2:
 275         for (i = pred_order; i < blocksize; i++)
 276             decoded[i] = a += b += decoded[i];
 277         break;
 278     case 3:
 279         for (i = pred_order; i < blocksize; i++)
 280             decoded[i] = a += b += c += decoded[i];
 281         break;
 282     case 4:
 283         for (i = pred_order; i < blocksize; i++)
 284             decoded[i] = a += b += c += d += decoded[i];
 285         break;
 286     default:
 287         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 288         return AVERROR_INVALIDDATA;
 289     }
 290
 291     return 0;
 292 }
 293
 294 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
 295                                int bps)
 296 {
 297     int i, ret;
 298     int coeff_prec, qlevel;
 299     int coeffs[32];
 300
 301     /* warm up samples */
 302     for (i = 0; i < pred_order; i++) {
 303         decoded[i] = get_sbits_long(&s->gb, bps);
 304     }
 305
 306     coeff_prec = get_bits(&s->gb, 4) + 1;
 307     if (coeff_prec == 16) {
 308         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 309         return AVERROR_INVALIDDATA;
 310     }
 311     qlevel = get_sbits(&s->gb, 5);
 312     if (qlevel < 0) {
 313         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 314                qlevel);
 315         return AVERROR_INVALIDDATA;
 316     }
 317
 318     for (i = 0; i < pred_order; i++) {
 319         coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
 320     }
 321
 322     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 323         return ret;
 324
 325     s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
 326
 327     return 0;
 328 }
 329
 330 static inline int decode_subframe(FLACContext *s, int channel)
 331 {
 332     int32_t *decoded = s->decoded[channel];
 333     int type, wasted = 0;
 334     int bps = s->bps;
 335     int i, tmp, ret;
 336
 337     if (channel == 0) {
 338         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
 339             bps++;
 340     } else {
 341         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
 342             bps++;
 343     }
 344
 345     if (get_bits1(&s->gb)) {
 346         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 347         return AVERROR_INVALIDDATA;
 348     }
 349     type = get_bits(&s->gb, 6);
 350
 351     if (get_bits1(&s->gb)) {
 352         int left = get_bits_left(&s->gb);
 353         wasted = 1;
 354         if ( left < 0 ||
 355             (left < bps && !show_bits_long(&s->gb, left)) ||
 356                            !show_bits_long(&s->gb, bps)) {
 357             av_log(s->avctx, AV_LOG_ERROR,
 358                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
 359                    bps, left);
 360             return AVERROR_INVALIDDATA;
 361         }
 362         while (!get_bits1(&s->gb))
 363             wasted++;
 364         bps -= wasted;
 365     }
 366     if (bps > 32) {
 367         avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
 368         return AVERROR_PATCHWELCOME;
 369     }
 370
 371 //FIXME use av_log2 for types
 372     if (type == 0) {
 373         tmp = get_sbits_long(&s->gb, bps);
 374         for (i = 0; i < s->blocksize; i++)
 375             decoded[i] = tmp;
 376     } else if (type == 1) {
 377         for (i = 0; i < s->blocksize; i++)
 378             decoded[i] = get_sbits_long(&s->gb, bps);
 379     } else if ((type >= 8) && (type <= 12)) {
 380         if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
 381             return ret;
 382     } else if (type >= 32) {
 383         if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
 384             return ret;
 385     } else {
 386         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 387         return AVERROR_INVALIDDATA;
 388     }
 389
 390     if (wasted) {
 391         int i;
 392         for (i = 0; i < s->blocksize; i++)
 393             decoded[i] <<= wasted;
 394     }
 395
 396     return 0;
 397 }
 398
 399 static int decode_frame(FLACContext *s)
 400 {
 401     int i, ret;
 402     GetBitContext *gb = &s->gb;
 403     FLACFrameInfo fi;
 404
 405     if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
 406         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
 407         return ret;
 408     }
 409
 410     if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
 411         s->channels = s->avctx->channels = fi.channels;
 412         ff_flac_set_channel_layout(s->avctx);
 413         ret = allocate_buffers(s);
 414         if (ret < 0)
 415             return ret;
 416     }
 417     s->channels = s->avctx->channels = fi.channels;
 418     if (!s->avctx->channel_layout)
 419         ff_flac_set_channel_layout(s->avctx);
 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 AVERROR_INVALIDDATA;
 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 AVERROR_INVALIDDATA;
 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 AVERROR_INVALIDDATA;
 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 AVERROR_INVALIDDATA;
 452     }
 453     if (fi.samplerate == 0)
 454         fi.samplerate = s->samplerate;
 455     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 456
 457     if (!s->got_streaminfo) {
 458         ret = allocate_buffers(s);
 459         if (ret < 0)
 460             return ret;
 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 ((ret = decode_subframe(s, i)) < 0)
 471             return ret;
 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     AVFrame *frame     = data;
 486     const uint8_t *buf = avpkt->data;
 487     int buf_size = avpkt->size;
 488     FLACContext *s = avctx->priv_data;
 489     int bytes_read = 0;
 490     int ret;
 491
 492     *got_frame_ptr = 0;
 493
 494     if (s->max_framesize == 0) {
 495         s->max_framesize =
 496             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 497                                        FLAC_MAX_CHANNELS, 32);
 498     }
 499
 500     /* check that there is at least the smallest decodable amount of data.
 501        this amount corresponds to the smallest valid FLAC frame possible.
 502        FF F8 69 02 00 00 9A 00 00 34 46 */
 503     if (buf_size < FLAC_MIN_FRAME_SIZE)
 504         return buf_size;
 505
 506     /* check for inline header */
 507     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 508         if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
 509             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 510             return ret;
 511         }
 512         return get_metadata_size(buf, buf_size);
 513     }
 514
 515     /* decode frame */
 516     init_get_bits(&s->gb, buf, buf_size*8);
 517     if ((ret = decode_frame(s)) < 0) {
 518         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 519         return ret;
 520     }
 521     bytes_read = (get_bits_count(&s->gb)+7)/8;
 522
 523     /* get output buffer */
 524     frame->nb_samples = s->blocksize;
 525     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
 526         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 527         return ret;
 528     }
 529
 530     s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
 531                                    s->blocksize, s->sample_shift);
 532
 533     if (bytes_read > buf_size) {
 534         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 535         return AVERROR_INVALIDDATA;
 536     }
 537     if (bytes_read < buf_size) {
 538         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 539                buf_size - bytes_read, buf_size);
 540     }
 541
 542     *got_frame_ptr = 1;
 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
 551     av_freep(&s->decoded_buffer);
 552
 553     return 0;
 554 }
 555
 556 AVCodec ff_flac_decoder = {
 557     .name           = "flac",
 558     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 559     .type           = AVMEDIA_TYPE_AUDIO,
 560     .id             = AV_CODEC_ID_FLAC,
 561     .priv_data_size = sizeof(FLACContext),
 562     .init           = flac_decode_init,
 563     .close          = flac_decode_close,
 564     .decode         = flac_decode_frame,
 565     .capabilities   = AV_CODEC_CAP_DR1,
 566     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
 567                                                       AV_SAMPLE_FMT_S16P,
 568                                                       AV_SAMPLE_FMT_S32,
 569                                                       AV_SAMPLE_FMT_S32P,
 570                                                       -1 },
 571 };