Remove a tab, somehow it sneaked past the hooks in the merge war.
[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         ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
232         buf += 4;
233         if (buf + metadata_size > buf_end) {
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     "flac",
658     AVMEDIA_TYPE_AUDIO,
659     CODEC_ID_FLAC,
660     sizeof(FLACContext),
661     flac_decode_init,
662     NULL,
663     flac_decode_close,
664     flac_decode_frame,
665     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
666 };