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