flacdec: fix buffer size checking in get_metadata_size()
[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 FFmpeg.
6  *
7  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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  *
27  * For more information on the FLAC format, visit:
28  *  http://flac.sourceforge.net/
29  *
30  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
31  * through, starting from the initial 'fLaC' signature; or by passing the
32  * 34-byte streaminfo structure through avctx->extradata[_size] followed
33  * by data starting with the 0xFFF8 marker.
34  */
35
36 #include <limits.h>
37
38 #include "libavutil/crc.h"
39 #include "avcodec.h"
40 #include "internal.h"
41 #include "get_bits.h"
42 #include "bytestream.h"
43 #include "golomb.h"
44 #include "flac.h"
45 #include "flacdata.h"
46
47 #undef NDEBUG
48 #include <assert.h>
49
50 typedef struct FLACContext {
51     FLACSTREAMINFO
52
53     AVCodecContext *avctx;                  ///< parent AVCodecContext
54     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
55
56     int blocksize;                          ///< number of samples in the current frame
57     int curr_bps;                           ///< bps for current subframe, adjusted for channel correlation and wasted bits
58     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
59     int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
60     int ch_mode;                            ///< channel decorrelation type in the current frame
61     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
62
63     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
64 } FLACContext;
65
66 static void allocate_buffers(FLACContext *s);
67
68 int ff_flac_is_extradata_valid(AVCodecContext *avctx,
69                                enum FLACExtradataFormat *format,
70                                uint8_t **streaminfo_start)
71 {
72     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
73         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
74         return 0;
75     }
76     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
77         /* extradata contains STREAMINFO only */
78         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
79             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
80                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
81         }
82         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
83         *streaminfo_start = avctx->extradata;
84     } else {
85         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
86             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
87             return 0;
88         }
89         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
90         *streaminfo_start = &avctx->extradata[8];
91     }
92     return 1;
93 }
94
95 static av_cold int flac_decode_init(AVCodecContext *avctx)
96 {
97     enum FLACExtradataFormat format;
98     uint8_t *streaminfo;
99     FLACContext *s = avctx->priv_data;
100     s->avctx = avctx;
101
102     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
103
104     /* for now, the raw FLAC header is allowed to be passed to the decoder as
105        frame data instead of extradata. */
106     if (!avctx->extradata)
107         return 0;
108
109     if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
110         return -1;
111
112     /* initialize based on the demuxer-supplied streamdata header */
113     ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
114     if (s->bps > 16)
115         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
116     else
117         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
118     allocate_buffers(s);
119     s->got_streaminfo = 1;
120
121     return 0;
122 }
123
124 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
125 {
126     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
127     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
128     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
129     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
130     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
131 }
132
133 static void allocate_buffers(FLACContext *s)
134 {
135     int i;
136
137     assert(s->max_blocksize);
138
139     for (i = 0; i < s->channels; i++) {
140         s->decoded[i] = av_realloc(s->decoded[i],
141                                    sizeof(int32_t)*s->max_blocksize);
142     }
143 }
144
145 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
146                               const uint8_t *buffer)
147 {
148     GetBitContext gb;
149     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
150
151     skip_bits(&gb, 16); /* skip min blocksize */
152     s->max_blocksize = get_bits(&gb, 16);
153     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
154         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
155                s->max_blocksize);
156         s->max_blocksize = 16;
157     }
158
159     skip_bits(&gb, 24); /* skip min frame size */
160     s->max_framesize = get_bits_long(&gb, 24);
161
162     s->samplerate = get_bits_long(&gb, 20);
163     s->channels = get_bits(&gb, 3) + 1;
164     s->bps = get_bits(&gb, 5) + 1;
165
166     avctx->channels = s->channels;
167     avctx->sample_rate = s->samplerate;
168     avctx->bits_per_raw_sample = s->bps;
169
170     s->samples  = get_bits_long(&gb, 32) << 4;
171     s->samples |= get_bits(&gb, 4);
172
173     skip_bits_long(&gb, 64); /* md5 sum */
174     skip_bits_long(&gb, 64); /* md5 sum */
175
176     dump_headers(avctx, s);
177 }
178
179 void ff_flac_parse_block_header(const uint8_t *block_header,
180                                 int *last, int *type, int *size)
181 {
182     int tmp = bytestream_get_byte(&block_header);
183     if (last)
184         *last = tmp & 0x80;
185     if (type)
186         *type = tmp & 0x7F;
187     if (size)
188         *size = bytestream_get_be24(&block_header);
189 }
190
191 /**
192  * Parse the STREAMINFO from an inline header.
193  * @param s the flac decoding context
194  * @param buf input buffer, starting with the "fLaC" marker
195  * @param buf_size buffer size
196  * @return non-zero if metadata is invalid
197  */
198 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
199 {
200     int metadata_type, metadata_size;
201
202     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
203         /* need more data */
204         return 0;
205     }
206     ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
207     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
208         metadata_size != FLAC_STREAMINFO_SIZE) {
209         return AVERROR_INVALIDDATA;
210     }
211     ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
212     allocate_buffers(s);
213     s->got_streaminfo = 1;
214
215     return 0;
216 }
217
218 /**
219  * Determine the size of an inline header.
220  * @param buf input buffer, starting with the "fLaC" marker
221  * @param buf_size buffer size
222  * @return number of bytes in the header, or 0 if more data is needed
223  */
224 static int get_metadata_size(const uint8_t *buf, int buf_size)
225 {
226     int metadata_last, metadata_size;
227     const uint8_t *buf_end = buf + buf_size;
228
229     buf += 4;
230     do {
231         if (buf_end - buf < 4)
232             return 0;
233         ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
234         buf += 4;
235         if (buf_end - buf < metadata_size) {
236             /* need more data in order to read the complete header */
237             return 0;
238         }
239         buf += metadata_size;
240     } while (!metadata_last);
241
242     return buf_size - (buf_end - buf);
243 }
244
245 static int decode_residuals(FLACContext *s, int channel, int pred_order)
246 {
247     int i, tmp, partition, method_type, rice_order;
248     int sample = 0, samples;
249
250     method_type = get_bits(&s->gb, 2);
251     if (method_type > 1) {
252         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
253                method_type);
254         return -1;
255     }
256
257     rice_order = get_bits(&s->gb, 4);
258
259     samples= s->blocksize >> rice_order;
260     if (pred_order > samples) {
261         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
262                pred_order, samples);
263         return -1;
264     }
265
266     sample=
267     i= pred_order;
268     for (partition = 0; partition < (1 << rice_order); partition++) {
269         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
270         if (tmp == (method_type == 0 ? 15 : 31)) {
271             tmp = get_bits(&s->gb, 5);
272             for (; i < samples; i++, sample++)
273                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
274         } else {
275             for (; i < samples; i++, sample++) {
276                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
277             }
278         }
279         i= 0;
280     }
281
282     return 0;
283 }
284
285 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
286 {
287     const int blocksize = s->blocksize;
288     int32_t *decoded = s->decoded[channel];
289     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
290
291     /* warm up samples */
292     for (i = 0; i < pred_order; i++) {
293         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
294     }
295
296     if (decode_residuals(s, channel, pred_order) < 0)
297         return -1;
298
299     if (pred_order > 0)
300         a = decoded[pred_order-1];
301     if (pred_order > 1)
302         b = a - decoded[pred_order-2];
303     if (pred_order > 2)
304         c = b - decoded[pred_order-2] + decoded[pred_order-3];
305     if (pred_order > 3)
306         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
307
308     switch (pred_order) {
309     case 0:
310         break;
311     case 1:
312         for (i = pred_order; i < blocksize; i++)
313             decoded[i] = a += decoded[i];
314         break;
315     case 2:
316         for (i = pred_order; i < blocksize; i++)
317             decoded[i] = a += b += decoded[i];
318         break;
319     case 3:
320         for (i = pred_order; i < blocksize; i++)
321             decoded[i] = a += b += c += decoded[i];
322         break;
323     case 4:
324         for (i = pred_order; i < blocksize; i++)
325             decoded[i] = a += b += c += d += decoded[i];
326         break;
327     default:
328         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
329         return -1;
330     }
331
332     return 0;
333 }
334
335 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
336 {
337     int i, j;
338     int coeff_prec, qlevel;
339     int coeffs[32];
340     int32_t *decoded = s->decoded[channel];
341
342     /* warm up samples */
343     for (i = 0; i < pred_order; i++) {
344         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
345     }
346
347     coeff_prec = get_bits(&s->gb, 4) + 1;
348     if (coeff_prec == 16) {
349         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
350         return -1;
351     }
352     qlevel = get_sbits(&s->gb, 5);
353     if (qlevel < 0) {
354         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
355                qlevel);
356         return -1;
357     }
358
359     for (i = 0; i < pred_order; i++) {
360         coeffs[i] = get_sbits(&s->gb, coeff_prec);
361     }
362
363     if (decode_residuals(s, channel, pred_order) < 0)
364         return -1;
365
366     if (s->bps > 16) {
367         int64_t sum;
368         for (i = pred_order; i < s->blocksize; i++) {
369             sum = 0;
370             for (j = 0; j < pred_order; j++)
371                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
372             decoded[i] += sum >> qlevel;
373         }
374     } else {
375         for (i = pred_order; i < s->blocksize-1; i += 2) {
376             int c;
377             int d = decoded[i-pred_order];
378             int s0 = 0, s1 = 0;
379             for (j = pred_order-1; j > 0; j--) {
380                 c = coeffs[j];
381                 s0 += c*d;
382                 d = decoded[i-j];
383                 s1 += c*d;
384             }
385             c = coeffs[0];
386             s0 += c*d;
387             d = decoded[i] += s0 >> qlevel;
388             s1 += c*d;
389             decoded[i+1] += s1 >> qlevel;
390         }
391         if (i < s->blocksize) {
392             int sum = 0;
393             for (j = 0; j < pred_order; j++)
394                 sum += coeffs[j] * decoded[i-j-1];
395             decoded[i] += sum >> qlevel;
396         }
397     }
398
399     return 0;
400 }
401
402 static inline int decode_subframe(FLACContext *s, int channel)
403 {
404     int type, wasted = 0;
405     int i, tmp;
406
407     s->curr_bps = s->bps;
408     if (channel == 0) {
409         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
410             s->curr_bps++;
411     } else {
412         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
413             s->curr_bps++;
414     }
415
416     if (get_bits1(&s->gb)) {
417         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
418         return -1;
419     }
420     type = get_bits(&s->gb, 6);
421
422     if (get_bits1(&s->gb)) {
423         wasted = 1;
424         while (!get_bits1(&s->gb))
425             wasted++;
426         s->curr_bps -= wasted;
427     }
428     if (s->curr_bps > 32) {
429         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
430         return -1;
431     }
432
433 //FIXME use av_log2 for types
434     if (type == 0) {
435         tmp = get_sbits_long(&s->gb, s->curr_bps);
436         for (i = 0; i < s->blocksize; i++)
437             s->decoded[channel][i] = tmp;
438     } else if (type == 1) {
439         for (i = 0; i < s->blocksize; i++)
440             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
441     } else if ((type >= 8) && (type <= 12)) {
442         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
443             return -1;
444     } else if (type >= 32) {
445         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
446             return -1;
447     } else {
448         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
449         return -1;
450     }
451
452     if (wasted) {
453         int i;
454         for (i = 0; i < s->blocksize; i++)
455             s->decoded[channel][i] <<= wasted;
456     }
457
458     return 0;
459 }
460
461 static int decode_frame(FLACContext *s)
462 {
463     int i;
464     GetBitContext *gb = &s->gb;
465     FLACFrameInfo fi;
466
467     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
468         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
469         return -1;
470     }
471
472     if (s->channels && fi.channels != s->channels) {
473         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
474                                        "is not supported\n");
475         return -1;
476     }
477     s->channels = s->avctx->channels = fi.channels;
478     s->ch_mode = fi.ch_mode;
479
480     if (!s->bps && !fi.bps) {
481         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
482         return -1;
483     }
484     if (!fi.bps) {
485         fi.bps = s->bps;
486     } else if (s->bps && fi.bps != s->bps) {
487         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
488                                        "supported\n");
489         return -1;
490     }
491     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
492
493     if (s->bps > 16) {
494         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
495         s->sample_shift = 32 - s->bps;
496         s->is32 = 1;
497     } else {
498         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
499         s->sample_shift = 16 - s->bps;
500         s->is32 = 0;
501     }
502
503     if (!s->max_blocksize)
504         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
505     if (fi.blocksize > s->max_blocksize) {
506         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
507                s->max_blocksize);
508         return -1;
509     }
510     s->blocksize = fi.blocksize;
511
512     if (!s->samplerate && !fi.samplerate) {
513         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
514                                         " or frame header\n");
515         return -1;
516     }
517     if (fi.samplerate == 0) {
518         fi.samplerate = s->samplerate;
519     } else if (s->samplerate && fi.samplerate != s->samplerate) {
520         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
521                s->samplerate, fi.samplerate);
522     }
523     s->samplerate = s->avctx->sample_rate = fi.samplerate;
524
525     if (!s->got_streaminfo) {
526         allocate_buffers(s);
527         s->got_streaminfo = 1;
528         dump_headers(s->avctx, (FLACStreaminfo *)s);
529     }
530
531 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
532
533     /* subframes */
534     for (i = 0; i < s->channels; i++) {
535         if (decode_subframe(s, i) < 0)
536             return -1;
537     }
538
539     align_get_bits(gb);
540
541     /* frame footer */
542     skip_bits(gb, 16); /* data crc */
543
544     return 0;
545 }
546
547 static int flac_decode_frame(AVCodecContext *avctx,
548                             void *data, int *data_size,
549                             AVPacket *avpkt)
550 {
551     const uint8_t *buf = avpkt->data;
552     int buf_size = avpkt->size;
553     FLACContext *s = avctx->priv_data;
554     int i, j = 0, bytes_read = 0;
555     int16_t *samples_16 = data;
556     int32_t *samples_32 = data;
557     int alloc_data_size= *data_size;
558     int output_size;
559
560     *data_size=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     /* check if allocated data size is large enough for output */
592     output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
593     if (output_size > alloc_data_size) {
594         av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
595                                        "allocated data size\n");
596         return -1;
597     }
598     *data_size = output_size;
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     return bytes_read;
644 }
645
646 static av_cold int flac_decode_close(AVCodecContext *avctx)
647 {
648     FLACContext *s = avctx->priv_data;
649     int i;
650
651     for (i = 0; i < s->channels; i++) {
652         av_freep(&s->decoded[i]);
653     }
654
655     return 0;
656 }
657
658 AVCodec ff_flac_decoder = {
659     "flac",
660     AVMEDIA_TYPE_AUDIO,
661     CODEC_ID_FLAC,
662     sizeof(FLACContext),
663     flac_decode_init,
664     NULL,
665     flac_decode_close,
666     flac_decode_frame,
667     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
668 };