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 "libavutil/channel_layout.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 typedef struct FLACContext {
  48     FLACSTREAMINFO
  49
  50     AVCodecContext *avctx;                  ///< parent AVCodecContext
  51     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
  52
  53     int blocksize;                          ///< number of samples in the current frame
  54     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
  55     int ch_mode;                            ///< channel decorrelation type in the current frame
  56     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
  57
  58     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
  59     uint8_t *decoded_buffer;
  60     unsigned int decoded_buffer_size;
  61
  62     FLACDSPContext dsp;
  63 } FLACContext;
  64
  65 static int allocate_buffers(FLACContext *s);
  66
  67 static void flac_set_bps(FLACContext *s)
  68 {
  69     enum AVSampleFormat req = s->avctx->request_sample_fmt;
  70     int need32 = s->bps > 16;
  71     int want32 = av_get_bytes_per_sample(req) > 2;
  72     int planar = av_sample_fmt_is_planar(req);
  73
  74     if (need32 || want32) {
  75         if (planar)
  76             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
  77         else
  78             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
  79         s->sample_shift = 32 - s->bps;
  80     } else {
  81         if (planar)
  82             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  83         else
  84             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
  85         s->sample_shift = 16 - s->bps;
  86     }
  87 }
  88
  89 static av_cold int flac_decode_init(AVCodecContext *avctx)
  90 {
  91     enum FLACExtradataFormat format;
  92     uint8_t *streaminfo;
  93     int ret;
  94     FLACContext *s = avctx->priv_data;
  95     s->avctx = avctx;
  96
  97     /* for now, the raw FLAC header is allowed to be passed to the decoder as
  98        frame data instead of extradata. */
  99     if (!avctx->extradata)
 100         return 0;
 101
 102     if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
 103         return -1;
 104
 105     /* initialize based on the demuxer-supplied streamdata header */
 106     avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
 107     ret = allocate_buffers(s);
 108     if (ret < 0)
 109         return ret;
 110     flac_set_bps(s);
 111     ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
 112     s->got_streaminfo = 1;
 113
 114     return 0;
 115 }
 116
 117 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
 118 {
 119     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
 120     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
 121     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 122     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 123     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
 124 }
 125
 126 static int allocate_buffers(FLACContext *s)
 127 {
 128     int buf_size;
 129
 130     buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
 131                                           AV_SAMPLE_FMT_S32P, 0);
 132     if (buf_size < 0)
 133         return buf_size;
 134
 135     av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
 136     if (!s->decoded_buffer)
 137         return AVERROR(ENOMEM);
 138
 139     return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
 140                                   s->decoded_buffer, s->channels,
 141                                   s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
 142 }
 143
 144 /**
 145  * Parse the STREAMINFO from an inline header.
 146  * @param s the flac decoding context
 147  * @param buf input buffer, starting with the "fLaC" marker
 148  * @param buf_size buffer size
 149  * @return non-zero if metadata is invalid
 150  */
 151 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
 152 {
 153     int metadata_type, metadata_size, ret;
 154
 155     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
 156         /* need more data */
 157         return 0;
 158     }
 159     avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
 160     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
 161         metadata_size != FLAC_STREAMINFO_SIZE) {
 162         return AVERROR_INVALIDDATA;
 163     }
 164     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
 165     ret = allocate_buffers(s);
 166     if (ret < 0)
 167         return ret;
 168     flac_set_bps(s);
 169     ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
 170     s->got_streaminfo = 1;
 171
 172     return 0;
 173 }
 174
 175 /**
 176  * Determine the size of an inline header.
 177  * @param buf input buffer, starting with the "fLaC" marker
 178  * @param buf_size buffer size
 179  * @return number of bytes in the header, or 0 if more data is needed
 180  */
 181 static int get_metadata_size(const uint8_t *buf, int buf_size)
 182 {
 183     int metadata_last, metadata_size;
 184     const uint8_t *buf_end = buf + buf_size;
 185
 186     buf += 4;
 187     do {
 188         if (buf_end - buf < 4)
 189             return 0;
 190         avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 191         buf += 4;
 192         if (buf_end - buf < metadata_size) {
 193             /* need more data in order to read the complete header */
 194             return 0;
 195         }
 196         buf += metadata_size;
 197     } while (!metadata_last);
 198
 199     return buf_size - (buf_end - buf);
 200 }
 201
 202 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
 203 {
 204     int i, tmp, partition, method_type, rice_order;
 205     int rice_bits, rice_esc;
 206     int samples;
 207
 208     method_type = get_bits(&s->gb, 2);
 209     if (method_type > 1) {
 210         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 211                method_type);
 212         return -1;
 213     }
 214
 215     rice_order = get_bits(&s->gb, 4);
 216
 217     samples= s->blocksize >> rice_order;
 218     if (pred_order > samples) {
 219         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 220                pred_order, samples);
 221         return -1;
 222     }
 223
 224     rice_bits = 4 + method_type;
 225     rice_esc  = (1 << rice_bits) - 1;
 226
 227     decoded += pred_order;
 228     i= pred_order;
 229     for (partition = 0; partition < (1 << rice_order); partition++) {
 230         tmp = get_bits(&s->gb, rice_bits);
 231         if (tmp == rice_esc) {
 232             tmp = get_bits(&s->gb, 5);
 233             for (; i < samples; i++)
 234                 *decoded++ = get_sbits_long(&s->gb, tmp);
 235         } else {
 236             for (; i < samples; i++) {
 237                 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 238             }
 239         }
 240         i= 0;
 241     }
 242
 243     return 0;
 244 }
 245
 246 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
 247                                  int pred_order, int bps)
 248 {
 249     const int blocksize = s->blocksize;
 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, decoded, 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, int32_t *decoded, int pred_order,
 297                                int bps)
 298 {
 299     int i;
 300     int coeff_prec, qlevel;
 301     int coeffs[32];
 302
 303     /* warm up samples */
 304     for (i = 0; i < pred_order; i++) {
 305         decoded[i] = get_sbits_long(&s->gb, bps);
 306     }
 307
 308     coeff_prec = get_bits(&s->gb, 4) + 1;
 309     if (coeff_prec == 16) {
 310         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 311         return -1;
 312     }
 313     qlevel = get_sbits(&s->gb, 5);
 314     if (qlevel < 0) {
 315         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 316                qlevel);
 317         return -1;
 318     }
 319
 320     for (i = 0; i < pred_order; i++) {
 321         coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
 322     }
 323
 324     if (decode_residuals(s, decoded, pred_order) < 0)
 325         return -1;
 326
 327     s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
 328
 329     return 0;
 330 }
 331
 332 static inline int decode_subframe(FLACContext *s, int channel)
 333 {
 334     int32_t *decoded = s->decoded[channel];
 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         avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
 370         return AVERROR_PATCHWELCOME;
 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             decoded[i] = tmp;
 378     } else if (type == 1) {
 379         for (i = 0; i < s->blocksize; i++)
 380             decoded[i] = get_sbits_long(&s->gb, bps);
 381     } else if ((type >= 8) && (type <= 12)) {
 382         if (decode_subframe_fixed(s, decoded, type & ~0x8, bps) < 0)
 383             return -1;
 384     } else if (type >= 32) {
 385         if (decode_subframe_lpc(s, decoded, (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             decoded[i] <<= wasted;
 396     }
 397
 398     return 0;
 399 }
 400
 401 static int decode_frame(FLACContext *s)
 402 {
 403     int i, ret;
 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 && s->got_streaminfo) {
 413         s->channels = s->avctx->channels = fi.channels;
 414         ff_flac_set_channel_layout(s->avctx);
 415         ret = allocate_buffers(s);
 416         if (ret < 0)
 417             return ret;
 418     }
 419     s->channels = s->avctx->channels = fi.channels;
 420     if (!s->avctx->channel_layout)
 421         ff_flac_set_channel_layout(s->avctx);
 422     s->ch_mode = fi.ch_mode;
 423
 424     if (!s->bps && !fi.bps) {
 425         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 426         return -1;
 427     }
 428     if (!fi.bps) {
 429         fi.bps = s->bps;
 430     } else if (s->bps && fi.bps != s->bps) {
 431         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 432                                        "supported\n");
 433         return -1;
 434     }
 435
 436     if (!s->bps) {
 437         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 438         flac_set_bps(s);
 439     }
 440
 441     if (!s->max_blocksize)
 442         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 443     if (fi.blocksize > s->max_blocksize) {
 444         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
 445                s->max_blocksize);
 446         return -1;
 447     }
 448     s->blocksize = fi.blocksize;
 449
 450     if (!s->samplerate && !fi.samplerate) {
 451         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 452                                         " or frame header\n");
 453         return -1;
 454     }
 455     if (fi.samplerate == 0)
 456         fi.samplerate = s->samplerate;
 457     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 458
 459     if (!s->got_streaminfo) {
 460         ret = allocate_buffers(s);
 461         if (ret < 0)
 462             return ret;
 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     AVFrame *frame     = data;
 488     const uint8_t *buf = avpkt->data;
 489     int buf_size = avpkt->size;
 490     FLACContext *s = avctx->priv_data;
 491     int bytes_read = 0;
 492     int ret;
 493
 494     *got_frame_ptr = 0;
 495
 496     if (s->max_framesize == 0) {
 497         s->max_framesize =
 498             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 499                                        FLAC_MAX_CHANNELS, 32);
 500     }
 501
 502     /* check that there is at least the smallest decodable amount of data.
 503        this amount corresponds to the smallest valid FLAC frame possible.
 504        FF F8 69 02 00 00 9A 00 00 34 46 */
 505     if (buf_size < FLAC_MIN_FRAME_SIZE)
 506         return buf_size;
 507
 508     /* check for inline header */
 509     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 510         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
 511             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 512             return -1;
 513         }
 514         return get_metadata_size(buf, buf_size);
 515     }
 516
 517     /* decode frame */
 518     init_get_bits(&s->gb, buf, buf_size*8);
 519     if (decode_frame(s) < 0) {
 520         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 521         return -1;
 522     }
 523     bytes_read = (get_bits_count(&s->gb)+7)/8;
 524
 525     /* get output buffer */
 526     frame->nb_samples = s->blocksize;
 527     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
 528         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 529         return ret;
 530     }
 531
 532     s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
 533                                    s->blocksize, s->sample_shift);
 534
 535     if (bytes_read > buf_size) {
 536         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 537         return -1;
 538     }
 539     if (bytes_read < buf_size) {
 540         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 541                buf_size - bytes_read, buf_size);
 542     }
 543
 544     *got_frame_ptr = 1;
 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
 553     av_freep(&s->decoded_buffer);
 554
 555     return 0;
 556 }
 557
 558 AVCodec ff_flac_decoder = {
 559     .name           = "flac",
 560     .type           = AVMEDIA_TYPE_AUDIO,
 561     .id             = AV_CODEC_ID_FLAC,
 562     .priv_data_size = sizeof(FLACContext),
 563     .init           = flac_decode_init,
 564     .close          = flac_decode_close,
 565     .decode         = flac_decode_frame,
 566     .capabilities   = CODEC_CAP_DR1,
 567     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 568     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
 569                                                       AV_SAMPLE_FMT_S16P,
 570                                                       AV_SAMPLE_FMT_S32,
 571                                                       AV_SAMPLE_FMT_S32P,
 572                                                       -1 },
 573 };