sdp.cpp

本源码包

/*
 *	This file is sdp parse source file, used to parse the packet of
 *	network and abstract the multimedia data
 *
 *	copyright (c) reserved 2008.09.09
 */

#include	"sdp.h"
#include	<ctype.h>
#include	<string.h>
#include	<stdio.h>
#include	<iostream>
#include	<string>

using	namespace	std;


static	unsigned int basevalue(unsigned char base)
{
	int		base64 = base;

	if(islower(base64))
	{
		return base64 - 71;
	}
	
	if(isupper(base64))
	{
		return	base64 - 65;
	}

	if(isdigit(base64))
	{
		return	base64 + 4;
	}

	if(base64 == '+')
	{
		return	base64 + 19;
	}

	if(base64 == '/')
	{
		return	base64 + 16;
	}
	
	if(base64 =='=')
	{
		return	0;
	}
}

int	base64decoder(char *result, char *src)
{
	unsigned int	ch0 = 0, ch1;
	char				buf[160], ch2;
 	int				length, point = -1, pointer = 0;

	length = strlen(src);

	while(length > ++ point)
	{
		if(src[point] != '=')
		{
			ch0 = basevalue(src[point]); 
			ch0 = ch0 << 18;
		}
		else
		{
			cout << "error!" << endl;
			return	0;
		}

		if(src[++ point] != '=')
		{
			ch1 = basevalue(src[point]);
			ch1 = ch1 << 12;
			ch0 = ch0 | ch1;
		}
		else
		{
			cout << "error!" << endl;
			return	0;
		}

		if(src[++ point] != '=')
		{
			ch1 = basevalue(src[point]);
			ch1 = ch1 << 6;
			ch0 = ch0 | ch1;
		}
		else
		{
			ch2 = (char)(ch0 >> 16);
			result[pointer ++] = ch2;
			break;
		}

		if(src[++ point] != '=')
		{
			ch1 = basevalue(src[point]);
			ch0 = ch1 | ch0;
		}
		else
		{
			ch2 = (char)(ch0 >> 16);
			result[pointer ++] = ch2;

			ch2 = (char)(ch0 >> 8);
			result[pointer ++] = ch2;
			break;
		}
		
		ch2 = (char)(ch0 >> 16);
		result[pointer ++] = ch2;

		ch2 = (char)(ch0 >> 8);
		result[pointer ++] = ch2;

		ch2 = (char)ch0;
		result[pointer ++] = ch2;
	}

	result[pointer] = '\0';
	return	pointer;
}

static	int	filter(const char *in, const char *filter, char *out)
{
	int		flen	= strlen(filter);
	int		slen	= strlen(in);

	if(!strncmp(in, filter, flen))
	{
		if(in[flen] == '"')
			flen ++;
		if(in[slen - 2] == '"')
			slen -= 2;
		memcpy(out, in + flen, slen - flen);
		out[slen - flen] = '\0';
		out[slen - flen] = '\0';
		return	slen - flen;
	}

	return	0;
}

char	*strdup(char *buf)
{
	if(buf != NULL)
	{
		int		len = strlen(buf);
		char *data = new char[len + 1];
		memcpy(data, buf, len);
		data[len] = 0;

		return	data;
	}

	return	NULL;
}

static	sdp_stream_t	*sdp_parse_m_symbol(char *data)
{
	sdp_stream_t	*desc = new	sdp_stream_t;
	char	buf[1024];
	if(filter(data, "m=", buf))
	{
		desc -> id = strdup(buf);
	}
	else
	{
		cout << "sdp: no m= found." << endl;
		delete	desc;
		return	NULL;
	}
	
	return	desc;
}

static	int	sdp_parse_stream(sdp_stream_t *desc, FILE *rfile, char *buffer)
{
	char	buf[1024], data[1024], *pdata;
	char	decode[1024];
	int		handled;

	if(rfile != NULL && desc != NULL)
	{
		pdata = fgets(data, 1024, rfile);
	}
	else
	{
		cout << "parameters error." << endl;
		return	-1;
	}

	while(pdata != NULL && data[0] != 'm')
	{
		handled = 0;
		if(filter(pdata, "a=control:streamid=", buf))
		{
			desc -> stream_id = atoi(buf);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=MaxBitRate:integer;", buf))
		{
			desc -> max_bit_rate = atoi(buf);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=AvgBitRate:integer;", buf))
		{
			desc -> avg_bit_rate = atoi(buf);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=MaxPacketSize:integer;", buf))
		{
			desc -> max_packet_size = atoi(buf);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=AvgPacketSize:integer;", buf))
		{
			desc -> avg_packet_size = atoi(buf);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=StartTime:integer;", buf)) 
		{
			desc -> start_time = atoi(buf);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=Preroll:integer;", buf))
		{
			desc -> preroll = atoi(buf);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=length:npt=", buf))
		{
			desc -> duration = (unsigned int)(atof(buf) * 1000);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=StreamName:string;", buf))
		{
			desc -> stream_name = strdup(buf);
			desc -> stream_name_size = strlen(desc -> stream_name);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=mimetype:string;", buf))
		{
			desc -> mime_type = strdup(buf);
			desc -> mime_type_size = strlen(desc -> mime_type);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=OpaqueData:buffer;", buf)) 
		{
			desc -> opaque_data_size = base64decoder(decode, buf);
			desc -> opaque_data = new char[desc -> opaque_data_size];
			memcpy(desc -> opaque_data, decode, desc -> opaque_data_size);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=ASMRuleBook:string;", buf))
		{
			desc -> asm_rule_book = strdup(buf);
			desc -> asm_rule_book_length = strlen(buf);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}
		
		if(pdata[0] != 'm')
		{
			printf("sdp stream parse: not handled: %s", data);
			pdata = fgets(data, 1024, rfile);
			continue;
		}
		else
		{
			memcpy(buffer, data, strlen(data));
			return	1;
		}
	}
	if(data[0] == 'm')
	{
		return	1;
	}
	return	0;
}


sdp_t	*sdp_parse(FILE *rfile)
{
	sdp_t	*desc = new sdp_t;
	sdp_stream_t	*stream;
	char	buf[1024], data[1024], *pdata;
	char	decode[1024];
	int		handled = 0;
	int		len;

	if(rfile == NULL)
	{
		return	NULL;
	}

	if((pdata = fgets(data, 1024, rfile)) == NULL)
	{
		return	NULL;
	}

	while(pdata != NULL)
	{
		handled = 0;

		if(filter(pdata, "a=Title:buffer;", buf))
		{
			base64decoder(decode, buf);
			desc -> title = strdup(decode);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=Author:buffer;", buf))
		{
			base64decoder(decode, buf);
			desc -> author = strdup(decode);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=Copyright:buffer;", buf))
		{
			base64decoder(decode, buf);
			desc -> copyright = strdup(decode);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=Abstract:buffer;", buf))
		{
			base64decoder(decode, buf);
			desc -> abstract = strdup(decode);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=StreamCount:integer;", buf))
		{
			desc -> stream_count = atoi(buf);
			desc -> stream  = new sdp_pstream_t[desc -> stream_count];
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(filter(pdata, "a=Flags:integer;", buf))
		{
			desc -> flags = atoi(buf);
			handled = 1;
			pdata = fgets(data, 1024, rfile);
			continue;
		}

		if(!handled)
		{
			if(pdata[0] == 'm')
			{
				goto header;
			}
			printf("sdp: not found: %s", data);
			pdata = fgets(data, 1024, rfile);
			continue;
		}
	}
	delete	desc;
	return	NULL;

header:
	do
	{
		stream = sdp_parse_m_symbol(data);
		if(stream != NULL)
		{
			len = sdp_parse_stream(stream, rfile, data);
			desc -> stream[stream -> stream_id] = stream;
		}
		else
		{
			delete	desc;
			return	NULL;
		}
	}while(len == 1);

	return	desc;
}

//	need to definatively delete all the dynamic memory
void sdp_free(sdp_t *desc) 
{
	if(desc == NULL)
	{
		return	;
	}
	
	if(desc -> owner)
		delete	desc -> owner;
	if(desc -> session_name)
		delete	desc -> session_name;
	if(desc -> uri)
		delete	desc -> uri;
	if(desc -> email)
		delete	desc -> email;
	if(desc -> phone)
		delete 	desc -> phone;
	if(desc -> connection)
		delete	desc -> connection;
	if(desc -> bandwidth)
		delete	desc -> bandwidth;
	if(desc -> title)
		delete	desc -> title;
	if(desc -> author)
		delete	desc -> author;
	if(desc -> copyright)
		delete	desc -> copyright;
	if(desc -> keywords)
		delete	desc -> keywords;
	if(desc -> asm_rule_book)
		delete	desc -> asm_rule_book;
	if(desc -> abstract)
		delete	desc -> abstract;
	if(desc -> stream)
	{
		int	i = 0;
		while(desc -> stream[i])
		{
			if(desc -> stream[i] -> id)
				delete	desc -> stream[i] -> id;
			if(desc -> stream[i] -> bandwidth)
				delete	desc -> stream[i] -> bandwidth;
			if(desc -> stream[i] -> range)
				delete	desc -> stream[i] -> range;
			if(desc -> stream[i] -> length)
				delete	desc -> stream[i] -> length;
			if(desc -> stream[i] -> rtpmap)
				delete	desc -> stream[i] -> rtpmap;
			if(desc -> stream[i] -> mimetype)
				delete	desc -> stream[i] -> mimetype;
			if(desc -> stream[i] -> stream_name)
				delete	desc -> stream[i] -> stream_name;
			if(desc -> stream[i] -> mime_type)
				delete	desc -> stream[i] -> mime_type;
			if(desc -> stream[i] -> opaque_data)
				delete	desc -> stream[i] -> opaque_data;
			if(desc -> stream[i] -> rmff_flags)
				delete	desc -> stream[i] -> rmff_flags;
			
			delete	desc -> stream[i];
			++ i;
		}
		delete	desc -> stream;
	}
  	delete	desc;
}