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         int left = get_bits_left(&s->gb);
 426         wasted = 1;
 427         if ( left < 0 ||
 428             (left < s->curr_bps && !show_bits_long(&s->gb, left)) ||
 429                                    !show_bits_long(&s->gb, s->curr_bps)) {
 430             av_log(s->avctx, AV_LOG_ERROR,
 431                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
 432                    s->curr_bps, left);
 433             return AVERROR_INVALIDDATA;
 434         }
 435         while (!get_bits1(&s->gb))
 436             wasted++;
 437         s->curr_bps -= wasted;
 438     }
 439     if (s->curr_bps > 32) {
 440         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
 441         return -1;
 442     }
 443
 444 //FIXME use av_log2 for types
 445     if (type == 0) {
 446         tmp = get_sbits_long(&s->gb, s->curr_bps);
 447         for (i = 0; i < s->blocksize; i++)
 448             s->decoded[channel][i] = tmp;
 449     } else if (type == 1) {
 450         for (i = 0; i < s->blocksize; i++)
 451             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
 452     } else if ((type >= 8) && (type <= 12)) {
 453         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
 454             return -1;
 455     } else if (type >= 32) {
 456         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
 457             return -1;
 458     } else {
 459         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 460         return -1;
 461     }
 462
 463     if (wasted) {
 464         int i;
 465         for (i = 0; i < s->blocksize; i++)
 466             s->decoded[channel][i] <<= wasted;
 467     }
 468
 469     return 0;
 470 }
 471
 472 static int decode_frame(FLACContext *s)
 473 {
 474     int i;
 475     GetBitContext *gb = &s->gb;
 476     FLACFrameInfo fi;
 477
 478     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
 479         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
 480         return -1;
 481     }
 482
 483     if (s->channels && fi.channels != s->channels) {
 484         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
 485                                        "is not supported\n");
 486         return -1;
 487     }
 488     s->channels = s->avctx->channels = fi.channels;
 489     s->ch_mode = fi.ch_mode;
 490
 491     if (!s->bps && !fi.bps) {
 492         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 493         return -1;
 494     }
 495     if (!fi.bps) {
 496         fi.bps = s->bps;
 497     } else if (s->bps && fi.bps != s->bps) {
 498         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 499                                        "supported\n");
 500         return -1;
 501     }
 502     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 503
 504     if (s->bps > 16) {
 505         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 506         s->sample_shift = 32 - s->bps;
 507         s->is32 = 1;
 508     } else {
 509         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 510         s->sample_shift = 16 - s->bps;
 511         s->is32 = 0;
 512     }
 513
 514     if (!s->max_blocksize)
 515         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 516     if (fi.blocksize > s->max_blocksize) {
 517         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
 518                s->max_blocksize);
 519         return -1;
 520     }
 521     s->blocksize = fi.blocksize;
 522
 523     if (!s->samplerate && !fi.samplerate) {
 524         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 525                                         " or frame header\n");
 526         return -1;
 527     }
 528     if (fi.samplerate == 0) {
 529         fi.samplerate = s->samplerate;
 530     } else if (s->samplerate && fi.samplerate != s->samplerate) {
 531         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
 532                s->samplerate, fi.samplerate);
 533     }
 534     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 535
 536     if (!s->got_streaminfo) {
 537         allocate_buffers(s);
 538         s->got_streaminfo = 1;
 539         dump_headers(s->avctx, (FLACStreaminfo *)s);
 540     }
 541
 542 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
 543
 544     /* subframes */
 545     for (i = 0; i < s->channels; i++) {
 546         if (decode_subframe(s, i) < 0)
 547             return -1;
 548     }
 549
 550     align_get_bits(gb);
 551
 552     /* frame footer */
 553     skip_bits(gb, 16); /* data crc */
 554
 555     return 0;
 556 }
 557
 558 static int flac_decode_frame(AVCodecContext *avctx, void *data,
 559                              int *got_frame_ptr, AVPacket *avpkt)
 560 {
 561     const uint8_t *buf = avpkt->data;
 562     int buf_size = avpkt->size;
 563     FLACContext *s = avctx->priv_data;
 564     int i, j = 0, bytes_read = 0;
 565     int16_t *samples_16;
 566     int32_t *samples_32;
 567     int ret;
 568
 569     *got_frame_ptr = 0;
 570
 571     if (s->max_framesize == 0) {
 572         s->max_framesize =
 573             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 574                                        FLAC_MAX_CHANNELS, 32);
 575     }
 576
 577     /* check that there is at least the smallest decodable amount of data.
 578        this amount corresponds to the smallest valid FLAC frame possible.
 579        FF F8 69 02 00 00 9A 00 00 34 46 */
 580     if (buf_size < FLAC_MIN_FRAME_SIZE)
 581         return buf_size;
 582
 583     /* check for inline header */
 584     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 585         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
 586             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 587             return -1;
 588         }
 589         return get_metadata_size(buf, buf_size);
 590     }
 591
 592     /* decode frame */
 593     init_get_bits(&s->gb, buf, buf_size*8);
 594     if (decode_frame(s) < 0) {
 595         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 596         return -1;
 597     }
 598     bytes_read = (get_bits_count(&s->gb)+7)/8;
 599
 600     /* get output buffer */
 601     s->frame.nb_samples = s->blocksize;
 602     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
 603         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 604         return ret;
 605     }
 606     samples_16 = (int16_t *)s->frame.data[0];
 607     samples_32 = (int32_t *)s->frame.data[0];
 608
 609 #define DECORRELATE(left, right)\
 610             assert(s->channels == 2);\
 611             for (i = 0; i < s->blocksize; i++) {\
 612                 int a= s->decoded[0][i];\
 613                 int b= s->decoded[1][i];\
 614                 if (s->is32) {\
 615                     *samples_32++ = (left)  << s->sample_shift;\
 616                     *samples_32++ = (right) << s->sample_shift;\
 617                 } else {\
 618                     *samples_16++ = (left)  << s->sample_shift;\
 619                     *samples_16++ = (right) << s->sample_shift;\
 620                 }\
 621             }\
 622             break;
 623
 624     switch (s->ch_mode) {
 625     case FLAC_CHMODE_INDEPENDENT:
 626         for (j = 0; j < s->blocksize; j++) {
 627             for (i = 0; i < s->channels; i++) {
 628                 if (s->is32)
 629                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
 630                 else
 631                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
 632             }
 633         }
 634         break;
 635     case FLAC_CHMODE_LEFT_SIDE:
 636         DECORRELATE(a,a-b)
 637     case FLAC_CHMODE_RIGHT_SIDE:
 638         DECORRELATE(a+b,b)
 639     case FLAC_CHMODE_MID_SIDE:
 640         DECORRELATE( (a-=b>>1) + b, a)
 641     }
 642
 643     if (bytes_read > buf_size) {
 644         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 645         return -1;
 646     }
 647     if (bytes_read < buf_size) {
 648         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 649                buf_size - bytes_read, buf_size);
 650     }
 651
 652     *got_frame_ptr   = 1;
 653     *(AVFrame *)data = s->frame;
 654
 655     return bytes_read;
 656 }
 657
 658 static av_cold int flac_decode_close(AVCodecContext *avctx)
 659 {
 660     FLACContext *s = avctx->priv_data;
 661     int i;
 662
 663     for (i = 0; i < s->channels; i++) {
 664         av_freep(&s->decoded[i]);
 665     }
 666
 667     return 0;
 668 }
 669
 670 AVCodec ff_flac_decoder = {
 671     .name           = "flac",
 672     .type           = AVMEDIA_TYPE_AUDIO,
 673     .id             = CODEC_ID_FLAC,
 674     .priv_data_size = sizeof(FLACContext),
 675     .init           = flac_decode_init,
 676     .close          = flac_decode_close,
 677     .decode         = flac_decode_frame,
 678     .capabilities   = CODEC_CAP_DR1,
 679     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 680 };