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     if (!s->avctx->channel_layout && s->channels <= 6)
 428         ff_flac_set_channel_layout(s->avctx);
 429     s->ch_mode = fi.ch_mode;
 430
 431     if (!s->bps && !fi.bps) {
 432         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 433         return -1;
 434     }
 435     if (!fi.bps) {
 436         fi.bps = s->bps;
 437     } else if (s->bps && fi.bps != s->bps) {
 438         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 439                                        "supported\n");
 440         return -1;
 441     }
 442
 443     if (!s->bps) {
 444         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 445         flac_set_bps(s);
 446     }
 447
 448     if (!s->max_blocksize)
 449         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 450     if (fi.blocksize > s->max_blocksize) {
 451         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
 452                s->max_blocksize);
 453         return -1;
 454     }
 455     s->blocksize = fi.blocksize;
 456
 457     if (!s->samplerate && !fi.samplerate) {
 458         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 459                                         " or frame header\n");
 460         return -1;
 461     }
 462     if (fi.samplerate == 0)
 463         fi.samplerate = s->samplerate;
 464     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 465
 466     if (!s->got_streaminfo) {
 467         ret = allocate_buffers(s);
 468         if (ret < 0)
 469             return ret;
 470         ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
 471         s->got_streaminfo = 1;
 472         dump_headers(s->avctx, (FLACStreaminfo *)s);
 473     }
 474
 475 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
 476
 477     /* subframes */
 478     for (i = 0; i < s->channels; i++) {
 479         if (decode_subframe(s, i) < 0)
 480             return -1;
 481     }
 482
 483     align_get_bits(gb);
 484
 485     /* frame footer */
 486     skip_bits(gb, 16); /* data crc */
 487
 488     return 0;
 489 }
 490
 491 static int flac_decode_frame(AVCodecContext *avctx, void *data,
 492                              int *got_frame_ptr, AVPacket *avpkt)
 493 {
 494     const uint8_t *buf = avpkt->data;
 495     int buf_size = avpkt->size;
 496     FLACContext *s = avctx->priv_data;
 497     int bytes_read = 0;
 498     int ret;
 499
 500     *got_frame_ptr = 0;
 501
 502     if (s->max_framesize == 0) {
 503         s->max_framesize =
 504             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 505                                        FLAC_MAX_CHANNELS, 32);
 506     }
 507
 508     /* check that there is at least the smallest decodable amount of data.
 509        this amount corresponds to the smallest valid FLAC frame possible.
 510        FF F8 69 02 00 00 9A 00 00 34 46 */
 511     if (buf_size < FLAC_MIN_FRAME_SIZE)
 512         return buf_size;
 513
 514     /* check for inline header */
 515     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 516         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
 517             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 518             return -1;
 519         }
 520         return get_metadata_size(buf, buf_size);
 521     }
 522
 523     /* decode frame */
 524     init_get_bits(&s->gb, buf, buf_size*8);
 525     if (decode_frame(s) < 0) {
 526         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 527         return -1;
 528     }
 529     bytes_read = (get_bits_count(&s->gb)+7)/8;
 530
 531     /* get output buffer */
 532     s->frame.nb_samples = s->blocksize;
 533     if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
 534         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 535         return ret;
 536     }
 537
 538     s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
 539                                    s->blocksize, s->sample_shift);
 540
 541     if (bytes_read > buf_size) {
 542         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 543         return -1;
 544     }
 545     if (bytes_read < buf_size) {
 546         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 547                buf_size - bytes_read, buf_size);
 548     }
 549
 550     *got_frame_ptr   = 1;
 551     *(AVFrame *)data = s->frame;
 552
 553     return bytes_read;
 554 }
 555
 556 static av_cold int flac_decode_close(AVCodecContext *avctx)
 557 {
 558     FLACContext *s = avctx->priv_data;
 559
 560     av_freep(&s->decoded_buffer);
 561
 562     return 0;
 563 }
 564
 565 AVCodec ff_flac_decoder = {
 566     .name           = "flac",
 567     .type           = AVMEDIA_TYPE_AUDIO,
 568     .id             = AV_CODEC_ID_FLAC,
 569     .priv_data_size = sizeof(FLACContext),
 570     .init           = flac_decode_init,
 571     .close          = flac_decode_close,
 572     .decode         = flac_decode_frame,
 573     .capabilities   = CODEC_CAP_DR1,
 574     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 575     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
 576                                                       AV_SAMPLE_FMT_S16P,
 577                                                       AV_SAMPLE_FMT_S32,
 578                                                       AV_SAMPLE_FMT_S32P,
 579                                                       AV_SAMPLE_FMT_NONE },
 580 };