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/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 avpriv_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 (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
 108         return -1;
 109
 110     /* initialize based on the demuxer-supplied streamdata header */
 111     avpriv_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 avpriv_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 avpriv_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     avpriv_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     avpriv_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         if (buf_end - buf < 4)
 230             return 0;
 231         avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 232         buf += 4;
 233         if (buf_end - buf < metadata_size) {
 234             /* need more data in order to read the complete header */
 235             return 0;
 236         }
 237         buf += metadata_size;
 238     } while (!metadata_last);
 239
 240     return buf_size - (buf_end - buf);
 241 }
 242
 243 static int decode_residuals(FLACContext *s, int channel, int pred_order)
 244 {
 245     int i, tmp, partition, method_type, rice_order;
 246     int sample = 0, samples;
 247
 248     method_type = get_bits(&s->gb, 2);
 249     if (method_type > 1) {
 250         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 251                method_type);
 252         return -1;
 253     }
 254
 255     rice_order = get_bits(&s->gb, 4);
 256
 257     samples= s->blocksize >> rice_order;
 258     if (pred_order > samples) {
 259         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 260                pred_order, samples);
 261         return -1;
 262     }
 263
 264     sample=
 265     i= pred_order;
 266     for (partition = 0; partition < (1 << rice_order); partition++) {
 267         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
 268         if (tmp == (method_type == 0 ? 15 : 31)) {
 269             tmp = get_bits(&s->gb, 5);
 270             for (; i < samples; i++, sample++)
 271                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
 272         } else {
 273             for (; i < samples; i++, sample++) {
 274                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 275             }
 276         }
 277         i= 0;
 278     }
 279
 280     return 0;
 281 }
 282
 283 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
 284 {
 285     const int blocksize = s->blocksize;
 286     int32_t *decoded = s->decoded[channel];
 287     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
 288
 289     /* warm up samples */
 290     for (i = 0; i < pred_order; i++) {
 291         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
 292     }
 293
 294     if (decode_residuals(s, channel, pred_order) < 0)
 295         return -1;
 296
 297     if (pred_order > 0)
 298         a = decoded[pred_order-1];
 299     if (pred_order > 1)
 300         b = a - decoded[pred_order-2];
 301     if (pred_order > 2)
 302         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 303     if (pred_order > 3)
 304         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 305
 306     switch (pred_order) {
 307     case 0:
 308         break;
 309     case 1:
 310         for (i = pred_order; i < blocksize; i++)
 311             decoded[i] = a += decoded[i];
 312         break;
 313     case 2:
 314         for (i = pred_order; i < blocksize; i++)
 315             decoded[i] = a += b += decoded[i];
 316         break;
 317     case 3:
 318         for (i = pred_order; i < blocksize; i++)
 319             decoded[i] = a += b += c += decoded[i];
 320         break;
 321     case 4:
 322         for (i = pred_order; i < blocksize; i++)
 323             decoded[i] = a += b += c += d += decoded[i];
 324         break;
 325     default:
 326         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 327         return -1;
 328     }
 329
 330     return 0;
 331 }
 332
 333 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
 334 {
 335     int i, j;
 336     int coeff_prec, qlevel;
 337     int coeffs[32];
 338     int32_t *decoded = s->decoded[channel];
 339
 340     /* warm up samples */
 341     for (i = 0; i < pred_order; i++) {
 342         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
 343     }
 344
 345     coeff_prec = get_bits(&s->gb, 4) + 1;
 346     if (coeff_prec == 16) {
 347         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 348         return -1;
 349     }
 350     qlevel = get_sbits(&s->gb, 5);
 351     if (qlevel < 0) {
 352         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 353                qlevel);
 354         return -1;
 355     }
 356
 357     for (i = 0; i < pred_order; i++) {
 358         coeffs[i] = get_sbits(&s->gb, coeff_prec);
 359     }
 360
 361     if (decode_residuals(s, channel, pred_order) < 0)
 362         return -1;
 363
 364     if (s->bps > 16) {
 365         int64_t sum;
 366         for (i = pred_order; i < s->blocksize; i++) {
 367             sum = 0;
 368             for (j = 0; j < pred_order; j++)
 369                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
 370             decoded[i] += sum >> qlevel;
 371         }
 372     } else {
 373         for (i = pred_order; i < s->blocksize-1; i += 2) {
 374             int c;
 375             int d = decoded[i-pred_order];
 376             int s0 = 0, s1 = 0;
 377             for (j = pred_order-1; j > 0; j--) {
 378                 c = coeffs[j];
 379                 s0 += c*d;
 380                 d = decoded[i-j];
 381                 s1 += c*d;
 382             }
 383             c = coeffs[0];
 384             s0 += c*d;
 385             d = decoded[i] += s0 >> qlevel;
 386             s1 += c*d;
 387             decoded[i+1] += s1 >> qlevel;
 388         }
 389         if (i < s->blocksize) {
 390             int sum = 0;
 391             for (j = 0; j < pred_order; j++)
 392                 sum += coeffs[j] * decoded[i-j-1];
 393             decoded[i] += sum >> qlevel;
 394         }
 395     }
 396
 397     return 0;
 398 }
 399
 400 static inline int decode_subframe(FLACContext *s, int channel)
 401 {
 402     int type, wasted = 0;
 403     int i, tmp;
 404
 405     s->curr_bps = s->bps;
 406     if (channel == 0) {
 407         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
 408             s->curr_bps++;
 409     } else {
 410         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
 411             s->curr_bps++;
 412     }
 413
 414     if (get_bits1(&s->gb)) {
 415         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 416         return -1;
 417     }
 418     type = get_bits(&s->gb, 6);
 419
 420     if (get_bits1(&s->gb)) {
 421         wasted = 1;
 422         while (!get_bits1(&s->gb))
 423             wasted++;
 424         s->curr_bps -= wasted;
 425     }
 426     if (s->curr_bps > 32) {
 427         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
 428         return -1;
 429     }
 430
 431 //FIXME use av_log2 for types
 432     if (type == 0) {
 433         tmp = get_sbits_long(&s->gb, s->curr_bps);
 434         for (i = 0; i < s->blocksize; i++)
 435             s->decoded[channel][i] = tmp;
 436     } else if (type == 1) {
 437         for (i = 0; i < s->blocksize; i++)
 438             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
 439     } else if ((type >= 8) && (type <= 12)) {
 440         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
 441             return -1;
 442     } else if (type >= 32) {
 443         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
 444             return -1;
 445     } else {
 446         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 447         return -1;
 448     }
 449
 450     if (wasted) {
 451         int i;
 452         for (i = 0; i < s->blocksize; i++)
 453             s->decoded[channel][i] <<= wasted;
 454     }
 455
 456     return 0;
 457 }
 458
 459 static int decode_frame(FLACContext *s)
 460 {
 461     int i;
 462     GetBitContext *gb = &s->gb;
 463     FLACFrameInfo fi;
 464
 465     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
 466         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
 467         return -1;
 468     }
 469
 470     if (s->channels && fi.channels != s->channels) {
 471         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
 472                                        "is not supported\n");
 473         return -1;
 474     }
 475     s->channels = s->avctx->channels = fi.channels;
 476     s->ch_mode = fi.ch_mode;
 477
 478     if (!s->bps && !fi.bps) {
 479         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 480         return -1;
 481     }
 482     if (!fi.bps) {
 483         fi.bps = s->bps;
 484     } else if (s->bps && fi.bps != s->bps) {
 485         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 486                                        "supported\n");
 487         return -1;
 488     }
 489     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 490
 491     if (s->bps > 16) {
 492         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 493         s->sample_shift = 32 - s->bps;
 494         s->is32 = 1;
 495     } else {
 496         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 497         s->sample_shift = 16 - s->bps;
 498         s->is32 = 0;
 499     }
 500
 501     if (!s->max_blocksize)
 502         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 503     if (fi.blocksize > s->max_blocksize) {
 504         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
 505                s->max_blocksize);
 506         return -1;
 507     }
 508     s->blocksize = fi.blocksize;
 509
 510     if (!s->samplerate && !fi.samplerate) {
 511         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 512                                         " or frame header\n");
 513         return -1;
 514     }
 515     if (fi.samplerate == 0) {
 516         fi.samplerate = s->samplerate;
 517     } else if (s->samplerate && fi.samplerate != s->samplerate) {
 518         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
 519                s->samplerate, fi.samplerate);
 520     }
 521     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 522
 523     if (!s->got_streaminfo) {
 524         allocate_buffers(s);
 525         s->got_streaminfo = 1;
 526         dump_headers(s->avctx, (FLACStreaminfo *)s);
 527     }
 528
 529 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
 530
 531     /* subframes */
 532     for (i = 0; i < s->channels; i++) {
 533         if (decode_subframe(s, i) < 0)
 534             return -1;
 535     }
 536
 537     align_get_bits(gb);
 538
 539     /* frame footer */
 540     skip_bits(gb, 16); /* data crc */
 541
 542     return 0;
 543 }
 544
 545 static int flac_decode_frame(AVCodecContext *avctx,
 546                             void *data, int *data_size,
 547                             AVPacket *avpkt)
 548 {
 549     const uint8_t *buf = avpkt->data;
 550     int buf_size = avpkt->size;
 551     FLACContext *s = avctx->priv_data;
 552     int i, j = 0, bytes_read = 0;
 553     int16_t *samples_16 = data;
 554     int32_t *samples_32 = data;
 555     int alloc_data_size= *data_size;
 556     int output_size;
 557
 558     *data_size=0;
 559
 560     if (s->max_framesize == 0) {
 561         s->max_framesize =
 562             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 563                                        FLAC_MAX_CHANNELS, 32);
 564     }
 565
 566     /* check that there is at least the smallest decodable amount of data.
 567        this amount corresponds to the smallest valid FLAC frame possible.
 568        FF F8 69 02 00 00 9A 00 00 34 46 */
 569     if (buf_size < FLAC_MIN_FRAME_SIZE)
 570         return buf_size;
 571
 572     /* check for inline header */
 573     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 574         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
 575             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 576             return -1;
 577         }
 578         return get_metadata_size(buf, buf_size);
 579     }
 580
 581     /* decode frame */
 582     init_get_bits(&s->gb, buf, buf_size*8);
 583     if (decode_frame(s) < 0) {
 584         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 585         return -1;
 586     }
 587     bytes_read = (get_bits_count(&s->gb)+7)/8;
 588
 589     /* check if allocated data size is large enough for output */
 590     output_size = s->blocksize * s->channels *
 591                   av_get_bytes_per_sample(avctx->sample_fmt);
 592     if (output_size > alloc_data_size) {
 593         av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
 594                                        "allocated data size\n");
 595         return -1;
 596     }
 597     *data_size = output_size;
 598
 599 #define DECORRELATE(left, right)\
 600             assert(s->channels == 2);\
 601             for (i = 0; i < s->blocksize; i++) {\
 602                 int a= s->decoded[0][i];\
 603                 int b= s->decoded[1][i];\
 604                 if (s->is32) {\
 605                     *samples_32++ = (left)  << s->sample_shift;\
 606                     *samples_32++ = (right) << s->sample_shift;\
 607                 } else {\
 608                     *samples_16++ = (left)  << s->sample_shift;\
 609                     *samples_16++ = (right) << s->sample_shift;\
 610                 }\
 611             }\
 612             break;
 613
 614     switch (s->ch_mode) {
 615     case FLAC_CHMODE_INDEPENDENT:
 616         for (j = 0; j < s->blocksize; j++) {
 617             for (i = 0; i < s->channels; i++) {
 618                 if (s->is32)
 619                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
 620                 else
 621                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
 622             }
 623         }
 624         break;
 625     case FLAC_CHMODE_LEFT_SIDE:
 626         DECORRELATE(a,a-b)
 627     case FLAC_CHMODE_RIGHT_SIDE:
 628         DECORRELATE(a+b,b)
 629     case FLAC_CHMODE_MID_SIDE:
 630         DECORRELATE( (a-=b>>1) + b, a)
 631     }
 632
 633     if (bytes_read > buf_size) {
 634         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 635         return -1;
 636     }
 637     if (bytes_read < buf_size) {
 638         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 639                buf_size - bytes_read, buf_size);
 640     }
 641
 642     return bytes_read;
 643 }
 644
 645 static av_cold int flac_decode_close(AVCodecContext *avctx)
 646 {
 647     FLACContext *s = avctx->priv_data;
 648     int i;
 649
 650     for (i = 0; i < s->channels; i++) {
 651         av_freep(&s->decoded[i]);
 652     }
 653
 654     return 0;
 655 }
 656
 657 AVCodec ff_flac_decoder = {
 658     .name           = "flac",
 659     .type           = AVMEDIA_TYPE_AUDIO,
 660     .id             = CODEC_ID_FLAC,
 661     .priv_data_size = sizeof(FLACContext),
 662     .init           = flac_decode_init,
 663     .close          = flac_decode_close,
 664     .decode         = flac_decode_frame,
 665     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 666 };