fbd4088df8
playing files which doesn't require cpu boosting. git-svn-id: svn://svn.rockbox.org/rockbox/trunk@7103 a1c6a512-1295-4272-9138-f99709370657
294 lines
8 KiB
C
294 lines
8 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2002 Björn Stenberg
|
|
*
|
|
* All files in this archive are subject to the GNU General Public License.
|
|
* See the file COPYING in the source tree root for full license agreement.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
#include "kernel.h"
|
|
#include "codecs.h"
|
|
|
|
#include "Tremor/ivorbisfile.h"
|
|
#include "Tremor/ogg.h"
|
|
#include "playback.h"
|
|
#include "dsp.h"
|
|
#include "lib/codeclib.h"
|
|
|
|
#define TEST_RESUME
|
|
|
|
static struct codec_api* rb;
|
|
|
|
/* Some standard functions and variables needed by Tremor */
|
|
|
|
int errno;
|
|
|
|
size_t strlen(const char *s)
|
|
{
|
|
return(rb->strlen(s));
|
|
}
|
|
|
|
char *strcpy(char *dest, const char *src)
|
|
{
|
|
return(rb->strcpy(dest,src));
|
|
}
|
|
|
|
char *strcat(char *dest, const char *src)
|
|
{
|
|
return(rb->strcat(dest,src));
|
|
}
|
|
|
|
size_t read_handler(void *ptr, size_t size, size_t nmemb, void *datasource)
|
|
{
|
|
(void)datasource;
|
|
return rb->read_filebuf(ptr, nmemb*size);
|
|
}
|
|
|
|
int initial_seek_handler(void *datasource, ogg_int64_t offset, int whence) {
|
|
(void)datasource;
|
|
(void)offset;
|
|
(void)whence;
|
|
return -1;
|
|
}
|
|
|
|
int seek_handler(void *datasource, ogg_int64_t offset, int whence)
|
|
{
|
|
(void)datasource;
|
|
|
|
if ( whence == SEEK_CUR ) {
|
|
offset += rb->curpos;
|
|
} else if ( whence == SEEK_END ) {
|
|
offset += rb->filesize;
|
|
}
|
|
|
|
if (rb->seek_buffer(offset)) {
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int close_handler(void *datasource)
|
|
{
|
|
(void)datasource;
|
|
return 0;
|
|
}
|
|
|
|
long tell_handler(void *datasource)
|
|
{
|
|
(void)datasource;
|
|
return rb->curpos;
|
|
}
|
|
|
|
/* This sets the DSP parameters based on the current logical bitstream
|
|
* (sampling rate, number of channels, etc). It also tries to guess
|
|
* reasonable buffer parameters based on the current quality setting.
|
|
*/
|
|
bool vorbis_set_codec_parameters(OggVorbis_File *vf)
|
|
{
|
|
vorbis_info* vi;
|
|
|
|
vi=ov_info(vf,-1);
|
|
|
|
if (vi==NULL) {
|
|
//rb->splash(HZ*2, true, "Vorbis Error");
|
|
return false;
|
|
}
|
|
|
|
if (rb->id3->frequency != NATIVE_FREQUENCY) {
|
|
rb->configure(CODEC_DSP_ENABLE, (bool *)true);
|
|
} else {
|
|
rb->configure(CODEC_DSP_ENABLE, (bool *)false);
|
|
}
|
|
|
|
rb->configure(DSP_SET_FREQUENCY, (int *)rb->id3->frequency);
|
|
|
|
if (vi->channels == 2) {
|
|
rb->configure(DSP_SET_STEREO_MODE, (int *)STEREO_INTERLEAVED);
|
|
} else if (vi->channels == 1) {
|
|
rb->configure(DSP_SET_STEREO_MODE, (int *)STEREO_MONO);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#ifdef USE_IRAM
|
|
extern char iramcopy[];
|
|
extern char iramstart[];
|
|
extern char iramend[];
|
|
#endif
|
|
|
|
|
|
/* reserve the PCM buffer in the IRAM area */
|
|
static char pcmbuf[4096] IDATA_ATTR;
|
|
|
|
/* this is the codec entry point */
|
|
enum codec_status codec_start(struct codec_api* api)
|
|
{
|
|
ov_callbacks callbacks;
|
|
OggVorbis_File vf;
|
|
|
|
int error;
|
|
long n;
|
|
int current_section;
|
|
int previous_section = -1;
|
|
int eof;
|
|
ogg_int64_t vf_offsets[2];
|
|
ogg_int64_t vf_dataoffsets;
|
|
ogg_uint32_t vf_serialnos;
|
|
ogg_int64_t vf_pcmlengths[2];
|
|
|
|
TEST_CODEC_API(api);
|
|
|
|
/* if you are using a global api pointer, don't forget to copy it!
|
|
otherwise you will get lovely "I04: IllInstr" errors... :-) */
|
|
rb = api;
|
|
|
|
#ifdef USE_IRAM
|
|
rb->memcpy(iramstart, iramcopy, iramend-iramstart);
|
|
#endif
|
|
|
|
rb->configure(DSP_DITHER, (bool *)false);
|
|
rb->configure(DSP_SET_SAMPLE_DEPTH, (int *)(16));
|
|
|
|
/* Note: These are sane defaults for these values. Perhaps
|
|
* they should be set differently based on quality setting
|
|
*/
|
|
rb->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*2));
|
|
|
|
/* The chunk size below is magic. If set any lower, resume
|
|
* doesn't work properly (ov_raw_seek() does the wrong thing).
|
|
*/
|
|
rb->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*256));
|
|
|
|
|
|
/* We need to flush reserver memory every track load. */
|
|
next_track:
|
|
if (codec_init(rb)) {
|
|
return CODEC_ERROR;
|
|
}
|
|
|
|
while (!*rb->taginfo_ready && !rb->stop_codec)
|
|
rb->sleep(1);
|
|
|
|
/* 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;
|
|
|
|
/* Open a non-seekable stream */
|
|
error=ov_open_callbacks(rb,&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 rb->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 ) {
|
|
vf.offsets = vf_offsets;
|
|
vf.dataoffsets = &vf_dataoffsets;
|
|
vf.serialnos = &vf_serialnos;
|
|
vf.pcmlengths = vf_pcmlengths;
|
|
|
|
vf.offsets[0] = 0;
|
|
vf.offsets[1] = rb->id3->filesize;
|
|
vf.dataoffsets[0] = vf.offset;
|
|
vf.pcmlengths[0] = 0;
|
|
vf.pcmlengths[1] = rb->id3->samples;
|
|
vf.serialnos[0] = vf.current_serialno;
|
|
vf.callbacks.seek_func=seek_handler;
|
|
vf.seekable = 1;
|
|
vf.end = rb->id3->filesize;
|
|
vf.ready_state = OPENED;
|
|
vf.links = 1;
|
|
} else {
|
|
//rb->logf("ov_open: %d", error);
|
|
return CODEC_ERROR;
|
|
}
|
|
|
|
if ( rb->id3->offset ) {
|
|
rb->advance_buffer(rb->id3->offset);
|
|
ov_raw_seek(&vf,rb->id3->offset);
|
|
rb->id3->offset = ov_raw_tell(&vf);
|
|
rb->set_elapsed(ov_time_tell(&vf));
|
|
}
|
|
|
|
eof=0;
|
|
rb->yield();
|
|
while (!eof) {
|
|
if (rb->stop_codec || rb->reload_codec)
|
|
break ;
|
|
|
|
if (rb->seek_time) {
|
|
|
|
if (ov_time_seek(&vf, rb->seek_time)) {
|
|
//rb->logf("ov_time_seek failed");
|
|
}
|
|
rb->seek_time = 0;
|
|
}
|
|
|
|
/* Read host-endian signed 16 bit PCM samples */
|
|
n=ov_read(&vf,pcmbuf,sizeof(pcmbuf),¤t_section);
|
|
|
|
/* Change DSP and buffer settings for this bitstream */
|
|
if ( current_section != previous_section ) {
|
|
if (!vorbis_set_codec_parameters(&vf)) {
|
|
return CODEC_ERROR;
|
|
} else {
|
|
previous_section = current_section;
|
|
}
|
|
}
|
|
|
|
if (n==0) {
|
|
eof=1;
|
|
} else if (n < 0) {
|
|
DEBUGF("Error decoding frame\n");
|
|
} else {
|
|
while (!rb->audiobuffer_insert(pcmbuf, n)) {
|
|
rb->sleep(1);
|
|
if ( rb->seek_time ) {
|
|
/* Hmmm, a seek was requested. Throw out the
|
|
* buffer and go back to the top of the loop.
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
if ( !rb->seek_time ) {
|
|
rb->id3->offset = ov_raw_tell(&vf);
|
|
rb->set_elapsed(ov_time_tell(&vf));
|
|
rb->yield();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (rb->request_next_track()) {
|
|
/* Clean things up for the next track */
|
|
vf.dataoffsets = NULL;
|
|
vf.offsets = NULL;
|
|
vf.serialnos = NULL;
|
|
vf.pcmlengths = NULL;
|
|
ov_clear(&vf);
|
|
goto next_track;
|
|
}
|
|
|
|
return CODEC_OK;
|
|
}
|
|
|