mms.c

Wiznet iRadio Source

#include "mms.h"
#include "socket.h"
#include "w5100.h"
#include "netconfig.h"
#include "util.h"
#include "vs1033.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

u8 mms_state;
MMS_MSG mms_msg;
MMS_PACKET pak;

u16 seq_num;
u8 mms_cnt;
u32 packet_length;
u16 p_size;

u16 mms_wptr;
u8 padd_size;

extern u8 tmp_buffer[MAX_BUF_SIZE];
extern u8 stream_buffer[STREAM_BUF_SIZE];
extern u32 stream_buffer_write;
extern u8 wr_update_flag;
extern u8 Server_Page[MAX_URL_SIZE/4];

u8 WMA_HEADER[26] = {'W', 0x00, 'M', 0x00,'F', 0x00,'S', 0x00,'D', 0x00,'K', 0x00,'V', 0x00,'e', 0x00,'r', 0x00,'s', 0x00,'i', 0x00,'o', 0x00,'n', '\0'};


/*
 * Put 32 bits inside a command buffer.
 */
static void mms_put_32 ( MMS_PACKET *pak, u32 value )
{
  pak->buf[pak->num_bytes  ] = value % 256;
  value = value >> 8;
  pak->buf[pak->num_bytes+1] = value % 256 ;
  value = value >> 8;
  pak->buf[pak->num_bytes+2] = value % 256 ;
  value = value >> 8;
  pak->buf[pak->num_bytes+3] = value % 256 ;

  pak->num_bytes += 4;
  return;
}


/*
 * Returns the 32 bits located at specified offset.
 */
static u32 mms_get_32 ( const u8 *buf,  const u16 offset )
{
  return ( (((u32)buf[offset+0]) << 0)  |
           (((u32)buf[offset+1]) << 8)  |
           (((u32)buf[offset+2]) << 16) |
           (((u32)buf[offset+3]) << 24) );
}



/*
 * Converts a string into a UTF-16 string.
 */
static void mms_string_utf16 ( u8 *dest, u8 *src, u16 len )
{

  u16 i;
  
  memset ( dest, 0, len );

  for ( i=0; i<len; ++i )
    {
      dest[i*2] = src[i];
      dest[i*2+1] = 0;
    }

  dest[i*2] = 0;
  dest[i*2+1] = 0;
  return;
}




/*
 * Sends a command packet to the server.
 */
void mms_send_packet (const int command, const u32 prefix1,  const u32 prefix2,  const u32 length, const u8 *data )
{  

  const unsigned int len8 = ( length + (length%8) ) / 8;

  pak.num_bytes = 0;

  mms_put_32( &pak, 0x00000001 );  // start sequence
  mms_put_32( &pak, 0xB00BFACE );  // Boob Face
  mms_put_32( &pak, length + 32 );
  mms_put_32( &pak, 0x20534d4d ); // protocol type "MMS "
  mms_put_32( &pak, len8 + 4 );
  mms_put_32( &pak, seq_num++ );
  mms_put_32( &pak, 0x0 );        // time stamp
  mms_put_32( &pak, 0x0 );	  // time stamp
  mms_put_32( &pak, 2+len8 );
  mms_put_32( &pak, 0x00030000 | command ); /* dir | command */
  mms_put_32( &pak, prefix1 );
  mms_put_32( &pak, prefix2 );

  memcpy( &pak.buf[48], data, length );

  send(SOCK_CLIENT, pak.buf, length+48);


}


u16 parse_mms(u8 s, u16 lengh)
{
	
	recv(s, (u8 *)&mms_msg.header , lengh);
	return(mms_msg.cmd);

}


void Parse_MMS(u16 len)
{
	u16 i ;
	u8 tmp[8], j,k;


//	MyPrintf("\r\nlen = %d",len);
	j = 0;
	for (i = 0; i < len; i++) {
		if (mms_wptr == 0) {
			// copy 8 byte
			tmp[j++] = tmp_buffer[i];
			if (j >= 8) {
				p_size = ((tmp[7] << 8) + tmp[6]);
				padd_size =  packet_length - (p_size -8);
				
//				MyPrintf("\r\np_size = %d, padd zero = %d",p_size, padd_size);
				
				mms_wptr = 8;
			}
			
		}else {
	
			stream_buffer[stream_buffer_write++] = tmp_buffer[i];
			
			if (stream_buffer_write >= STREAM_BUF_SIZE) {
				stream_buffer_write = 0;
				wr_update_flag = 1;
			}
			
			mms_wptr++;
			
			if (mms_wptr >= p_size) {
				mms_wptr = 0;
				j = 0;
				//padding 0
				for (k = 0; k < padd_size; k++)
					stream_buffer[stream_buffer_write++] = 0;
				
					if (stream_buffer_write >= STREAM_BUF_SIZE) {
						stream_buffer_write = 0;
						wr_update_flag = 1;
					}
			}
		}
		
	}
	
	


}

void mms_pre_receive(void)
{
  u16 len;
  u32 total = 0;

  u8 data [24];
  u16 file_len;
  u8 flag = 1;
  u8 * ptr = 0;
  


	stream_buffer_write = 0;
	// receive packet

	while(flag) {
		
		if ((len = getSn_RX_RSR(SOCK_CLIENT)) > 0) {
			//get the packet size
			len = recv(SOCK_CLIENT, tmp_buffer , 8);
			total += len;
			file_len = (tmp_buffer[7] <<8)+ tmp_buffer[6];
			MyPrintf("\r\nfile len = %d", file_len);

			while(1) {
				if ((len = getSn_RX_RSR(SOCK_CLIENT)) > 0) {
					len = recv(SOCK_CLIENT, tmp_buffer, len);
					total += len;
					// copy tmp_buffer ==> stream buffer

					memcpy(&stream_buffer[stream_buffer_write], tmp_buffer, len);
					stream_buffer_write += len;

					if (total >= file_len) {
						MyPrintf(" total = %d stream_b_wp = %d", total, stream_buffer_write);
						ptr = memstr(&tmp_buffer[0], &WMA_HEADER[0], (int)len);
						if (ptr > 0) flag = 0;
				
						break;
					}

				}
			}
		}
		
	}


	
		
	// send "Media stream MBR"
	memset ( data, 0, 16 ); 
	mms_send_packet (MMS_CMD_MBR, 1, 0x0001ffff, 16, data );

	//receive 
	while(1){
		if ((len = getSn_RX_RSR(SOCK_CLIENT)) > 0) {
			recv(SOCK_CLIENT, (u8 *)&mms_msg.header , len);
			if (mms_msg.direction[0]== 0x04) break;
		}
	}

	
	// send "Strting sending from"		
	memset ( data, 0, 24 ); 
	data[8] =0xff; data[9] =0xff; data[10] =0xff; data[11] = 0xff;
	data[12] =0xff; data[13] =0xff; data[14] =0xff; data[15] = 0xff;
	data[20] = 0x04;
	mms_send_packet (MMS_CMD_START_PACKET, 1, 0x0001ffff, 24, data );
	
	//receive 
	while(1){
		if ((len = getSn_RX_RSR(SOCK_CLIENT)) > 0) {
			recv(SOCK_CLIENT, (u8 *)&mms_msg.header , len);
			if (mms_msg.direction[0]== 0x04) break;
		}
	}

}

//
//  Handshake with the MMS server.
//  ( we don't care about server's answers )
//
void mms_handshake ( void)
{

  u16 cmd;
  u16 packet_len;
  char str [ 80 ];
  u8 data [ 1460 ];

   mms_state = MMS_STATE_SND_INFO;
   seq_num = 0;
   mms_cnt = 0;

  memset ( data, 0, sizeof (data) );
  strcpy ( str, "\034\003NSPlayer/4.1.0.3928; {3300AD50-2C39-46c0-AE0A-60181587CBA}" );

  mms_string_utf16 ( data, (unsigned char *) str, strlen(str)+2 );
//  mms_send_packet ( mms, MMS_CMD_HELLO, 0xf0f0f0f0b, 0x0004000b, strlen(str)*2 + 6, data );
  mms_send_packet (MMS_CMD_HELLO, 0xf0f0f0f0, 0x0004000b, strlen(str)*2 + 8, data );

  while(mms_state != MMS_STATE_RECV_H_REP) {

	cmd = 0;
	if ((packet_len = getSn_RX_RSR(SOCK_CLIENT)) > 0) {
		cmd = parse_mms(SOCK_CLIENT, packet_len);
	}
       

	switch(mms_state) {
		case MMS_STATE_SND_INFO :
			if (cmd == 0x0001) {
			         mms_send_packet ( MMS_CMD_TEST_REQ , 0xf0f0f0f1, 0x0004000b, 0, pak.buf );
				mms_state = MMS_STATE_RECV_INFO;
			}
			break;
		case MMS_STATE_RECV_INFO: 
			if (cmd == 0x0015) {
				mms_cnt++;
				if (mms_cnt >=3) {
				  // transport protocol selection
				  memset ( &data, 0, sizeof(data) );
				  mms_string_utf16 ( &data[8], (u8 *)str, 28 );
				  mms_string_utf16 ( &data[8], (unsigned char *) "\002\000\\\\192.168.0.129\\TCP\\1037\0000", 28 );
				  
				  mms_send_packet (MMS_CMD_TX_INFO, 0xf0f0f0f1, 0xffffffff, 28*2+8, data );
				  mms_state = MMS_STATE_SND_TINFO;
				}
				
			}
			break;
		case MMS_STATE_SND_TINFO:
			if (cmd == 0x0002) {
				  mms_string_utf16 ( &data[8], Server_Page, strlen(Server_Page) );
				  memset ( data, 0, 8 );
				  mms_send_packet ( MMS_CMD_REQ_FILE, 0, 0, strlen(Server_Page)*2+12, data );
				  mms_state = MMS_STATE_RECV_M_DETAIL;
			}
			break;
		case MMS_STATE_RECV_M_DETAIL:
			if (cmd == 0x0006) {
				packet_length= mms_get_32(mms_msg.data,  44);
				MyPrintf("\r\npacket len : %d",packet_length);
				//send header request

				memset ( data, 0, 40 ); 
				data[5] = 0x80;
				data[8] = 0xff; data[9] = 0xff;	data[10] = 0xff; data[11] = 0xff;
				data[32] = 2;

				// Header request
				mms_send_packet (MMS_CMD_HEADER_REQUEST, 1, 0, 40, data );
				mms_state = MMS_STATE_SND_H_REQ;
			}
			break;
		case MMS_STATE_SND_H_REQ:
			//Receive " Sending header response "
			if (cmd == 0x0011) {
				mms_state = MMS_STATE_RECV_H_REP;
			}
			break;
		case MMS_STATE_RECV_H_REP:

			break;

		default :
			break;
	}



  }

}