rmff.cpp

本源码包

}

rmff_prop_t	*rmff_new_prop(unsigned int	max_bit_rate,\
		unsigned int avg_bit_rate, \
		unsigned int max_packet_size, \
		unsigned int avg_packet_size, \
		unsigned int num_packets, \
		unsigned int duration, \
		unsigned int preroll, \
		unsigned int index_offset, \
		unsigned int data_offset, \
		unsigned short num_streams, \
		unsigned short flags)
{
	rmff_prop_t	*prop = new rmff_prop_t;

	prop -> object_id = PROP_TAG;
	prop -> size 	  = 50;
	prop -> object_version = 0;
	prop -> max_bit_rate   = max_bit_rate;
	prop -> avg_bit_rate   = avg_bit_rate;
	prop -> max_packet_size = max_packet_size;
	prop -> avg_packet_size = avg_packet_size;
	prop -> num_packets     = num_packets;
	prop -> duration        = duration;
	prop -> preroll         = preroll;
	prop -> index_offset    = index_offset;
	prop -> data_offset     = data_offset;
	prop -> num_streams     = num_streams;
	prop -> flags           = flags;

	return	prop;
}


rmff_mdpr_t *rmff_new_mdpr(\
      uint16_t   stream_number,\
      uint32_t   max_bit_rate,\
      uint32_t   avg_bit_rate,\
      uint32_t   max_packet_size,\
      uint32_t   avg_packet_size,\
      uint32_t   start_time,\
	  uint32_t   preroll,\
      uint32_t   duration,\
      const char *stream_name,\
      const char *mime_type,\
      uint32_t   type_specific_len,\
      const char *type_specific_data ) 
{
  	rmff_mdpr_t *mdpr = new rmff_mdpr_t;

  	mdpr->object_id=MDPR_TAG;
  	mdpr->object_version=0;

  	mdpr->stream_number=stream_number;
  	mdpr->max_bit_rate=max_bit_rate;
  	mdpr->avg_bit_rate=avg_bit_rate;
  	mdpr->max_packet_size=max_packet_size;
  	mdpr->avg_packet_size=avg_packet_size;
  	mdpr->start_time=start_time;
  	mdpr->preroll=preroll;
  	mdpr->duration=duration;
  	mdpr->stream_name_size=0;
  	
	if(stream_name) 
  	{
    	mdpr->stream_name=strdup(stream_name);
    	mdpr->stream_name_size=strlen(stream_name);
  	}
  	
	mdpr->mime_type_size=0;
  	if(mime_type) 
  	{
    	mdpr->mime_type = strdup(mime_type);
    	mdpr->mime_type_size = strlen(mime_type);
  	}

	mdpr->type_specific_len = type_specific_len;
  	mdpr->type_specific_data = new char[type_specific_len];
  	memcpy(mdpr->type_specific_data,type_specific_data,type_specific_len);
  	mdpr->mlti_data = NULL;
  
  	mdpr->size = mdpr -> stream_name_size + mdpr -> mime_type_size + \
			   mdpr -> type_specific_len + 46;

  	return mdpr;
}

rmff_cont_t *rmff_new_cont(const char *title, const char *author, \
		const char *copyright, const char *comment) 
{

  	rmff_cont_t *cont= new rmff_cont_t;

  	cont->object_id=CONT_TAG;
  	cont->object_version=0;

  	cont->title=NULL;
  	cont->author=NULL;
  	cont->copyright=NULL;
  	cont->comment=NULL;
  
  	cont->title_len=0;
  	cont->author_len=0;
  	cont->copyright_len=0;
  	cont->comment_len=0;

  	if(title) 
  	{
    	cont->title_len=strlen(title);
    	cont->title=strdup(title);
  	}
  	if(author) 
  	{
    	cont->author_len=strlen(author);
    	cont->author=strdup(author);
  	}
  	if(copyright) 
	{
    	cont->copyright_len=strlen(copyright);
    	cont->copyright=strdup(copyright);
  	}

	cont -> comment_len = 0;
	cont -> comment     = NULL;
  	if(comment)
	{
    	cont->comment_len = strlen(comment);
    	cont->comment = strdup(comment);
  	}
  	cont->size = cont -> title_len+cont -> author_len + \
			   cont -> copyright_len + cont -> comment_len + 18;

  	return cont;
}

rmff_data_t *rmff_new_dataheader(uint32_t num_packets, \
		uint32_t next_data_header) 
{
  	rmff_data_t *data = new rmff_data_t;

  	data->object_id = DATA_TAG;
  	data->size = 18;
  	data->object_version = 0;
  	data->num_packets = num_packets;
  	data->next_data_header = next_data_header;

  	return data;
}
  

void rmff_fix_header(rmff_header_t *h) 
{
  	int num_headers=0;
  	int header_size=0;
  	rmff_mdpr_t **streams;
  	int num_streams=0;

  	if (!h) 
  	{
    	printf("rmff_fix_header: fatal: no header given.\n");
    	return;
  	}

  	if(!h->streams) 
  	{
    	printf("rmff_fix_header: warning: no MDPR chunks\n");
  	} 
  	else
  	{
    	streams=h->streams;
    	while (*streams)
    	{
      		num_streams++;
      		num_headers++;
      		header_size+=(*streams)->size;
      		streams++;
    	}
  	}
  
  	if(h->prop) 
  	{
    	if(h->prop->size != 50)
    	{
      		h->prop->size=50;
    	}

    	if(h->prop->num_streams != num_streams)
    	{
      		h->prop->num_streams=num_streams;
    	}

    	num_headers++;
    	header_size+=50;
  	} 
  	else
    	printf("rmff_fix_header: warning: no PROP chunk.\n");

  	if(h->cont) 
  	{
    	num_headers++;
    	header_size+=h->cont->size;
  	} 
  	else
    	printf("rmff_fix_header: warning: no CONT chunk.\n");

  	if(!h->data) 
  	{
    	h->data = new rmff_data_t;
    	h->data->object_id = DATA_TAG;
    	h->data->object_version = 0;
    	h->data->size = 34;
    	h->data->num_packets = 0;
    	h->data->next_data_header = 0;
  	}
  	num_headers ++;

  
  	if(!h->fileheader) 
  	{
    	h->fileheader = new rmff_fileheader_t;
    	h->fileheader->object_id = RMF_TAG;
    	h->fileheader->size = 34;
    	h->fileheader->object_version = 0;
    	h->fileheader->file_version = 0;
    	h->fileheader->num_headers = num_headers+1;
  	}
  	header_size += h->fileheader->size;
  	num_headers ++;

  	if(h->fileheader->num_headers != num_headers) 
  	{
    	h->fileheader->num_headers = num_headers;
  	}

  	if(h->prop) 
  	{
    	if(h->prop->data_offset != header_size) 
		{
      		h->prop->data_offset = header_size;
    	}

    	if(h->prop->num_packets == 0) 
		{
      		int p=(int)(h->prop->avg_bit_rate/8.0 * \
					(h->prop->duration/1000.0)/h->prop->avg_packet_size);
      		h->prop->num_packets=p;
    	}

    	if(h->data->num_packets == 0) 
		{
      		h->data->num_packets = h->prop->num_packets;
    	}	
    
    	h->data->size = h->prop->num_packets * h->prop->avg_packet_size;
  	}
}


int rmff_get_header_size(rmff_header_t *h) 
{

  	if(!h) 
		return 0;

  	if(!h -> prop) 
		return -1;

  	return h -> prop -> data_offset + 18;
}


void rmff_free_header(rmff_header_t *h) {

  if (!h) return;

  if (h->fileheader) delete h->fileheader;
  if (h->prop) delete h->prop;
  if (h->data) delete h->data;
  if (h->cont)
  {
    delete h->cont->title;
    delete h->cont->author;
    delete h->cont->copyright;
    delete h->cont->comment;
    delete h->cont;
  }
  if (h->streams)
  {
    rmff_mdpr_t **s=h->streams;

    while(*s) {
      delete (*s)->stream_name;
      delete (*s)->mime_type;
      delete (*s)->type_specific_data;
      delete *s;
      s++;
    }
    delete h->streams;
  }
  delete h;
}