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