git.sesse.net Git - ffmpeg/blob - libavcodec/flac.c

   1 /*
   2  * FLAC (Free Lossless Audio Codec) decoder
   3  * Copyright (c) 2003 Alex Beregszaszi
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 /**
  21  * @file flac.c
  22  * FLAC (Free Lossless Audio Codec) decoder
  23  * @author Alex Beregszaszi
  24  *
  25  * For more information on the FLAC format, visit:
  26  *  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 #define ALT_BITSTREAM_READER
  37 #include "avcodec.h"
  38 #include "bitstream.h"
  39 #include "golomb.h"
  40 #include "crc.h"
  41
  42 #undef NDEBUG
  43 #include <assert.h>
  44
  45 #define MAX_CHANNELS 8
  46 #define MAX_BLOCKSIZE 65535
  47 #define FLAC_STREAMINFO_SIZE 34
  48
  49 enum decorrelation_type {
  50     INDEPENDENT,
  51     LEFT_SIDE,
  52     RIGHT_SIDE,
  53     MID_SIDE,
  54 };
  55
  56 typedef struct FLACContext {
  57     AVCodecContext *avctx;
  58     GetBitContext gb;
  59
  60     int min_blocksize, max_blocksize;
  61     int min_framesize, max_framesize;
  62     int samplerate, channels;
  63     int blocksize/*, last_blocksize*/;
  64     int bps, curr_bps;
  65     enum decorrelation_type decorrelation;
  66
  67     int32_t *decoded[MAX_CHANNELS];
  68     uint8_t *bitstream;
  69     int bitstream_size;
  70     int bitstream_index;
  71     unsigned int allocated_bitstream_size;
  72 } FLACContext;
  73
  74 #define METADATA_TYPE_STREAMINFO 0
  75
  76 static int sample_rate_table[] =
  77 { 0, 0, 0, 0,
  78   8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
  79   0, 0, 0, 0 };
  80
  81 static int sample_size_table[] =
  82 { 0, 8, 12, 0, 16, 20, 24, 0 };
  83
  84 static int blocksize_table[] = {
  85      0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0,
  86 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
  87 };
  88
  89 static int64_t get_utf8(GetBitContext *gb){
  90     int64_t val;
  91     GET_UTF8(val, get_bits(gb, 8), return -1;)
  92     return val;
  93 }
  94
  95 static void metadata_streaminfo(FLACContext *s);
  96 static void dump_headers(FLACContext *s);
  97
  98 static int flac_decode_init(AVCodecContext * avctx)
  99 {
 100     FLACContext *s = avctx->priv_data;
 101     s->avctx = avctx;
 102
 103     /* initialize based on the demuxer-supplied streamdata header */
 104     if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
 105         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 106         metadata_streaminfo(s);
 107         dump_headers(s);
 108     }
 109
 110     return 0;
 111 }
 112
 113 static void dump_headers(FLACContext *s)
 114 {
 115     av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
 116     av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
 117     av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 118     av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 119     av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
 120 }
 121
 122 static void allocate_buffers(FLACContext *s){
 123     int i;
 124
 125     assert(s->max_blocksize);
 126
 127     if(s->max_framesize == 0 && s->max_blocksize){
 128         s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
 129     }
 130
 131     for (i = 0; i < s->channels; i++)
 132     {
 133         s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
 134     }
 135
 136     s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
 137 }
 138
 139 static void metadata_streaminfo(FLACContext *s)
 140 {
 141     /* mandatory streaminfo */
 142     s->min_blocksize = get_bits(&s->gb, 16);
 143     s->max_blocksize = get_bits(&s->gb, 16);
 144
 145     s->min_framesize = get_bits_long(&s->gb, 24);
 146     s->max_framesize = get_bits_long(&s->gb, 24);
 147
 148     s->samplerate = get_bits_long(&s->gb, 20);
 149     s->channels = get_bits(&s->gb, 3) + 1;
 150     s->bps = get_bits(&s->gb, 5) + 1;
 151
 152     s->avctx->channels = s->channels;
 153     s->avctx->sample_rate = s->samplerate;
 154
 155     skip_bits(&s->gb, 36); /* total num of samples */
 156
 157     skip_bits(&s->gb, 64); /* md5 sum */
 158     skip_bits(&s->gb, 64); /* md5 sum */
 159
 160     allocate_buffers(s);
 161 }
 162
 163 static int decode_residuals(FLACContext *s, int channel, int pred_order)
 164 {
 165     int i, tmp, partition, method_type, rice_order;
 166     int sample = 0, samples;
 167
 168     method_type = get_bits(&s->gb, 2);
 169     if (method_type != 0){
 170         av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
 171         return -1;
 172     }
 173
 174     rice_order = get_bits(&s->gb, 4);
 175
 176     samples= s->blocksize >> rice_order;
 177
 178     sample=
 179     i= pred_order;
 180     for (partition = 0; partition < (1 << rice_order); partition++)
 181     {
 182         tmp = get_bits(&s->gb, 4);
 183         if (tmp == 15)
 184         {
 185             av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
 186             tmp = get_bits(&s->gb, 5);
 187             for (; i < samples; i++, sample++)
 188                 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
 189         }
 190         else
 191         {
 192 //            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
 193             for (; i < samples; i++, sample++){
 194                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 195             }
 196         }
 197         i= 0;
 198     }
 199
 200 //    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
 201
 202     return 0;
 203 }
 204
 205 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
 206 {
 207     int i;
 208
 209 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
 210
 211     /* warm up samples */
 212 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
 213
 214     for (i = 0; i < pred_order; i++)
 215     {
 216         s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
 217 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
 218     }
 219
 220     if (decode_residuals(s, channel, pred_order) < 0)
 221         return -1;
 222
 223     switch(pred_order)
 224     {
 225         case 0:
 226             break;
 227         case 1:
 228             for (i = pred_order; i < s->blocksize; i++)
 229                 s->decoded[channel][i] +=   s->decoded[channel][i-1];
 230             break;
 231         case 2:
 232             for (i = pred_order; i < s->blocksize; i++)
 233                 s->decoded[channel][i] += 2*s->decoded[channel][i-1]
 234                                           - s->decoded[channel][i-2];
 235             break;
 236         case 3:
 237             for (i = pred_order; i < s->blocksize; i++)
 238                 s->decoded[channel][i] += 3*s->decoded[channel][i-1]
 239                                         - 3*s->decoded[channel][i-2]
 240                                         +   s->decoded[channel][i-3];
 241             break;
 242         case 4:
 243             for (i = pred_order; i < s->blocksize; i++)
 244                 s->decoded[channel][i] += 4*s->decoded[channel][i-1]
 245                                         - 6*s->decoded[channel][i-2]
 246                                         + 4*s->decoded[channel][i-3]
 247                                         -   s->decoded[channel][i-4];
 248             break;
 249         default:
 250             av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 251             return -1;
 252     }
 253
 254     return 0;
 255 }
 256
 257 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
 258 {
 259     int i, j;
 260     int coeff_prec, qlevel;
 261     int coeffs[pred_order];
 262
 263 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
 264
 265     /* warm up samples */
 266 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
 267
 268     for (i = 0; i < pred_order; i++)
 269     {
 270         s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
 271 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
 272     }
 273
 274     coeff_prec = get_bits(&s->gb, 4) + 1;
 275     if (coeff_prec == 16)
 276     {
 277         av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
 278         return -1;
 279     }
 280 //    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);
 281     qlevel = get_sbits(&s->gb, 5);
 282 //    av_log(s->avctx, AV_LOG_DEBUG, "   quant level: %d\n", qlevel);
 283     if(qlevel < 0){
 284         av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
 285         return -1;
 286     }
 287
 288     for (i = 0; i < pred_order; i++)
 289     {
 290         coeffs[i] = get_sbits(&s->gb, coeff_prec);
 291 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
 292     }
 293
 294     if (decode_residuals(s, channel, pred_order) < 0)
 295         return -1;
 296
 297     if (s->bps > 16) {
 298         int64_t sum;
 299         for (i = pred_order; i < s->blocksize; i++)
 300         {
 301             sum = 0;
 302             for (j = 0; j < pred_order; j++)
 303                 sum += (int64_t)coeffs[j] * s->decoded[channel][i-j-1];
 304             s->decoded[channel][i] += sum >> qlevel;
 305         }
 306     } else {
 307         int sum;
 308         for (i = pred_order; i < s->blocksize; i++)
 309         {
 310             sum = 0;
 311             for (j = 0; j < pred_order; j++)
 312                 sum += coeffs[j] * s->decoded[channel][i-j-1];
 313             s->decoded[channel][i] += sum >> qlevel;
 314         }
 315     }
 316
 317     return 0;
 318 }
 319
 320 static inline int decode_subframe(FLACContext *s, int channel)
 321 {
 322     int type, wasted = 0;
 323     int i, tmp;
 324
 325     s->curr_bps = s->bps;
 326     if(channel == 0){
 327         if(s->decorrelation == RIGHT_SIDE)
 328             s->curr_bps++;
 329     }else{
 330         if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
 331             s->curr_bps++;
 332     }
 333
 334     if (get_bits1(&s->gb))
 335     {
 336         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 337         return -1;
 338     }
 339     type = get_bits(&s->gb, 6);
 340 //    wasted = get_bits1(&s->gb);
 341
 342 //    if (wasted)
 343 //    {
 344 //        while (!get_bits1(&s->gb))
 345 //            wasted++;
 346 //        if (wasted)
 347 //            wasted++;
 348 //        s->curr_bps -= wasted;
 349 //    }
 350 #if 0
 351     wasted= 16 - av_log2(show_bits(&s->gb, 17));
 352     skip_bits(&s->gb, wasted+1);
 353     s->curr_bps -= wasted;
 354 #else
 355     if (get_bits1(&s->gb))
 356     {
 357         wasted = 1;
 358         while (!get_bits1(&s->gb))
 359             wasted++;
 360         s->curr_bps -= wasted;
 361         av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
 362     }
 363 #endif
 364 //FIXME use av_log2 for types
 365     if (type == 0)
 366     {
 367         av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
 368         tmp = get_sbits(&s->gb, s->curr_bps);
 369         for (i = 0; i < s->blocksize; i++)
 370             s->decoded[channel][i] = tmp;
 371     }
 372     else if (type == 1)
 373     {
 374         av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
 375         for (i = 0; i < s->blocksize; i++)
 376             s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
 377     }
 378     else if ((type >= 8) && (type <= 12))
 379     {
 380 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
 381         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
 382             return -1;
 383     }
 384     else if (type >= 32)
 385     {
 386 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
 387         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
 388             return -1;
 389     }
 390     else
 391     {
 392         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 393         return -1;
 394     }
 395
 396     if (wasted)
 397     {
 398         int i;
 399         for (i = 0; i < s->blocksize; i++)
 400             s->decoded[channel][i] <<= wasted;
 401     }
 402
 403     return 0;
 404 }
 405
 406 static int decode_frame(FLACContext *s)
 407 {
 408     int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
 409     int decorrelation, bps, blocksize, samplerate;
 410
 411     blocksize_code = get_bits(&s->gb, 4);
 412
 413     sample_rate_code = get_bits(&s->gb, 4);
 414
 415     assignment = get_bits(&s->gb, 4); /* channel assignment */
 416     if (assignment < 8 && s->channels == assignment+1)
 417         decorrelation = INDEPENDENT;
 418     else if (assignment >=8 && assignment < 11 && s->channels == 2)
 419         decorrelation = LEFT_SIDE + assignment - 8;
 420     else
 421     {
 422         av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
 423         return -1;
 424     }
 425
 426     sample_size_code = get_bits(&s->gb, 3);
 427     if(sample_size_code == 0)
 428         bps= s->bps;
 429     else if((sample_size_code != 3) && (sample_size_code != 7))
 430         bps = sample_size_table[sample_size_code];
 431     else
 432     {
 433         av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code);
 434         return -1;
 435     }
 436
 437     if (get_bits1(&s->gb))
 438     {
 439         av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
 440         return -1;
 441     }
 442
 443     if(get_utf8(&s->gb) < 0){
 444         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
 445         return -1;
 446     }
 447 #if 0
 448     if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
 449         (s->min_blocksize != s->max_blocksize)){
 450     }else{
 451     }
 452 #endif
 453
 454     if (blocksize_code == 0)
 455         blocksize = s->min_blocksize;
 456     else if (blocksize_code == 6)
 457         blocksize = get_bits(&s->gb, 8)+1;
 458     else if (blocksize_code == 7)
 459         blocksize = get_bits(&s->gb, 16)+1;
 460     else
 461         blocksize = blocksize_table[blocksize_code];
 462
 463     if(blocksize > s->max_blocksize){
 464         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
 465         return -1;
 466     }
 467
 468     if (sample_rate_code == 0){
 469         samplerate= s->samplerate;
 470     }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
 471         samplerate = sample_rate_table[sample_rate_code];
 472     else if (sample_rate_code == 12)
 473         samplerate = get_bits(&s->gb, 8) * 1000;
 474     else if (sample_rate_code == 13)
 475         samplerate = get_bits(&s->gb, 16);
 476     else if (sample_rate_code == 14)
 477         samplerate = get_bits(&s->gb, 16) * 10;
 478     else{
 479         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
 480         return -1;
 481     }
 482
 483     skip_bits(&s->gb, 8);
 484     crc8= av_crc(av_crc07, 0, s->gb.buffer, get_bits_count(&s->gb)/8);
 485     if(crc8){
 486         av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
 487         return -1;
 488     }
 489
 490     s->blocksize    = blocksize;
 491     s->samplerate   = samplerate;
 492     s->bps          = bps;
 493     s->decorrelation= decorrelation;
 494
 495 //    dump_headers(s);
 496
 497     /* subframes */
 498     for (i = 0; i < s->channels; i++)
 499     {
 500 //        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
 501         if (decode_subframe(s, i) < 0)
 502             return -1;
 503     }
 504
 505     align_get_bits(&s->gb);
 506
 507     /* frame footer */
 508     skip_bits(&s->gb, 16); /* data crc */
 509
 510     return 0;
 511 }
 512
 513 static inline int16_t shift_to_16_bits(int32_t data, int bps)
 514 {
 515     if (bps == 24) {
 516         return (data >> 8);
 517     } else if (bps == 20) {
 518         return (data >> 4);
 519     } else {
 520         return data;
 521     }
 522 }
 523
 524 static int flac_decode_frame(AVCodecContext *avctx,
 525                             void *data, int *data_size,
 526                             uint8_t *buf, int buf_size)
 527 {
 528     FLACContext *s = avctx->priv_data;
 529     int metadata_last, metadata_type, metadata_size;
 530     int tmp = 0, i, j = 0, input_buf_size = 0;
 531     int16_t *samples = data;
 532
 533     if(s->max_framesize == 0){
 534         s->max_framesize= 65536; // should hopefully be enough for the first header
 535         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
 536     }
 537
 538     if(1 && s->max_framesize){//FIXME truncated
 539             buf_size= FFMAX(FFMIN(buf_size, s->max_framesize - s->bitstream_size), 0);
 540             input_buf_size= buf_size;
 541
 542             if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
 543 //                printf("memmove\n");
 544                 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
 545                 s->bitstream_index=0;
 546             }
 547             memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
 548             buf= &s->bitstream[s->bitstream_index];
 549             buf_size += s->bitstream_size;
 550             s->bitstream_size= buf_size;
 551
 552             if(buf_size < s->max_framesize){
 553 //                printf("wanna more data ...\n");
 554                 return input_buf_size;
 555             }
 556     }
 557
 558     init_get_bits(&s->gb, buf, buf_size*8);
 559
 560     /* fLaC signature (be) */
 561     if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
 562     {
 563         skip_bits(&s->gb, 32);
 564
 565         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
 566         do {
 567             metadata_last = get_bits(&s->gb, 1);
 568             metadata_type = get_bits(&s->gb, 7);
 569             metadata_size = get_bits_long(&s->gb, 24);
 570
 571             av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
 572                 metadata_last, metadata_type,
 573                 metadata_size);
 574             if(metadata_size){
 575                 switch(metadata_type)
 576                 {
 577                 case METADATA_TYPE_STREAMINFO:{
 578                     metadata_streaminfo(s);
 579
 580                     /* Buffer might have been reallocated, reinit bitreader */
 581                     if(buf != &s->bitstream[s->bitstream_index])
 582                     {
 583                         int bits_count = get_bits_count(&s->gb);
 584                         buf= &s->bitstream[s->bitstream_index];
 585                         init_get_bits(&s->gb, buf, buf_size*8);
 586                         skip_bits(&s->gb, bits_count);
 587                     }
 588
 589                     dump_headers(s);
 590                     break;}
 591                 default:
 592                     for(i=0; i<metadata_size; i++)
 593                         skip_bits(&s->gb, 8);
 594                 }
 595             }
 596         } while(!metadata_last);
 597     }
 598     else
 599     {
 600
 601         tmp = show_bits(&s->gb, 16);
 602         if(tmp != 0xFFF8){
 603             av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
 604             while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
 605                 skip_bits(&s->gb, 8);
 606             goto end; // we may not have enough bits left to decode a frame, so try next time
 607         }
 608         skip_bits(&s->gb, 16);
 609         if (decode_frame(s) < 0){
 610             av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 611             s->bitstream_size=0;
 612             s->bitstream_index=0;
 613             return -1;
 614         }
 615     }
 616
 617
 618 #if 0
 619     /* fix the channel order here */
 620     if (s->order == MID_SIDE)
 621     {
 622         short *left = samples;
 623         short *right = samples + s->blocksize;
 624         for (i = 0; i < s->blocksize; i += 2)
 625         {
 626             uint32_t x = s->decoded[0][i];
 627             uint32_t y = s->decoded[0][i+1];
 628
 629             right[i] = x - (y / 2);
 630             left[i] = right[i] + y;
 631         }
 632         *data_size = 2 * s->blocksize;
 633     }
 634     else
 635     {
 636     for (i = 0; i < s->channels; i++)
 637     {
 638         switch(s->order)
 639         {
 640             case INDEPENDENT:
 641                 for (j = 0; j < s->blocksize; j++)
 642                     samples[(s->blocksize*i)+j] = s->decoded[i][j];
 643                 break;
 644             case LEFT_SIDE:
 645             case RIGHT_SIDE:
 646                 if (i == 0)
 647                     for (j = 0; j < s->blocksize; j++)
 648                         samples[(s->blocksize*i)+j] = s->decoded[0][j];
 649                 else
 650                     for (j = 0; j < s->blocksize; j++)
 651                         samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
 652                 break;
 653 //            case MID_SIDE:
 654 //                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
 655         }
 656         *data_size += s->blocksize;
 657     }
 658     }
 659 #else
 660 #define DECORRELATE(left, right)\
 661             assert(s->channels == 2);\
 662             for (i = 0; i < s->blocksize; i++)\
 663             {\
 664                 int a= s->decoded[0][i];\
 665                 int b= s->decoded[1][i];\
 666                 *(samples++) = (left ) >> (16 - s->bps);\
 667                 *(samples++) = (right) >> (16 - s->bps);\
 668             }\
 669             break;
 670
 671     switch(s->decorrelation)
 672     {
 673         case INDEPENDENT:
 674             for (j = 0; j < s->blocksize; j++)
 675             {
 676                 for (i = 0; i < s->channels; i++)
 677                     *(samples++) = shift_to_16_bits(s->decoded[i][j], s->bps);
 678             }
 679             break;
 680         case LEFT_SIDE:
 681             DECORRELATE(a,a-b)
 682         case RIGHT_SIDE:
 683             DECORRELATE(a+b,b)
 684         case MID_SIDE:
 685             DECORRELATE( (a-=b>>1) + b, a)
 686     }
 687 #endif
 688
 689     *data_size = (int8_t *)samples - (int8_t *)data;
 690 //    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
 691
 692 //    s->last_blocksize = s->blocksize;
 693 end:
 694     i= (get_bits_count(&s->gb)+7)/8;;
 695     if(i > buf_size){
 696         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
 697         s->bitstream_size=0;
 698         s->bitstream_index=0;
 699         return -1;
 700     }
 701
 702     if(s->bitstream_size){
 703         s->bitstream_index += i;
 704         s->bitstream_size  -= i;
 705         return input_buf_size;
 706     }else
 707         return i;
 708 }
 709
 710 static int flac_decode_close(AVCodecContext *avctx)
 711 {
 712     FLACContext *s = avctx->priv_data;
 713     int i;
 714
 715     for (i = 0; i < s->channels; i++)
 716     {
 717         av_freep(&s->decoded[i]);
 718     }
 719     av_freep(&s->bitstream);
 720
 721     return 0;
 722 }
 723
 724 static void flac_flush(AVCodecContext *avctx){
 725     FLACContext *s = avctx->priv_data;
 726
 727     s->bitstream_size=
 728     s->bitstream_index= 0;
 729 }
 730
 731 AVCodec flac_decoder = {
 732     "flac",
 733     CODEC_TYPE_AUDIO,
 734     CODEC_ID_FLAC,
 735     sizeof(FLACContext),
 736     flac_decode_init,
 737     NULL,
 738     flac_decode_close,
 739     flac_decode_frame,
 740     .flush= flac_flush,
 741 };