/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * $Id$ * * Copyright (C) 2002 Björn Stenberg * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * ****************************************************************************/ #include "codeclib.h" #include "libtremor/ivorbisfile.h" #include "libtremor/ogg.h" #ifdef SIMULATOR #include "lib/tlsf/src/tlsf.h" #endif CODEC_HEADER #if defined(CPU_ARM) || defined(CPU_COLDFIRE) || defined(CPU_MIPS) #include jmp_buf rb_jump_buf; #endif /* Some standard functions and variables needed by Tremor */ static size_t read_handler(void *ptr, size_t size, size_t nmemb, void *datasource) { (void)datasource; return ci->read_filebuf(ptr, nmemb*size); } static int initial_seek_handler(void *datasource, ogg_int64_t offset, int whence) { (void)datasource; (void)offset; (void)whence; return -1; } static int seek_handler(void *datasource, ogg_int64_t offset, int whence) { (void)datasource; if (whence == SEEK_CUR) { offset += ci->curpos; } else if (whence == SEEK_END) { offset += ci->filesize; } if (ci->seek_buffer(offset)) { return 0; } return -1; } static int close_handler(void *datasource) { (void)datasource; return 0; } static long tell_handler(void *datasource) { (void)datasource; return ci->curpos; } /* This sets the DSP parameters based on the current logical bitstream * (sampling rate, number of channels, etc). */ static bool vorbis_set_codec_parameters(OggVorbis_File *vf) { vorbis_info *vi; vi = ov_info(vf, -1); if (vi == NULL) { return false; } ci->configure(DSP_SWITCH_FREQUENCY, ci->id3->frequency); codec_set_replaygain(ci->id3); if (vi->channels == 2) { ci->configure(DSP_SET_STEREO_MODE, STEREO_NONINTERLEAVED); } else if (vi->channels == 1) { ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO); } return true; } /* this is the codec entry point */ enum codec_status codec_main(enum codec_entry_call_reason reason) { if (reason == CODEC_LOAD) { if (codec_init()) return CODEC_ERROR; ci->configure(DSP_SET_SAMPLE_DEPTH, 24); } return CODEC_OK; } /* this is called for each file to process */ enum codec_status codec_run(void) { ov_callbacks callbacks; OggVorbis_File vf; ogg_int32_t **pcm; int error = CODEC_ERROR; long n; int current_section; int previous_section; int eof; ogg_int64_t vf_offsets[2]; ogg_int64_t vf_dataoffsets; ogg_uint32_t vf_serialnos; ogg_int64_t vf_pcmlengths[2]; intptr_t param; #if defined(CPU_ARM) || defined(CPU_COLDFIRE) || defined(CPU_MIPS) if (setjmp(rb_jump_buf) != 0) { /* malloc failed; finish with this track */ goto done; } #endif ogg_malloc_init(); /* Create a decoder instance */ callbacks.read_func = read_handler; callbacks.seek_func = initial_seek_handler; callbacks.tell_func = tell_handler; callbacks.close_func = close_handler; ci->seek_buffer(0); /* Open a non-seekable stream */ error = ov_open_callbacks(ci, &vf, NULL, 0, callbacks); /* If the non-seekable open was successful, we need to supply the missing * data to make it seekable. This is a hack, but it's reasonable since we * don't want to run the whole file through the buffer before we start * playing. Using Tremor's seekable open routine would cause us to do * this, so we pretend not to be seekable at first. Then we fill in the * missing fields of vf with 1) information in ci->id3, and 2) info * obtained by Tremor in the above ov_open call. * * Note that this assumes there is only ONE logical Vorbis bitstream in our * physical Ogg bitstream. This is verified in metadata.c, well before we * get here. */ if (!error) { ogg_free(vf.offsets); ogg_free(vf.dataoffsets); ogg_free(vf.serialnos); vf.offsets = vf_offsets; vf.dataoffsets = &vf_dataoffsets; vf.serialnos = &vf_serialnos; vf.pcmlengths = vf_pcmlengths; vf.offsets[0] = 0; vf.offsets[1] = ci->id3->filesize; vf.dataoffsets[0] = vf.offset; vf.pcmlengths[0] = 0; vf.pcmlengths[1] = ci->id3->samples; vf.serialnos[0] = vf.current_serialno; vf.callbacks.seek_func = seek_handler; vf.seekable = 1; vf.end = ci->id3->filesize; vf.ready_state = OPENED; vf.links = 1; } else { DEBUGF("Vorbis: ov_open failed: %d\n", error); goto done; } if (ci->id3->offset) { ci->seek_buffer(ci->id3->offset); ov_raw_seek(&vf, ci->id3->offset); ci->set_elapsed(ov_time_tell(&vf)); ci->set_offset(ov_raw_tell(&vf)); } else { ci->set_elapsed(0); } previous_section = -1; eof = 0; while (!eof) { enum codec_command_action action = ci->get_command(¶m); if (action == CODEC_ACTION_HALT) break; if (action == CODEC_ACTION_SEEK_TIME) { if (ov_time_seek(&vf, param)) { //ci->logf("ov_time_seek failed"); } ci->set_elapsed(ov_time_tell(&vf)); ci->seek_complete(); } /* Read host-endian signed 24-bit PCM samples */ n = ov_read_fixed(&vf, &pcm, 1024, ¤t_section); /* Change DSP and buffer settings for this bitstream */ if (current_section != previous_section) { if (!vorbis_set_codec_parameters(&vf)) { goto done; } else { previous_section = current_section; } } if (n == 0) { eof = 1; } else if (n < 0) { DEBUGF("Vorbis: Error decoding frame\n"); } else { ci->pcmbuf_insert(pcm[0], pcm[1], n); ci->set_offset(ov_raw_tell(&vf)); ci->set_elapsed(ov_time_tell(&vf)); } } error = CODEC_OK; done: #if 0 /* defined(SIMULATOR) */ { size_t bufsize; void* buf = ci->codec_get_buffer(&bufsize); DEBUGF("Vorbis: Memory max: %u\n", get_max_size(buf)); } #endif ogg_malloc_destroy(); /* Clean things up for the next track */ vf.dataoffsets = NULL; vf.offsets = NULL; vf.serialnos = NULL; vf.pcmlengths = NULL; ov_clear(&vf); return error; }