diff --git a/bsp/stm32_radio/wav.c b/bsp/stm32_radio/wav.c index abf169cfb28b9526f271c692119a2c37ec0ac8ea..ceaf152ec50da8286661bbb3ca92a4b4d720734d 100644 --- a/bsp/stm32_radio/wav.c +++ b/bsp/stm32_radio/wav.c @@ -39,7 +39,7 @@ void wav(char* filename) rt_uint8_t* buf; rt_size_t len; rt_device_t device; - + /* open audio device and set tx done call back */ device = rt_device_find("snd"); rt_device_set_tx_complete(device, wav_tx_done); @@ -55,11 +55,11 @@ void wav(char* filename) rt_kprintf("...done!\n"); if (len > 0) rt_device_write(device, 0, buf, len); } while (len != 0); - + /* close device and file */ rt_device_close(device); close(fd); - + /* delete memory pool */ #ifdef STATIC_MEMPOOL rt_mp_detach(mp); @@ -69,37 +69,3 @@ void wav(char* filename) } } FINSH_FUNCTION_EXPORT(wav, wav test) - -/* DMA Test */ -#define BufferSize 32 -u8 SPI2_Buffer_Tx[BufferSize] = {0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59, - 0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62, - 0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B, - 0x6C,0x6D,0x6E,0x6F,0x70}; - -void wm(int cnt) -{ - rt_device_t device; - rt_uint8_t *buf; - - mp = rt_mp_create("wav", WAV_MP_NUM, WAV_MP_BUFSZ); - - device = rt_device_find("snd"); - rt_device_set_tx_complete(device, wav_tx_done); - rt_device_open(device, RT_DEVICE_OFLAG_WRONLY); - - while(cnt) - { - buf = rt_mp_alloc(mp, RT_WAITING_FOREVER); - rt_memcpy(buf, SPI2_Buffer_Tx, BufferSize); - - rt_device_write(device, 0, buf, BufferSize); - - cnt --; - } - - rt_device_close(device); - rt_mp_delete(mp); -} -FINSH_FUNCTION_EXPORT(wm, wm test) - diff --git a/bsp/stm32_radio/wma.c b/bsp/stm32_radio/wma.c new file mode 100644 index 0000000000000000000000000000000000000000..90e584d1d405aaaa3cd6da20c41e396adf11b0e5 --- /dev/null +++ b/bsp/stm32_radio/wma.c @@ -0,0 +1,409 @@ +/* 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> 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)