aacsbr: prevent multiple ff_aac_sbr_ctx_init()
[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  * @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         ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
230         buf += 4;
231         if (buf + metadata_size > buf_end) {
232             /* need more data in order to read the complete header */
233             return 0;
234         }
235         buf += metadata_size;
236     } while (!metadata_last);
237
238     return buf_size - (buf_end - buf);
239 }
240
241 static int decode_residuals(FLACContext *s, int channel, int pred_order)
242 {
243     int i, tmp, partition, method_type, rice_order;
244     int sample = 0, samples;
245
246     method_type = get_bits(&s->gb, 2);
247     if (method_type > 1) {
248         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
249                method_type);
250         return -1;
251     }
252
253     rice_order = get_bits(&s->gb, 4);
254
255     samples= s->blocksize >> rice_order;
256     if (pred_order > samples) {
257         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
258                pred_order, samples);
259         return -1;
260     }
261
262     sample=
263     i= pred_order;
264     for (partition = 0; partition < (1 << rice_order); partition++) {
265         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
266         if (tmp == (method_type == 0 ? 15 : 31)) {
267             tmp = get_bits(&s->gb, 5);
268             for (; i < samples; i++, sample++)
269                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
270         } else {
271             for (; i < samples; i++, sample++) {
272                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
273             }
274         }
275         i= 0;
276     }
277
278     return 0;
279 }
280
281 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
282 {
283     const int blocksize = s->blocksize;
284     int32_t *decoded = s->decoded[channel];
285     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
286
287     /* warm up samples */
288     for (i = 0; i < pred_order; i++) {
289         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
290     }
291
292     if (decode_residuals(s, channel, pred_order) < 0)
293         return -1;
294
295     if (pred_order > 0)
296         a = decoded[pred_order-1];
297     if (pred_order > 1)
298         b = a - decoded[pred_order-2];
299     if (pred_order > 2)
300         c = b - decoded[pred_order-2] + decoded[pred_order-3];
301     if (pred_order > 3)
302         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
303
304     switch (pred_order) {
305     case 0:
306         break;
307     case 1:
308         for (i = pred_order; i < blocksize; i++)
309             decoded[i] = a += decoded[i];
310         break;
311     case 2:
312         for (i = pred_order; i < blocksize; i++)
313             decoded[i] = a += b += decoded[i];
314         break;
315     case 3:
316         for (i = pred_order; i < blocksize; i++)
317             decoded[i] = a += b += c += decoded[i];
318         break;
319     case 4:
320         for (i = pred_order; i < blocksize; i++)
321             decoded[i] = a += b += c += d += decoded[i];
322         break;
323     default:
324         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
325         return -1;
326     }
327
328     return 0;
329 }
330
331 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
332 {
333     int i, j;
334     int coeff_prec, qlevel;
335     int coeffs[32];
336     int32_t *decoded = s->decoded[channel];
337
338     /* warm up samples */
339     for (i = 0; i < pred_order; i++) {
340         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
341     }
342
343     coeff_prec = get_bits(&s->gb, 4) + 1;
344     if (coeff_prec == 16) {
345         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
346         return -1;
347     }
348     qlevel = get_sbits(&s->gb, 5);
349     if (qlevel < 0) {
350         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
351                qlevel);
352         return -1;
353     }
354
355     for (i = 0; i < pred_order; i++) {
356         coeffs[i] = get_sbits(&s->gb, coeff_prec);
357     }
358
359     if (decode_residuals(s, channel, pred_order) < 0)
360         return -1;
361
362     if (s->bps > 16) {
363         int64_t sum;
364         for (i = pred_order; i < s->blocksize; i++) {
365             sum = 0;
366             for (j = 0; j < pred_order; j++)
367                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
368             decoded[i] += sum >> qlevel;
369         }
370     } else {
371         for (i = pred_order; i < s->blocksize-1; i += 2) {
372             int c;
373             int d = decoded[i-pred_order];
374             int s0 = 0, s1 = 0;
375             for (j = pred_order-1; j > 0; j--) {
376                 c = coeffs[j];
377                 s0 += c*d;
378                 d = decoded[i-j];
379                 s1 += c*d;
380             }
381             c = coeffs[0];
382             s0 += c*d;
383             d = decoded[i] += s0 >> qlevel;
384             s1 += c*d;
385             decoded[i+1] += s1 >> qlevel;
386         }
387         if (i < s->blocksize) {
388             int sum = 0;
389             for (j = 0; j < pred_order; j++)
390                 sum += coeffs[j] * decoded[i-j-1];
391             decoded[i] += sum >> qlevel;
392         }
393     }
394
395     return 0;
396 }
397
398 static inline int decode_subframe(FLACContext *s, int channel)
399 {
400     int type, wasted = 0;
401     int i, tmp;
402
403     s->curr_bps = s->bps;
404     if (channel == 0) {
405         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
406             s->curr_bps++;
407     } else {
408         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
409             s->curr_bps++;
410     }
411
412     if (get_bits1(&s->gb)) {
413         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
414         return -1;
415     }
416     type = get_bits(&s->gb, 6);
417
418     if (get_bits1(&s->gb)) {
419         wasted = 1;
420         while (!get_bits1(&s->gb))
421             wasted++;
422         s->curr_bps -= wasted;
423     }
424     if (s->curr_bps > 32) {
425         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
426         return -1;
427     }
428
429 //FIXME use av_log2 for types
430     if (type == 0) {
431         tmp = get_sbits_long(&s->gb, s->curr_bps);
432         for (i = 0; i < s->blocksize; i++)
433             s->decoded[channel][i] = tmp;
434     } else if (type == 1) {
435         for (i = 0; i < s->blocksize; i++)
436             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
437     } else if ((type >= 8) && (type <= 12)) {
438         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
439             return -1;
440     } else if (type >= 32) {
441         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
442             return -1;
443     } else {
444         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
445         return -1;
446     }
447
448     if (wasted) {
449         int i;
450         for (i = 0; i < s->blocksize; i++)
451             s->decoded[channel][i] <<= wasted;
452     }
453
454     return 0;
455 }
456
457 static int decode_frame(FLACContext *s)
458 {
459     int i;
460     GetBitContext *gb = &s->gb;
461     FLACFrameInfo fi;
462
463     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
464         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
465         return -1;
466     }
467
468     if (s->channels && fi.channels != s->channels) {
469         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
470                                        "is not supported\n");
471         return -1;
472     }
473     s->channels = s->avctx->channels = fi.channels;
474     s->ch_mode = fi.ch_mode;
475
476     if (!s->bps && !fi.bps) {
477         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
478         return -1;
479     }
480     if (!fi.bps) {
481         fi.bps = s->bps;
482     } else if (s->bps && fi.bps != s->bps) {
483         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
484                                        "supported\n");
485         return -1;
486     }
487     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
488
489     if (s->bps > 16) {
490         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
491         s->sample_shift = 32 - s->bps;
492         s->is32 = 1;
493     } else {
494         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
495         s->sample_shift = 16 - s->bps;
496         s->is32 = 0;
497     }
498
499     if (!s->max_blocksize)
500         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
501     if (fi.blocksize > s->max_blocksize) {
502         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
503                s->max_blocksize);
504         return -1;
505     }
506     s->blocksize = fi.blocksize;
507
508     if (!s->samplerate && !fi.samplerate) {
509         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
510                                         " or frame header\n");
511         return -1;
512     }
513     if (fi.samplerate == 0) {
514         fi.samplerate = s->samplerate;
515     } else if (s->samplerate && fi.samplerate != s->samplerate) {
516         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
517                s->samplerate, fi.samplerate);
518     }
519     s->samplerate = s->avctx->sample_rate = fi.samplerate;
520
521     if (!s->got_streaminfo) {
522         allocate_buffers(s);
523         s->got_streaminfo = 1;
524         dump_headers(s->avctx, (FLACStreaminfo *)s);
525     }
526
527 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
528
529     /* subframes */
530     for (i = 0; i < s->channels; i++) {
531         if (decode_subframe(s, i) < 0)
532             return -1;
533     }
534
535     align_get_bits(gb);
536
537     /* frame footer */
538     skip_bits(gb, 16); /* data crc */
539
540     return 0;
541 }
542
543 static int flac_decode_frame(AVCodecContext *avctx,
544                             void *data, int *data_size,
545                             AVPacket *avpkt)
546 {
547     const uint8_t *buf = avpkt->data;
548     int buf_size = avpkt->size;
549     FLACContext *s = avctx->priv_data;
550     int i, j = 0, bytes_read = 0;
551     int16_t *samples_16 = data;
552     int32_t *samples_32 = data;
553     int alloc_data_size= *data_size;
554     int output_size;
555
556     *data_size=0;
557
558     if (s->max_framesize == 0) {
559         s->max_framesize =
560             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
561                                        FLAC_MAX_CHANNELS, 32);
562     }
563
564     /* check that there is at least the smallest decodable amount of data.
565        this amount corresponds to the smallest valid FLAC frame possible.
566        FF F8 69 02 00 00 9A 00 00 34 46 */
567     if (buf_size < FLAC_MIN_FRAME_SIZE)
568         return buf_size;
569
570     /* check for inline header */
571     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
572         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
573             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
574             return -1;
575         }
576         return get_metadata_size(buf, buf_size);
577     }
578
579     /* decode frame */
580     init_get_bits(&s->gb, buf, buf_size*8);
581     if (decode_frame(s) < 0) {
582         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
583         return -1;
584     }
585     bytes_read = (get_bits_count(&s->gb)+7)/8;
586
587     /* check if allocated data size is large enough for output */
588     output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
589     if (output_size > alloc_data_size) {
590         av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
591                                        "allocated data size\n");
592         return -1;
593     }
594     *data_size = output_size;
595
596 #define DECORRELATE(left, right)\
597             assert(s->channels == 2);\
598             for (i = 0; i < s->blocksize; i++) {\
599                 int a= s->decoded[0][i];\
600                 int b= s->decoded[1][i];\
601                 if (s->is32) {\
602                     *samples_32++ = (left)  << s->sample_shift;\
603                     *samples_32++ = (right) << s->sample_shift;\
604                 } else {\
605                     *samples_16++ = (left)  << s->sample_shift;\
606                     *samples_16++ = (right) << s->sample_shift;\
607                 }\
608             }\
609             break;
610
611     switch (s->ch_mode) {
612     case FLAC_CHMODE_INDEPENDENT:
613         for (j = 0; j < s->blocksize; j++) {
614             for (i = 0; i < s->channels; i++) {
615                 if (s->is32)
616                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
617                 else
618                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
619             }
620         }
621         break;
622     case FLAC_CHMODE_LEFT_SIDE:
623         DECORRELATE(a,a-b)
624     case FLAC_CHMODE_RIGHT_SIDE:
625         DECORRELATE(a+b,b)
626     case FLAC_CHMODE_MID_SIDE:
627         DECORRELATE( (a-=b>>1) + b, a)
628     }
629
630     if (bytes_read > buf_size) {
631         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
632         return -1;
633     }
634     if (bytes_read < buf_size) {
635         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
636                buf_size - bytes_read, buf_size);
637     }
638
639     return bytes_read;
640 }
641
642 static av_cold int flac_decode_close(AVCodecContext *avctx)
643 {
644     FLACContext *s = avctx->priv_data;
645     int i;
646
647     for (i = 0; i < s->channels; i++) {
648         av_freep(&s->decoded[i]);
649     }
650
651     return 0;
652 }
653
654 AVCodec ff_flac_decoder = {
655     .name           = "flac",
656     .type           = AVMEDIA_TYPE_AUDIO,
657     .id             = CODEC_ID_FLAC,
658     .priv_data_size = sizeof(FLACContext),
659     .init           = flac_decode_init,
660     .close          = flac_decode_close,
661     .decode         = flac_decode_frame,
662     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
663 };