Theme Editor: Added support for upper-case wps file extensions
[kugel-rb.git] / apps / codecs / flac.c
blob14ddd3cb0592cae42244987d44194e9887f5361f
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2005 Dave Chapman
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
22 #include "codeclib.h"
23 #include <codecs/libffmpegFLAC/decoder.h>
25 CODEC_HEADER
27 /* The output buffers containing the decoded samples (channels 0 and 1) */
28 int32_t decoded0[MAX_BLOCKSIZE] IBSS_ATTR_FLAC_DECODED0;
29 int32_t decoded1[MAX_BLOCKSIZE] IBSS_ATTR;
31 #define MAX_SUPPORTED_SEEKTABLE_SIZE 5000
33 /* Notes about seeking:
35 The full seek table consists of:
36 uint64_t sample (only 36 bits are used)
37 uint64_t offset
38 uint32_t blocksize
40 We also limit the sample and offset values to 32-bits - Rockbox doesn't
41 support files bigger than 2GB on FAT32 filesystems.
43 The reference FLAC encoder produces a seek table with points every
44 10 seconds, but this can be overridden by the user when encoding a file.
46 With the default settings, a typical 4 minute track will contain
47 24 seek points.
49 Taking the extreme case of a Rockbox supported file to be a 2GB (compressed)
50 16-bit/44.1KHz mono stream with a likely uncompressed size of 4GB:
51 Total duration is: 48694 seconds (about 810 minutes - 13.5 hours)
52 Total number of seek points: 4869
54 Therefore we limit the number of seek points to 5000. This is a
55 very extreme case, and requires 5000*8=40000 bytes of storage.
57 If we come across a FLAC file with more than this number of seekpoints, we
58 just use the first 5000.
62 struct FLACseekpoints {
63 uint32_t sample;
64 uint32_t offset;
65 uint16_t blocksize;
68 struct FLACseekpoints seekpoints[MAX_SUPPORTED_SEEKTABLE_SIZE];
69 int nseekpoints;
71 static int8_t *bit_buffer;
72 static size_t buff_size;
74 static bool flac_init(FLACContext* fc, int first_frame_offset)
76 unsigned char buf[255];
77 bool found_streaminfo=false;
78 uint32_t seekpoint_hi,seekpoint_lo;
79 uint32_t offset_hi,offset_lo;
80 uint16_t blocksize;
81 int endofmetadata=0;
82 uint32_t blocklength;
84 ci->memset(fc,0,sizeof(FLACContext));
85 nseekpoints=0;
87 fc->sample_skip = 0;
89 /* Skip any foreign tags at start of file */
90 ci->seek_buffer(first_frame_offset);
92 fc->metadatalength = first_frame_offset;
94 if (ci->read_filebuf(buf, 4) < 4)
96 return false;
99 if (ci->memcmp(buf,"fLaC",4) != 0)
101 return false;
103 fc->metadatalength += 4;
105 while (!endofmetadata) {
106 if (ci->read_filebuf(buf, 4) < 4)
108 return false;
111 endofmetadata=(buf[0]&0x80);
112 blocklength = (buf[1] << 16) | (buf[2] << 8) | buf[3];
113 fc->metadatalength+=blocklength+4;
115 if ((buf[0] & 0x7f) == 0) /* 0 is the STREAMINFO block */
117 if (ci->read_filebuf(buf, blocklength) < blocklength) return false;
119 fc->filesize = ci->filesize;
120 fc->min_blocksize = (buf[0] << 8) | buf[1];
121 fc->max_blocksize = (buf[2] << 8) | buf[3];
122 fc->min_framesize = (buf[4] << 16) | (buf[5] << 8) | buf[6];
123 fc->max_framesize = (buf[7] << 16) | (buf[8] << 8) | buf[9];
124 fc->samplerate = (buf[10] << 12) | (buf[11] << 4)
125 | ((buf[12] & 0xf0) >> 4);
126 fc->channels = ((buf[12]&0x0e)>>1) + 1;
127 fc->bps = (((buf[12]&0x01) << 4) | ((buf[13]&0xf0)>>4) ) + 1;
129 /* totalsamples is a 36-bit field, but we assume <= 32 bits are
130 used */
131 fc->totalsamples = (buf[14] << 24) | (buf[15] << 16)
132 | (buf[16] << 8) | buf[17];
134 /* Calculate track length (in ms) and estimate the bitrate
135 (in kbit/s) */
136 fc->length = ((int64_t) fc->totalsamples * 1000) / fc->samplerate;
138 found_streaminfo=true;
139 } else if ((buf[0] & 0x7f) == 3) { /* 3 is the SEEKTABLE block */
140 while ((nseekpoints < MAX_SUPPORTED_SEEKTABLE_SIZE) &&
141 (blocklength >= 18)) {
142 if (ci->read_filebuf(buf,18) < 18) return false;
143 blocklength-=18;
145 seekpoint_hi=(buf[0] << 24) | (buf[1] << 16) |
146 (buf[2] << 8) | buf[3];
147 seekpoint_lo=(buf[4] << 24) | (buf[5] << 16) |
148 (buf[6] << 8) | buf[7];
149 offset_hi=(buf[8] << 24) | (buf[9] << 16) |
150 (buf[10] << 8) | buf[11];
151 offset_lo=(buf[12] << 24) | (buf[13] << 16) |
152 (buf[14] << 8) | buf[15];
154 blocksize=(buf[16] << 8) | buf[17];
156 /* Only store seekpoints where the high 32 bits are zero */
157 if ((seekpoint_hi == 0) && (seekpoint_lo != 0xffffffff) &&
158 (offset_hi == 0)) {
159 seekpoints[nseekpoints].sample=seekpoint_lo;
160 seekpoints[nseekpoints].offset=offset_lo;
161 seekpoints[nseekpoints].blocksize=blocksize;
162 nseekpoints++;
165 /* Skip any unread seekpoints */
166 if (blocklength > 0)
167 ci->advance_buffer(blocklength);
168 } else {
169 /* Skip to next metadata block */
170 ci->advance_buffer(blocklength);
174 if (found_streaminfo) {
175 fc->bitrate = ((int64_t) (fc->filesize-fc->metadatalength) * 8)
176 / fc->length;
177 return true;
178 } else {
179 return false;
183 /* Synchronize to next frame in stream - adapted from libFLAC 1.1.3b2 */
184 static bool frame_sync(FLACContext* fc) {
185 unsigned int x = 0;
186 bool cached = false;
188 /* Make sure we're byte aligned. */
189 align_get_bits(&fc->gb);
191 while(1) {
192 if(fc->gb.size_in_bits - get_bits_count(&fc->gb) < 8) {
193 /* Error, end of bitstream, a valid stream should never reach here
194 * since the buffer should contain at least one frame header.
196 return false;
199 if(cached)
200 cached = false;
201 else
202 x = get_bits(&fc->gb, 8);
204 if(x == 0xff) { /* MAGIC NUMBER for first 8 frame sync bits. */
205 x = get_bits(&fc->gb, 8);
206 /* We have to check if we just read two 0xff's in a row; the second
207 * may actually be the beginning of the sync code.
209 if(x == 0xff) { /* MAGIC NUMBER for first 8 frame sync bits. */
210 cached = true;
212 else if(x >> 2 == 0x3e) { /* MAGIC NUMBER for last 6 sync bits. */
213 /* Succesfully synced. */
214 break;
219 /* Advance and init bit buffer to the new frame. */
220 ci->advance_buffer((get_bits_count(&fc->gb)-16)>>3); /* consumed bytes */
221 bit_buffer = ci->request_buffer(&buff_size, MAX_FRAMESIZE+16);
222 init_get_bits(&fc->gb, bit_buffer, buff_size*8);
224 /* Decode the frame to verify the frame crc and
225 * fill fc with its metadata.
227 if(flac_decode_frame(fc, decoded0, decoded1,
228 bit_buffer, buff_size, ci->yield) < 0) {
229 return false;
232 return true;
235 /* Seek to sample - adapted from libFLAC 1.1.3b2+ */
236 static bool flac_seek(FLACContext* fc, uint32_t target_sample) {
237 off_t orig_pos = ci->curpos;
238 off_t pos = -1;
239 unsigned long lower_bound, upper_bound;
240 unsigned long lower_bound_sample, upper_bound_sample;
241 int i;
242 unsigned approx_bytes_per_frame;
243 uint32_t this_frame_sample = fc->samplenumber;
244 unsigned this_block_size = fc->blocksize;
245 bool needs_seek = true, first_seek = true;
247 /* We are just guessing here. */
248 if(fc->max_framesize > 0)
249 approx_bytes_per_frame = (fc->max_framesize + fc->min_framesize)/2 + 1;
250 /* Check if it's a known fixed-blocksize stream. */
251 else if(fc->min_blocksize == fc->max_blocksize && fc->min_blocksize > 0)
252 approx_bytes_per_frame = fc->min_blocksize*fc->channels*fc->bps/8 + 64;
253 else
254 approx_bytes_per_frame = 4608 * fc->channels * fc->bps/8 + 64;
256 /* Set an upper and lower bound on where in the stream we will search. */
257 lower_bound = fc->metadatalength;
258 lower_bound_sample = 0;
259 upper_bound = fc->filesize;
260 upper_bound_sample = fc->totalsamples>0 ? fc->totalsamples : target_sample;
262 /* Refine the bounds if we have a seektable with suitable points. */
263 if(nseekpoints > 0) {
264 /* Find the closest seek point <= target_sample, if it exists. */
265 for(i = nseekpoints-1; i >= 0; i--) {
266 if(seekpoints[i].sample <= target_sample)
267 break;
269 if(i >= 0) { /* i.e. we found a suitable seek point... */
270 lower_bound = fc->metadatalength + seekpoints[i].offset;
271 lower_bound_sample = seekpoints[i].sample;
274 /* Find the closest seek point > target_sample, if it exists. */
275 for(i = 0; i < nseekpoints; i++) {
276 if(seekpoints[i].sample > target_sample)
277 break;
279 if(i < nseekpoints) { /* i.e. we found a suitable seek point... */
280 upper_bound = fc->metadatalength + seekpoints[i].offset;
281 upper_bound_sample = seekpoints[i].sample;
285 while(1) {
286 /* Check if bounds are still ok. */
287 if(lower_bound_sample >= upper_bound_sample ||
288 lower_bound > upper_bound) {
289 return false;
292 /* Calculate new seek position */
293 if(needs_seek) {
294 pos = (off_t)(lower_bound +
295 (((target_sample - lower_bound_sample) *
296 (int64_t)(upper_bound - lower_bound)) /
297 (upper_bound_sample - lower_bound_sample)) -
298 approx_bytes_per_frame);
300 if(pos >= (off_t)upper_bound)
301 pos = (off_t)upper_bound-1;
302 if(pos < (off_t)lower_bound)
303 pos = (off_t)lower_bound;
306 if(!ci->seek_buffer(pos))
307 return false;
309 bit_buffer = ci->request_buffer(&buff_size, MAX_FRAMESIZE+16);
310 init_get_bits(&fc->gb, bit_buffer, buff_size*8);
312 /* Now we need to get a frame. It is possible for our seek
313 * to land in the middle of audio data that looks exactly like
314 * a frame header from a future version of an encoder. When
315 * that happens, frame_sync() will return false.
316 * But there is a remote possibility that it is properly
317 * synced at such a "future-codec frame", so to make sure,
318 * we wait to see several "unparseable" errors in a row before
319 * bailing out.
322 unsigned unparseable_count;
323 bool got_a_frame = false;
324 for(unparseable_count = 0; !got_a_frame
325 && unparseable_count < 10; unparseable_count++) {
326 if(frame_sync(fc))
327 got_a_frame = true;
329 if(!got_a_frame) {
330 ci->seek_buffer(orig_pos);
331 return false;
335 this_frame_sample = fc->samplenumber;
336 this_block_size = fc->blocksize;
338 if(target_sample >= this_frame_sample
339 && target_sample < this_frame_sample+this_block_size) {
340 /* Found the frame containing the target sample. */
341 fc->sample_skip = target_sample - this_frame_sample;
342 break;
345 if(this_frame_sample + this_block_size >= upper_bound_sample &&
346 !first_seek) {
347 if(pos == (off_t)lower_bound || !needs_seek) {
348 ci->seek_buffer(orig_pos);
349 return false;
351 /* Our last move backwards wasn't big enough, try again. */
352 approx_bytes_per_frame *= 2;
353 continue;
355 /* Allow one seek over upper bound,
356 * required for streams with unknown total samples.
358 first_seek = false;
360 /* Make sure we are not seeking in a corrupted stream */
361 if(this_frame_sample < lower_bound_sample) {
362 ci->seek_buffer(orig_pos);
363 return false;
366 approx_bytes_per_frame = this_block_size*fc->channels*fc->bps/8 + 64;
368 /* We need to narrow the search. */
369 if(target_sample < this_frame_sample) {
370 upper_bound_sample = this_frame_sample;
371 upper_bound = ci->curpos;
373 else { /* Target is beyond this frame. */
374 /* We are close, continue in decoding next frames. */
375 if(target_sample < this_frame_sample + 4*this_block_size) {
376 pos = ci->curpos + fc->framesize;
377 needs_seek = false;
380 lower_bound_sample = this_frame_sample + this_block_size;
381 lower_bound = ci->curpos + fc->framesize;
385 return true;
388 /* Seek to file offset */
389 static bool flac_seek_offset(FLACContext* fc, uint32_t offset) {
390 unsigned unparseable_count;
391 bool got_a_frame = false;
393 if(!ci->seek_buffer(offset))
394 return false;
396 bit_buffer = ci->request_buffer(&buff_size, MAX_FRAMESIZE);
397 init_get_bits(&fc->gb, bit_buffer, buff_size*8);
399 for(unparseable_count = 0; !got_a_frame
400 && unparseable_count < 10; unparseable_count++) {
401 if(frame_sync(fc))
402 got_a_frame = true;
405 if(!got_a_frame) {
406 ci->seek_buffer(fc->metadatalength);
407 return false;
410 return true;
413 /* this is the codec entry point */
414 enum codec_status codec_main(void)
416 int8_t *buf;
417 FLACContext fc;
418 uint32_t samplesdone = 0;
419 uint32_t elapsedtime;
420 size_t bytesleft;
421 int consumed;
422 int res;
423 int frame;
424 int retval;
426 /* Generic codec initialisation */
427 ci->configure(DSP_SET_SAMPLE_DEPTH, FLAC_OUTPUT_DEPTH-1);
429 next_track:
431 /* Need to save offset for later use (cleared indirectly by flac_init) */
432 samplesdone=ci->id3->offset;
434 if (codec_init()) {
435 LOGF("FLAC: Error initialising codec\n");
436 retval = CODEC_ERROR;
437 goto exit;
440 while (!*ci->taginfo_ready && !ci->stop_codec)
441 ci->sleep(1);
443 if (!flac_init(&fc,ci->id3->first_frame_offset)) {
444 LOGF("FLAC: Error initialising codec\n");
445 retval = CODEC_ERROR;
446 goto done;
449 ci->configure(DSP_SWITCH_FREQUENCY, ci->id3->frequency);
450 ci->configure(DSP_SET_STEREO_MODE, fc.channels == 1 ?
451 STEREO_MONO : STEREO_NONINTERLEAVED);
452 codec_set_replaygain(ci->id3);
454 if (samplesdone) {
455 flac_seek_offset(&fc, samplesdone);
456 samplesdone=0;
459 /* The main decoding loop */
460 frame=0;
461 buf = ci->request_buffer(&bytesleft, MAX_FRAMESIZE);
462 while (bytesleft) {
463 ci->yield();
464 if (ci->stop_codec || ci->new_track) {
465 break;
468 /* Deal with any pending seek requests */
469 if (ci->seek_time) {
470 if (flac_seek(&fc,(uint32_t)(((uint64_t)(ci->seek_time-1)
471 *ci->id3->frequency)/1000))) {
472 /* Refill the input buffer */
473 buf = ci->request_buffer(&bytesleft, MAX_FRAMESIZE);
475 ci->seek_complete();
478 if((res=flac_decode_frame(&fc,decoded0,decoded1,buf,
479 bytesleft,ci->yield)) < 0) {
480 LOGF("FLAC: Frame %d, error %d\n",frame,res);
481 retval = CODEC_ERROR;
482 goto done;
484 consumed=fc.gb.index/8;
485 frame++;
487 ci->yield();
488 ci->pcmbuf_insert(&decoded0[fc.sample_skip], &decoded1[fc.sample_skip],
489 fc.blocksize - fc.sample_skip);
491 fc.sample_skip = 0;
493 /* Update the elapsed-time indicator */
494 samplesdone=fc.samplenumber+fc.blocksize;
495 elapsedtime=(samplesdone*10)/(ci->id3->frequency/100);
496 ci->set_elapsed(elapsedtime);
498 ci->advance_buffer(consumed);
500 buf = ci->request_buffer(&bytesleft, MAX_FRAMESIZE);
502 retval = CODEC_OK;
504 done:
505 LOGF("FLAC: Decoded %lu samples\n",(unsigned long)samplesdone);
507 if (ci->request_next_track())
508 goto next_track;
510 exit:
511 return retval;