Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/codecs/wma.c
Björn Stenberg 6427d127aa Calculate watermark from bitrate and harddisk spinup time. 
Use a smaller PCM buffer on targets with 2MB or less ram.
(FS#9703)


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@19743 a1c6a512-1295-4272-9138-f99709370657
2009-01-10 21:10:56 +00:00

614 lines
19 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 Dave Chapman
*
* ASF parsing code based on libasf by Juho Vähä-Herttua
* http://code.google.com/p/libasf/ libasf itself was based on the ASF
* parser in VLC - http://www.videolan.org/
*
* 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 "libwma/asf.h"
#include "libwma/wmadec.h"
CODEC_HEADER
int packet_count=0;
/* The output buffer containing the decoded samples (channels 0 and 1)
BLOCK_MAX_SIZE is 2048 (samples) and MAX_CHANNELS is 2.
*/
static uint32_t decoded[BLOCK_MAX_SIZE * MAX_CHANNELS] IBSS_ATTR;
/* NOTE: WMADecodeContext is 120152 bytes (on x86) */
static WMADecodeContext wmadec;
enum asf_error_e {
ASF_ERROR_INTERNAL = -1, /* incorrect input to API calls */
ASF_ERROR_OUTOFMEM = -2, /* some malloc inside program failed */
ASF_ERROR_EOF = -3, /* unexpected end of file */
ASF_ERROR_IO = -4, /* error reading or writing to file */
ASF_ERROR_INVALID_LENGTH = -5, /* length value conflict in input data */
ASF_ERROR_INVALID_VALUE = -6, /* other value conflict in input data */
ASF_ERROR_INVALID_OBJECT = -7, /* ASF object missing or in wrong place */
ASF_ERROR_OBJECT_SIZE = -8, /* invalid ASF object size (too small) */
ASF_ERROR_SEEKABLE = -9, /* file not seekable */
ASF_ERROR_SEEK = -10 /* file is seekable but seeking failed */
};
/* Read an unaligned 32-bit little endian long from buffer. */
static unsigned long get_long_le(void* buf)
{
unsigned char* p = (unsigned char*) buf;
return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
}
/* Read an unaligned 16-bit little endian short from buffer. */
static unsigned short get_short_le(void* buf)
{
unsigned char* p = (unsigned char*) buf;
return p[0] | (p[1] << 8);
}
#define GETLEN2b(bits) (((bits) == 0x03) ? 4 : bits)
#define GETVALUE2b(bits, data) \
(((bits) != 0x03) ? ((bits) != 0x02) ? ((bits) != 0x01) ? \
0 : *(data) : get_short_le(data) : get_long_le(data))
static int asf_read_packet(uint8_t** audiobuf, int* audiobufsize, int* packetlength, asf_waveformatex_t* wfx)
{
uint8_t tmp8, packet_flags, packet_property;
int stream_id;
int ec_length, opaque_data, ec_length_type;
int datalen;
uint8_t data[18];
uint8_t* datap;
uint32_t length;
uint32_t padding_length;
uint32_t send_time;
uint16_t duration;
uint16_t payload_count;
int payload_length_type;
uint32_t payload_hdrlen;
int payload_datalen;
int multiple;
uint32_t replicated_length;
uint32_t media_object_number;
uint32_t media_object_offset;
uint32_t bytesread = 0;
uint8_t* buf;
size_t bufsize;
int i;
/*DEBUGF("Reading new packet at %d bytes ", (int)ci->curpos);*/
if (ci->read_filebuf(&tmp8, 1) == 0) {
return ASF_ERROR_EOF;
}
bytesread++;
/* TODO: We need a better way to detect endofstream */
if (tmp8 != 0x82) {
DEBUGF("Read failed: packet did not sync\n");
return -1;
}
if (tmp8 & 0x80) {
ec_length = tmp8 & 0x0f;
opaque_data = (tmp8 >> 4) & 0x01;
ec_length_type = (tmp8 >> 5) & 0x03;
if (ec_length_type != 0x00 || opaque_data != 0 || ec_length != 0x02) {
DEBUGF("incorrect error correction flags\n");
return ASF_ERROR_INVALID_VALUE;
}
/* Skip ec_data */
ci->advance_buffer(ec_length);
bytesread += ec_length;
} else {
ec_length = 0;
}
if (ci->read_filebuf(&packet_flags, 1) == 0) { return ASF_ERROR_EOF; }
if (ci->read_filebuf(&packet_property, 1) == 0) { return ASF_ERROR_EOF; }
bytesread += 2;
datalen = GETLEN2b((packet_flags >> 1) & 0x03) +
GETLEN2b((packet_flags >> 3) & 0x03) +
GETLEN2b((packet_flags >> 5) & 0x03) + 6;
#if 0
if (datalen > sizeof(data)) {
DEBUGF("Unexpectedly long datalen in data - %d\n",datalen);
return ASF_ERROR_OUTOFMEM;
}
#endif
if (ci->read_filebuf(data, datalen) == 0) {
return ASF_ERROR_EOF;
}
bytesread += datalen;
datap = data;
length = GETVALUE2b((packet_flags >> 5) & 0x03, datap);
datap += GETLEN2b((packet_flags >> 5) & 0x03);
/* sequence value is not used */
GETVALUE2b((packet_flags >> 1) & 0x03, datap);
datap += GETLEN2b((packet_flags >> 1) & 0x03);
padding_length = GETVALUE2b((packet_flags >> 3) & 0x03, datap);
datap += GETLEN2b((packet_flags >> 3) & 0x03);
send_time = get_long_le(datap);
datap += 4;
duration = get_short_le(datap);
datap += 2;
/*DEBUGF("and duration %d ms\n", duration);*/
/* this is really idiotic, packet length can (and often will) be
* undefined and we just have to use the header packet size as the size
* value */
if (!((packet_flags >> 5) & 0x03)) {
length = wfx->packet_size;
}
/* this is also really idiotic, if packet length is smaller than packet
* size, we need to manually add the additional bytes into padding length
*/
if (length < wfx->packet_size) {
padding_length += wfx->packet_size - length;
length = wfx->packet_size;
}
if (length > wfx->packet_size) {
DEBUGF("packet with too big length value\n");
return ASF_ERROR_INVALID_LENGTH;
}
/* check if we have multiple payloads */
if (packet_flags & 0x01) {
if (ci->read_filebuf(&tmp8, 1) == 0) {
return ASF_ERROR_EOF;
}
payload_count = tmp8 & 0x3f;
payload_length_type = (tmp8 >> 6) & 0x03;
bytesread++;
} else {
payload_count = 1;
payload_length_type = 0x02; /* not used */
}
if (length < bytesread) {
DEBUGF("header exceeded packet size, invalid file - length=%d, bytesread=%d\n",(int)length,(int)bytesread);
/* FIXME: should this be checked earlier? */
return ASF_ERROR_INVALID_LENGTH;
}
/* We now parse the individual payloads, and move all payloads
belonging to our audio stream to a contiguous block, starting at
the location of the first payload.
*/
*audiobuf = NULL;
*audiobufsize = 0;
*packetlength = length - bytesread;
buf = ci->request_buffer(&bufsize, length);
datap = buf;
if (bufsize != length) {
/* This should only happen with packets larger than 32KB (the
guard buffer size). All the streams I've seen have
relatively small packets less than about 8KB), but I don't
know what is expected.
*/
DEBUGF("Could not read packet (requested %d bytes, received %d), curpos=%d, aborting\n",
(int)length,(int)bufsize,(int)ci->curpos);
return -1;
}
for (i=0; i<payload_count; i++) {
stream_id = datap[0]&0x7f;
datap++;
bytesread++;
payload_hdrlen = GETLEN2b(packet_property & 0x03) +
GETLEN2b((packet_property >> 2) & 0x03) +
GETLEN2b((packet_property >> 4) & 0x03);
//DEBUGF("payload_hdrlen = %d\n",payload_hdrlen);
#if 0
/* TODO */
if (payload_hdrlen > size) {
return ASF_ERROR_INVALID_LENGTH;
}
#endif
if (payload_hdrlen > sizeof(data)) {
DEBUGF("Unexpectedly long datalen in data - %d\n",datalen);
return ASF_ERROR_OUTOFMEM;
}
bytesread += payload_hdrlen;
media_object_number = GETVALUE2b((packet_property >> 4) & 0x03, datap);
datap += GETLEN2b((packet_property >> 4) & 0x03);
media_object_offset = GETVALUE2b((packet_property >> 2) & 0x03, datap);
datap += GETLEN2b((packet_property >> 2) & 0x03);
replicated_length = GETVALUE2b(packet_property & 0x03, datap);
datap += GETLEN2b(packet_property & 0x03);
/* TODO: Validate replicated_length */
/* TODO: Is the content of this important for us? */
datap += replicated_length;
bytesread += replicated_length;
multiple = packet_flags & 0x01;
if (multiple) {
int x;
x = GETLEN2b(payload_length_type);
if (x != 2) {
/* in multiple payloads datalen should be a word */
return ASF_ERROR_INVALID_VALUE;
}
#if 0
if (skip + tmp > datalen) {
/* not enough data */
return ASF_ERROR_INVALID_LENGTH;
}
#endif
payload_datalen = GETVALUE2b(payload_length_type, datap);
datap += x;
bytesread += x;
} else {
payload_datalen = length - bytesread - padding_length;
}
if (stream_id == wfx->audiostream)
{
if (*audiobuf == NULL) {
/* The first payload can stay where it is */
*audiobuf = datap;
*audiobufsize = payload_datalen;
} else {
/* The second and subsequent payloads in this packet
that belong to the audio stream need to be moved to be
contiguous with the first payload.
*/
memmove(*audiobuf + *audiobufsize, datap, payload_datalen);
*audiobufsize += payload_datalen;
}
}
datap += payload_datalen;
bytesread += payload_datalen;
}
if (*audiobuf != NULL)
return 1;
else
return 0;
}
static int get_timestamp(int *duration)
{
uint8_t tmp8, packet_flags, packet_property;
int ec_length, opaque_data, ec_length_type;
int datalen;
uint8_t data[18];
uint8_t* datap;
uint32_t length;
uint32_t padding_length;
uint32_t send_time;
uint32_t bytesread = 0;
packet_count++;
if (ci->read_filebuf(&tmp8, 1) == 0) {
DEBUGF("ASF ERROR (EOF?)\n");
return ASF_ERROR_EOF;
}
bytesread++;
/* TODO: We need a better way to detect endofstream */
if (tmp8 != 0x82) {
DEBUGF("Get timestamp: Detected end of stream\n");
return ASF_ERROR_EOF;
}
if (tmp8 & 0x80) {
ec_length = tmp8 & 0x0f;
opaque_data = (tmp8 >> 4) & 0x01;
ec_length_type = (tmp8 >> 5) & 0x03;
if (ec_length_type != 0x00 || opaque_data != 0 || ec_length != 0x02) {
DEBUGF("incorrect error correction flags\n");
return ASF_ERROR_INVALID_VALUE;
}
/* Skip ec_data */
ci->advance_buffer(ec_length);
bytesread += ec_length;
} else {
ec_length = 0;
}
if (ci->read_filebuf(&packet_flags, 1) == 0) {
DEBUGF("Detected end of stream 2\n");
return ASF_ERROR_EOF;
}
if (ci->read_filebuf(&packet_property, 1) == 0) {
DEBUGF("Detected end of stream3\n");
return ASF_ERROR_EOF;
}
bytesread += 2;
datalen = GETLEN2b((packet_flags >> 1) & 0x03) +
GETLEN2b((packet_flags >> 3) & 0x03) +
GETLEN2b((packet_flags >> 5) & 0x03) + 6;
if (ci->read_filebuf(data, datalen) == 0) {
DEBUGF("Detected end of stream4\n");
return ASF_ERROR_EOF;
}
bytesread += datalen;
datap = data;
length = GETVALUE2b((packet_flags >> 5) & 0x03, datap);
datap += GETLEN2b((packet_flags >> 5) & 0x03);
/* sequence value is not used */
GETVALUE2b((packet_flags >> 1) & 0x03, datap);
datap += GETLEN2b((packet_flags >> 1) & 0x03);
padding_length = GETVALUE2b((packet_flags >> 3) & 0x03, datap);
datap += GETLEN2b((packet_flags >> 3) & 0x03);
send_time = get_long_le(datap);
datap += 4;
*duration = get_short_le(datap);
/*the get_timestamp function advances us 12-13 bytes past the packet start,
need to undo this here so that we stay synced with the packet*/
ci->seek_buffer(ci->curpos-bytesread);
return send_time;
}
/*entry point for seeks*/
static int seek(int ms, asf_waveformatex_t* wfx)
{
int time, duration, delta, temp, count=0;
/*estimate packet number from bitrate*/
int initial_packet = ci->curpos/wfx->packet_size;
int packet_num = (((int64_t)ms)*(wfx->bitrate>>3))/wfx->packet_size/1000;
int last_packet = ci->id3->filesize / wfx->packet_size;
if (packet_num > last_packet) {
packet_num = last_packet;
}
/*calculate byte address of the start of that packet*/
int packet_offset = packet_num*wfx->packet_size;
/*seek to estimated packet*/
ci->seek_buffer(ci->id3->first_frame_offset+packet_offset);
temp = ms;
while (1)
{
/*for very large files it can be difficult and unimportant to find the exact packet*/
count++;
/*check the time stamp of our packet*/
time = get_timestamp(&duration);
DEBUGF("seeked to %d ms with duration %d\n", time, duration);
if (time < 0) {
/*unknown error, try to recover*/
DEBUGF("UKNOWN SEEK ERROR\n");
ci->seek_buffer(ci->id3->first_frame_offset+initial_packet*wfx->packet_size);
/*seek failed so return time stamp of the initial packet*/
return get_timestamp(&duration);
}
if ((time+duration>=ms && time<=ms) || count > 10) {
DEBUGF("Found our packet! Now at %d packet\n", packet_num);
return time;
} else {
/*seek again*/
delta = ms-time;
/*estimate new packet number from bitrate and our current position*/
temp += delta;
packet_num = ((temp/1000)*(wfx->bitrate>>3) - (wfx->packet_size>>1))/wfx->packet_size; //round down!
packet_offset = packet_num*wfx->packet_size;
ci->seek_buffer(ci->id3->first_frame_offset+packet_offset);
}
}
}
/* this is the codec entry point */
enum codec_status codec_main(void)
{
uint32_t elapsedtime;
int retval;
asf_waveformatex_t wfx;
size_t resume_offset;
int i;
int wmares, res;
uint8_t* audiobuf;
int audiobufsize;
int packetlength = 0;
int errcount = 0;
/* Generic codec initialisation */
ci->configure(DSP_SET_SAMPLE_DEPTH, 29);
next_track:
/* Wait for the metadata to be read */
while (!*ci->taginfo_ready && !ci->stop_codec)
ci->sleep(1);
retval = CODEC_OK;
/* Remember the resume position - when the codec is opened, the
playback engine will reset it. */
resume_offset = ci->id3->offset;
restart_track:
if (codec_init()) {
LOGF("WMA: Error initialising codec\n");
retval = CODEC_ERROR;
goto exit;
}
/* Copy the format metadata we've stored in the id3 TOC field. This
saves us from parsing it again here. */
memcpy(&wfx, ci->id3->toc, sizeof(wfx));
if (wma_decode_init(&wmadec,&wfx) < 0) {
LOGF("WMA: Unsupported or corrupt file\n");
retval = CODEC_ERROR;
goto exit;
}
DEBUGF("**************** IN WMA.C ******************\n");
if (resume_offset > ci->id3->first_frame_offset)
{
/* Get start of current packet */
int packet_offset = (resume_offset - ci->id3->first_frame_offset)
% wfx.packet_size;
ci->seek_buffer(resume_offset - packet_offset);
elapsedtime = get_timestamp(&i);
ci->set_elapsed(elapsedtime);
}
else
{
/* Now advance the file position to the first frame */
ci->seek_buffer(ci->id3->first_frame_offset);
elapsedtime = 0;
}
resume_offset = 0;
ci->configure(DSP_SWITCH_FREQUENCY, wfx.rate);
ci->configure(DSP_SET_STEREO_MODE, wfx.channels == 1 ?
STEREO_MONO : STEREO_INTERLEAVED);
codec_set_replaygain(ci->id3);
/* The main decoding loop */
res = 1;
while (res >= 0)
{
ci->yield();
if (ci->stop_codec || ci->new_track) {
goto done;
}
/* Deal with any pending seek requests */
if (ci->seek_time){
if (ci->seek_time == 1) {
ci->seek_complete();
goto restart_track; /* Pretend you never saw this... */
}
elapsedtime = seek(ci->seek_time, &wfx);
if (elapsedtime < 1){
ci->seek_complete();
goto next_track;
}
/*DEBUGF("Seek returned %d\n", (int)elapsedtime);*/
ci->set_elapsed(elapsedtime);
/*flush the wma decoder state*/
wmadec.last_superframe_len = 0;
wmadec.last_bitoffset = 0;
ci->seek_complete();
}
errcount = 0;
new_packet:
res = asf_read_packet(&audiobuf, &audiobufsize, &packetlength, &wfx);
if (res < 0) {
/* We'll try to recover from a parse error a certain number of
* times. If we succeed, the error counter will be reset.
*/
errcount++;
DEBUGF("read_packet error %d, errcount %d\n",wmares, errcount);
if (errcount > 5) {
goto done;
} else {
ci->advance_buffer(packetlength);
goto new_packet;
}
} else if (res > 0) {
wma_decode_superframe_init(&wmadec, audiobuf, audiobufsize);
for (i=0; i < wmadec.nb_frames; i++)
{
wmares = wma_decode_superframe_frame(&wmadec,
decoded,
audiobuf, audiobufsize);
ci->yield ();
if (wmares < 0) {
/* Do the above, but for errors in decode. */
errcount++;
DEBUGF("WMA decode error %d, errcount %d\n",wmares, errcount);
if (errcount > 5) {
goto done;
} else {
ci->advance_buffer(packetlength);
goto new_packet;
}
} else if (wmares > 0) {
ci->pcmbuf_insert(decoded, NULL, wmares);
elapsedtime += (wmares*10)/(wfx.rate/100);
ci->set_elapsed(elapsedtime);
}
ci->yield();
}
}
ci->advance_buffer(packetlength);
}
retval = CODEC_OK;
done:
/*LOGF("WMA: Decoded %ld samples\n",elapsedtime*wfx.rate/1000);*/
if (ci->request_next_track())
goto next_track;
exit:
return retval;
}
Reference in a new issue View git blame Copy permalink