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