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