Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/codecs/adx.c
Tomasz Malesinski 80da8b141c FS#6357, patch 1: let iramcopy and bss share the same space in codecs and 
plugins. Currently, in case of plugins using IRAM bss is cleared twice,
once in the loader, once in PLUGIN_IRAM_INIT. For codecs, bss is cleared only
during codec initialization. Also, removed double variables in codecs
storing a pointer to codec_api.


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@11606 a1c6a512-1295-4272-9138-f99709370657
2006-11-26 18:31:41 +00:00

336 lines
11 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
*
* Copyright (C) 2006 Adam Gashlin (hcs)
*
* 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 "codeclib.h"
#include "inttypes.h"
CODEC_HEADER
/* Maximum number of bytes to process in one iteration */
#define WAV_CHUNK_SIZE (1024*2)
/* Volume for ADX decoder */
#define BASE_VOL 0x2000
/* Number of times to loop looped tracks when repeat is disabled */
#define LOOP_TIMES 2
/* Length of fade-out for looped tracks (milliseconds) */
#define FADE_LENGTH 10000L
static int16_t samples[WAV_CHUNK_SIZE] IBSS_ATTR;
/* this is the codec entry point */
enum codec_status codec_main(void)
{
int channels;
int sampleswritten, i;
uint8_t *buf;
int32_t ch1_1, ch1_2, ch2_1, ch2_2; /* ADPCM history */
size_t n, bufsize;
int endofstream; /* end of stream flag */
uint32_t avgbytespersec;
int looping; /* looping flag */
int loop_count; /* number of loops done so far */
int fade_count; /* countdown for fadeout */
int fade_frames; /* length of fade in frames */
off_t start_adr, end_adr; /* loop points */
off_t chanstart, bufoff;
/* Generic codec initialisation */
/* we only render 16 bits */
ci->configure(DSP_SET_SAMPLE_DEPTH, (long *)16);
/*ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*256));*/
next_track:
DEBUGF("ADX: next_track\n");
if (codec_init()) {
return CODEC_ERROR;
}
DEBUGF("ADX: after init\n");
/* init history */
ch1_1=ch1_2=ch2_1=ch2_2=0;
/* wait for track info to load */
while (!*ci->taginfo_ready && !ci->stop_codec)
ci->sleep(1);
/* Read the entire file (or as much as possible) */
DEBUGF("ADX: request initial buffer\n");
ci->configure(CODEC_SET_FILEBUF_WATERMARK, (int *)(ci->filesize));
ci->seek_buffer(0);
buf = ci->request_buffer(&n, ci->filesize);
if (!buf || n < 0x38) {
return CODEC_ERROR;
}
bufsize = n;
bufoff = 0;
DEBUGF("ADX: read size = %x\n",bufsize);
/* Get file header for starting offset, channel count */
chanstart = ((buf[2] << 8) | buf[3]) + 4;
channels = buf[7];
/* useful for seeking and reporting current playback position */
avgbytespersec = ci->id3->frequency * 18 * channels / 32;
DEBUGF("avgbytespersec=%d\n",avgbytespersec);
/* Get loop data */
looping = 0; start_adr = 0; end_adr = 0;
if (!memcmp(buf+0x10,"\x01\xF4\x03\x00",4)) {
/* Soul Calibur 2 style (type 03) */
DEBUGF("ADX: type 03 found\n");
/* check if header is too small for loop data */
if (chanstart-6 < 0x2c) looping=0;
else {
looping = (buf[0x18]) ||
(buf[0x19]) ||
(buf[0x1a]) ||
(buf[0x1b]);
end_adr = (buf[0x28]<<24) |
(buf[0x29]<<16) |
(buf[0x2a]<<8) |
(buf[0x2b]);
start_adr = (
(buf[0x1c]<<24) |
(buf[0x1d]<<16) |
(buf[0x1e]<<8) |
(buf[0x1f])
)/32*channels*18+chanstart;
}
} else if (!memcmp(buf+0x10,"\x01\xF4\x04\x00",4)) {
/* Standard (type 04) */
DEBUGF("ADX: type 04 found\n");
/* check if header is too small for loop data */
if (chanstart-6 < 0x38) looping=0;
else {
looping = (buf[0x24]) ||
(buf[0x25]) ||
(buf[0x26]) ||
(buf[0x27]);
end_adr = (buf[0x34]<<24) |
(buf[0x35]<<16) |
(buf[0x36]<<8) |
buf[0x37];
start_adr = (
(buf[0x28]<<24) |
(buf[0x29]<<16) |
(buf[0x2a]<<8) |
(buf[0x2b])
)/32*channels*18+chanstart;
}
} else {
DEBUGF("ADX: error, couldn't determine ADX type\n");
return CODEC_ERROR;
}
if (looping) {
DEBUGF("ADX: looped, start: %x end: %x\n",start_adr,end_adr);
} else {
DEBUGF("ADX: not looped\n");
}
/* advance to first frame */
/*ci->seek_buffer(chanstart);*/
DEBUGF("ADX: first frame at %x\n",chanstart);
bufoff = chanstart;
/* setup pcm buffer format */
ci->configure(DSP_SWITCH_FREQUENCY, (long *)(ci->id3->frequency));
if (channels == 2) {
ci->configure(DSP_SET_STEREO_MODE, (long *)STEREO_INTERLEAVED);
} else if (channels == 1) {
ci->configure(DSP_SET_STEREO_MODE, (long *)STEREO_MONO);
} else {
DEBUGF("ADX CODEC_ERROR: more than 2 channels\n");
return CODEC_ERROR;
}
endofstream = 0;
loop_count = 0;
fade_count = -1; /* disable fade */
fade_frames = 1;
/* The main decoder loop */
while (!endofstream) {
ci->yield();
if (ci->stop_codec || ci->new_track) {
break;
}
/* do we need to loop? */
if (bufoff >= end_adr-18*channels && looping) {
DEBUGF("ADX: loop!\n");
/* check for endless looping */
if (ci->global_settings->repeat_mode==REPEAT_ONE) {
loop_count=0;
fade_count = -1; /* disable fade */
} else {
/* otherwise start fade after LOOP_TIMES loops */
loop_count++;
if (loop_count >= LOOP_TIMES && fade_count < 0) {
/* frames to fade over */
fade_frames = FADE_LENGTH*ci->id3->frequency/32/1000;
/* volume relative to fade_frames */
fade_count = fade_frames;
DEBUGF("ADX: fade_frames = %d\n",fade_frames);
}
}
bufoff = start_adr;
}
/* do we need to seek? */
if (ci->seek_time) {
uint32_t newpos;
DEBUGF("ADX: seek to %dms\n",ci->seek_time);
endofstream = 0;
loop_count = 0;
fade_count = -1; /* disable fade */
fade_frames = 1;
newpos = (((uint64_t)avgbytespersec*(ci->seek_time - 1))
/ (1000LL*18*channels))*(18*channels);
bufoff = chanstart + newpos;
while (bufoff > end_adr-18*channels) {
bufoff-=end_adr-start_adr;
loop_count++;
}
ci->seek_complete();
}
if (bufoff>ci->filesize-channels*18) break; /* End of stream */
/* dance with the devil in the pale moonlight */
if ((bufoff > ci->curpos + (off_t)bufsize - channels*18) ||
bufoff < ci->curpos) {
DEBUGF("ADX: requesting another buffer at %x size %x\n",
bufoff,ci->filesize-bufoff);
ci->seek_buffer(bufoff);
buf = ci->request_buffer(&n, ci->filesize-bufoff);
bufsize = n;
DEBUGF("ADX: read size = %x\n",bufsize);
if ((off_t)bufsize < channels*18) {
/* if we can't get a full frame, just request a single
frame (should be able to fit it in the guard buffer) */
DEBUGF("ADX: requesting single frame at %x\n",bufoff);
buf = ci->request_buffer(&n, channels*18);
bufsize=n;
DEBUGF("ADX: read size = %x\n",bufsize);
}
if (!buf) {
DEBUGF("ADX: couldn't get buffer at %x size %x\n",
bufoff,ci->filesize-bufoff);
return CODEC_ERROR;
}
buf-=bufoff;
}
if (bufsize == 0) break; /* End of stream */
sampleswritten=0;
while (
/* Is there data in the file buffer? */
((size_t)bufoff <= ci->curpos+bufsize-(18*channels)) &&
/* Is there space in the output buffer? */
(sampleswritten <= WAV_CHUNK_SIZE-(32*channels)) &&
/* Should we be looping? */
((!looping) || bufoff < end_adr-18*channels)) {
/* decode 18 bytes to 32 samples (from bero) */
int32_t scale = ((buf[bufoff] << 8) | (buf[bufoff+1])) * BASE_VOL;
int32_t ch1_0, d;
for (i = 2; i < 18; i++)
{
d = (buf[bufoff+i] >> 4) & 15;
if (d & 8) d-= 16;
ch1_0 = (d*scale + 0x7298L*ch1_1 - 0x3350L*ch1_2) >> 14;
if (ch1_0 > 32767) ch1_0 = 32767;
else if (ch1_0 < -32768) ch1_0 = -32768;
samples[sampleswritten] = ch1_0;
sampleswritten+=channels;
ch1_2 = ch1_1; ch1_1 = ch1_0;
d = buf[bufoff+i] & 15;
if (d & 8) d -= 16;
ch1_0 = (d*scale + 0x7298L*ch1_1 - 0x3350L*ch1_2) >> 14;
if (ch1_0 > 32767) ch1_0 = 32767;
else if (ch1_0 < -32768) ch1_0 = -32768;
samples[sampleswritten] = ch1_0;
sampleswritten+=channels;
ch1_2 = ch1_1; ch1_1 = ch1_0;
}
bufoff+=18;
if (channels == 2) {
int32_t scale = ((buf[bufoff] << 8)|(buf[bufoff+1]))*BASE_VOL;
int32_t ch2_0, d;
sampleswritten-=63;
for (i = 2; i < 18; i++)
{
d = (buf[bufoff+i] >> 4) & 15;
if (d & 8) d-= 16;
ch2_0 = (d*scale + 0x7298L*ch2_1 - 0x3350L*ch2_2) >> 14;
if (ch2_0 > 32767) ch2_0 = 32767;
else if (ch2_0 < -32768) ch2_0 = -32768;
samples[sampleswritten] = ch2_0;
sampleswritten+=2;
ch2_2 = ch2_1; ch2_1 = ch2_0;
d = buf[bufoff+i] & 15;
if (d & 8) d -= 16;
ch2_0 = (d*scale + 0x7298L*ch2_1 - 0x3350L*ch2_2) >> 14;
if (ch2_0 > 32767) ch2_0 = 32767;
else if (ch2_0 < -32768) ch2_0 = -32768;
samples[sampleswritten] = ch2_0;
sampleswritten+=2;
ch2_2 = ch2_1; ch2_1 = ch2_0;
}
bufoff+=18;
sampleswritten--; /* go back to first channel's next sample */
}
if (fade_count>0) {
fade_count--;
for (i=0;i<(channels==1?32:64);i++) samples[sampleswritten-i-1]=
((int32_t)samples[sampleswritten-i-1])*fade_count/fade_frames;
if (fade_count==0) {endofstream=1; break;}
}
}
/* 2 bytes per sample */
while (!ci->pcmbuf_insert((char *)samples, sampleswritten*2))
ci->yield();
ci->set_elapsed(
((end_adr-start_adr)*loop_count + bufoff-chanstart)*
1000LL/avgbytespersec);
}
if (ci->request_next_track())
goto next_track;
return CODEC_OK;
}
Reference in a new issue View git blame Copy permalink