add wma example

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@28 bbd45198-f89e-11dd-88c7-29a3b14d5316

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)
-

bsp/stm32_radio/wma.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)