00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00036 #include <limits.h>
00037
00038 #define ALT_BITSTREAM_READER
00039 #include "avcodec.h"
00040 #include "bitstream.h"
00041 #include "golomb.h"
00042 #include "crc.h"
00043
00044 #undef NDEBUG
00045 #include <assert.h>
00046
00047 #define MAX_CHANNELS 8
00048 #define MAX_BLOCKSIZE 65535
00049 #define FLAC_STREAMINFO_SIZE 34
00050
00051 enum decorrelation_type {
00052 INDEPENDENT,
00053 LEFT_SIDE,
00054 RIGHT_SIDE,
00055 MID_SIDE,
00056 };
00057
00058 typedef struct FLACContext {
00059 AVCodecContext *avctx;
00060 GetBitContext gb;
00061
00062 int min_blocksize, max_blocksize;
00063 int min_framesize, max_framesize;
00064 int samplerate, channels;
00065 int blocksize;
00066 int bps, curr_bps;
00067 enum decorrelation_type decorrelation;
00068
00069 int32_t *decoded[MAX_CHANNELS];
00070 uint8_t *bitstream;
00071 int bitstream_size;
00072 int bitstream_index;
00073 unsigned int allocated_bitstream_size;
00074 } FLACContext;
00075
00076 #define METADATA_TYPE_STREAMINFO 0
00077
00078 static int sample_rate_table[] =
00079 { 0, 0, 0, 0,
00080 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
00081 0, 0, 0, 0 };
00082
00083 static int sample_size_table[] =
00084 { 0, 8, 12, 0, 16, 20, 24, 0 };
00085
00086 static int blocksize_table[] = {
00087 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0,
00088 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
00089 };
00090
00091 static int64_t get_utf8(GetBitContext *gb){
00092 int64_t val;
00093 GET_UTF8(val, get_bits(gb, 8), return -1;)
00094 return val;
00095 }
00096
00097 static void metadata_streaminfo(FLACContext *s);
00098 static void allocate_buffers(FLACContext *s);
00099 static int metadata_parse(FLACContext *s);
00100
00101 static int flac_decode_init(AVCodecContext * avctx)
00102 {
00103 FLACContext *s = avctx->priv_data;
00104 s->avctx = avctx;
00105
00106 if (avctx->extradata_size > 4) {
00107
00108 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
00109 if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
00110 metadata_streaminfo(s);
00111 allocate_buffers(s);
00112 } else {
00113 metadata_parse(s);
00114 }
00115 }
00116
00117 return 0;
00118 }
00119
00120 static void dump_headers(FLACContext *s)
00121 {
00122 av_log(s->avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
00123 av_log(s->avctx, AV_LOG_DEBUG, " Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
00124 av_log(s->avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
00125 av_log(s->avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
00126 av_log(s->avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
00127 }
00128
00129 static void allocate_buffers(FLACContext *s){
00130 int i;
00131
00132 assert(s->max_blocksize);
00133
00134 if(s->max_framesize == 0 && s->max_blocksize){
00135 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8;
00136 }
00137
00138 for (i = 0; i < s->channels; i++)
00139 {
00140 s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
00141 }
00142
00143 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
00144 }
00145
00146 static void metadata_streaminfo(FLACContext *s)
00147 {
00148
00149 s->min_blocksize = get_bits(&s->gb, 16);
00150 s->max_blocksize = get_bits(&s->gb, 16);
00151
00152 s->min_framesize = get_bits_long(&s->gb, 24);
00153 s->max_framesize = get_bits_long(&s->gb, 24);
00154
00155 s->samplerate = get_bits_long(&s->gb, 20);
00156 s->channels = get_bits(&s->gb, 3) + 1;
00157 s->bps = get_bits(&s->gb, 5) + 1;
00158
00159 s->avctx->channels = s->channels;
00160 s->avctx->sample_rate = s->samplerate;
00161
00162 skip_bits(&s->gb, 36);
00163
00164 skip_bits(&s->gb, 64);
00165 skip_bits(&s->gb, 64);
00166
00167 dump_headers(s);
00168 }
00169
00177 static int metadata_parse(FLACContext *s)
00178 {
00179 int i, metadata_last, metadata_type, metadata_size, streaminfo_updated=0;
00180 int initial_pos= get_bits_count(&s->gb);
00181
00182 if (show_bits_long(&s->gb, 32) == MKBETAG('f','L','a','C')) {
00183 skip_bits(&s->gb, 32);
00184
00185 av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
00186 do {
00187 metadata_last = get_bits1(&s->gb);
00188 metadata_type = get_bits(&s->gb, 7);
00189 metadata_size = get_bits_long(&s->gb, 24);
00190
00191 if(get_bits_count(&s->gb) + 8*metadata_size > s->gb.size_in_bits){
00192 skip_bits_long(&s->gb, initial_pos - get_bits_count(&s->gb));
00193 break;
00194 }
00195
00196 av_log(s->avctx, AV_LOG_DEBUG,
00197 " metadata block: flag = %d, type = %d, size = %d\n",
00198 metadata_last, metadata_type, metadata_size);
00199 if (metadata_size) {
00200 switch (metadata_type) {
00201 case METADATA_TYPE_STREAMINFO:
00202 metadata_streaminfo(s);
00203 streaminfo_updated = 1;
00204 break;
00205
00206 default:
00207 for (i=0; i<metadata_size; i++)
00208 skip_bits(&s->gb, 8);
00209 }
00210 }
00211 } while (!metadata_last);
00212
00213 if (streaminfo_updated)
00214 allocate_buffers(s);
00215 return 1;
00216 }
00217 return 0;
00218 }
00219
00220 static int decode_residuals(FLACContext *s, int channel, int pred_order)
00221 {
00222 int i, tmp, partition, method_type, rice_order;
00223 int sample = 0, samples;
00224
00225 method_type = get_bits(&s->gb, 2);
00226 if (method_type > 1){
00227 av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
00228 return -1;
00229 }
00230
00231 rice_order = get_bits(&s->gb, 4);
00232
00233 samples= s->blocksize >> rice_order;
00234 if (pred_order > samples) {
00235 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", pred_order, samples);
00236 return -1;
00237 }
00238
00239 sample=
00240 i= pred_order;
00241 for (partition = 0; partition < (1 << rice_order); partition++)
00242 {
00243 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
00244 if (tmp == (method_type == 0 ? 15 : 31))
00245 {
00246 av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
00247 tmp = get_bits(&s->gb, 5);
00248 for (; i < samples; i++, sample++)
00249 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
00250 }
00251 else
00252 {
00253
00254 for (; i < samples; i++, sample++){
00255 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
00256 }
00257 }
00258 i= 0;
00259 }
00260
00261
00262
00263 return 0;
00264 }
00265
00266 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
00267 {
00268 const int blocksize = s->blocksize;
00269 int32_t *decoded = s->decoded[channel];
00270 int a, b, c, d, i;
00271
00272
00273
00274
00275
00276
00277 for (i = 0; i < pred_order; i++)
00278 {
00279 decoded[i] = get_sbits(&s->gb, s->curr_bps);
00280
00281 }
00282
00283 if (decode_residuals(s, channel, pred_order) < 0)
00284 return -1;
00285
00286 a = decoded[pred_order-1];
00287 b = a - decoded[pred_order-2];
00288 c = b - decoded[pred_order-2] + decoded[pred_order-3];
00289 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
00290
00291 switch(pred_order)
00292 {
00293 case 0:
00294 break;
00295 case 1:
00296 for (i = pred_order; i < blocksize; i++)
00297 decoded[i] = a += decoded[i];
00298 break;
00299 case 2:
00300 for (i = pred_order; i < blocksize; i++)
00301 decoded[i] = a += b += decoded[i];
00302 break;
00303 case 3:
00304 for (i = pred_order; i < blocksize; i++)
00305 decoded[i] = a += b += c += decoded[i];
00306 break;
00307 case 4:
00308 for (i = pred_order; i < blocksize; i++)
00309 decoded[i] = a += b += c += d += decoded[i];
00310 break;
00311 default:
00312 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
00313 return -1;
00314 }
00315
00316 return 0;
00317 }
00318
00319 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
00320 {
00321 int i, j;
00322 int coeff_prec, qlevel;
00323 int coeffs[pred_order];
00324 int32_t *decoded = s->decoded[channel];
00325
00326
00327
00328
00329
00330
00331 for (i = 0; i < pred_order; i++)
00332 {
00333 decoded[i] = get_sbits(&s->gb, s->curr_bps);
00334
00335 }
00336
00337 coeff_prec = get_bits(&s->gb, 4) + 1;
00338 if (coeff_prec == 16)
00339 {
00340 av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
00341 return -1;
00342 }
00343
00344 qlevel = get_sbits(&s->gb, 5);
00345
00346 if(qlevel < 0){
00347 av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
00348 return -1;
00349 }
00350
00351 for (i = 0; i < pred_order; i++)
00352 {
00353 coeffs[i] = get_sbits(&s->gb, coeff_prec);
00354
00355 }
00356
00357 if (decode_residuals(s, channel, pred_order) < 0)
00358 return -1;
00359
00360 if (s->bps > 16) {
00361 int64_t sum;
00362 for (i = pred_order; i < s->blocksize; i++)
00363 {
00364 sum = 0;
00365 for (j = 0; j < pred_order; j++)
00366 sum += (int64_t)coeffs[j] * decoded[i-j-1];
00367 decoded[i] += sum >> qlevel;
00368 }
00369 } else {
00370 for (i = pred_order; i < s->blocksize-1; i += 2)
00371 {
00372 int c;
00373 int d = decoded[i-pred_order];
00374 int s0 = 0, s1 = 0;
00375 for (j = pred_order-1; j > 0; j--)
00376 {
00377 c = coeffs[j];
00378 s0 += c*d;
00379 d = decoded[i-j];
00380 s1 += c*d;
00381 }
00382 c = coeffs[0];
00383 s0 += c*d;
00384 d = decoded[i] += s0 >> qlevel;
00385 s1 += c*d;
00386 decoded[i+1] += s1 >> qlevel;
00387 }
00388 if (i < s->blocksize)
00389 {
00390 int sum = 0;
00391 for (j = 0; j < pred_order; j++)
00392 sum += coeffs[j] * decoded[i-j-1];
00393 decoded[i] += sum >> qlevel;
00394 }
00395 }
00396
00397 return 0;
00398 }
00399
00400 static inline int decode_subframe(FLACContext *s, int channel)
00401 {
00402 int type, wasted = 0;
00403 int i, tmp;
00404
00405 s->curr_bps = s->bps;
00406 if(channel == 0){
00407 if(s->decorrelation == RIGHT_SIDE)
00408 s->curr_bps++;
00409 }else{
00410 if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
00411 s->curr_bps++;
00412 }
00413
00414 if (get_bits1(&s->gb))
00415 {
00416 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
00417 return -1;
00418 }
00419 type = get_bits(&s->gb, 6);
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430 #if 0
00431 wasted= 16 - av_log2(show_bits(&s->gb, 17));
00432 skip_bits(&s->gb, wasted+1);
00433 s->curr_bps -= wasted;
00434 #else
00435 if (get_bits1(&s->gb))
00436 {
00437 wasted = 1;
00438 while (!get_bits1(&s->gb))
00439 wasted++;
00440 s->curr_bps -= wasted;
00441 av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
00442 }
00443 #endif
00444
00445 if (type == 0)
00446 {
00447 av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
00448 tmp = get_sbits(&s->gb, s->curr_bps);
00449 for (i = 0; i < s->blocksize; i++)
00450 s->decoded[channel][i] = tmp;
00451 }
00452 else if (type == 1)
00453 {
00454 av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
00455 for (i = 0; i < s->blocksize; i++)
00456 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
00457 }
00458 else if ((type >= 8) && (type <= 12))
00459 {
00460
00461 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
00462 return -1;
00463 }
00464 else if (type >= 32)
00465 {
00466
00467 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
00468 return -1;
00469 }
00470 else
00471 {
00472 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
00473 return -1;
00474 }
00475
00476 if (wasted)
00477 {
00478 int i;
00479 for (i = 0; i < s->blocksize; i++)
00480 s->decoded[channel][i] <<= wasted;
00481 }
00482
00483 return 0;
00484 }
00485
00486 static int decode_frame(FLACContext *s, int alloc_data_size)
00487 {
00488 int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
00489 int decorrelation, bps, blocksize, samplerate;
00490
00491 blocksize_code = get_bits(&s->gb, 4);
00492
00493 sample_rate_code = get_bits(&s->gb, 4);
00494
00495 assignment = get_bits(&s->gb, 4);
00496 if (assignment < 8 && s->channels == assignment+1)
00497 decorrelation = INDEPENDENT;
00498 else if (assignment >=8 && assignment < 11 && s->channels == 2)
00499 decorrelation = LEFT_SIDE + assignment - 8;
00500 else
00501 {
00502 av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
00503 return -1;
00504 }
00505
00506 sample_size_code = get_bits(&s->gb, 3);
00507 if(sample_size_code == 0)
00508 bps= s->bps;
00509 else if((sample_size_code != 3) && (sample_size_code != 7))
00510 bps = sample_size_table[sample_size_code];
00511 else
00512 {
00513 av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code);
00514 return -1;
00515 }
00516
00517 if (get_bits1(&s->gb))
00518 {
00519 av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
00520 return -1;
00521 }
00522
00523 if(get_utf8(&s->gb) < 0){
00524 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
00525 return -1;
00526 }
00527 #if 0
00528 if (
00529 (s->min_blocksize != s->max_blocksize)){
00530 }else{
00531 }
00532 #endif
00533
00534 if (blocksize_code == 0)
00535 blocksize = s->min_blocksize;
00536 else if (blocksize_code == 6)
00537 blocksize = get_bits(&s->gb, 8)+1;
00538 else if (blocksize_code == 7)
00539 blocksize = get_bits(&s->gb, 16)+1;
00540 else
00541 blocksize = blocksize_table[blocksize_code];
00542
00543 if(blocksize > s->max_blocksize){
00544 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
00545 return -1;
00546 }
00547
00548 if(blocksize * s->channels * sizeof(int16_t) > alloc_data_size)
00549 return -1;
00550
00551 if (sample_rate_code == 0){
00552 samplerate= s->samplerate;
00553 }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
00554 samplerate = sample_rate_table[sample_rate_code];
00555 else if (sample_rate_code == 12)
00556 samplerate = get_bits(&s->gb, 8) * 1000;
00557 else if (sample_rate_code == 13)
00558 samplerate = get_bits(&s->gb, 16);
00559 else if (sample_rate_code == 14)
00560 samplerate = get_bits(&s->gb, 16) * 10;
00561 else{
00562 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
00563 return -1;
00564 }
00565
00566 skip_bits(&s->gb, 8);
00567 crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
00568 s->gb.buffer, get_bits_count(&s->gb)/8);
00569 if(crc8){
00570 av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
00571 return -1;
00572 }
00573
00574 s->blocksize = blocksize;
00575 s->samplerate = samplerate;
00576 s->bps = bps;
00577 s->decorrelation= decorrelation;
00578
00579
00580
00581
00582 for (i = 0; i < s->channels; i++)
00583 {
00584
00585 if (decode_subframe(s, i) < 0)
00586 return -1;
00587 }
00588
00589 align_get_bits(&s->gb);
00590
00591
00592 skip_bits(&s->gb, 16);
00593
00594 return 0;
00595 }
00596
00597 static int flac_decode_frame(AVCodecContext *avctx,
00598 void *data, int *data_size,
00599 const uint8_t *buf, int buf_size)
00600 {
00601 FLACContext *s = avctx->priv_data;
00602 int tmp = 0, i, j = 0, input_buf_size = 0;
00603 int16_t *samples = data;
00604 int alloc_data_size= *data_size;
00605
00606 *data_size=0;
00607
00608 if(s->max_framesize == 0){
00609 s->max_framesize= 65536;
00610 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
00611 }
00612
00613 if(1 && s->max_framesize){
00614 if(s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
00615 buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
00616 input_buf_size= buf_size;
00617
00618 if(s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
00619 return -1;
00620
00621 if(s->allocated_bitstream_size < s->bitstream_size + buf_size)
00622 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
00623
00624 if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
00625
00626 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
00627 s->bitstream_index=0;
00628 }
00629 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
00630 buf= &s->bitstream[s->bitstream_index];
00631 buf_size += s->bitstream_size;
00632 s->bitstream_size= buf_size;
00633
00634 if(buf_size < s->max_framesize){
00635
00636 return input_buf_size;
00637 }
00638 }
00639
00640 init_get_bits(&s->gb, buf, buf_size*8);
00641
00642 if (!metadata_parse(s))
00643 {
00644 tmp = show_bits(&s->gb, 16);
00645 if((tmp & 0xFFFE) != 0xFFF8){
00646 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
00647 while(get_bits_count(&s->gb)/8+2 < buf_size && (show_bits(&s->gb, 16) & 0xFFFE) != 0xFFF8)
00648 skip_bits(&s->gb, 8);
00649 goto end;
00650 }
00651 skip_bits(&s->gb, 16);
00652 if (decode_frame(s, alloc_data_size) < 0){
00653 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
00654 s->bitstream_size=0;
00655 s->bitstream_index=0;
00656 return -1;
00657 }
00658 }
00659
00660
00661 #if 0
00662
00663 if (s->order == MID_SIDE)
00664 {
00665 short *left = samples;
00666 short *right = samples + s->blocksize;
00667 for (i = 0; i < s->blocksize; i += 2)
00668 {
00669 uint32_t x = s->decoded[0][i];
00670 uint32_t y = s->decoded[0][i+1];
00671
00672 right[i] = x - (y / 2);
00673 left[i] = right[i] + y;
00674 }
00675 *data_size = 2 * s->blocksize;
00676 }
00677 else
00678 {
00679 for (i = 0; i < s->channels; i++)
00680 {
00681 switch(s->order)
00682 {
00683 case INDEPENDENT:
00684 for (j = 0; j < s->blocksize; j++)
00685 samples[(s->blocksize*i)+j] = s->decoded[i][j];
00686 break;
00687 case LEFT_SIDE:
00688 case RIGHT_SIDE:
00689 if (i == 0)
00690 for (j = 0; j < s->blocksize; j++)
00691 samples[(s->blocksize*i)+j] = s->decoded[0][j];
00692 else
00693 for (j = 0; j < s->blocksize; j++)
00694 samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
00695 break;
00696
00697
00698 }
00699 *data_size += s->blocksize;
00700 }
00701 }
00702 #else
00703 #define DECORRELATE(left, right)\
00704 assert(s->channels == 2);\
00705 for (i = 0; i < s->blocksize; i++)\
00706 {\
00707 int a= s->decoded[0][i];\
00708 int b= s->decoded[1][i];\
00709 *samples++ = ((left) << (24 - s->bps)) >> 8;\
00710 *samples++ = ((right) << (24 - s->bps)) >> 8;\
00711 }\
00712 break;
00713
00714 switch(s->decorrelation)
00715 {
00716 case INDEPENDENT:
00717 for (j = 0; j < s->blocksize; j++)
00718 {
00719 for (i = 0; i < s->channels; i++)
00720 *samples++ = (s->decoded[i][j] << (24 - s->bps)) >> 8;
00721 }
00722 break;
00723 case LEFT_SIDE:
00724 DECORRELATE(a,a-b)
00725 case RIGHT_SIDE:
00726 DECORRELATE(a+b,b)
00727 case MID_SIDE:
00728 DECORRELATE( (a-=b>>1) + b, a)
00729 }
00730 #endif
00731
00732 *data_size = (int8_t *)samples - (int8_t *)data;
00733
00734
00735
00736 end:
00737 i= (get_bits_count(&s->gb)+7)/8;;
00738 if(i > buf_size){
00739 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
00740 s->bitstream_size=0;
00741 s->bitstream_index=0;
00742 return -1;
00743 }
00744
00745 if(s->bitstream_size){
00746 s->bitstream_index += i;
00747 s->bitstream_size -= i;
00748 return input_buf_size;
00749 }else
00750 return i;
00751 }
00752
00753 static int flac_decode_close(AVCodecContext *avctx)
00754 {
00755 FLACContext *s = avctx->priv_data;
00756 int i;
00757
00758 for (i = 0; i < s->channels; i++)
00759 {
00760 av_freep(&s->decoded[i]);
00761 }
00762 av_freep(&s->bitstream);
00763
00764 return 0;
00765 }
00766
00767 static void flac_flush(AVCodecContext *avctx){
00768 FLACContext *s = avctx->priv_data;
00769
00770 s->bitstream_size=
00771 s->bitstream_index= 0;
00772 }
00773
00774 AVCodec flac_decoder = {
00775 "flac",
00776 CODEC_TYPE_AUDIO,
00777 CODEC_ID_FLAC,
00778 sizeof(FLACContext),
00779 flac_decode_init,
00780 NULL,
00781 flac_decode_close,
00782 flac_decode_frame,
00783 .flush= flac_flush,
00784 };