Libav 0.7.1
|
00001 /* 00002 * FLAC (Free Lossless Audio Codec) decoder 00003 * Copyright (c) 2003 Alex Beregszaszi 00004 * 00005 * This file is part of Libav. 00006 * 00007 * Libav is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU Lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * Libav is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * Lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU Lesser General Public 00018 * License along with Libav; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00020 */ 00021 00036 #include <limits.h> 00037 00038 #include "libavutil/crc.h" 00039 #include "avcodec.h" 00040 #include "internal.h" 00041 #include "get_bits.h" 00042 #include "bytestream.h" 00043 #include "golomb.h" 00044 #include "flac.h" 00045 #include "flacdata.h" 00046 00047 #undef NDEBUG 00048 #include <assert.h> 00049 00050 typedef struct FLACContext { 00051 FLACSTREAMINFO 00052 00053 AVCodecContext *avctx; 00054 GetBitContext gb; 00055 00056 int blocksize; 00057 int curr_bps; 00058 int sample_shift; 00059 int is32; 00060 int ch_mode; 00061 int got_streaminfo; 00062 00063 int32_t *decoded[FLAC_MAX_CHANNELS]; 00064 } FLACContext; 00065 00066 static void allocate_buffers(FLACContext *s); 00067 00068 int ff_flac_is_extradata_valid(AVCodecContext *avctx, 00069 enum FLACExtradataFormat *format, 00070 uint8_t **streaminfo_start) 00071 { 00072 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) { 00073 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n"); 00074 return 0; 00075 } 00076 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) { 00077 /* extradata contains STREAMINFO only */ 00078 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) { 00079 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n", 00080 FLAC_STREAMINFO_SIZE-avctx->extradata_size); 00081 } 00082 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO; 00083 *streaminfo_start = avctx->extradata; 00084 } else { 00085 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) { 00086 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n"); 00087 return 0; 00088 } 00089 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER; 00090 *streaminfo_start = &avctx->extradata[8]; 00091 } 00092 return 1; 00093 } 00094 00095 static av_cold int flac_decode_init(AVCodecContext *avctx) 00096 { 00097 enum FLACExtradataFormat format; 00098 uint8_t *streaminfo; 00099 FLACContext *s = avctx->priv_data; 00100 s->avctx = avctx; 00101 00102 avctx->sample_fmt = AV_SAMPLE_FMT_S16; 00103 00104 /* for now, the raw FLAC header is allowed to be passed to the decoder as 00105 frame data instead of extradata. */ 00106 if (!avctx->extradata) 00107 return 0; 00108 00109 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo)) 00110 return -1; 00111 00112 /* initialize based on the demuxer-supplied streamdata header */ 00113 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo); 00114 if (s->bps > 16) 00115 avctx->sample_fmt = AV_SAMPLE_FMT_S32; 00116 else 00117 avctx->sample_fmt = AV_SAMPLE_FMT_S16; 00118 allocate_buffers(s); 00119 s->got_streaminfo = 1; 00120 00121 return 0; 00122 } 00123 00124 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s) 00125 { 00126 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize); 00127 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize); 00128 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate); 00129 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels); 00130 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps); 00131 } 00132 00133 static void allocate_buffers(FLACContext *s) 00134 { 00135 int i; 00136 00137 assert(s->max_blocksize); 00138 00139 for (i = 0; i < s->channels; i++) { 00140 s->decoded[i] = av_realloc(s->decoded[i], 00141 sizeof(int32_t)*s->max_blocksize); 00142 } 00143 } 00144 00145 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, 00146 const uint8_t *buffer) 00147 { 00148 GetBitContext gb; 00149 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8); 00150 00151 skip_bits(&gb, 16); /* skip min blocksize */ 00152 s->max_blocksize = get_bits(&gb, 16); 00153 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) { 00154 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n", 00155 s->max_blocksize); 00156 s->max_blocksize = 16; 00157 } 00158 00159 skip_bits(&gb, 24); /* skip min frame size */ 00160 s->max_framesize = get_bits_long(&gb, 24); 00161 00162 s->samplerate = get_bits_long(&gb, 20); 00163 s->channels = get_bits(&gb, 3) + 1; 00164 s->bps = get_bits(&gb, 5) + 1; 00165 00166 avctx->channels = s->channels; 00167 avctx->sample_rate = s->samplerate; 00168 avctx->bits_per_raw_sample = s->bps; 00169 00170 s->samples = get_bits_long(&gb, 32) << 4; 00171 s->samples |= get_bits(&gb, 4); 00172 00173 skip_bits_long(&gb, 64); /* md5 sum */ 00174 skip_bits_long(&gb, 64); /* md5 sum */ 00175 00176 dump_headers(avctx, s); 00177 } 00178 00179 void ff_flac_parse_block_header(const uint8_t *block_header, 00180 int *last, int *type, int *size) 00181 { 00182 int tmp = bytestream_get_byte(&block_header); 00183 if (last) 00184 *last = tmp & 0x80; 00185 if (type) 00186 *type = tmp & 0x7F; 00187 if (size) 00188 *size = bytestream_get_be24(&block_header); 00189 } 00190 00198 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size) 00199 { 00200 int metadata_type, metadata_size; 00201 00202 if (buf_size < FLAC_STREAMINFO_SIZE+8) { 00203 /* need more data */ 00204 return 0; 00205 } 00206 ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size); 00207 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO || 00208 metadata_size != FLAC_STREAMINFO_SIZE) { 00209 return AVERROR_INVALIDDATA; 00210 } 00211 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]); 00212 allocate_buffers(s); 00213 s->got_streaminfo = 1; 00214 00215 return 0; 00216 } 00217 00224 static int get_metadata_size(const uint8_t *buf, int buf_size) 00225 { 00226 int metadata_last, metadata_size; 00227 const uint8_t *buf_end = buf + buf_size; 00228 00229 buf += 4; 00230 do { 00231 if (buf_end - buf < 4) 00232 return 0; 00233 ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size); 00234 buf += 4; 00235 if (buf_end - buf < metadata_size) { 00236 /* need more data in order to read the complete header */ 00237 return 0; 00238 } 00239 buf += metadata_size; 00240 } while (!metadata_last); 00241 00242 return buf_size - (buf_end - buf); 00243 } 00244 00245 static int decode_residuals(FLACContext *s, int channel, int pred_order) 00246 { 00247 int i, tmp, partition, method_type, rice_order; 00248 int sample = 0, samples; 00249 00250 method_type = get_bits(&s->gb, 2); 00251 if (method_type > 1) { 00252 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", 00253 method_type); 00254 return -1; 00255 } 00256 00257 rice_order = get_bits(&s->gb, 4); 00258 00259 samples= s->blocksize >> rice_order; 00260 if (pred_order > samples) { 00261 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", 00262 pred_order, samples); 00263 return -1; 00264 } 00265 00266 sample= 00267 i= pred_order; 00268 for (partition = 0; partition < (1 << rice_order); partition++) { 00269 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5); 00270 if (tmp == (method_type == 0 ? 15 : 31)) { 00271 tmp = get_bits(&s->gb, 5); 00272 for (; i < samples; i++, sample++) 00273 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp); 00274 } else { 00275 for (; i < samples; i++, sample++) { 00276 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); 00277 } 00278 } 00279 i= 0; 00280 } 00281 00282 return 0; 00283 } 00284 00285 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) 00286 { 00287 const int blocksize = s->blocksize; 00288 int32_t *decoded = s->decoded[channel]; 00289 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i; 00290 00291 /* warm up samples */ 00292 for (i = 0; i < pred_order; i++) { 00293 decoded[i] = get_sbits_long(&s->gb, s->curr_bps); 00294 } 00295 00296 if (decode_residuals(s, channel, pred_order) < 0) 00297 return -1; 00298 00299 if (pred_order > 0) 00300 a = decoded[pred_order-1]; 00301 if (pred_order > 1) 00302 b = a - decoded[pred_order-2]; 00303 if (pred_order > 2) 00304 c = b - decoded[pred_order-2] + decoded[pred_order-3]; 00305 if (pred_order > 3) 00306 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4]; 00307 00308 switch (pred_order) { 00309 case 0: 00310 break; 00311 case 1: 00312 for (i = pred_order; i < blocksize; i++) 00313 decoded[i] = a += decoded[i]; 00314 break; 00315 case 2: 00316 for (i = pred_order; i < blocksize; i++) 00317 decoded[i] = a += b += decoded[i]; 00318 break; 00319 case 3: 00320 for (i = pred_order; i < blocksize; i++) 00321 decoded[i] = a += b += c += decoded[i]; 00322 break; 00323 case 4: 00324 for (i = pred_order; i < blocksize; i++) 00325 decoded[i] = a += b += c += d += decoded[i]; 00326 break; 00327 default: 00328 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); 00329 return -1; 00330 } 00331 00332 return 0; 00333 } 00334 00335 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) 00336 { 00337 int i, j; 00338 int coeff_prec, qlevel; 00339 int coeffs[32]; 00340 int32_t *decoded = s->decoded[channel]; 00341 00342 /* warm up samples */ 00343 for (i = 0; i < pred_order; i++) { 00344 decoded[i] = get_sbits_long(&s->gb, s->curr_bps); 00345 } 00346 00347 coeff_prec = get_bits(&s->gb, 4) + 1; 00348 if (coeff_prec == 16) { 00349 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); 00350 return -1; 00351 } 00352 qlevel = get_sbits(&s->gb, 5); 00353 if (qlevel < 0) { 00354 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", 00355 qlevel); 00356 return -1; 00357 } 00358 00359 for (i = 0; i < pred_order; i++) { 00360 coeffs[i] = get_sbits(&s->gb, coeff_prec); 00361 } 00362 00363 if (decode_residuals(s, channel, pred_order) < 0) 00364 return -1; 00365 00366 if (s->bps > 16) { 00367 int64_t sum; 00368 for (i = pred_order; i < s->blocksize; i++) { 00369 sum = 0; 00370 for (j = 0; j < pred_order; j++) 00371 sum += (int64_t)coeffs[j] * decoded[i-j-1]; 00372 decoded[i] += sum >> qlevel; 00373 } 00374 } else { 00375 for (i = pred_order; i < s->blocksize-1; i += 2) { 00376 int c; 00377 int d = decoded[i-pred_order]; 00378 int s0 = 0, s1 = 0; 00379 for (j = pred_order-1; j > 0; j--) { 00380 c = coeffs[j]; 00381 s0 += c*d; 00382 d = decoded[i-j]; 00383 s1 += c*d; 00384 } 00385 c = coeffs[0]; 00386 s0 += c*d; 00387 d = decoded[i] += s0 >> qlevel; 00388 s1 += c*d; 00389 decoded[i+1] += s1 >> qlevel; 00390 } 00391 if (i < s->blocksize) { 00392 int sum = 0; 00393 for (j = 0; j < pred_order; j++) 00394 sum += coeffs[j] * decoded[i-j-1]; 00395 decoded[i] += sum >> qlevel; 00396 } 00397 } 00398 00399 return 0; 00400 } 00401 00402 static inline int decode_subframe(FLACContext *s, int channel) 00403 { 00404 int type, wasted = 0; 00405 int i, tmp; 00406 00407 s->curr_bps = s->bps; 00408 if (channel == 0) { 00409 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE) 00410 s->curr_bps++; 00411 } else { 00412 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE) 00413 s->curr_bps++; 00414 } 00415 00416 if (get_bits1(&s->gb)) { 00417 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n"); 00418 return -1; 00419 } 00420 type = get_bits(&s->gb, 6); 00421 00422 if (get_bits1(&s->gb)) { 00423 int left = get_bits_left(&s->gb); 00424 wasted = 1; 00425 if ( left < 0 || 00426 (left < s->curr_bps && !show_bits_long(&s->gb, left)) || 00427 !show_bits_long(&s->gb, s->curr_bps)) { 00428 av_log(s->avctx, AV_LOG_ERROR, 00429 "Invalid number of wasted bits > available bits (%d) - left=%d\n", 00430 s->curr_bps, left); 00431 return AVERROR_INVALIDDATA; 00432 } 00433 while (!get_bits1(&s->gb)) 00434 wasted++; 00435 s->curr_bps -= wasted; 00436 } 00437 if (s->curr_bps > 32) { 00438 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0); 00439 return -1; 00440 } 00441 00442 //FIXME use av_log2 for types 00443 if (type == 0) { 00444 tmp = get_sbits_long(&s->gb, s->curr_bps); 00445 for (i = 0; i < s->blocksize; i++) 00446 s->decoded[channel][i] = tmp; 00447 } else if (type == 1) { 00448 for (i = 0; i < s->blocksize; i++) 00449 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps); 00450 } else if ((type >= 8) && (type <= 12)) { 00451 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) 00452 return -1; 00453 } else if (type >= 32) { 00454 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) 00455 return -1; 00456 } else { 00457 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); 00458 return -1; 00459 } 00460 00461 if (wasted) { 00462 int i; 00463 for (i = 0; i < s->blocksize; i++) 00464 s->decoded[channel][i] <<= wasted; 00465 } 00466 00467 return 0; 00468 } 00469 00470 static int decode_frame(FLACContext *s) 00471 { 00472 int i; 00473 GetBitContext *gb = &s->gb; 00474 FLACFrameInfo fi; 00475 00476 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) { 00477 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n"); 00478 return -1; 00479 } 00480 00481 if (s->channels && fi.channels != s->channels) { 00482 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream " 00483 "is not supported\n"); 00484 return -1; 00485 } 00486 s->channels = s->avctx->channels = fi.channels; 00487 s->ch_mode = fi.ch_mode; 00488 00489 if (!s->bps && !fi.bps) { 00490 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n"); 00491 return -1; 00492 } 00493 if (!fi.bps) { 00494 fi.bps = s->bps; 00495 } else if (s->bps && fi.bps != s->bps) { 00496 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not " 00497 "supported\n"); 00498 return -1; 00499 } 00500 s->bps = s->avctx->bits_per_raw_sample = fi.bps; 00501 00502 if (s->bps > 16) { 00503 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32; 00504 s->sample_shift = 32 - s->bps; 00505 s->is32 = 1; 00506 } else { 00507 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16; 00508 s->sample_shift = 16 - s->bps; 00509 s->is32 = 0; 00510 } 00511 00512 if (!s->max_blocksize) 00513 s->max_blocksize = FLAC_MAX_BLOCKSIZE; 00514 if (fi.blocksize > s->max_blocksize) { 00515 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize, 00516 s->max_blocksize); 00517 return -1; 00518 } 00519 s->blocksize = fi.blocksize; 00520 00521 if (!s->samplerate && !fi.samplerate) { 00522 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO" 00523 " or frame header\n"); 00524 return -1; 00525 } 00526 if (fi.samplerate == 0) { 00527 fi.samplerate = s->samplerate; 00528 } else if (s->samplerate && fi.samplerate != s->samplerate) { 00529 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n", 00530 s->samplerate, fi.samplerate); 00531 } 00532 s->samplerate = s->avctx->sample_rate = fi.samplerate; 00533 00534 if (!s->got_streaminfo) { 00535 allocate_buffers(s); 00536 s->got_streaminfo = 1; 00537 dump_headers(s->avctx, (FLACStreaminfo *)s); 00538 } 00539 00540 // dump_headers(s->avctx, (FLACStreaminfo *)s); 00541 00542 /* subframes */ 00543 for (i = 0; i < s->channels; i++) { 00544 if (decode_subframe(s, i) < 0) 00545 return -1; 00546 } 00547 00548 align_get_bits(gb); 00549 00550 /* frame footer */ 00551 skip_bits(gb, 16); /* data crc */ 00552 00553 return 0; 00554 } 00555 00556 static int flac_decode_frame(AVCodecContext *avctx, 00557 void *data, int *data_size, 00558 AVPacket *avpkt) 00559 { 00560 const uint8_t *buf = avpkt->data; 00561 int buf_size = avpkt->size; 00562 FLACContext *s = avctx->priv_data; 00563 int i, j = 0, bytes_read = 0; 00564 int16_t *samples_16 = data; 00565 int32_t *samples_32 = data; 00566 int alloc_data_size= *data_size; 00567 int output_size; 00568 00569 *data_size=0; 00570 00571 if (s->max_framesize == 0) { 00572 s->max_framesize = 00573 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE, 00574 FLAC_MAX_CHANNELS, 32); 00575 } 00576 00577 /* check that there is at least the smallest decodable amount of data. 00578 this amount corresponds to the smallest valid FLAC frame possible. 00579 FF F8 69 02 00 00 9A 00 00 34 46 */ 00580 if (buf_size < FLAC_MIN_FRAME_SIZE) 00581 return buf_size; 00582 00583 /* check for inline header */ 00584 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) { 00585 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) { 00586 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n"); 00587 return -1; 00588 } 00589 return get_metadata_size(buf, buf_size); 00590 } 00591 00592 /* decode frame */ 00593 init_get_bits(&s->gb, buf, buf_size*8); 00594 if (decode_frame(s) < 0) { 00595 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n"); 00596 return -1; 00597 } 00598 bytes_read = (get_bits_count(&s->gb)+7)/8; 00599 00600 /* check if allocated data size is large enough for output */ 00601 output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2); 00602 if (output_size > alloc_data_size) { 00603 av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than " 00604 "allocated data size\n"); 00605 return -1; 00606 } 00607 *data_size = output_size; 00608 00609 #define DECORRELATE(left, right)\ 00610 assert(s->channels == 2);\ 00611 for (i = 0; i < s->blocksize; i++) {\ 00612 int a= s->decoded[0][i];\ 00613 int b= s->decoded[1][i];\ 00614 if (s->is32) {\ 00615 *samples_32++ = (left) << s->sample_shift;\ 00616 *samples_32++ = (right) << s->sample_shift;\ 00617 } else {\ 00618 *samples_16++ = (left) << s->sample_shift;\ 00619 *samples_16++ = (right) << s->sample_shift;\ 00620 }\ 00621 }\ 00622 break; 00623 00624 switch (s->ch_mode) { 00625 case FLAC_CHMODE_INDEPENDENT: 00626 for (j = 0; j < s->blocksize; j++) { 00627 for (i = 0; i < s->channels; i++) { 00628 if (s->is32) 00629 *samples_32++ = s->decoded[i][j] << s->sample_shift; 00630 else 00631 *samples_16++ = s->decoded[i][j] << s->sample_shift; 00632 } 00633 } 00634 break; 00635 case FLAC_CHMODE_LEFT_SIDE: 00636 DECORRELATE(a,a-b) 00637 case FLAC_CHMODE_RIGHT_SIDE: 00638 DECORRELATE(a+b,b) 00639 case FLAC_CHMODE_MID_SIDE: 00640 DECORRELATE( (a-=b>>1) + b, a) 00641 } 00642 00643 if (bytes_read > buf_size) { 00644 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size); 00645 return -1; 00646 } 00647 if (bytes_read < buf_size) { 00648 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n", 00649 buf_size - bytes_read, buf_size); 00650 } 00651 00652 return bytes_read; 00653 } 00654 00655 static av_cold int flac_decode_close(AVCodecContext *avctx) 00656 { 00657 FLACContext *s = avctx->priv_data; 00658 int i; 00659 00660 for (i = 0; i < s->channels; i++) { 00661 av_freep(&s->decoded[i]); 00662 } 00663 00664 return 0; 00665 } 00666 00667 AVCodec ff_flac_decoder = { 00668 "flac", 00669 AVMEDIA_TYPE_AUDIO, 00670 CODEC_ID_FLAC, 00671 sizeof(FLACContext), 00672 flac_decode_init, 00673 NULL, 00674 flac_decode_close, 00675 flac_decode_frame, 00676 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), 00677 };