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  *
  27  * For more information on the FLAC format, visit:
  28  *  http://flac.sourceforge.net/
  29  *
  30  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
  31  * through, starting from the initial 'fLaC' signature; or by passing the
  32  * 34-byte streaminfo structure through avctx->extradata[_size] followed
  33  * by data starting with the 0xFFF8 marker.
  34  */
  35
  36 #include <limits.h>
  37
  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
  47 #undef NDEBUG
  48 #include <assert.h>
  49
  50 typedef struct FLACContext {
  51     FLACSTREAMINFO
  52
  53     AVCodecContext *avctx;                  ///< parent AVCodecContext
  54     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
  55
  56     int blocksize;                          ///< number of samples in the current frame
  57     int curr_bps;                           ///< bps for current subframe, adjusted for channel correlation and wasted bits
  58     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
  59     int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
  60     int ch_mode;                            ///< channel decorrelation type in the current frame
  61     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
  62
  63     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
  64 } FLACContext;
  65
  66 static void allocate_buffers(FLACContext *s);
  67
  68 int ff_flac_is_extradata_valid(AVCodecContext *avctx,
  69                                enum FLACExtradataFormat *format,
  70                                uint8_t **streaminfo_start)
  71 {
  72     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
  73         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
  74         return 0;
  75     }
  76     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
  77         /* extradata contains STREAMINFO only */
  78         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
  79             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
  80                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
  81         }
  82         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
  83         *streaminfo_start = avctx->extradata;
  84     } else {
  85         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
  86             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
  87             return 0;
  88         }
  89         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
  90         *streaminfo_start = &avctx->extradata[8];
  91     }
  92     return 1;
  93 }
  94
  95 static av_cold int flac_decode_init(AVCodecContext *avctx)
  96 {
  97     enum FLACExtradataFormat format;
  98     uint8_t *streaminfo;
  99     FLACContext *s = avctx->priv_data;
 100     s->avctx = avctx;
 101
 102     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 103
 104     /* for now, the raw FLAC header is allowed to be passed to the decoder as
 105        frame data instead of extradata. */
 106     if (!avctx->extradata)
 107         return 0;
 108
 109     if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
 110         return -1;
 111
 112     /* initialize based on the demuxer-supplied streamdata header */
 113     ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
 114     if (s->bps > 16)
 115         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 116     else
 117         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 118     allocate_buffers(s);
 119     s->got_streaminfo = 1;
 120
 121     return 0;
 122 }
 123
 124 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
 125 {
 126     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
 127     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
 128     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 129     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 130     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
 131 }
 132
 133 static void allocate_buffers(FLACContext *s)
 134 {
 135     int i;
 136
 137     assert(s->max_blocksize);
 138
 139     for (i = 0; i < s->channels; i++) {
 140         s->decoded[i] = av_realloc(s->decoded[i],
 141                                    sizeof(int32_t)*s->max_blocksize);
 142     }
 143 }
 144
 145 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
 146                               const uint8_t *buffer)
 147 {
 148     GetBitContext gb;
 149     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
 150
 151     skip_bits(&gb, 16); /* skip min blocksize */
 152     s->max_blocksize = get_bits(&gb, 16);
 153     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
 154         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
 155                s->max_blocksize);
 156         s->max_blocksize = 16;
 157     }
 158
 159     skip_bits(&gb, 24); /* skip min frame size */
 160     s->max_framesize = get_bits_long(&gb, 24);
 161
 162     s->samplerate = get_bits_long(&gb, 20);
 163     s->channels = get_bits(&gb, 3) + 1;
 164     s->bps = get_bits(&gb, 5) + 1;
 165
 166     avctx->channels = s->channels;
 167     avctx->sample_rate = s->samplerate;
 168     avctx->bits_per_raw_sample = s->bps;
 169
 170     s->samples  = get_bits_long(&gb, 32) << 4;
 171     s->samples |= get_bits(&gb, 4);
 172
 173     skip_bits_long(&gb, 64); /* md5 sum */
 174     skip_bits_long(&gb, 64); /* md5 sum */
 175
 176     dump_headers(avctx, s);
 177 }
 178
 179 void ff_flac_parse_block_header(const uint8_t *block_header,
 180                                 int *last, int *type, int *size)
 181 {
 182     int tmp = bytestream_get_byte(&block_header);
 183     if (last)
 184         *last = tmp & 0x80;
 185     if (type)
 186         *type = tmp & 0x7F;
 187     if (size)
 188         *size = bytestream_get_be24(&block_header);
 189 }
 190
 191 /**
 192  * Parse the STREAMINFO from an inline header.
 193  * @param s the flac decoding context
 194  * @param buf input buffer, starting with the "fLaC" marker
 195  * @param buf_size buffer size
 196  * @return non-zero if metadata is invalid
 197  */
 198 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
 199 {
 200     int metadata_type, metadata_size;
 201
 202     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
 203         /* need more data */
 204         return 0;
 205     }
 206     ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
 207     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
 208         metadata_size != FLAC_STREAMINFO_SIZE) {
 209         return AVERROR_INVALIDDATA;
 210     }
 211     ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
 212     allocate_buffers(s);
 213     s->got_streaminfo = 1;
 214
 215     return 0;
 216 }
 217
 218 /**
 219  * Determine the size of an inline header.
 220  * @param buf input buffer, starting with the "fLaC" marker
 221  * @param buf_size buffer size
 222  * @return number of bytes in the header, or 0 if more data is needed
 223  */
 224 static int get_metadata_size(const uint8_t *buf, int buf_size)
 225 {
 226     int metadata_last, metadata_size;
 227     const uint8_t *buf_end = buf + buf_size;
 228
 229     buf += 4;
 230     do {
 231         ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 232         buf += 4;
 233         if (buf + metadata_size > buf_end) {
 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 * (s->is32 ? 4 : 2);
 591     if (output_size > alloc_data_size) {
 592         av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
 593                                        "allocated data size\n");
 594         return -1;
 595     }
 596     *data_size = output_size;
 597
 598 #define DECORRELATE(left, right)\
 599             assert(s->channels == 2);\
 600             for (i = 0; i < s->blocksize; i++) {\
 601                 int a= s->decoded[0][i];\
 602                 int b= s->decoded[1][i];\
 603                 if (s->is32) {\
 604                     *samples_32++ = (left)  << s->sample_shift;\
 605                     *samples_32++ = (right) << s->sample_shift;\
 606                 } else {\
 607                     *samples_16++ = (left)  << s->sample_shift;\
 608                     *samples_16++ = (right) << s->sample_shift;\
 609                 }\
 610             }\
 611             break;
 612
 613     switch (s->ch_mode) {
 614     case FLAC_CHMODE_INDEPENDENT:
 615         for (j = 0; j < s->blocksize; j++) {
 616             for (i = 0; i < s->channels; i++) {
 617                 if (s->is32)
 618                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
 619                 else
 620                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
 621             }
 622         }
 623         break;
 624     case FLAC_CHMODE_LEFT_SIDE:
 625         DECORRELATE(a,a-b)
 626     case FLAC_CHMODE_RIGHT_SIDE:
 627         DECORRELATE(a+b,b)
 628     case FLAC_CHMODE_MID_SIDE:
 629         DECORRELATE( (a-=b>>1) + b, a)
 630     }
 631
 632     if (bytes_read > buf_size) {
 633         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 634         return -1;
 635     }
 636     if (bytes_read < buf_size) {
 637         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 638                buf_size - bytes_read, buf_size);
 639     }
 640
 641     return bytes_read;
 642 }
 643
 644 static av_cold int flac_decode_close(AVCodecContext *avctx)
 645 {
 646     FLACContext *s = avctx->priv_data;
 647     int i;
 648
 649     for (i = 0; i < s->channels; i++) {
 650         av_freep(&s->decoded[i]);
 651     }
 652
 653     return 0;
 654 }
 655
 656 AVCodec ff_flac_decoder = {
 657     "flac",
 658     AVMEDIA_TYPE_AUDIO,
 659     CODEC_ID_FLAC,
 660     sizeof(FLACContext),
 661     flac_decode_init,
 662     NULL,
 663     flac_decode_close,
 664     flac_decode_frame,
 665     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 666 };