// samples are written to from one thread, and read from another (this one)
int fifoRead (int fifoBasePtr, int fifoPtrPtr, int fifoCheckBasePtr, int fifoCheckVal) {
int *fifoBase;
int *fifoPtr;
int readData;
int *fifoCheckBase;
int readCheckData;
fifoBase = (int *)(fifoBasePtr);
fifoPtr = (int *)(fifoPtrPtr);
fifoCheckBase = (int *)(fifoCheckBasePtr);
// Check the sample number
readCheckData = fifoCheckBase[*fifoPtr];
#if PRINT == PWM_FLOW_CHECK
if (readCheckData != fifoCheckVal)
{
printstrln("PWM Fifo Checking failure");
printstr("Expected: ");
printintln(fifoCheckVal);
printstr("Actual: ");
printintln(readCheckData);
while(1);
}
#endif
// now perform read
readData = fifoBase[*fifoPtr];
(*fifoPtr)++;
(*fifoPtr) = (*fifoPtr) & PWM_FIFO_MASK;
return (readData);
}
int media_input_fifo_enable(media_input_fifo_t media_input_fifo0,
int rate)
{
volatile ififo_t *media_input_fifo = (ififo_t *) media_input_fifo0;
int packetSize;
// This is the calculation of the SYT_INTERVAL
#ifndef AVB_1722_FORMAT_SAF
// packetSize = (((rate+(AVB1722_PACKET_RATE-1))/AVB1722_PACKET_RATE) * 4) / 3;
switch (rate)
{
case 8000: packetSize = 1; break;
case 16000: packetSize = 2; break;
case 32000: packetSize = 8; break;
case 44100: packetSize = 8; break;
case 48000: packetSize = 8; break;
case 88200: packetSize = 16; break;
case 96000: packetSize = 16; break;
case 176400: packetSize = 32; break;
case 192000: packetSize = 32; break;
default: printstrln("ERROR: Invalid sample rate"); break;
}
#else
packetSize = ((rate+(AVB1722_PACKET_RATE-1))/AVB1722_PACKET_RATE);
#endif
media_input_fifo->rdIndex = (int) &media_input_fifo->buf[0];
media_input_fifo->wrIndex = (int) &media_input_fifo->buf[0];
media_input_fifo->startIndex = (int) &media_input_fifo->buf[0];
media_input_fifo->dbc = 0;
media_input_fifo->fifoEnd = (int) &media_input_fifo->buf[MEDIA_INPUT_FIFO_SAMPLE_FIFO_SIZE-1];
media_input_fifo->sampleCountInPacket = 0;
media_input_fifo->ptr = 0;
media_input_fifo->packetSize = packetSize + 2; // two for the DBC and timestamp
return packetSize;
}
/**
* @brief Connect to the flash. Should be called before any accessing the flash memory.
* @return 0 if connecting was successful.
*/
int connect_to_flash(void) {
int result = fl_connect(SPI_port);
if (result != 0) {
printstrln("Could not connect to flash memory");
}
return result;
}
// xscope socket data handler
void xtcp_handle_xscope_tcp_event(chanend c_xtcp, xtcp_connection_t *conn)
{
// Ignore events that are not directly relevant to tcp handler
//printintln(conn->event);
switch (conn->event) {
case XTCP_IFUP:
case XTCP_IFDOWN:
conn_active = 0;
return;
case XTCP_ALREADY_HANDLED:
return;
default:
break;
}
// Check if the connection is an client app connection
if (conn->local_port == TCP_XSCOPE_PORT) {
switch (conn->event) {
case XTCP_NEW_CONNECTION:
if (conn_active) {
printstrln("a host connection is already active");
xtcp_abort(c_xtcp, conn);
}
else
conn_active = 1;
break;
case XTCP_RECV_DATA: {
xtcp_recv(c_xtcp, (char *) &xscope_data);
process_xscope_data(c_xtcp, xscope_data);
}
break;
case XTCP_SENT_DATA:
case XTCP_REQUEST_DATA:
case XTCP_RESEND_DATA:
tcp_send(c_xtcp, conn);
break;
case XTCP_TIMED_OUT:
case XTCP_ABORTED:
case XTCP_CLOSED:
conn_active = 0;
break;
default:
// Ignore anything else
break;
}
conn->event = XTCP_ALREADY_HANDLED;
}
return;
}
static void process_xscope_data(chanend c_xtcp, xscope_protocol xscope_data)
{
/* Custom protocol definition
* Start with cmd_type, send end_token as 0 as last
* Listen: 0-dc-inport-proto-dc
* Connect: 1-dc-out_port-proto-host_ipconfig
* Send: 2-1-local_port-dc-remote_addr
* Close: 2-2-local_port-dc-remote_addr
*/
#define CONTROLLER_IP {169, 254, 196, 179}
#if !defined(CONTROLLER_IP)
#warning No define of form CONTROLLER_IP
#error Rebuild the application with this define assigned to the host controller ip
#endif
xtcp_ipaddr_t ipaddr = CONTROLLER_IP;
/*ipaddr[0] = atoi(xscope_data.ip_addr_1);
ipaddr[1] = atoi(xscope_data.ip_addr_2);
ipaddr[2] = atoi(xscope_data.ip_addr_3);
ipaddr[3] = atoi(xscope_data.ip_addr_4);*/
switch (xscope_data.cmd_type) {
case XSCOPE_CMD_LISTEN: //listen; for server type conn
xtcp_listen(c_xtcp, xscope_data.port_no, xscope_data.protocol);
printstr("Listening on port: ");
printintln(xscope_data.port_no);
break;
case XSCOPE_CMD_CONNECT: //connect; for client type conn
xtcp_connect(c_xtcp, xscope_data.port_no, ipaddr, xscope_data.protocol);
printstr("Connected to host on port: ");
printintln(xscope_data.port_no);
break;
case XSCOPE_CMD_SEND: { //Send data
int conn_id;
xtcp_connection_t conn;
if (PROTO_TCP == xscope_data.protocol)
conn_id = get_tcp_conn_id(ipaddr, xscope_data.port_no);
else if (PROTO_UDP == xscope_data.protocol)
conn_id = get_udp_conn_id(ipaddr, xscope_data.port_no);
if (conn_id) {
conn.id = conn_id;
xtcp_init_send(c_xtcp, &conn);
printstr("Sending data on the connection: ");
printintln(conn_id);
}
}
break;
case XSCOPE_CMD_CLOSE: { //Close command
int conn_id;
xtcp_connection_t conn;
if (PROTO_TCP == xscope_data.protocol)
conn_id = get_tcp_conn_id(ipaddr, xscope_data.port_no);
else if (PROTO_UDP == xscope_data.protocol)
conn_id = get_udp_conn_id(ipaddr, xscope_data.port_no);
if (conn_id) {
conn.id = conn_id;
xtcp_close(c_xtcp, &conn);
printstr("Closing the connection: ");
printintln(conn_id);
}
}
break;
case XSCOPE_CMD_CTRLR_SEND: //this is a controller send command; do nothing
break;
default:
printstrln("unknown command received");
break;
}
}
int decoderMain(chanend pcmChan, chanend rxChan, chanend mp3Reset)
{
int bytesLeft, nRead, err, offset, outOfData, eofReached, nFrames;
int reset;
unsigned char readBuf[READBUF_SIZE], *readPtr;
// unsigned char mp3_data
// short outBuf[MAX_NCHAN * MAX_NGRAN * MAX_NSAMP];
// short outBuf[256];
MP3FrameInfo mp3FrameInfo;
HMP3Decoder hMP3Decoder;
if ( (hMP3Decoder = MP3InitDecoder()) == 0 )
{
return -2;
// puts("Init died");
}
bytesLeft = 0;
outOfData = 0;
eofReached = 0;
readPtr = readBuf;
nRead = 0;
nFrames = 0;
do
{
bytesLeft = RxNewFrame(readBuf, READBUF_SIZE, rxChan, mp3Reset);
if (bytesLeft == 0)
{
break;
}
readPtr = readBuf;
/* decode one MP3 frame - if offset < 0 then bytesLeft was less than a full frame */
err = MP3Decode(hMP3Decoder, &readPtr, &bytesLeft, NULL, 1, pcmChan);
// err = MP3Decode(hMP3Decoder, &readPtr, &bytesLeft, NULL, 0, pcmChan);
nFrames++;
// printintln(nFrames);
// Need to flush the PCM buffer for next frame decode
// By outputting all ones to the channel
// OutputToPCMBuf(0xffff, 0xffff, pcmChan);
if (err)
{
/* error occurred */
switch (err)
{
case ERR_MP3_INDATA_UNDERFLOW:
printstrln("HERE");
outOfData = 1;
break;
case ERR_MP3_MAINDATA_UNDERFLOW:
/* do nothing - next call to decode will provide more mainData */
break;
case ERR_MP3_FREE_BITRATE_SYNC:
default:
outOfData = 1;
// printintln(err);
// printstrln("\nHERE2");
// while (1);
break;
}
}
else
{
/* no error */
MP3GetLastFrameInfo(hMP3Decoder, &mp3FrameInfo);
}
} while (!outOfData);
// printstr("FINISHED: ");
// printintln(err);
MP3FreeDecoder(hMP3Decoder);
// printDebug(1, debugChan);
return 0;
}
// HTTP event handler
void tcp_handle_event(chanend tcp_svr, xtcp_connection_t *conn)
{
// We have received an event from the TCP stack, so respond
// appropriately
// Ignore events that are not directly relevant to http
switch (conn->event)
{
case XTCP_IFUP: {
xtcp_ipconfig_t ipconfig;
xtcp_get_ipconfig(tcp_svr, &ipconfig);
#if IPV6
unsigned short a;
unsigned int i;
int f;
xtcp_ipaddr_t *addr = &ipconfig.ipaddr;
printstr("IPV6 Address = [");
for(i = 0, f = 0; i < sizeof(xtcp_ipaddr_t); i += 2) {
a = (addr->u8[i] << 8) + addr->u8[i + 1];
if(a == 0 && f >= 0) {
if(f++ == 0) {
printstr("::");
}
} else {
if(f > 0) {
f = -1;
} else if(i > 0) {
printstr(":");
}
printhex(a);
}
}
printstrln("]");
#else
printstr("IP Address: ");
printint(ipconfig.ipaddr[0]);printstr(".");
printint(ipconfig.ipaddr[1]);printstr(".");
printint(ipconfig.ipaddr[2]);printstr(".");
printint(ipconfig.ipaddr[3]);printstr("\n");
#endif
}
return;
case XTCP_IFDOWN:
case XTCP_ALREADY_HANDLED:
return;
default:
break;
}
// Check if the connection is a http connection
if (conn->local_port == 80) {
switch (conn->event)
{
case XTCP_NEW_CONNECTION:
httpd_init_state(tcp_svr, conn);
break;
case XTCP_RECV_DATA:
httpd_recv(tcp_svr, conn);
break;
case XTCP_SENT_DATA:
case XTCP_REQUEST_DATA:
case XTCP_RESEND_DATA:
httpd_send(tcp_svr, conn);
break;
case XTCP_TIMED_OUT:
case XTCP_ABORTED:
case XTCP_CLOSED:
httpd_free_state(conn);
break;
default:
// Ignore anything else
break;
}
conn->event = XTCP_ALREADY_HANDLED;
}
////
return;
}
