521 lines
17 KiB
C
521 lines
17 KiB
C
|
/**************************************************************************
|
||
|
|
kate: space-indent on; indent-width 4; mixedindent off; indent-mode cstyle;
|
||
|
|
* __________ __ ___.
|
||
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
||
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
||
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
||
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
||
|
|
* \/ \/ \/ \/ \/
|
||
|
|
*
|
||
|
|
* Copyright (C) 2006 Frederik M.J. Vestre
|
||
|
|
* Based on vorbis.c codec interface:
|
||
|
|
* Copyright (C) 2002 Bjrn 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 "libspeex/speex/ogg.h"
|
||
|
|
#include "libspeex/speex/speex.h"
|
||
|
|
#include "libspeex/speex/speex_header.h"
|
||
|
|
#include "libspeex/speex/speex_stereo.h"
|
||
|
|
#include "libspeex/speex/speex_callbacks.h"
|
||
|
|
#include "codeclib.h"
|
||
|
|
#define MAX_FRAME_SIZE 2000
|
||
|
|
#define CHUNKSIZE 10000 /*2kb*/
|
||
|
|
#define SEEK_CHUNKSIZE 7*CHUNKSIZE
|
||
|
|
#include <stdio.h>
|
||
|
|
|
||
|
|
//#define LOGF(...)
|
||
|
|
|
||
|
|
CODEC_HEADER
|
||
|
|
|
||
|
|
struct codec_api *rb;
|
||
|
|
|
||
|
|
int get_more_data(spx_ogg_sync_state *oy,struct codec_api *rb){
|
||
|
|
int bytes;
|
||
|
|
char *buffer;
|
||
|
|
buffer=(char *)spx_ogg_sync_buffer(oy,CHUNKSIZE);
|
||
|
|
bytes=rb->read_filebuf(buffer, sizeof(char)*CHUNKSIZE);
|
||
|
|
spx_ogg_sync_wrote(oy,bytes);
|
||
|
|
return bytes;
|
||
|
|
}
|
||
|
|
/* The read/seek functions track absolute position within the stream */
|
||
|
|
|
||
|
|
static spx_int64_t get_next_page(spx_ogg_sync_state *oy,spx_ogg_page *og,
|
||
|
|
spx_int64_t boundary,struct codec_api *rb){
|
||
|
|
spx_int64_t localoffset=rb->curpos;
|
||
|
|
if(boundary>0)boundary+=rb->curpos;
|
||
|
|
while(1){
|
||
|
|
long more;
|
||
|
|
more=spx_ogg_sync_pageseek(oy,og);
|
||
|
|
if(more<0){
|
||
|
|
/* skipped n bytes */
|
||
|
|
localoffset-=more;
|
||
|
|
}else{
|
||
|
|
if(more==0){
|
||
|
|
/* send more paramedics */
|
||
|
|
if(!boundary)return(-1);
|
||
|
|
{
|
||
|
|
long ret=1;
|
||
|
|
ret=get_more_data(oy,rb);
|
||
|
|
if(ret==0)
|
||
|
|
return(-2);
|
||
|
|
if(ret<0)
|
||
|
|
return(-3);
|
||
|
|
}
|
||
|
|
}else{
|
||
|
|
/* got a page. Return the offset at the page beginning,
|
||
|
|
advance the internal offset past the page end */
|
||
|
|
spx_int64_t ret=localoffset;
|
||
|
|
return(ret);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static spx_int64_t seek_backwards(
|
||
|
|
spx_ogg_sync_state *oy,spx_ogg_page *og,
|
||
|
|
spx_int64_t wantedpos,
|
||
|
|
struct codec_api *rb
|
||
|
|
){
|
||
|
|
spx_int64_t crofs;
|
||
|
|
spx_int64_t *curoffset=&crofs;
|
||
|
|
*curoffset=rb->curpos;
|
||
|
|
spx_int64_t begin=*curoffset;
|
||
|
|
spx_int64_t end=begin;
|
||
|
|
spx_int64_t ret;
|
||
|
|
spx_int64_t offset=-1;
|
||
|
|
spx_int64_t avgpagelen=-1;
|
||
|
|
spx_int64_t lastgranule=-1;
|
||
|
|
short time=-1;
|
||
|
|
while(offset==-1){
|
||
|
|
begin-=SEEK_CHUNKSIZE;
|
||
|
|
if(begin<0){
|
||
|
|
if(time<0){
|
||
|
|
begin=0;
|
||
|
|
time++;
|
||
|
|
}else{
|
||
|
|
LOGF("Can't seek that early:%d\n",begin);
|
||
|
|
return -3;/*too early*/
|
||
|
|
}
|
||
|
|
}
|
||
|
|
*curoffset=begin;
|
||
|
|
rb->seek_buffer(*curoffset);
|
||
|
|
spx_ogg_sync_reset(oy);
|
||
|
|
lastgranule=-1;
|
||
|
|
while(*curoffset<end){
|
||
|
|
ret=get_next_page(oy,og,end-*curoffset,rb);
|
||
|
|
if(ret>0){
|
||
|
|
if(lastgranule!=-1){
|
||
|
|
if(avgpagelen<0)
|
||
|
|
avgpagelen=(spx_ogg_page_granulepos(og)-lastgranule);
|
||
|
|
else
|
||
|
|
avgpagelen=((spx_ogg_page_granulepos(og)-lastgranule)
|
||
|
|
+avgpagelen)/2;
|
||
|
|
}
|
||
|
|
lastgranule=spx_ogg_page_granulepos(og);
|
||
|
|
if((lastgranule-(avgpagelen/4))<wantedpos&&
|
||
|
|
(lastgranule+avgpagelen+(avgpagelen/4))>wantedpos){
|
||
|
|
/*wanted offset found Yeay!*/
|
||
|
|
/*LOGF("GnPagefound:%d,%d,%d,%d\n",ret,
|
||
|
|
lastgranule,wantedpos,avgpagelen);*/
|
||
|
|
return ret;
|
||
|
|
}else if (lastgranule>wantedpos){/*too late, seek more*/
|
||
|
|
if(offset!=-1){
|
||
|
|
LOGF("Toolate, returnanyway:%d,%d,%d,%d\n",
|
||
|
|
ret,lastgranule,wantedpos,avgpagelen);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
} else{ /*if (spx_ogg_page_granulepos(&og)<wantedpos)*/
|
||
|
|
/*too early*/
|
||
|
|
offset=ret;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
} else if(ret==-3) return(-3);
|
||
|
|
else if(ret<=0)
|
||
|
|
break;
|
||
|
|
else if(*curoffset<end) {
|
||
|
|
/*this should not be possible*/
|
||
|
|
//LOGF("Seek:get_earlier_page:Offset:not_cached by granule:"\"%d,%d,%d,%d,%d\n",*curoffset,end,begin,wantedpos,curpos);
|
||
|
|
offset=ret;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
int speex_seek_page_granule(
|
||
|
|
spx_int64_t pos,
|
||
|
|
spx_int64_t curpos,
|
||
|
|
spx_ogg_sync_state *oy,
|
||
|
|
spx_int64_t headerssize,
|
||
|
|
struct codec_api *rb
|
||
|
|
){
|
||
|
|
/* TODO: Someone may want to try to implement seek to packet,
|
||
|
|
* instead of just to page (should be more accurate, not be any faster)*/
|
||
|
|
spx_int64_t crofs;
|
||
|
|
spx_int64_t *curbyteoffset=&crofs;
|
||
|
|
*curbyteoffset=rb->curpos;
|
||
|
|
spx_int64_t curoffset;
|
||
|
|
curoffset=*curbyteoffset;
|
||
|
|
spx_int64_t offset=0;
|
||
|
|
spx_ogg_page og={0,0,0,0};
|
||
|
|
spx_int64_t avgpagelen=-1;
|
||
|
|
spx_int64_t lastgranule=-1;
|
||
|
|
if(abs(pos-curpos)>10000 && headerssize>0 && curoffset-headerssize>10000){
|
||
|
|
/*if seeking for more that 10sec,
|
||
|
|
headersize is known & more than 10kb is played,
|
||
|
|
try to guess a place to seek from the number of
|
||
|
|
bytes playe for this position, this works best when
|
||
|
|
the bitrate is relativly constant.*/
|
||
|
|
curoffset=(int)((((float)(*curbyteoffset-(headerssize))
|
||
|
|
*(float)pos)/(float)curpos)*0.98);
|
||
|
|
if(curoffset<0)
|
||
|
|
curoffset=0;
|
||
|
|
//spx_int64_t toffset=curoffset;
|
||
|
|
rb->seek_buffer(curoffset);
|
||
|
|
spx_ogg_sync_reset(oy);
|
||
|
|
offset=get_next_page(oy,&og,-1,rb);
|
||
|
|
if(offset<0){/*could not find new page,use old offset*/
|
||
|
|
LOGF("Seek/guess/fault:%d->-<-%d,%d:%d,%d,%d\n",
|
||
|
|
curpos,0,pos,offset,0,
|
||
|
|
rb->curpos,/*stream_length*/0);
|
||
|
|
curoffset=*curbyteoffset;
|
||
|
|
rb->seek_buffer(curoffset);
|
||
|
|
spx_ogg_sync_reset(oy);
|
||
|
|
}else{
|
||
|
|
if(spx_ogg_page_granulepos(&og)==0&&pos>5000){
|
||
|
|
LOGF("SEEK/guess/fault:%d->-<-%d,%d:%d,%d,%d\n",
|
||
|
|
curpos,spx_ogg_page_granulepos(&og),pos,
|
||
|
|
offset,0,rb->curpos,/*stream_length*/0);
|
||
|
|
curoffset=*curbyteoffset;
|
||
|
|
rb->seek_buffer(curoffset);
|
||
|
|
spx_ogg_sync_reset(oy);
|
||
|
|
}else{
|
||
|
|
curoffset=offset;
|
||
|
|
curpos=spx_ogg_page_granulepos(&og);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*which way do we want to seek?*/
|
||
|
|
if(curpos>pos){/*backwards*/
|
||
|
|
offset=seek_backwards(oy,&og,pos,rb);
|
||
|
|
if(offset>0){
|
||
|
|
*curbyteoffset=curoffset;
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}else{/*forwards*/
|
||
|
|
while((offset=get_next_page(oy,&og,-1,rb))>0){
|
||
|
|
if(lastgranule!=-1){
|
||
|
|
if(avgpagelen<0)
|
||
|
|
avgpagelen=(spx_ogg_page_granulepos(&og)-lastgranule);
|
||
|
|
else
|
||
|
|
avgpagelen=((spx_ogg_page_granulepos(&og)-lastgranule)
|
||
|
|
+avgpagelen)/2;
|
||
|
|
}
|
||
|
|
lastgranule=spx_ogg_page_granulepos(&og);
|
||
|
|
if(((lastgranule-(avgpagelen/4))<pos
|
||
|
|
&&(lastgranule+avgpagelen+(avgpagelen/4))>pos)||
|
||
|
|
lastgranule>pos
|
||
|
|
){
|
||
|
|
/*wanted offset found Yeay!*/
|
||
|
|
*curbyteoffset=offset;
|
||
|
|
return offset;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
rb->seek_buffer(*curbyteoffset);
|
||
|
|
spx_ogg_sync_reset(oy);
|
||
|
|
LOGF("Seek failed:%d\n",offset);
|
||
|
|
rb->splash(HZ*2, true, "Seek failed");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
static void *process_header(
|
||
|
|
spx_ogg_packet *op,
|
||
|
|
int enh_enabled,
|
||
|
|
int *frame_size,
|
||
|
|
int *rate,
|
||
|
|
int *nframes,
|
||
|
|
int *channels,
|
||
|
|
SpeexStereoState *stereo,
|
||
|
|
int *extra_headers
|
||
|
|
){
|
||
|
|
void *st;
|
||
|
|
const SpeexMode *mode;
|
||
|
|
SpeexHeader *header;
|
||
|
|
int modeID;
|
||
|
|
SpeexCallback callback;
|
||
|
|
header = speex_packet_to_header((char*)op->packet, op->bytes);
|
||
|
|
if (!header){
|
||
|
|
DEBUGF ("Cannot read header\n");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
if (header->mode >= SPEEX_NB_MODES){
|
||
|
|
DEBUGF ("Mode does not exist\n");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
modeID = header->mode;
|
||
|
|
|
||
|
|
mode = speex_lib_get_mode (modeID);
|
||
|
|
if (header->speex_version_id > 1){
|
||
|
|
DEBUGF("Undecodeable bitstream");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
if (mode->bitstream_version < header->mode_bitstream_version){
|
||
|
|
DEBUGF("Undecodeable bitstream, newer bitstream");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
if (mode->bitstream_version > header->mode_bitstream_version){
|
||
|
|
DEBUGF("Too old bitstream");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
st = speex_decoder_init(mode);
|
||
|
|
if (!st){
|
||
|
|
DEBUGF("Decoder init failed");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
speex_decoder_ctl(st, SPEEX_SET_ENH, &enh_enabled);
|
||
|
|
speex_decoder_ctl(st, SPEEX_GET_FRAME_SIZE, frame_size);
|
||
|
|
|
||
|
|
if (*channels==-1)
|
||
|
|
*channels = header->nb_channels;
|
||
|
|
|
||
|
|
if (!(*channels==1)){
|
||
|
|
callback.callback_id = SPEEX_INBAND_STEREO;
|
||
|
|
callback.func = speex_std_stereo_request_handler;
|
||
|
|
callback.data = stereo;
|
||
|
|
speex_decoder_ctl(st, SPEEX_SET_HANDLER, &callback);
|
||
|
|
}
|
||
|
|
if (!*rate)
|
||
|
|
*rate = header->rate;
|
||
|
|
|
||
|
|
speex_decoder_ctl(st, SPEEX_SET_SAMPLING_RATE, rate);
|
||
|
|
|
||
|
|
*nframes = header->frames_per_packet;
|
||
|
|
|
||
|
|
if (*channels == 2) {
|
||
|
|
rb->configure(DSP_SET_STEREO_MODE, (int *)STEREO_INTERLEAVED);
|
||
|
|
} else if (*channels == 1) {
|
||
|
|
rb->configure(DSP_SET_STEREO_MODE, (int *)STEREO_MONO);
|
||
|
|
}
|
||
|
|
|
||
|
|
*extra_headers = header->extra_headers;
|
||
|
|
|
||
|
|
codec_free(header);
|
||
|
|
return st;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#ifdef USE_IRAM
|
||
|
|
extern char iramcopy[];
|
||
|
|
extern char iramstart[];
|
||
|
|
extern char iramend[];
|
||
|
|
extern char iedata[];
|
||
|
|
extern char iend[];
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* this is the codec entry point */
|
||
|
|
enum codec_status codec_main()
|
||
|
|
{
|
||
|
|
SpeexBits vf;
|
||
|
|
int error;
|
||
|
|
int eof;
|
||
|
|
spx_ogg_sync_state oy;
|
||
|
|
spx_ogg_page og;
|
||
|
|
spx_ogg_packet op;
|
||
|
|
spx_ogg_stream_state os;
|
||
|
|
spx_int64_t page_granule=0, cur_granule=0;
|
||
|
|
int enh_enabled;
|
||
|
|
int nframes=2;
|
||
|
|
int eos=0;
|
||
|
|
SpeexStereoState stereo = SPEEX_STEREO_STATE_INIT;
|
||
|
|
int channels=-1;
|
||
|
|
int rate=0,samplerate=0;
|
||
|
|
int extra_headers;
|
||
|
|
int stream_init=0;
|
||
|
|
int page_nb_packets,frame_size,packet_count=0;
|
||
|
|
int lookahead;
|
||
|
|
int headerssize=-1;
|
||
|
|
unsigned long strtoffset;
|
||
|
|
short output[MAX_FRAME_SIZE];
|
||
|
|
enh_enabled = 1;
|
||
|
|
void *st=0;
|
||
|
|
rb = ci;
|
||
|
|
|
||
|
|
#if 0 /*USE_IRAM */
|
||
|
|
rb->memcpy(iramstart, iramcopy, iramend - iramstart);
|
||
|
|
rb->memset(iedata, 0, iend - iedata);
|
||
|
|
#endif
|
||
|
|
//rb->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (long *)(CHUNKSIZE*128));
|
||
|
|
// rb->configure(DSP_DITHER, (bool *)false);
|
||
|
|
rb->configure(DSP_SET_SAMPLE_DEPTH, (long *)16);
|
||
|
|
/* We need to flush reserver memory every track load. */
|
||
|
|
next_track:
|
||
|
|
if (codec_init()) {
|
||
|
|
error = CODEC_ERROR;
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
strtoffset=rb->id3->offset;
|
||
|
|
while (!*rb->taginfo_ready && !rb->stop_codec)
|
||
|
|
rb->sleep(1);
|
||
|
|
|
||
|
|
|
||
|
|
spx_ogg_sync_init(&oy);
|
||
|
|
spx_ogg_alloc_buffer(&oy,2*CHUNKSIZE);
|
||
|
|
samplerate=rb->id3->frequency;
|
||
|
|
codec_set_replaygain(rb->id3);
|
||
|
|
speex_bits_init(&vf);
|
||
|
|
|
||
|
|
eof = 0;
|
||
|
|
while (!eof) {
|
||
|
|
rb->yield();
|
||
|
|
if (rb->stop_codec || rb->new_track)
|
||
|
|
break;
|
||
|
|
|
||
|
|
if (rb->seek_time) {/*seek (seeks to the page before the position*/
|
||
|
|
if(samplerate!=0&&packet_count>1){
|
||
|
|
LOGF("Speex seek page:%d,%d,%d,%d\n",
|
||
|
|
((spx_int64_t)rb->seek_time/1000)
|
||
|
|
*(spx_int64_t)samplerate,
|
||
|
|
page_granule,
|
||
|
|
rb->seek_time,
|
||
|
|
(page_granule/samplerate)*1000,
|
||
|
|
samplerate
|
||
|
|
);
|
||
|
|
speex_seek_page_granule(
|
||
|
|
((spx_int64_t)rb->seek_time/1000)
|
||
|
|
*(spx_int64_t)samplerate,
|
||
|
|
page_granule,&oy,
|
||
|
|
headerssize,
|
||
|
|
rb
|
||
|
|
);
|
||
|
|
rb->seek_complete();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
int j;
|
||
|
|
next_page:
|
||
|
|
/*Get the ogg buffer for writing*/
|
||
|
|
if(get_more_data(&oy,rb)<1){/*read error*/
|
||
|
|
error=CODEC_ERROR;
|
||
|
|
goto done;
|
||
|
|
}
|
||
|
|
/*Loop for all complete pages we got (most likely only one)*/
|
||
|
|
while (spx_ogg_sync_pageout(&oy, &og)==1){
|
||
|
|
int packet_no;
|
||
|
|
if (stream_init == 0) {
|
||
|
|
spx_ogg_stream_init(&os,spx_ogg_page_serialno(&og));
|
||
|
|
stream_init = 1;
|
||
|
|
}
|
||
|
|
/*Add page to the bitstream*/
|
||
|
|
spx_ogg_stream_pagein(&os, &og);
|
||
|
|
|
||
|
|
page_granule = spx_ogg_page_granulepos(&og);
|
||
|
|
page_nb_packets = spx_ogg_page_packets(&og);
|
||
|
|
|
||
|
|
cur_granule = page_granule;
|
||
|
|
|
||
|
|
/*Extract all available packets*/
|
||
|
|
packet_no=0;
|
||
|
|
|
||
|
|
while (!eos && spx_ogg_stream_packetout(&os, &op)==1){
|
||
|
|
/*If first packet, process as Speex header*/
|
||
|
|
if (packet_count==0){
|
||
|
|
st = process_header(&op, enh_enabled, &frame_size,
|
||
|
|
&samplerate,&nframes, &channels,
|
||
|
|
&stereo, &extra_headers);
|
||
|
|
speex_decoder_ctl(st, SPEEX_GET_LOOKAHEAD, &lookahead);
|
||
|
|
if (!nframes)
|
||
|
|
nframes=1;
|
||
|
|
if (!st){
|
||
|
|
error=CODEC_ERROR;
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
rb->id3->vbr = true;
|
||
|
|
rb->id3->frequency = samplerate;
|
||
|
|
rb->configure(DSP_SET_FREQUENCY, (int *)samplerate);
|
||
|
|
headerssize+=og.header_len+og.body_len;/*Speex header in
|
||
|
|
it's own page, add the whole page headersize*/
|
||
|
|
} else if (packet_count<=1+extra_headers){
|
||
|
|
headerssize+=op.bytes;/*add packet to headersize*/
|
||
|
|
/* Ignore extra headers */
|
||
|
|
} else {
|
||
|
|
if(packet_count<=2+extra_headers){
|
||
|
|
if (strtoffset) {
|
||
|
|
rb->seek_buffer(strtoffset);
|
||
|
|
spx_ogg_sync_reset(&oy);
|
||
|
|
packet_count++;
|
||
|
|
goto next_page;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
packet_no++;
|
||
|
|
if (op.e_o_s) /*End of stream condition*/
|
||
|
|
eos=1;
|
||
|
|
/*Copy Ogg packet to Speex bitstream*/
|
||
|
|
speex_bits_read_from(&vf, (char*)op.packet, op.bytes);
|
||
|
|
for (j=0;j!=nframes;j++){
|
||
|
|
int ret;
|
||
|
|
/*Decode frame*/
|
||
|
|
ret = speex_decode_int(st, &vf, output);
|
||
|
|
if (ret==-1)
|
||
|
|
break;
|
||
|
|
if (ret==-2)
|
||
|
|
break;
|
||
|
|
if (speex_bits_remaining(&vf)<0)
|
||
|
|
break;
|
||
|
|
if (channels==2)
|
||
|
|
speex_decode_stereo_int(output, frame_size,&stereo);
|
||
|
|
{
|
||
|
|
int new_frame_size = frame_size;
|
||
|
|
if (new_frame_size>0){
|
||
|
|
rb->pcmbuf_insert(
|
||
|
|
(const char*)output,
|
||
|
|
(const char*)output,
|
||
|
|
new_frame_size*channels
|
||
|
|
);
|
||
|
|
cur_granule+=new_frame_size/2;/*2 bytes/sample*/
|
||
|
|
rb->set_offset((long)rb->curpos);
|
||
|
|
rb->set_elapsed((samplerate==0)?0:
|
||
|
|
cur_granule*1000/samplerate
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
packet_count++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
done:
|
||
|
|
if (rb->request_next_track()) {
|
||
|
|
/* Clean things up for the next track */
|
||
|
|
speex_decoder_destroy(st);
|
||
|
|
speex_bits_reset(&vf);
|
||
|
|
if (stream_init==1)
|
||
|
|
spx_ogg_stream_reset(&os);
|
||
|
|
spx_ogg_sync_reset(&oy);
|
||
|
|
cur_granule=stream_init=rate=samplerate=headerssize=packet_count=eos=0;
|
||
|
|
stereo.balance=stereo.smooth_left=stereo.smooth_right= 1;
|
||
|
|
stereo.e_ratio = .5;
|
||
|
|
stereo.reserved1=stereo.reserved2= 0;
|
||
|
|
goto next_track;
|
||
|
|
}
|
||
|
|
error = CODEC_OK;
|
||
|
|
exit:
|
||
|
|
speex_bits_destroy(&vf);
|
||
|
|
if (stream_init)
|
||
|
|
spx_ogg_stream_destroy(&os);
|
||
|
|
spx_ogg_sync_destroy(&oy);
|
||
|
|
return error;
|
||
|
|
}
|