rt-thread/bsp/stm32_radio/wma.c

410 lines
10 KiB
C

/* wma player test */
#include "libwma/asf.h"
#include "libwma/wmadec.h"
/* 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];
/* 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 */
};
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;
/* rt_kprintf("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)
{
rt_kprintf("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)
{
rt_kprintf("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 (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;
/* rt_kprintf("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)
{
rt_kprintf("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)
{
rt_kprintf("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.
*/
rt_kprintf("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);
// rt_kprintf("payload_hdrlen = %d\n",payload_hdrlen);
if (payload_hdrlen > sizeof(data))
{
rt_kprintf("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;
}
payload_datalen = GETVALUE2b(payload_length_type, datap);
datap += x;
bytesread += x;
}
else
{
payload_datalen = length - bytesread - padding_length;
}
if (replicated_length==1)
datap++;
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;
}
/* this is the codec entry point */
void wma_run(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 */
next_track:
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;
}
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;
/* The main decoding loop */
res = 1;
while (res >= 0)
{
/* Deal with any pending seek requests */
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++;
rt_kprintf("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);
if (wmares < 0)
{
/* Do the above, but for errors in decode. */
errcount++;
rt_kprintf("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);
}
}
}
}
retval = CODEC_OK;
done:
/*LOGF("WMA: Decoded %ld samples\n",elapsedtime*wfx.rate/1000);*/
return retval;
}
void wma()
{}
FINSH_FUNCTION_EXPORT(wma, wma test)