Drop unnecessary av_uninit attributes from some variable declarations.
[ffmpeg.git] / libavcodec / flacdec.c
1 /*
2  * FLAC (Free Lossless Audio Codec) decoder
3  * Copyright (c) 2003 Alex Beregszaszi
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * FLAC (Free Lossless Audio Codec) decoder
25  * @author Alex Beregszaszi
26  * @see http://flac.sourceforge.net/
27  *
28  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
29  * through, starting from the initial 'fLaC' signature; or by passing the
30  * 34-byte streaminfo structure through avctx->extradata[_size] followed
31  * by data starting with the 0xFFF8 marker.
32  */
33
34 #include <limits.h>
35
36 #include "libavutil/crc.h"
37 #include "avcodec.h"
38 #include "internal.h"
39 #include "get_bits.h"
40 #include "bytestream.h"
41 #include "golomb.h"
42 #include "flac.h"
43 #include "flacdata.h"
44
45 #undef NDEBUG
46 #include <assert.h>
47
48 typedef struct FLACContext {
49     FLACSTREAMINFO
50
51     AVCodecContext *avctx;                  ///< parent AVCodecContext
52     AVFrame frame;
53     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
54
55     int blocksize;                          ///< number of samples in the current frame
56     int curr_bps;                           ///< bps for current subframe, adjusted for channel correlation and wasted bits
57     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
58     int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
59     int ch_mode;                            ///< channel decorrelation type in the current frame
60     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
61
62     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
63 } FLACContext;
64
65 static void allocate_buffers(FLACContext *s);
66
67 int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
68                                enum FLACExtradataFormat *format,
69                                uint8_t **streaminfo_start)
70 {
71     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
72         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
73         return 0;
74     }
75     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
76         /* extradata contains STREAMINFO only */
77         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
78             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
79                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
80         }
81         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
82         *streaminfo_start = avctx->extradata;
83     } else {
84         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
85             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
86             return 0;
87         }
88         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
89         *streaminfo_start = &avctx->extradata[8];
90     }
91     return 1;
92 }
93
94 static av_cold int flac_decode_init(AVCodecContext *avctx)
95 {
96     enum FLACExtradataFormat format;
97     uint8_t *streaminfo;
98     FLACContext *s = avctx->priv_data;
99     s->avctx = avctx;
100
101     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
102
103     /* for now, the raw FLAC header is allowed to be passed to the decoder as
104        frame data instead of extradata. */
105     if (!avctx->extradata)
106         return 0;
107
108     if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
109         return -1;
110
111     /* initialize based on the demuxer-supplied streamdata header */
112     avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
113     if (s->bps > 16)
114         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
115     else
116         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
117     allocate_buffers(s);
118     s->got_streaminfo = 1;
119
120     avcodec_get_frame_defaults(&s->frame);
121     avctx->coded_frame = &s->frame;
122
123     return 0;
124 }
125
126 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
127 {
128     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
129     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
130     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
131     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
132     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
133 }
134
135 static void allocate_buffers(FLACContext *s)
136 {
137     int i;
138
139     assert(s->max_blocksize);
140
141     for (i = 0; i < s->channels; i++) {
142         s->decoded[i] = av_realloc(s->decoded[i],
143                                    sizeof(int32_t)*s->max_blocksize);
144     }
145 }
146
147 void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
148                               const uint8_t *buffer)
149 {
150     GetBitContext gb;
151     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
152
153     skip_bits(&gb, 16); /* skip min blocksize */
154     s->max_blocksize = get_bits(&gb, 16);
155     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
156         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
157                s->max_blocksize);
158         s->max_blocksize = 16;
159     }
160
161     skip_bits(&gb, 24); /* skip min frame size */
162     s->max_framesize = get_bits_long(&gb, 24);
163
164     s->samplerate = get_bits_long(&gb, 20);
165     s->channels = get_bits(&gb, 3) + 1;
166     s->bps = get_bits(&gb, 5) + 1;
167
168     avctx->channels = s->channels;
169     avctx->sample_rate = s->samplerate;
170     avctx->bits_per_raw_sample = s->bps;
171
172     s->samples  = get_bits_long(&gb, 32) << 4;
173     s->samples |= get_bits(&gb, 4);
174
175     skip_bits_long(&gb, 64); /* md5 sum */
176     skip_bits_long(&gb, 64); /* md5 sum */
177
178     dump_headers(avctx, s);
179 }
180
181 void avpriv_flac_parse_block_header(const uint8_t *block_header,
182                                 int *last, int *type, int *size)
183 {
184     int tmp = bytestream_get_byte(&block_header);
185     if (last)
186         *last = tmp & 0x80;
187     if (type)
188         *type = tmp & 0x7F;
189     if (size)
190         *size = bytestream_get_be24(&block_header);
191 }
192
193 /**
194  * Parse the STREAMINFO from an inline header.
195  * @param s the flac decoding context
196  * @param buf input buffer, starting with the "fLaC" marker
197  * @param buf_size buffer size
198  * @return non-zero if metadata is invalid
199  */
200 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
201 {
202     int metadata_type, metadata_size;
203
204     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
205         /* need more data */
206         return 0;
207     }
208     avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
209     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
210         metadata_size != FLAC_STREAMINFO_SIZE) {
211         return AVERROR_INVALIDDATA;
212     }
213     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
214     allocate_buffers(s);
215     s->got_streaminfo = 1;
216
217     return 0;
218 }
219
220 /**
221  * Determine the size of an inline header.
222  * @param buf input buffer, starting with the "fLaC" marker
223  * @param buf_size buffer size
224  * @return number of bytes in the header, or 0 if more data is needed
225  */
226 static int get_metadata_size(const uint8_t *buf, int buf_size)
227 {
228     int metadata_last, metadata_size;
229     const uint8_t *buf_end = buf + buf_size;
230
231     buf += 4;
232     do {
233         if (buf_end - buf < 4)
234             return 0;
235         avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
236         buf += 4;
237         if (buf_end - buf < metadata_size) {
238             /* need more data in order to read the complete header */
239             return 0;
240         }
241         buf += metadata_size;
242     } while (!metadata_last);
243
244     return buf_size - (buf_end - buf);
245 }
246
247 static int decode_residuals(FLACContext *s, int channel, int pred_order)
248 {
249     int i, tmp, partition, method_type, rice_order;
250     int sample = 0, samples;
251
252     method_type = get_bits(&s->gb, 2);
253     if (method_type > 1) {
254         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
255                method_type);
256         return -1;
257     }
258
259     rice_order = get_bits(&s->gb, 4);
260
261     samples= s->blocksize >> rice_order;
262     if (pred_order > samples) {
263         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
264                pred_order, samples);
265         return -1;
266     }
267
268     sample=
269     i= pred_order;
270     for (partition = 0; partition < (1 << rice_order); partition++) {
271         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
272         if (tmp == (method_type == 0 ? 15 : 31)) {
273             tmp = get_bits(&s->gb, 5);
274             for (; i < samples; i++, sample++)
275                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
276         } else {
277             for (; i < samples; i++, sample++) {
278                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
279             }
280         }
281         i= 0;
282     }
283
284     return 0;
285 }
286
287 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
288 {
289     const int blocksize = s->blocksize;
290     int32_t *decoded = s->decoded[channel];
291     int a, b, c, d, i;
292
293     /* warm up samples */
294     for (i = 0; i < pred_order; i++) {
295         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
296     }
297
298     if (decode_residuals(s, channel, pred_order) < 0)
299         return -1;
300
301     if (pred_order > 0)
302         a = decoded[pred_order-1];
303     if (pred_order > 1)
304         b = a - decoded[pred_order-2];
305     if (pred_order > 2)
306         c = b - decoded[pred_order-2] + decoded[pred_order-3];
307     if (pred_order > 3)
308         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
309
310     switch (pred_order) {
311     case 0:
312         break;
313     case 1:
314         for (i = pred_order; i < blocksize; i++)
315             decoded[i] = a += decoded[i];
316         break;
317     case 2:
318         for (i = pred_order; i < blocksize; i++)
319             decoded[i] = a += b += decoded[i];
320         break;
321     case 3:
322         for (i = pred_order; i < blocksize; i++)
323             decoded[i] = a += b += c += decoded[i];
324         break;
325     case 4:
326         for (i = pred_order; i < blocksize; i++)
327             decoded[i] = a += b += c += d += decoded[i];
328         break;
329     default:
330         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
331         return -1;
332     }
333
334     return 0;
335 }
336
337 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
338 {
339     int i, j;
340     int coeff_prec, qlevel;
341     int coeffs[32];
342     int32_t *decoded = s->decoded[channel];
343
344     /* warm up samples */
345     for (i = 0; i < pred_order; i++) {
346         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
347     }
348
349     coeff_prec = get_bits(&s->gb, 4) + 1;
350     if (coeff_prec == 16) {
351         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
352         return -1;
353     }
354     qlevel = get_sbits(&s->gb, 5);
355     if (qlevel < 0) {
356         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
357                qlevel);
358         return -1;
359     }
360
361     for (i = 0; i < pred_order; i++) {
362         coeffs[i] = get_sbits(&s->gb, coeff_prec);
363     }
364
365     if (decode_residuals(s, channel, pred_order) < 0)
366         return -1;
367
368     if (s->bps > 16) {
369         int64_t sum;
370         for (i = pred_order; i < s->blocksize; i++) {
371             sum = 0;
372             for (j = 0; j < pred_order; j++)
373                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
374             decoded[i] += sum >> qlevel;
375         }
376     } else {
377         for (i = pred_order; i < s->blocksize-1; i += 2) {
378             int c;
379             int d = decoded[i-pred_order];
380             int s0 = 0, s1 = 0;
381             for (j = pred_order-1; j > 0; j--) {
382                 c = coeffs[j];
383                 s0 += c*d;
384                 d = decoded[i-j];
385                 s1 += c*d;
386             }
387             c = coeffs[0];
388             s0 += c*d;
389             d = decoded[i] += s0 >> qlevel;
390             s1 += c*d;
391             decoded[i+1] += s1 >> qlevel;
392         }
393         if (i < s->blocksize) {
394             int sum = 0;
395             for (j = 0; j < pred_order; j++)
396                 sum += coeffs[j] * decoded[i-j-1];
397             decoded[i] += sum >> qlevel;
398         }
399     }
400
401     return 0;
402 }
403
404 static inline int decode_subframe(FLACContext *s, int channel)
405 {
406     int type, wasted = 0;
407     int i, tmp;
408
409     s->curr_bps = s->bps;
410     if (channel == 0) {
411         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
412             s->curr_bps++;
413     } else {
414         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
415             s->curr_bps++;
416     }
417
418     if (get_bits1(&s->gb)) {
419         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
420         return -1;
421     }
422     type = get_bits(&s->gb, 6);
423
424     if (get_bits1(&s->gb)) {
425         wasted = 1;
426         while (!get_bits1(&s->gb))
427             wasted++;
428         s->curr_bps -= wasted;
429     }
430     if (s->curr_bps > 32) {
431         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
432         return -1;
433     }
434
435 //FIXME use av_log2 for types
436     if (type == 0) {
437         tmp = get_sbits_long(&s->gb, s->curr_bps);
438         for (i = 0; i < s->blocksize; i++)
439             s->decoded[channel][i] = tmp;
440     } else if (type == 1) {
441         for (i = 0; i < s->blocksize; i++)
442             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
443     } else if ((type >= 8) && (type <= 12)) {
444         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
445             return -1;
446     } else if (type >= 32) {
447         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
448             return -1;
449     } else {
450         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
451         return -1;
452     }
453
454     if (wasted) {
455         int i;
456         for (i = 0; i < s->blocksize; i++)
457             s->decoded[channel][i] <<= wasted;
458     }
459
460     return 0;
461 }
462
463 static int decode_frame(FLACContext *s)
464 {
465     int i;
466     GetBitContext *gb = &s->gb;
467     FLACFrameInfo fi;
468
469     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
470         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
471         return -1;
472     }
473
474     if (s->channels && fi.channels != s->channels) {
475         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
476                                        "is not supported\n");
477         return -1;
478     }
479     s->channels = s->avctx->channels = fi.channels;
480     s->ch_mode = fi.ch_mode;
481
482     if (!s->bps && !fi.bps) {
483         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
484         return -1;
485     }
486     if (!fi.bps) {
487         fi.bps = s->bps;
488     } else if (s->bps && fi.bps != s->bps) {
489         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
490                                        "supported\n");
491         return -1;
492     }
493     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
494
495     if (s->bps > 16) {
496         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
497         s->sample_shift = 32 - s->bps;
498         s->is32 = 1;
499     } else {
500         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
501         s->sample_shift = 16 - s->bps;
502         s->is32 = 0;
503     }
504
505     if (!s->max_blocksize)
506         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
507     if (fi.blocksize > s->max_blocksize) {
508         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
509                s->max_blocksize);
510         return -1;
511     }
512     s->blocksize = fi.blocksize;
513
514     if (!s->samplerate && !fi.samplerate) {
515         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
516                                         " or frame header\n");
517         return -1;
518     }
519     if (fi.samplerate == 0) {
520         fi.samplerate = s->samplerate;
521     } else if (s->samplerate && fi.samplerate != s->samplerate) {
522         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
523                s->samplerate, fi.samplerate);
524     }
525     s->samplerate = s->avctx->sample_rate = fi.samplerate;
526
527     if (!s->got_streaminfo) {
528         allocate_buffers(s);
529         s->got_streaminfo = 1;
530         dump_headers(s->avctx, (FLACStreaminfo *)s);
531     }
532
533 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
534
535     /* subframes */
536     for (i = 0; i < s->channels; i++) {
537         if (decode_subframe(s, i) < 0)
538             return -1;
539     }
540
541     align_get_bits(gb);
542
543     /* frame footer */
544     skip_bits(gb, 16); /* data crc */
545
546     return 0;
547 }
548
549 static int flac_decode_frame(AVCodecContext *avctx, void *data,
550                              int *got_frame_ptr, AVPacket *avpkt)
551 {
552     const uint8_t *buf = avpkt->data;
553     int buf_size = avpkt->size;
554     FLACContext *s = avctx->priv_data;
555     int i, j = 0, bytes_read = 0;
556     int16_t *samples_16;
557     int32_t *samples_32;
558     int ret;
559
560     *got_frame_ptr = 0;
561
562     if (s->max_framesize == 0) {
563         s->max_framesize =
564             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
565                                        FLAC_MAX_CHANNELS, 32);
566     }
567
568     /* check that there is at least the smallest decodable amount of data.
569        this amount corresponds to the smallest valid FLAC frame possible.
570        FF F8 69 02 00 00 9A 00 00 34 46 */
571     if (buf_size < FLAC_MIN_FRAME_SIZE)
572         return buf_size;
573
574     /* check for inline header */
575     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
576         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
577             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
578             return -1;
579         }
580         return get_metadata_size(buf, buf_size);
581     }
582
583     /* decode frame */
584     init_get_bits(&s->gb, buf, buf_size*8);
585     if (decode_frame(s) < 0) {
586         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
587         return -1;
588     }
589     bytes_read = (get_bits_count(&s->gb)+7)/8;
590
591     /* get output buffer */
592     s->frame.nb_samples = s->blocksize;
593     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
594         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
595         return ret;
596     }
597     samples_16 = (int16_t *)s->frame.data[0];
598     samples_32 = (int32_t *)s->frame.data[0];
599
600 #define DECORRELATE(left, right)\
601             assert(s->channels == 2);\
602             for (i = 0; i < s->blocksize; i++) {\
603                 int a= s->decoded[0][i];\
604                 int b= s->decoded[1][i];\
605                 if (s->is32) {\
606                     *samples_32++ = (left)  << s->sample_shift;\
607                     *samples_32++ = (right) << s->sample_shift;\
608                 } else {\
609                     *samples_16++ = (left)  << s->sample_shift;\
610                     *samples_16++ = (right) << s->sample_shift;\
611                 }\
612             }\
613             break;
614
615     switch (s->ch_mode) {
616     case FLAC_CHMODE_INDEPENDENT:
617         for (j = 0; j < s->blocksize; j++) {
618             for (i = 0; i < s->channels; i++) {
619                 if (s->is32)
620                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
621                 else
622                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
623             }
624         }
625         break;
626     case FLAC_CHMODE_LEFT_SIDE:
627         DECORRELATE(a,a-b)
628     case FLAC_CHMODE_RIGHT_SIDE:
629         DECORRELATE(a+b,b)
630     case FLAC_CHMODE_MID_SIDE:
631         DECORRELATE( (a-=b>>1) + b, a)
632     }
633
634     if (bytes_read > buf_size) {
635         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
636         return -1;
637     }
638     if (bytes_read < buf_size) {
639         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
640                buf_size - bytes_read, buf_size);
641     }
642
643     *got_frame_ptr   = 1;
644     *(AVFrame *)data = s->frame;
645
646     return bytes_read;
647 }
648
649 static av_cold int flac_decode_close(AVCodecContext *avctx)
650 {
651     FLACContext *s = avctx->priv_data;
652     int i;
653
654     for (i = 0; i < s->channels; i++) {
655         av_freep(&s->decoded[i]);
656     }
657
658     return 0;
659 }
660
661 AVCodec ff_flac_decoder = {
662     .name           = "flac",
663     .type           = AVMEDIA_TYPE_AUDIO,
664     .id             = CODEC_ID_FLAC,
665     .priv_data_size = sizeof(FLACContext),
666     .init           = flac_decode_init,
667     .close          = flac_decode_close,
668     .decode         = flac_decode_frame,
669     .capabilities   = CODEC_CAP_DR1,
670     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
671 };