rtsp_testapp.c

嵌入式系统中c程序实现了rtsp协议的基本内容

#include <string.h>
#include "rtsp_client.h"
#include "rtsp_private.h"


#define PAUSE         0x1
#define PLAY          0x2
#define SETUP         0x3

//extern STVID_Handle_t VideoHandle[];
//extern STAUD_Handle_t AUDHndl;
/*--- Global variable---*/

static rtsp_client_t *rtsp_client;
//static http_client_t *http_client;
//static http_resp_t *http_resp;
static  const char transport_str_ovc[] =  "MP2T/H2221/UDP;unicast;client_port=%d";

static  const char transport_str[] =  "RTP/AVP;unicast;client_port=%d-%d";
static void parse_transport_str(char * str);

typedef struct {
  unsigned int  rtp_server_port;
  unsigned short  rtp_client_port;
  unsigned int rtp_ttl;
  unsigned int rtp_ip;
  unsigned int state;
}player_t;
static player_t *player;
#define REACH_TAG     0
#define REACH_SEQ     1
#define REACH_TIME    2
#define REACH_PORT    3
#define REACH_CLPORT  4
#define REACH_SRVPORT 5
#define REACH_TTL     6
#define REACH_DEST    7
#define REACH_SRC     8
#define REACH_SSRC    9
#define INADDR_NONE    ((U32) 0xffffffff)  /* 255.255.255.255 */

extern  char*strdup(  const char*buf);

void  Rtsp_Printf(const char *format, ...)
{
    char report_buf[1024] ;
    va_list      list;
	
    va_start(list, format);
    vsprintf(report_buf, format, list);
    va_end(list);
    printf("%s\n",report_buf);  
	return;
}
#define CHECK_SEACHANGE_MEMORY_LEAK

typedef struct mem_list
{
    
    int memsize;
    void* memaddress;
	char filename[256];
	int linenumber;
	struct  mem_list *pNext;
}my_memory_test_t;


static  my_memory_test_t *mem_infor_list=NULL; 

static void Add_mem_information(char filename[],int linenum,int  size,void* address)
{
	my_memory_test_t *pTempElement=NULL;
	
	my_memory_test_t *Localmem = (my_memory_test_t *)malloc(sizeof(my_memory_test_t));
	if(Localmem==NULL)
	{
		VODERRORDBG_Printf("!!!!Error: Can't allocate the memory in function AddSemaphore.\n");
		return ;
	}
	Localmem->memsize= size;
	Localmem->memaddress= address;
	Localmem->linenumber= linenum;
	memset(Localmem->filename,0x00,256);
	memcpy(Localmem->filename,filename,255);
	
	Localmem->pNext    = NULL;
	
	if(mem_infor_list == NULL)
	{
		mem_infor_list = Localmem;
		
	}
	else
	{
		pTempElement = mem_infor_list->pNext;
		if(pTempElement == NULL)
		{
			mem_infor_list->pNext = Localmem;
		}
		else
		{
			while(pTempElement)
			{
				if(pTempElement->pNext ==NULL)
				{
					pTempElement->pNext = Localmem;
					break;
				}
				else
				{
					pTempElement=pTempElement->pNext;
				}
			}
		}
	}
}

static void Delmeminformation(void*  address)
{
	my_memory_test_t *p1,*p2;
	if(mem_infor_list == NULL)
	{
		//OS_DEBUG(sttbx_Print("List Null\n"));
		return ;
	}
	p1 = mem_infor_list;
	while((address!=p1->memaddress)&&(p1->pNext!=NULL))
	{
		p2=p1;
		p1=p1->pNext;
	}
	
	if(address==p1->memaddress)
	{
		if(p1==mem_infor_list)
		{
			mem_infor_list=p1->pNext;
		}
		else
		{
			p2->pNext=p1->pNext;
		}
	}
	
	free(p1);
	
}


void *Rtsp_Malloc(int length,int line,char *name)
{
   void *ptr;

	//Rtsp_Printf("malloc file=%s,line=%d,length=%d\n",name,line,length);
	  ptr= malloc (length );
	  if(ptr!=NULL)
	  {
	 // Add_mem_information(name,line,length, ptr);
	  return ptr;
	  }
	  return NULL;
}

void Rtsp_Free(void * buf,int line,char filename[])
{

	//Rtsp_Printf("free file=%s,line=%d\n",filename,line);
	if(buf!=NULL)
	{
	       //  Delmeminformation(buf);
	         free(buf);
	}

}

int check_mem_left(void)
{	
	my_memory_test_t *tempmem_infor_list=NULL; 
	int count=0;
	
	tempmem_infor_list=mem_infor_list;
	while(tempmem_infor_list!=NULL)
	{		
		printf("file=%s,line=%d,size=%d,address=%x\n",tempmem_infor_list->filename,tempmem_infor_list->linenumber,tempmem_infor_list->memsize,tempmem_infor_list->memaddress);
		count+=tempmem_infor_list->memsize;
		tempmem_infor_list=tempmem_infor_list->pNext;
	}
	
	printf("total leak memory=%d\n",count);
}


/* U32 inet_addr(const char *cp)
 {
     struct in_addr val;

     if (inet_aton(cp, &val)) {
         return (val.s_addr);
     }
     return (INADDR_NONE);
 }*/

static void do_relative_url_to_absolute (char **control_string,
				  const char *base_url,
				  int dontfree)
{
  char *str, *cpystr;
  uint32_t cblen, malloclen;
  malloclen = cblen = strlen(base_url);

  if (base_url[cblen - 1] != '/') malloclen++;
  /*
   * If the control string is just a *, use the base url only
   */
  cpystr = *control_string;

  if (strcmp(cpystr, "*") != 0) {

    if (*cpystr == '/') cpystr++;

    /* duh - add 1 for \0...*/
    str = (char *)Rtsp_Malloc(strlen(cpystr) + malloclen + 1,__LINE__,__FILE__);
    if (str == NULL)
    	{

      return;
    	}

    strcpy(str, base_url);
    if (base_url[cblen - 1] != '/') {
      strcat(str, "/");
    }

    if (*cpystr == '/') cpystr++;
    strcat(str, cpystr);
  } 
  else {

    str = strdup(base_url);
	
  }

  if (dontfree == 0) 
  {
    Rtsp_Free(*control_string,__LINE__,__FILE__);
  }

  *control_string = str;
}

/*
 * convert_relative_urls_to_absolute - for every url inside the session
 * description, convert relative to absolute.
 */
static void convert_relative_urls_to_absolute (session_desc_t *sdp,char *base_url)
{
  media_desc_t *media;
  
  if (base_url == NULL)
    return;

  if ((sdp->control_string != NULL) &&
      (strncmp(sdp->control_string, "rtsp://", strlen("rtsp://"))) != 0) {
    do_relative_url_to_absolute(&sdp->control_string, base_url, 0);
  }
  for (media = sdp->media; media != NULL; media = media->next) {
    if ((media->control_string != NULL) &&
	(strncmp(media->control_string, "rtsp://", strlen("rtsp://")) != 0)) {
      do_relative_url_to_absolute(&media->control_string, base_url, 0);
    }
  }

}

static void parse_transport_str(char * str)
{
    int i,j,state;
    char num[64], tag[64],*endptr;
  j=0;
      i=0;
      state = REACH_TAG;
      while (1) {
        switch (state) {
          case REACH_TAG:
            switch (str[i]) {
              case ';':
              case ',':
              case '=':
              case '\n':
                tag[j++] = '\0';
                j = 0;
                if (!strcmp(tag, "port")) {
                  num[j++] = '0';  /* avoid empty fields */
                  state = REACH_PORT;
                } else if (!strcmp(tag, "client_port")) {
                  num[j++] = '0';  /* avoid empty fields */
                  state = REACH_CLPORT;
                } else if (!strcmp(tag, "server_port")) {
                  num[j++] = '0';  /* avoid empty fields */
                  state = REACH_SRVPORT;
                } else if (!strcmp(tag, "ttl")) {
                  num[j++] = '0';  /* avoid empty fields */
                  state = REACH_TTL;
                } else if (!strcmp(tag, "destination")) {
                  state = REACH_DEST;
                } else if (!strcmp(tag, "source")) {
                  state = REACH_SRC;
                } else if (!strcmp(tag, "ssrc")) {
                  num[j++] = '0';  /* avoid empty fields */
                  state = REACH_SSRC;
                }
                break;
              default:
                tag[j++] = tolower(str[i]);
                j %= 64; /* avoid illegal access */
                break;
            }
            break;
          case REACH_PORT: