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/crc.h"
  37 #include "avcodec.h"
  38 #include "internal.h"
  39 #include "get_bits.h"
  40 #include "bytestream.h"
  41 #include "golomb.h"
  42 #include "flac.h"
  43 #include "flacdata.h"
  44
  45 #undef NDEBUG
  46 #include <assert.h>
  47
  48 typedef struct FLACContext {
  49     FLACSTREAMINFO
  50
  51     AVCodecContext *avctx;                  ///< parent AVCodecContext
  52     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
  53
  54     int blocksize;                          ///< number of samples in the current frame
  55     int curr_bps;                           ///< bps for current subframe, adjusted for channel correlation and wasted bits
  56     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
  57     int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
  58     int ch_mode;                            ///< channel decorrelation type in the current frame
  59     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
  60
  61     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
  62 } FLACContext;
  63
  64 static void allocate_buffers(FLACContext *s);
  65
  66 int ff_flac_is_extradata_valid(AVCodecContext *avctx,
  67                                enum FLACExtradataFormat *format,
  68                                uint8_t **streaminfo_start)
  69 {
  70     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
  71         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
  72         return 0;
  73     }
  74     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
  75         /* extradata contains STREAMINFO only */
  76         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
  77             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
  78                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
  79         }
  80         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
  81         *streaminfo_start = avctx->extradata;
  82     } else {
  83         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
  84             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
  85             return 0;
  86         }
  87         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
  88         *streaminfo_start = &avctx->extradata[8];
  89     }
  90     return 1;
  91 }
  92
  93 static av_cold int flac_decode_init(AVCodecContext *avctx)
  94 {
  95     enum FLACExtradataFormat format;
  96     uint8_t *streaminfo;
  97     FLACContext *s = avctx->priv_data;
  98     s->avctx = avctx;
  99
 100     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 101
 102     /* for now, the raw FLAC header is allowed to be passed to the decoder as
 103        frame data instead of extradata. */
 104     if (!avctx->extradata)
 105         return 0;
 106
 107     if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
 108         return -1;
 109
 110     /* initialize based on the demuxer-supplied streamdata header */
 111     ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
 112     if (s->bps > 16)
 113         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 114     else
 115         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 116     allocate_buffers(s);
 117     s->got_streaminfo = 1;
 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 void allocate_buffers(FLACContext *s)
 132 {
 133     int i;
 134
 135     assert(s->max_blocksize);
 136
 137     for (i = 0; i < s->channels; i++) {
 138         s->decoded[i] = av_realloc(s->decoded[i],
 139                                    sizeof(int32_t)*s->max_blocksize);
 140     }
 141 }
 142
 143 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
 144                               const uint8_t *buffer)
 145 {
 146     GetBitContext gb;
 147     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
 148
 149     skip_bits(&gb, 16); /* skip min blocksize */
 150     s->max_blocksize = get_bits(&gb, 16);
 151     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
 152         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
 153                s->max_blocksize);
 154         s->max_blocksize = 16;
 155     }
 156
 157     skip_bits(&gb, 24); /* skip min frame size */
 158     s->max_framesize = get_bits_long(&gb, 24);
 159
 160     s->samplerate = get_bits_long(&gb, 20);
 161     s->channels = get_bits(&gb, 3) + 1;
 162     s->bps = get_bits(&gb, 5) + 1;
 163
 164     avctx->channels = s->channels;
 165     avctx->sample_rate = s->samplerate;
 166     avctx->bits_per_raw_sample = s->bps;
 167
 168     s->samples  = get_bits_long(&gb, 32) << 4;
 169     s->samples |= get_bits(&gb, 4);
 170
 171     skip_bits_long(&gb, 64); /* md5 sum */
 172     skip_bits_long(&gb, 64); /* md5 sum */
 173
 174     dump_headers(avctx, s);
 175 }
 176
 177 void ff_flac_parse_block_header(const uint8_t *block_header,
 178                                 int *last, int *type, int *size)
 179 {
 180     int tmp = bytestream_get_byte(&block_header);
 181     if (last)
 182         *last = tmp & 0x80;
 183     if (type)
 184         *type = tmp & 0x7F;
 185     if (size)
 186         *size = bytestream_get_be24(&block_header);
 187 }
 188
 189 /**
 190  * Parse the STREAMINFO from an inline header.
 191  * @param s the flac decoding context
 192  * @param buf input buffer, starting with the "fLaC" marker
 193  * @param buf_size buffer size
 194  * @return non-zero if metadata is invalid
 195  */
 196 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
 197 {
 198     int metadata_type, metadata_size;
 199
 200     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
 201         /* need more data */
 202         return 0;
 203     }
 204     ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
 205     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
 206         metadata_size != FLAC_STREAMINFO_SIZE) {
 207         return AVERROR_INVALIDDATA;
 208     }
 209     ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
 210     allocate_buffers(s);
 211     s->got_streaminfo = 1;
 212
 213     return 0;
 214 }
 215
 216 /**
 217  * Determine the size of an inline header.
 218  * @param buf input buffer, starting with the "fLaC" marker
 219  * @param buf_size buffer size
 220  * @return number of bytes in the header, or 0 if more data is needed
 221  */
 222 static int get_metadata_size(const uint8_t *buf, int buf_size)
 223 {
 224     int metadata_last, metadata_size;
 225     const uint8_t *buf_end = buf + buf_size;
 226
 227     buf += 4;
 228     do {
 229         ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 230         buf += 4;
 231         if (buf + metadata_size > buf_end) {
 232             /* need more data in order to read the complete header */
 233             return 0;
 234         }
 235         buf += metadata_size;
 236     } while (!metadata_last);
 237
 238     return buf_size - (buf_end - buf);
 239 }
 240
 241 static int decode_residuals(FLACContext *s, int channel, int pred_order)
 242 {
 243     int i, tmp, partition, method_type, rice_order;
 244     int sample = 0, samples;
 245
 246     method_type = get_bits(&s->gb, 2);
 247     if (method_type > 1) {
 248         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 249                method_type);
 250         return -1;
 251     }
 252
 253     rice_order = get_bits(&s->gb, 4);
 254
 255     samples= s->blocksize >> rice_order;
 256     if (pred_order > samples) {
 257         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 258                pred_order, samples);
 259         return -1;
 260     }
 261
 262     sample=
 263     i= pred_order;
 264     for (partition = 0; partition < (1 << rice_order); partition++) {
 265         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
 266         if (tmp == (method_type == 0 ? 15 : 31)) {
 267             tmp = get_bits(&s->gb, 5);
 268             for (; i < samples; i++, sample++)
 269                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
 270         } else {
 271             for (; i < samples; i++, sample++) {
 272                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 273             }
 274         }
 275         i= 0;
 276     }
 277
 278     return 0;
 279 }
 280
 281 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
 282 {
 283     const int blocksize = s->blocksize;
 284     int32_t *decoded = s->decoded[channel];
 285     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
 286
 287     /* warm up samples */
 288     for (i = 0; i < pred_order; i++) {
 289         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
 290     }
 291
 292     if (decode_residuals(s, channel, pred_order) < 0)
 293         return -1;
 294
 295     if (pred_order > 0)
 296         a = decoded[pred_order-1];
 297     if (pred_order > 1)
 298         b = a - decoded[pred_order-2];
 299     if (pred_order > 2)
 300         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 301     if (pred_order > 3)
 302         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 303
 304     switch (pred_order) {
 305     case 0:
 306         break;
 307     case 1:
 308         for (i = pred_order; i < blocksize; i++)
 309             decoded[i] = a += decoded[i];
 310         break;
 311     case 2:
 312         for (i = pred_order; i < blocksize; i++)
 313             decoded[i] = a += b += decoded[i];
 314         break;
 315     case 3:
 316         for (i = pred_order; i < blocksize; i++)
 317             decoded[i] = a += b += c += decoded[i];
 318         break;
 319     case 4:
 320         for (i = pred_order; i < blocksize; i++)
 321             decoded[i] = a += b += c += d += decoded[i];
 322         break;
 323     default:
 324         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 325         return -1;
 326     }
 327
 328     return 0;
 329 }
 330
 331 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
 332 {
 333     int i, j;
 334     int coeff_prec, qlevel;
 335     int coeffs[32];
 336     int32_t *decoded = s->decoded[channel];
 337
 338     /* warm up samples */
 339     for (i = 0; i < pred_order; i++) {
 340         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
 341     }
 342
 343     coeff_prec = get_bits(&s->gb, 4) + 1;
 344     if (coeff_prec == 16) {
 345         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 346         return -1;
 347     }
 348     qlevel = get_sbits(&s->gb, 5);
 349     if (qlevel < 0) {
 350         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 351                qlevel);
 352         return -1;
 353     }
 354
 355     for (i = 0; i < pred_order; i++) {
 356         coeffs[i] = get_sbits(&s->gb, coeff_prec);
 357     }
 358
 359     if (decode_residuals(s, channel, pred_order) < 0)
 360         return -1;
 361
 362     if (s->bps > 16) {
 363         int64_t sum;
 364         for (i = pred_order; i < s->blocksize; i++) {
 365             sum = 0;
 366             for (j = 0; j < pred_order; j++)
 367                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
 368             decoded[i] += sum >> qlevel;
 369         }
 370     } else {
 371         for (i = pred_order; i < s->blocksize-1; i += 2) {
 372             int c;
 373             int d = decoded[i-pred_order];
 374             int s0 = 0, s1 = 0;
 375             for (j = pred_order-1; j > 0; j--) {
 376                 c = coeffs[j];
 377                 s0 += c*d;
 378                 d = decoded[i-j];
 379                 s1 += c*d;
 380             }
 381             c = coeffs[0];
 382             s0 += c*d;
 383             d = decoded[i] += s0 >> qlevel;
 384             s1 += c*d;
 385             decoded[i+1] += s1 >> qlevel;
 386         }
 387         if (i < s->blocksize) {
 388             int sum = 0;
 389             for (j = 0; j < pred_order; j++)
 390                 sum += coeffs[j] * decoded[i-j-1];
 391             decoded[i] += sum >> qlevel;
 392         }
 393     }
 394
 395     return 0;
 396 }
 397
 398 static inline int decode_subframe(FLACContext *s, int channel)
 399 {
 400     int type, wasted = 0;
 401     int i, tmp;
 402
 403     s->curr_bps = s->bps;
 404     if (channel == 0) {
 405         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
 406             s->curr_bps++;
 407     } else {
 408         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
 409             s->curr_bps++;
 410     }
 411
 412     if (get_bits1(&s->gb)) {
 413         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 414         return -1;
 415     }
 416     type = get_bits(&s->gb, 6);
 417
 418     if (get_bits1(&s->gb)) {
 419         wasted = 1;
 420         while (!get_bits1(&s->gb))
 421             wasted++;
 422         s->curr_bps -= wasted;
 423     }
 424     if (s->curr_bps > 32) {
 425         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
 426         return -1;
 427     }
 428
 429 //FIXME use av_log2 for types
 430     if (type == 0) {
 431         tmp = get_sbits_long(&s->gb, s->curr_bps);
 432         for (i = 0; i < s->blocksize; i++)
 433             s->decoded[channel][i] = tmp;
 434     } else if (type == 1) {
 435         for (i = 0; i < s->blocksize; i++)
 436             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
 437     } else if ((type >= 8) && (type <= 12)) {
 438         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
 439             return -1;
 440     } else if (type >= 32) {
 441         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
 442             return -1;
 443     } else {
 444         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 445         return -1;
 446     }
 447
 448     if (wasted) {
 449         int i;
 450         for (i = 0; i < s->blocksize; i++)
 451             s->decoded[channel][i] <<= wasted;
 452     }
 453
 454     return 0;
 455 }
 456
 457 static int decode_frame(FLACContext *s)
 458 {
 459     int i;
 460     GetBitContext *gb = &s->gb;
 461     FLACFrameInfo fi;
 462
 463     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
 464         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
 465         return -1;
 466     }
 467
 468     if (s->channels && fi.channels != s->channels) {
 469         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
 470                                        "is not supported\n");
 471         return -1;
 472     }
 473     s->channels = s->avctx->channels = fi.channels;
 474     s->ch_mode = fi.ch_mode;
 475
 476     if (!s->bps && !fi.bps) {
 477         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 478         return -1;
 479     }
 480     if (!fi.bps) {
 481         fi.bps = s->bps;
 482     } else if (s->bps && fi.bps != s->bps) {
 483         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 484                                        "supported\n");
 485         return -1;
 486     }
 487     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 488
 489     if (s->bps > 16) {
 490         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 491         s->sample_shift = 32 - s->bps;
 492         s->is32 = 1;
 493     } else {
 494         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 495         s->sample_shift = 16 - s->bps;
 496         s->is32 = 0;
 497     }
 498
 499     if (!s->max_blocksize)
 500         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 501     if (fi.blocksize > s->max_blocksize) {
 502         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
 503                s->max_blocksize);
 504         return -1;
 505     }
 506     s->blocksize = fi.blocksize;
 507
 508     if (!s->samplerate && !fi.samplerate) {
 509         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 510                                         " or frame header\n");
 511         return -1;
 512     }
 513     if (fi.samplerate == 0) {
 514         fi.samplerate = s->samplerate;
 515     } else if (s->samplerate && fi.samplerate != s->samplerate) {
 516         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
 517                s->samplerate, fi.samplerate);
 518     }
 519     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 520
 521     if (!s->got_streaminfo) {
 522         allocate_buffers(s);
 523         s->got_streaminfo = 1;
 524         dump_headers(s->avctx, (FLACStreaminfo *)s);
 525     }
 526
 527 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
 528
 529     /* subframes */
 530     for (i = 0; i < s->channels; i++) {
 531         if (decode_subframe(s, i) < 0)
 532             return -1;
 533     }
 534
 535     align_get_bits(gb);
 536
 537     /* frame footer */
 538     skip_bits(gb, 16); /* data crc */
 539
 540     return 0;
 541 }
 542
 543 static int flac_decode_frame(AVCodecContext *avctx,
 544                             void *data, int *data_size,
 545                             AVPacket *avpkt)
 546 {
 547     const uint8_t *buf = avpkt->data;
 548     int buf_size = avpkt->size;
 549     FLACContext *s = avctx->priv_data;
 550     int i, j = 0, bytes_read = 0;
 551     int16_t *samples_16 = data;
 552     int32_t *samples_32 = data;
 553     int alloc_data_size= *data_size;
 554     int output_size;
 555
 556     *data_size=0;
 557
 558     if (s->max_framesize == 0) {
 559         s->max_framesize =
 560             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 561                                        FLAC_MAX_CHANNELS, 32);
 562     }
 563
 564     /* check that there is at least the smallest decodable amount of data.
 565        this amount corresponds to the smallest valid FLAC frame possible.
 566        FF F8 69 02 00 00 9A 00 00 34 46 */
 567     if (buf_size < FLAC_MIN_FRAME_SIZE)
 568         return buf_size;
 569
 570     /* check for inline header */
 571     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 572         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
 573             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 574             return -1;
 575         }
 576         return get_metadata_size(buf, buf_size);
 577     }
 578
 579     /* decode frame */
 580     init_get_bits(&s->gb, buf, buf_size*8);
 581     if (decode_frame(s) < 0) {
 582         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 583         return -1;
 584     }
 585     bytes_read = (get_bits_count(&s->gb)+7)/8;
 586
 587     /* check if allocated data size is large enough for output */
 588     output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
 589     if (output_size > alloc_data_size) {
 590         av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
 591                                        "allocated data size\n");
 592         return -1;
 593     }
 594     *data_size = output_size;
 595
 596 #define DECORRELATE(left, right)\
 597             assert(s->channels == 2);\
 598             for (i = 0; i < s->blocksize; i++) {\
 599                 int a= s->decoded[0][i];\
 600                 int b= s->decoded[1][i];\
 601                 if (s->is32) {\
 602                     *samples_32++ = (left)  << s->sample_shift;\
 603                     *samples_32++ = (right) << s->sample_shift;\
 604                 } else {\
 605                     *samples_16++ = (left)  << s->sample_shift;\
 606                     *samples_16++ = (right) << s->sample_shift;\
 607                 }\
 608             }\
 609             break;
 610
 611     switch (s->ch_mode) {
 612     case FLAC_CHMODE_INDEPENDENT:
 613         for (j = 0; j < s->blocksize; j++) {
 614             for (i = 0; i < s->channels; i++) {
 615                 if (s->is32)
 616                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
 617                 else
 618                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
 619             }
 620         }
 621         break;
 622     case FLAC_CHMODE_LEFT_SIDE:
 623         DECORRELATE(a,a-b)
 624     case FLAC_CHMODE_RIGHT_SIDE:
 625         DECORRELATE(a+b,b)
 626     case FLAC_CHMODE_MID_SIDE:
 627         DECORRELATE( (a-=b>>1) + b, a)
 628     }
 629
 630     if (bytes_read > buf_size) {
 631         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 632         return -1;
 633     }
 634     if (bytes_read < buf_size) {
 635         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 636                buf_size - bytes_read, buf_size);
 637     }
 638
 639     return bytes_read;
 640 }
 641
 642 static av_cold int flac_decode_close(AVCodecContext *avctx)
 643 {
 644     FLACContext *s = avctx->priv_data;
 645     int i;
 646
 647     for (i = 0; i < s->channels; i++) {
 648         av_freep(&s->decoded[i]);
 649     }
 650
 651     return 0;
 652 }
 653
 654 AVCodec ff_flac_decoder = {
 655     .name           = "flac",
 656     .type           = AVMEDIA_TYPE_AUDIO,
 657     .id             = CODEC_ID_FLAC,
 658     .priv_data_size = sizeof(FLACContext),
 659     .init           = flac_decode_init,
 660     .close          = flac_decode_close,
 661     .decode         = flac_decode_frame,
 662     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 663 };