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 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 const int64_t flac_channel_layouts[6] = {
  66     AV_CH_LAYOUT_MONO,
  67     AV_CH_LAYOUT_STEREO,
  68     AV_CH_LAYOUT_SURROUND,
  69     AV_CH_LAYOUT_QUAD,
  70     AV_CH_LAYOUT_5POINT0,
  71     AV_CH_LAYOUT_5POINT1
  72 };
  73
  74 static void allocate_buffers(FLACContext *s);
  75
  76 int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
  77                                enum FLACExtradataFormat *format,
  78                                uint8_t **streaminfo_start)
  79 {
  80     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
  81         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
  82         return 0;
  83     }
  84     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
  85         /* extradata contains STREAMINFO only */
  86         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
  87             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
  88                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
  89         }
  90         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
  91         *streaminfo_start = avctx->extradata;
  92     } else {
  93         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
  94             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
  95             return 0;
  96         }
  97         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
  98         *streaminfo_start = &avctx->extradata[8];
  99     }
 100     return 1;
 101 }
 102
 103 static void flac_set_bps(FLACContext *s)
 104 {
 105     if (s->bps > 16) {
 106         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 107         s->sample_shift = 32 - s->bps;
 108         s->is32 = 1;
 109     } else {
 110         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 111         s->sample_shift = 16 - s->bps;
 112         s->is32 = 0;
 113     }
 114 }
 115
 116 static av_cold int flac_decode_init(AVCodecContext *avctx)
 117 {
 118     enum FLACExtradataFormat format;
 119     uint8_t *streaminfo;
 120     FLACContext *s = avctx->priv_data;
 121     s->avctx = avctx;
 122
 123     /* for now, the raw FLAC header is allowed to be passed to the decoder as
 124        frame data instead of extradata. */
 125     if (!avctx->extradata)
 126         return 0;
 127
 128     if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
 129         return -1;
 130
 131     /* initialize based on the demuxer-supplied streamdata header */
 132     avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
 133     allocate_buffers(s);
 134     flac_set_bps(s);
 135     s->got_streaminfo = 1;
 136
 137     avcodec_get_frame_defaults(&s->frame);
 138     avctx->coded_frame = &s->frame;
 139
 140     if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
 141         avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
 142
 143     return 0;
 144 }
 145
 146 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
 147 {
 148     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
 149     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
 150     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 151     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 152     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
 153 }
 154
 155 static void allocate_buffers(FLACContext *s)
 156 {
 157     int i;
 158
 159     assert(s->max_blocksize);
 160
 161     for (i = 0; i < s->channels; i++) {
 162         s->decoded[i] = av_malloc(sizeof(int32_t)*s->max_blocksize);
 163     }
 164 }
 165
 166 void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
 167                               const uint8_t *buffer)
 168 {
 169     GetBitContext gb;
 170     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
 171
 172     skip_bits(&gb, 16); /* skip min blocksize */
 173     s->max_blocksize = get_bits(&gb, 16);
 174     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
 175         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
 176                s->max_blocksize);
 177         s->max_blocksize = 16;
 178     }
 179
 180     skip_bits(&gb, 24); /* skip min frame size */
 181     s->max_framesize = get_bits_long(&gb, 24);
 182
 183     s->samplerate = get_bits_long(&gb, 20);
 184     s->channels = get_bits(&gb, 3) + 1;
 185     s->bps = get_bits(&gb, 5) + 1;
 186
 187     avctx->channels = s->channels;
 188     avctx->sample_rate = s->samplerate;
 189     avctx->bits_per_raw_sample = s->bps;
 190
 191     s->samples  = get_bits_long(&gb, 32) << 4;
 192     s->samples |= get_bits(&gb, 4);
 193
 194     skip_bits_long(&gb, 64); /* md5 sum */
 195     skip_bits_long(&gb, 64); /* md5 sum */
 196
 197     dump_headers(avctx, s);
 198 }
 199
 200 void avpriv_flac_parse_block_header(const uint8_t *block_header,
 201                                 int *last, int *type, int *size)
 202 {
 203     int tmp = bytestream_get_byte(&block_header);
 204     if (last)
 205         *last = tmp & 0x80;
 206     if (type)
 207         *type = tmp & 0x7F;
 208     if (size)
 209         *size = bytestream_get_be24(&block_header);
 210 }
 211
 212 /**
 213  * Parse the STREAMINFO from an inline header.
 214  * @param s the flac decoding context
 215  * @param buf input buffer, starting with the "fLaC" marker
 216  * @param buf_size buffer size
 217  * @return non-zero if metadata is invalid
 218  */
 219 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
 220 {
 221     int metadata_type, metadata_size;
 222
 223     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
 224         /* need more data */
 225         return 0;
 226     }
 227     avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
 228     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
 229         metadata_size != FLAC_STREAMINFO_SIZE) {
 230         return AVERROR_INVALIDDATA;
 231     }
 232     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
 233     allocate_buffers(s);
 234     s->got_streaminfo = 1;
 235
 236     return 0;
 237 }
 238
 239 /**
 240  * Determine the size of an inline header.
 241  * @param buf input buffer, starting with the "fLaC" marker
 242  * @param buf_size buffer size
 243  * @return number of bytes in the header, or 0 if more data is needed
 244  */
 245 static int get_metadata_size(const uint8_t *buf, int buf_size)
 246 {
 247     int metadata_last, metadata_size;
 248     const uint8_t *buf_end = buf + buf_size;
 249
 250     buf += 4;
 251     do {
 252         if (buf_end - buf < 4)
 253             return 0;
 254         avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 255         buf += 4;
 256         if (buf_end - buf < metadata_size) {
 257             /* need more data in order to read the complete header */
 258             return 0;
 259         }
 260         buf += metadata_size;
 261     } while (!metadata_last);
 262
 263     return buf_size - (buf_end - buf);
 264 }
 265
 266 static int decode_residuals(FLACContext *s, int channel, int pred_order)
 267 {
 268     int i, tmp, partition, method_type, rice_order;
 269     int sample = 0, samples;
 270
 271     method_type = get_bits(&s->gb, 2);
 272     if (method_type > 1) {
 273         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 274                method_type);
 275         return -1;
 276     }
 277
 278     rice_order = get_bits(&s->gb, 4);
 279
 280     samples= s->blocksize >> rice_order;
 281     if (pred_order > samples) {
 282         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 283                pred_order, samples);
 284         return -1;
 285     }
 286
 287     sample=
 288     i= pred_order;
 289     for (partition = 0; partition < (1 << rice_order); partition++) {
 290         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
 291         if (tmp == (method_type == 0 ? 15 : 31)) {
 292             tmp = get_bits(&s->gb, 5);
 293             for (; i < samples; i++, sample++)
 294                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
 295         } else {
 296             for (; i < samples; i++, sample++) {
 297                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 298             }
 299         }
 300         i= 0;
 301     }
 302
 303     return 0;
 304 }
 305
 306 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order,
 307                                  int bps)
 308 {
 309     const int blocksize = s->blocksize;
 310     int32_t *decoded = s->decoded[channel];
 311     int a, b, c, d, i;
 312
 313     /* warm up samples */
 314     for (i = 0; i < pred_order; i++) {
 315         decoded[i] = get_sbits_long(&s->gb, bps);
 316     }
 317
 318     if (decode_residuals(s, channel, pred_order) < 0)
 319         return -1;
 320
 321     if (pred_order > 0)
 322         a = decoded[pred_order-1];
 323     if (pred_order > 1)
 324         b = a - decoded[pred_order-2];
 325     if (pred_order > 2)
 326         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 327     if (pred_order > 3)
 328         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 329
 330     switch (pred_order) {
 331     case 0:
 332         break;
 333     case 1:
 334         for (i = pred_order; i < blocksize; i++)
 335             decoded[i] = a += decoded[i];
 336         break;
 337     case 2:
 338         for (i = pred_order; i < blocksize; i++)
 339             decoded[i] = a += b += decoded[i];
 340         break;
 341     case 3:
 342         for (i = pred_order; i < blocksize; i++)
 343             decoded[i] = a += b += c += decoded[i];
 344         break;
 345     case 4:
 346         for (i = pred_order; i < blocksize; i++)
 347             decoded[i] = a += b += c += d += decoded[i];
 348         break;
 349     default:
 350         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 351         return -1;
 352     }
 353
 354     return 0;
 355 }
 356
 357 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order,
 358                                int bps)
 359 {
 360     int i, j;
 361     int coeff_prec, qlevel;
 362     int coeffs[32];
 363     int32_t *decoded = s->decoded[channel];
 364
 365     /* warm up samples */
 366     for (i = 0; i < pred_order; i++) {
 367         decoded[i] = get_sbits_long(&s->gb, bps);
 368     }
 369
 370     coeff_prec = get_bits(&s->gb, 4) + 1;
 371     if (coeff_prec == 16) {
 372         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 373         return -1;
 374     }
 375     qlevel = get_sbits(&s->gb, 5);
 376     if (qlevel < 0) {
 377         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 378                qlevel);
 379         return -1;
 380     }
 381
 382     for (i = 0; i < pred_order; i++) {
 383         coeffs[i] = get_sbits(&s->gb, coeff_prec);
 384     }
 385
 386     if (decode_residuals(s, channel, pred_order) < 0)
 387         return -1;
 388
 389     if (s->bps > 16) {
 390         int64_t sum;
 391         for (i = pred_order; i < s->blocksize; i++) {
 392             sum = 0;
 393             for (j = 0; j < pred_order; j++)
 394                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
 395             decoded[i] += sum >> qlevel;
 396         }
 397     } else {
 398         for (i = pred_order; i < s->blocksize-1; i += 2) {
 399             int c;
 400             int d = decoded[i-pred_order];
 401             int s0 = 0, s1 = 0;
 402             for (j = pred_order-1; j > 0; j--) {
 403                 c = coeffs[j];
 404                 s0 += c*d;
 405                 d = decoded[i-j];
 406                 s1 += c*d;
 407             }
 408             c = coeffs[0];
 409             s0 += c*d;
 410             d = decoded[i] += s0 >> qlevel;
 411             s1 += c*d;
 412             decoded[i+1] += s1 >> qlevel;
 413         }
 414         if (i < s->blocksize) {
 415             int sum = 0;
 416             for (j = 0; j < pred_order; j++)
 417                 sum += coeffs[j] * decoded[i-j-1];
 418             decoded[i] += sum >> qlevel;
 419         }
 420     }
 421
 422     return 0;
 423 }
 424
 425 static inline int decode_subframe(FLACContext *s, int channel)
 426 {
 427     int type, wasted = 0;
 428     int bps = s->bps;
 429     int i, tmp;
 430
 431     if (channel == 0) {
 432         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
 433             bps++;
 434     } else {
 435         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
 436             bps++;
 437     }
 438
 439     if (get_bits1(&s->gb)) {
 440         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 441         return -1;
 442     }
 443     type = get_bits(&s->gb, 6);
 444
 445     if (get_bits1(&s->gb)) {
 446         int left = get_bits_left(&s->gb);
 447         wasted = 1;
 448         if ( left < 0 ||
 449             (left < bps && !show_bits_long(&s->gb, left)) ||
 450                            !show_bits_long(&s->gb, bps)) {
 451             av_log(s->avctx, AV_LOG_ERROR,
 452                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
 453                    bps, left);
 454             return AVERROR_INVALIDDATA;
 455         }
 456         while (!get_bits1(&s->gb))
 457             wasted++;
 458         bps -= wasted;
 459     }
 460     if (bps > 32) {
 461         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
 462         return -1;
 463     }
 464
 465 //FIXME use av_log2 for types
 466     if (type == 0) {
 467         tmp = get_sbits_long(&s->gb, bps);
 468         for (i = 0; i < s->blocksize; i++)
 469             s->decoded[channel][i] = tmp;
 470     } else if (type == 1) {
 471         for (i = 0; i < s->blocksize; i++)
 472             s->decoded[channel][i] = get_sbits_long(&s->gb, bps);
 473     } else if ((type >= 8) && (type <= 12)) {
 474         if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0)
 475             return -1;
 476     } else if (type >= 32) {
 477         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0)
 478             return -1;
 479     } else {
 480         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 481         return -1;
 482     }
 483
 484     if (wasted) {
 485         int i;
 486         for (i = 0; i < s->blocksize; i++)
 487             s->decoded[channel][i] <<= wasted;
 488     }
 489
 490     return 0;
 491 }
 492
 493 static int decode_frame(FLACContext *s)
 494 {
 495     int i;
 496     GetBitContext *gb = &s->gb;
 497     FLACFrameInfo fi;
 498
 499     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
 500         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
 501         return -1;
 502     }
 503
 504     if (s->channels && fi.channels != s->channels) {
 505         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
 506                                        "is not supported\n");
 507         return -1;
 508     }
 509     s->channels = s->avctx->channels = fi.channels;
 510     s->ch_mode = fi.ch_mode;
 511
 512     if (!s->bps && !fi.bps) {
 513         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 514         return -1;
 515     }
 516     if (!fi.bps) {
 517         fi.bps = s->bps;
 518     } else if (s->bps && fi.bps != s->bps) {
 519         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 520                                        "supported\n");
 521         return -1;
 522     }
 523     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 524
 525     flac_set_bps(s);
 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 };