Libav 0.7.1
libavcodec/flacdec.c
Go to the documentation of this file.
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         ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
00232         buf += 4;
00233         if (buf + metadata_size > buf_end) {
00234             /* need more data in order to read the complete header */
00235             return 0;
00236         }
00237         buf += metadata_size;
00238     } while (!metadata_last);
00239 
00240     return buf_size - (buf_end - buf);
00241 }
00242 
00243 static int decode_residuals(FLACContext *s, int channel, int pred_order)
00244 {
00245     int i, tmp, partition, method_type, rice_order;
00246     int sample = 0, samples;
00247 
00248     method_type = get_bits(&s->gb, 2);
00249     if (method_type > 1) {
00250         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
00251                method_type);
00252         return -1;
00253     }
00254 
00255     rice_order = get_bits(&s->gb, 4);
00256 
00257     samples= s->blocksize >> rice_order;
00258     if (pred_order > samples) {
00259         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
00260                pred_order, samples);
00261         return -1;
00262     }
00263 
00264     sample=
00265     i= pred_order;
00266     for (partition = 0; partition < (1 << rice_order); partition++) {
00267         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
00268         if (tmp == (method_type == 0 ? 15 : 31)) {
00269             tmp = get_bits(&s->gb, 5);
00270             for (; i < samples; i++, sample++)
00271                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
00272         } else {
00273             for (; i < samples; i++, sample++) {
00274                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
00275             }
00276         }
00277         i= 0;
00278     }
00279 
00280     return 0;
00281 }
00282 
00283 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
00284 {
00285     const int blocksize = s->blocksize;
00286     int32_t *decoded = s->decoded[channel];
00287     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
00288 
00289     /* warm up samples */
00290     for (i = 0; i < pred_order; i++) {
00291         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
00292     }
00293 
00294     if (decode_residuals(s, channel, pred_order) < 0)
00295         return -1;
00296 
00297     if (pred_order > 0)
00298         a = decoded[pred_order-1];
00299     if (pred_order > 1)
00300         b = a - decoded[pred_order-2];
00301     if (pred_order > 2)
00302         c = b - decoded[pred_order-2] + decoded[pred_order-3];
00303     if (pred_order > 3)
00304         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
00305 
00306     switch (pred_order) {
00307     case 0:
00308         break;
00309     case 1:
00310         for (i = pred_order; i < blocksize; i++)
00311             decoded[i] = a += decoded[i];
00312         break;
00313     case 2:
00314         for (i = pred_order; i < blocksize; i++)
00315             decoded[i] = a += b += decoded[i];
00316         break;
00317     case 3:
00318         for (i = pred_order; i < blocksize; i++)
00319             decoded[i] = a += b += c += decoded[i];
00320         break;
00321     case 4:
00322         for (i = pred_order; i < blocksize; i++)
00323             decoded[i] = a += b += c += d += decoded[i];
00324         break;
00325     default:
00326         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
00327         return -1;
00328     }
00329 
00330     return 0;
00331 }
00332 
00333 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
00334 {
00335     int i, j;
00336     int coeff_prec, qlevel;
00337     int coeffs[32];
00338     int32_t *decoded = s->decoded[channel];
00339 
00340     /* warm up samples */
00341     for (i = 0; i < pred_order; i++) {
00342         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
00343     }
00344 
00345     coeff_prec = get_bits(&s->gb, 4) + 1;
00346     if (coeff_prec == 16) {
00347         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
00348         return -1;
00349     }
00350     qlevel = get_sbits(&s->gb, 5);
00351     if (qlevel < 0) {
00352         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
00353                qlevel);
00354         return -1;
00355     }
00356 
00357     for (i = 0; i < pred_order; i++) {
00358         coeffs[i] = get_sbits(&s->gb, coeff_prec);
00359     }
00360 
00361     if (decode_residuals(s, channel, pred_order) < 0)
00362         return -1;
00363 
00364     if (s->bps > 16) {
00365         int64_t sum;
00366         for (i = pred_order; i < s->blocksize; i++) {
00367             sum = 0;
00368             for (j = 0; j < pred_order; j++)
00369                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
00370             decoded[i] += sum >> qlevel;
00371         }
00372     } else {
00373         for (i = pred_order; i < s->blocksize-1; i += 2) {
00374             int c;
00375             int d = decoded[i-pred_order];
00376             int s0 = 0, s1 = 0;
00377             for (j = pred_order-1; j > 0; j--) {
00378                 c = coeffs[j];
00379                 s0 += c*d;
00380                 d = decoded[i-j];
00381                 s1 += c*d;
00382             }
00383             c = coeffs[0];
00384             s0 += c*d;
00385             d = decoded[i] += s0 >> qlevel;
00386             s1 += c*d;
00387             decoded[i+1] += s1 >> qlevel;
00388         }
00389         if (i < s->blocksize) {
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->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
00408             s->curr_bps++;
00409     } else {
00410         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
00411             s->curr_bps++;
00412     }
00413 
00414     if (get_bits1(&s->gb)) {
00415         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
00416         return -1;
00417     }
00418     type = get_bits(&s->gb, 6);
00419 
00420     if (get_bits1(&s->gb)) {
00421         wasted = 1;
00422         while (!get_bits1(&s->gb))
00423             wasted++;
00424         s->curr_bps -= wasted;
00425     }
00426     if (s->curr_bps > 32) {
00427         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
00428         return -1;
00429     }
00430 
00431 //FIXME use av_log2 for types
00432     if (type == 0) {
00433         tmp = get_sbits_long(&s->gb, s->curr_bps);
00434         for (i = 0; i < s->blocksize; i++)
00435             s->decoded[channel][i] = tmp;
00436     } else if (type == 1) {
00437         for (i = 0; i < s->blocksize; i++)
00438             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
00439     } else if ((type >= 8) && (type <= 12)) {
00440         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
00441             return -1;
00442     } else if (type >= 32) {
00443         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
00444             return -1;
00445     } else {
00446         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
00447         return -1;
00448     }
00449 
00450     if (wasted) {
00451         int i;
00452         for (i = 0; i < s->blocksize; i++)
00453             s->decoded[channel][i] <<= wasted;
00454     }
00455 
00456     return 0;
00457 }
00458 
00459 static int decode_frame(FLACContext *s)
00460 {
00461     int i;
00462     GetBitContext *gb = &s->gb;
00463     FLACFrameInfo fi;
00464 
00465     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
00466         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
00467         return -1;
00468     }
00469 
00470     if (s->channels && fi.channels != s->channels) {
00471         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
00472                                        "is not supported\n");
00473         return -1;
00474     }
00475     s->channels = s->avctx->channels = fi.channels;
00476     s->ch_mode = fi.ch_mode;
00477 
00478     if (!s->bps && !fi.bps) {
00479         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
00480         return -1;
00481     }
00482     if (!fi.bps) {
00483         fi.bps = s->bps;
00484     } else if (s->bps && fi.bps != s->bps) {
00485         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
00486                                        "supported\n");
00487         return -1;
00488     }
00489     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
00490 
00491     if (s->bps > 16) {
00492         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
00493         s->sample_shift = 32 - s->bps;
00494         s->is32 = 1;
00495     } else {
00496         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00497         s->sample_shift = 16 - s->bps;
00498         s->is32 = 0;
00499     }
00500 
00501     if (!s->max_blocksize)
00502         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
00503     if (fi.blocksize > s->max_blocksize) {
00504         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
00505                s->max_blocksize);
00506         return -1;
00507     }
00508     s->blocksize = fi.blocksize;
00509 
00510     if (!s->samplerate && !fi.samplerate) {
00511         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
00512                                         " or frame header\n");
00513         return -1;
00514     }
00515     if (fi.samplerate == 0) {
00516         fi.samplerate = s->samplerate;
00517     } else if (s->samplerate && fi.samplerate != s->samplerate) {
00518         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
00519                s->samplerate, fi.samplerate);
00520     }
00521     s->samplerate = s->avctx->sample_rate = fi.samplerate;
00522 
00523     if (!s->got_streaminfo) {
00524         allocate_buffers(s);
00525         s->got_streaminfo = 1;
00526         dump_headers(s->avctx, (FLACStreaminfo *)s);
00527     }
00528 
00529 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
00530 
00531     /* subframes */
00532     for (i = 0; i < s->channels; i++) {
00533         if (decode_subframe(s, i) < 0)
00534             return -1;
00535     }
00536 
00537     align_get_bits(gb);
00538 
00539     /* frame footer */
00540     skip_bits(gb, 16); /* data crc */
00541 
00542     return 0;
00543 }
00544 
00545 static int flac_decode_frame(AVCodecContext *avctx,
00546                             void *data, int *data_size,
00547                             AVPacket *avpkt)
00548 {
00549     const uint8_t *buf = avpkt->data;
00550     int buf_size = avpkt->size;
00551     FLACContext *s = avctx->priv_data;
00552     int i, j = 0, bytes_read = 0;
00553     int16_t *samples_16 = data;
00554     int32_t *samples_32 = data;
00555     int alloc_data_size= *data_size;
00556     int output_size;
00557 
00558     *data_size=0;
00559 
00560     if (s->max_framesize == 0) {
00561         s->max_framesize =
00562             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
00563                                        FLAC_MAX_CHANNELS, 32);
00564     }
00565 
00566     /* check that there is at least the smallest decodable amount of data.
00567        this amount corresponds to the smallest valid FLAC frame possible.
00568        FF F8 69 02 00 00 9A 00 00 34 46 */
00569     if (buf_size < FLAC_MIN_FRAME_SIZE)
00570         return buf_size;
00571 
00572     /* check for inline header */
00573     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
00574         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
00575             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
00576             return -1;
00577         }
00578         return get_metadata_size(buf, buf_size);
00579     }
00580 
00581     /* decode frame */
00582     init_get_bits(&s->gb, buf, buf_size*8);
00583     if (decode_frame(s) < 0) {
00584         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
00585         return -1;
00586     }
00587     bytes_read = (get_bits_count(&s->gb)+7)/8;
00588 
00589     /* check if allocated data size is large enough for output */
00590     output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
00591     if (output_size > alloc_data_size) {
00592         av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
00593                                        "allocated data size\n");
00594         return -1;
00595     }
00596     *data_size = output_size;
00597 
00598 #define DECORRELATE(left, right)\
00599             assert(s->channels == 2);\
00600             for (i = 0; i < s->blocksize; i++) {\
00601                 int a= s->decoded[0][i];\
00602                 int b= s->decoded[1][i];\
00603                 if (s->is32) {\
00604                     *samples_32++ = (left)  << s->sample_shift;\
00605                     *samples_32++ = (right) << s->sample_shift;\
00606                 } else {\
00607                     *samples_16++ = (left)  << s->sample_shift;\
00608                     *samples_16++ = (right) << s->sample_shift;\
00609                 }\
00610             }\
00611             break;
00612 
00613     switch (s->ch_mode) {
00614     case FLAC_CHMODE_INDEPENDENT:
00615         for (j = 0; j < s->blocksize; j++) {
00616             for (i = 0; i < s->channels; i++) {
00617                 if (s->is32)
00618                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
00619                 else
00620                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
00621             }
00622         }
00623         break;
00624     case FLAC_CHMODE_LEFT_SIDE:
00625         DECORRELATE(a,a-b)
00626     case FLAC_CHMODE_RIGHT_SIDE:
00627         DECORRELATE(a+b,b)
00628     case FLAC_CHMODE_MID_SIDE:
00629         DECORRELATE( (a-=b>>1) + b, a)
00630     }
00631 
00632     if (bytes_read > buf_size) {
00633         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
00634         return -1;
00635     }
00636     if (bytes_read < buf_size) {
00637         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
00638                buf_size - bytes_read, buf_size);
00639     }
00640 
00641     return bytes_read;
00642 }
00643 
00644 static av_cold int flac_decode_close(AVCodecContext *avctx)
00645 {
00646     FLACContext *s = avctx->priv_data;
00647     int i;
00648 
00649     for (i = 0; i < s->channels; i++) {
00650         av_freep(&s->decoded[i]);
00651     }
00652 
00653     return 0;
00654 }
00655 
00656 AVCodec ff_flac_decoder = {
00657     "flac",
00658     AVMEDIA_TYPE_AUDIO,
00659     CODEC_ID_FLAC,
00660     sizeof(FLACContext),
00661     flac_decode_init,
00662     NULL,
00663     flac_decode_close,
00664     flac_decode_frame,
00665     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
00666 };