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
00181 if (show_bits_long(&s->gb, 32) == MKBETAG('f','L','a','C')) {
00182 skip_bits(&s->gb, 32);
00183
00184 av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
00185 do {
00186 metadata_last = get_bits1(&s->gb);
00187 metadata_type = get_bits(&s->gb, 7);
00188 metadata_size = get_bits_long(&s->gb, 24);
00189
00190 av_log(s->avctx, AV_LOG_DEBUG,
00191 " metadata block: flag = %d, type = %d, size = %d\n",
00192 metadata_last, metadata_type, metadata_size);
00193 if (metadata_size) {
00194 switch (metadata_type) {
00195 case METADATA_TYPE_STREAMINFO:
00196 metadata_streaminfo(s);
00197 streaminfo_updated = 1;
00198 break;
00199
00200 default:
00201 for (i=0; i<metadata_size; i++)
00202 skip_bits(&s->gb, 8);
00203 }
00204 }
00205 } while (!metadata_last);
00206
00207 if (streaminfo_updated)
00208 allocate_buffers(s);
00209 return 1;
00210 }
00211 return 0;
00212 }
00213
00214 static int decode_residuals(FLACContext *s, int channel, int pred_order)
00215 {
00216 int i, tmp, partition, method_type, rice_order;
00217 int sample = 0, samples;
00218
00219 method_type = get_bits(&s->gb, 2);
00220 if (method_type > 1){
00221 av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
00222 return -1;
00223 }
00224
00225 rice_order = get_bits(&s->gb, 4);
00226
00227 samples= s->blocksize >> rice_order;
00228 if (pred_order > samples) {
00229 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", pred_order, samples);
00230 return -1;
00231 }
00232
00233 sample=
00234 i= pred_order;
00235 for (partition = 0; partition < (1 << rice_order); partition++)
00236 {
00237 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
00238 if (tmp == (method_type == 0 ? 15 : 31))
00239 {
00240 av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
00241 tmp = get_bits(&s->gb, 5);
00242 for (; i < samples; i++, sample++)
00243 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
00244 }
00245 else
00246 {
00247
00248 for (; i < samples; i++, sample++){
00249 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
00250 }
00251 }
00252 i= 0;
00253 }
00254
00255
00256
00257 return 0;
00258 }
00259
00260 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
00261 {
00262 const int blocksize = s->blocksize;
00263 int32_t *decoded = s->decoded[channel];
00264 int a, b, c, d, i;
00265
00266
00267
00268
00269
00270
00271 for (i = 0; i < pred_order; i++)
00272 {
00273 decoded[i] = get_sbits(&s->gb, s->curr_bps);
00274
00275 }
00276
00277 if (decode_residuals(s, channel, pred_order) < 0)
00278 return -1;
00279
00280 a = decoded[pred_order-1];
00281 b = a - decoded[pred_order-2];
00282 c = b - decoded[pred_order-2] + decoded[pred_order-3];
00283 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
00284
00285 switch(pred_order)
00286 {
00287 case 0:
00288 break;
00289 case 1:
00290 for (i = pred_order; i < blocksize; i++)
00291 decoded[i] = a += decoded[i];
00292 break;
00293 case 2:
00294 for (i = pred_order; i < blocksize; i++)
00295 decoded[i] = a += b += decoded[i];
00296 break;
00297 case 3:
00298 for (i = pred_order; i < blocksize; i++)
00299 decoded[i] = a += b += c += decoded[i];
00300 break;
00301 case 4:
00302 for (i = pred_order; i < blocksize; i++)
00303 decoded[i] = a += b += c += d += decoded[i];
00304 break;
00305 default:
00306 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
00307 return -1;
00308 }
00309
00310 return 0;
00311 }
00312
00313 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
00314 {
00315 int i, j;
00316 int coeff_prec, qlevel;
00317 int coeffs[pred_order];
00318 int32_t *decoded = s->decoded[channel];
00319
00320
00321
00322
00323
00324
00325 for (i = 0; i < pred_order; i++)
00326 {
00327 decoded[i] = get_sbits(&s->gb, s->curr_bps);
00328
00329 }
00330
00331 coeff_prec = get_bits(&s->gb, 4) + 1;
00332 if (coeff_prec == 16)
00333 {
00334 av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
00335 return -1;
00336 }
00337
00338 qlevel = get_sbits(&s->gb, 5);
00339
00340 if(qlevel < 0){
00341 av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
00342 return -1;
00343 }
00344
00345 for (i = 0; i < pred_order; i++)
00346 {
00347 coeffs[i] = get_sbits(&s->gb, coeff_prec);
00348
00349 }
00350
00351 if (decode_residuals(s, channel, pred_order) < 0)
00352 return -1;
00353
00354 if (s->bps > 16) {
00355 int64_t sum;
00356 for (i = pred_order; i < s->blocksize; i++)
00357 {
00358 sum = 0;
00359 for (j = 0; j < pred_order; j++)
00360 sum += (int64_t)coeffs[j] * decoded[i-j-1];
00361 decoded[i] += sum >> qlevel;
00362 }
00363 } else {
00364 for (i = pred_order; i < s->blocksize-1; i += 2)
00365 {
00366 int c;
00367 int d = decoded[i-pred_order];
00368 int s0 = 0, s1 = 0;
00369 for (j = pred_order-1; j > 0; j--)
00370 {
00371 c = coeffs[j];
00372 s0 += c*d;
00373 d = decoded[i-j];
00374 s1 += c*d;
00375 }
00376 c = coeffs[0];
00377 s0 += c*d;
00378 d = decoded[i] += s0 >> qlevel;
00379 s1 += c*d;
00380 decoded[i+1] += s1 >> qlevel;
00381 }
00382 if (i < s->blocksize)
00383 {
00384 int sum = 0;
00385 for (j = 0; j < pred_order; j++)
00386 sum += coeffs[j] * decoded[i-j-1];
00387 decoded[i] += sum >> qlevel;
00388 }
00389 }
00390
00391 return 0;
00392 }
00393
00394 static inline int decode_subframe(FLACContext *s, int channel)
00395 {
00396 int type, wasted = 0;
00397 int i, tmp;
00398
00399 s->curr_bps = s->bps;
00400 if(channel == 0){
00401 if(s->decorrelation == RIGHT_SIDE)
00402 s->curr_bps++;
00403 }else{
00404 if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
00405 s->curr_bps++;
00406 }
00407
00408 if (get_bits1(&s->gb))
00409 {
00410 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
00411 return -1;
00412 }
00413 type = get_bits(&s->gb, 6);
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424 #if 0
00425 wasted= 16 - av_log2(show_bits(&s->gb, 17));
00426 skip_bits(&s->gb, wasted+1);
00427 s->curr_bps -= wasted;
00428 #else
00429 if (get_bits1(&s->gb))
00430 {
00431 wasted = 1;
00432 while (!get_bits1(&s->gb))
00433 wasted++;
00434 s->curr_bps -= wasted;
00435 av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
00436 }
00437 #endif
00438
00439 if (type == 0)
00440 {
00441 av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
00442 tmp = get_sbits(&s->gb, s->curr_bps);
00443 for (i = 0; i < s->blocksize; i++)
00444 s->decoded[channel][i] = tmp;
00445 }
00446 else if (type == 1)
00447 {
00448 av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
00449 for (i = 0; i < s->blocksize; i++)
00450 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
00451 }
00452 else if ((type >= 8) && (type <= 12))
00453 {
00454
00455 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
00456 return -1;
00457 }
00458 else if (type >= 32)
00459 {
00460
00461 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
00462 return -1;
00463 }
00464 else
00465 {
00466 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
00467 return -1;
00468 }
00469
00470 if (wasted)
00471 {
00472 int i;
00473 for (i = 0; i < s->blocksize; i++)
00474 s->decoded[channel][i] <<= wasted;
00475 }
00476
00477 return 0;
00478 }
00479
00480 static int decode_frame(FLACContext *s, int alloc_data_size)
00481 {
00482 int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
00483 int decorrelation, bps, blocksize, samplerate;
00484
00485 blocksize_code = get_bits(&s->gb, 4);
00486
00487 sample_rate_code = get_bits(&s->gb, 4);
00488
00489 assignment = get_bits(&s->gb, 4);
00490 if (assignment < 8 && s->channels == assignment+1)
00491 decorrelation = INDEPENDENT;
00492 else if (assignment >=8 && assignment < 11 && s->channels == 2)
00493 decorrelation = LEFT_SIDE + assignment - 8;
00494 else
00495 {
00496 av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
00497 return -1;
00498 }
00499
00500 sample_size_code = get_bits(&s->gb, 3);
00501 if(sample_size_code == 0)
00502 bps= s->bps;
00503 else if((sample_size_code != 3) && (sample_size_code != 7))
00504 bps = sample_size_table[sample_size_code];
00505 else
00506 {
00507 av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code);
00508 return -1;
00509 }
00510
00511 if (get_bits1(&s->gb))
00512 {
00513 av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
00514 return -1;
00515 }
00516
00517 if(get_utf8(&s->gb) < 0){
00518 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
00519 return -1;
00520 }
00521 #if 0
00522 if (
00523 (s->min_blocksize != s->max_blocksize)){
00524 }else{
00525 }
00526 #endif
00527
00528 if (blocksize_code == 0)
00529 blocksize = s->min_blocksize;
00530 else if (blocksize_code == 6)
00531 blocksize = get_bits(&s->gb, 8)+1;
00532 else if (blocksize_code == 7)
00533 blocksize = get_bits(&s->gb, 16)+1;
00534 else
00535 blocksize = blocksize_table[blocksize_code];
00536
00537 if(blocksize > s->max_blocksize){
00538 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
00539 return -1;
00540 }
00541
00542 if(blocksize * s->channels * sizeof(int16_t) > alloc_data_size)
00543 return -1;
00544
00545 if (sample_rate_code == 0){
00546 samplerate= s->samplerate;
00547 }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
00548 samplerate = sample_rate_table[sample_rate_code];
00549 else if (sample_rate_code == 12)
00550 samplerate = get_bits(&s->gb, 8) * 1000;
00551 else if (sample_rate_code == 13)
00552 samplerate = get_bits(&s->gb, 16);
00553 else if (sample_rate_code == 14)
00554 samplerate = get_bits(&s->gb, 16) * 10;
00555 else{
00556 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
00557 return -1;
00558 }
00559
00560 skip_bits(&s->gb, 8);
00561 crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
00562 s->gb.buffer, get_bits_count(&s->gb)/8);
00563 if(crc8){
00564 av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
00565 return -1;
00566 }
00567
00568 s->blocksize = blocksize;
00569 s->samplerate = samplerate;
00570 s->bps = bps;
00571 s->decorrelation= decorrelation;
00572
00573
00574
00575
00576 for (i = 0; i < s->channels; i++)
00577 {
00578
00579 if (decode_subframe(s, i) < 0)
00580 return -1;
00581 }
00582
00583 align_get_bits(&s->gb);
00584
00585
00586 skip_bits(&s->gb, 16);
00587
00588 return 0;
00589 }
00590
00591 static int flac_decode_frame(AVCodecContext *avctx,
00592 void *data, int *data_size,
00593 const uint8_t *buf, int buf_size)
00594 {
00595 FLACContext *s = avctx->priv_data;
00596 int tmp = 0, i, j = 0, input_buf_size = 0;
00597 int16_t *samples = data;
00598 int alloc_data_size= *data_size;
00599
00600 *data_size=0;
00601
00602 if(s->max_framesize == 0){
00603 s->max_framesize= 65536;
00604 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
00605 }
00606
00607 if(1 && s->max_framesize){
00608 buf_size= FFMAX(FFMIN(buf_size, s->max_framesize - s->bitstream_size), 0);
00609 input_buf_size= buf_size;
00610
00611 if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
00612
00613 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
00614 s->bitstream_index=0;
00615 }
00616 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
00617 buf= &s->bitstream[s->bitstream_index];
00618 buf_size += s->bitstream_size;
00619 s->bitstream_size= buf_size;
00620
00621 if(buf_size < s->max_framesize){
00622
00623 return input_buf_size;
00624 }
00625 }
00626
00627 init_get_bits(&s->gb, buf, buf_size*8);
00628
00629 if (!metadata_parse(s))
00630 {
00631 tmp = show_bits(&s->gb, 16);
00632 if((tmp & 0xFFFE) != 0xFFF8){
00633 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
00634 while(get_bits_count(&s->gb)/8+2 < buf_size && (show_bits(&s->gb, 16) & 0xFFFE) != 0xFFF8)
00635 skip_bits(&s->gb, 8);
00636 goto end;
00637 }
00638 skip_bits(&s->gb, 16);
00639 if (decode_frame(s, alloc_data_size) < 0){
00640 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
00641 s->bitstream_size=0;
00642 s->bitstream_index=0;
00643 return -1;
00644 }
00645 }
00646
00647
00648 #if 0
00649
00650 if (s->order == MID_SIDE)
00651 {
00652 short *left = samples;
00653 short *right = samples + s->blocksize;
00654 for (i = 0; i < s->blocksize; i += 2)
00655 {
00656 uint32_t x = s->decoded[0][i];
00657 uint32_t y = s->decoded[0][i+1];
00658
00659 right[i] = x - (y / 2);
00660 left[i] = right[i] + y;
00661 }
00662 *data_size = 2 * s->blocksize;
00663 }
00664 else
00665 {
00666 for (i = 0; i < s->channels; i++)
00667 {
00668 switch(s->order)
00669 {
00670 case INDEPENDENT:
00671 for (j = 0; j < s->blocksize; j++)
00672 samples[(s->blocksize*i)+j] = s->decoded[i][j];
00673 break;
00674 case LEFT_SIDE:
00675 case RIGHT_SIDE:
00676 if (i == 0)
00677 for (j = 0; j < s->blocksize; j++)
00678 samples[(s->blocksize*i)+j] = s->decoded[0][j];
00679 else
00680 for (j = 0; j < s->blocksize; j++)
00681 samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
00682 break;
00683
00684
00685 }
00686 *data_size += s->blocksize;
00687 }
00688 }
00689 #else
00690 #define DECORRELATE(left, right)\
00691 assert(s->channels == 2);\
00692 for (i = 0; i < s->blocksize; i++)\
00693 {\
00694 int a= s->decoded[0][i];\
00695 int b= s->decoded[1][i];\
00696 *samples++ = ((left) << (24 - s->bps)) >> 8;\
00697 *samples++ = ((right) << (24 - s->bps)) >> 8;\
00698 }\
00699 break;
00700
00701 switch(s->decorrelation)
00702 {
00703 case INDEPENDENT:
00704 for (j = 0; j < s->blocksize; j++)
00705 {
00706 for (i = 0; i < s->channels; i++)
00707 *samples++ = (s->decoded[i][j] << (24 - s->bps)) >> 8;
00708 }
00709 break;
00710 case LEFT_SIDE:
00711 DECORRELATE(a,a-b)
00712 case RIGHT_SIDE:
00713 DECORRELATE(a+b,b)
00714 case MID_SIDE:
00715 DECORRELATE( (a-=b>>1) + b, a)
00716 }
00717 #endif
00718
00719 *data_size = (int8_t *)samples - (int8_t *)data;
00720
00721
00722
00723 end:
00724 i= (get_bits_count(&s->gb)+7)/8;;
00725 if(i > buf_size){
00726 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
00727 s->bitstream_size=0;
00728 s->bitstream_index=0;
00729 return -1;
00730 }
00731
00732 if(s->bitstream_size){
00733 s->bitstream_index += i;
00734 s->bitstream_size -= i;
00735 return input_buf_size;
00736 }else
00737 return i;
00738 }
00739
00740 static int flac_decode_close(AVCodecContext *avctx)
00741 {
00742 FLACContext *s = avctx->priv_data;
00743 int i;
00744
00745 for (i = 0; i < s->channels; i++)
00746 {
00747 av_freep(&s->decoded[i]);
00748 }
00749 av_freep(&s->bitstream);
00750
00751 return 0;
00752 }
00753
00754 static void flac_flush(AVCodecContext *avctx){
00755 FLACContext *s = avctx->priv_data;
00756
00757 s->bitstream_size=
00758 s->bitstream_index= 0;
00759 }
00760
00761 AVCodec flac_decoder = {
00762 "flac",
00763 CODEC_TYPE_AUDIO,
00764 CODEC_ID_FLAC,
00765 sizeof(FLACContext),
00766 flac_decode_init,
00767 NULL,
00768 flac_decode_close,
00769 flac_decode_frame,
00770 .flush= flac_flush,
00771 };