rmff.c

linux下流媒体下载程序代码

    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 = xmalloc(sizeof(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;
}

struct rmff_cont_t *new_rmff_cont(const char *title, const char *author, const char *copyright, const char *comment)
{

    struct rmff_cont_t *cont = xmalloc(sizeof(struct 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);
    }
    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;
}

struct rmff_data_t *new_rmff_dataheader(uint32_t num_packets,
					uint32_t next_data_header)
{
  
    struct rmff_data_t *data = xmalloc(sizeof(struct 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;
}
 


/*
 * totaly based on xine-lib rmff_print_header function
 * print rmff_header
 */
void rmff_print_header(struct rmff_header_t *h)
{

    struct rmff_mdpr_t *stream;

    if(!h) return;
  
    display(MSDL_DBG,"=----- RMFF header -----=\n");

    if(h->fileheader) {
	display(MSDL_DBG,
		"FILE:\n"
		"      file version      : %d\n"
		"      number of headers : %d\n",
		h->fileheader->file_version,
		h->fileheader->num_headers);
    }
  
    if(h->cont) {
	display(MSDL_DBG,
		"CONT:\n"
		"      title      : %s\n"
		"      author     : %s\n"
		"      copyright  : %s\n"
		"      comment    : %s\n",
		h->cont->title,h->cont->author,
		h->cont->copyright,h->cont->comment);
    }

    if(h->prop) {
	char flags[100]; /* this is enough */
	snprintf(flags,100,"%s %s %s\n",
		 (h->prop->flags & PN_SAVE_ENABLED) ? "save_enabled" : "",
		 (h->prop->flags & PN_PERFECT_PLAY_ENABLED) ? "perfect_play_enabled" : "",
		 (h->prop->flags & PN_LIVE_BROADCAST) ? "live_broadcast" : "");
    
    
	display(MSDL_DBG,
		"PROP:\n"
		"      bitrate (max/avg)     : %i/%i\n"
		"      packet size(max/avg)  : %i/%i\n"
		"      packets        : %i\n"
		"      duration       : %i\n"
		"      pre-buffer     : %i\n"
		"      index_offset   : %i (%x)\n"
		"      data offset    : %i (%x)\n"
		"      media streams  : %i\n"
		"      flags          : %s\n",
		h->prop->max_bit_rate,h->prop->avg_bit_rate,
		h->prop->max_packet_size,h->prop->avg_packet_size,
		h->prop->num_packets,
		h->prop->duration,
		h->prop->preroll,
		h->prop->index_offset,h->prop->index_offset,
		h->prop->data_offset,h->prop->data_offset,
		h->prop->num_streams,
		flags);
    }
  
  
    if(h->streams) {
	int i;
	for(i = 0 ; (stream = h->streams[i]) ; i++) {
	    display(MSDL_DBG,
		    "STREAM %i:\n"
		    "      stream name [mime-type]  : %s [%s]\n"
		    "      bitrate (max/avg)        : %i/%i\n"
		    "      packet size (max/avg)    : %i/%i\n"
		    "      start time   : %i\n"
		    "      pre-buffer   : %i ms\n"
		    "      duration     : %i ms\n"
		    "      type specific data : %d bytes\n",
		    stream->stream_number,
		    stream->stream_name,stream->mime_type,
		    stream->max_bit_rate,stream->avg_bit_rate,
		    stream->max_packet_size,stream->avg_packet_size,
		    stream->start_time,
		    stream->preroll,
		    stream->duration,
		    stream->type_specific_len);
      
	    dbgdump(stream->type_specific_data,stream->type_specific_len);
	    display(MSDL_DBG,"\n");
	}
    }
  
    if(h->data) {
	display(MSDL_DBG,
		"DATA:\n"
		"      size      : %i\n"
		"      packets   : %i\n"
		"      next DATA : 0x%08x\n",
		h->data->size,
		h->data->num_packets,
		h->data->next_data_header);
    }
  
}



/*
 * totaly based on xine-lib rmff_fix_header function
 * fix rmff header to write at the beginning of file
 */
void rmff_fix_header(struct rmff_header_t *h)
{

    unsigned int num_headers=0;
    unsigned int header_size=0;
    struct rmff_mdpr_t **streams;
    int num_streams=0;

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

    if (!h->streams) {
	display(MSDL_DBG,"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) {
	    display(MSDL_DBG,"rmff_fix_header: correcting prop.size from %i to %i\n",
		    h->prop->size, 50);
	    h->prop->size=50;
	}
	if (h->prop->num_streams != num_streams) {
	    display(MSDL_DBG,"rmff_fix_header: correcting prop.num_streams from %i to %i\n",
		    h->prop->num_streams, num_streams);
	    h->prop->num_streams=num_streams;
	}
	num_headers++;
	header_size+=50;
    } 
    else
	display(MSDL_ERR,"rmff_fix_header: warning: no PROP chunk.\n");
  
    if (h->cont) {
	num_headers++;
	header_size+=h->cont->size;
    }
    else
	display(MSDL_DBG,"rmff_fix_header: warning: no CONT chunk.\n");

    if (!h->data) {
	display(MSDL_DBG,"rmff_fix_header: no DATA chunk, creating one\n");
    
	h->data = xmalloc(sizeof(struct 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) {
	display(MSDL_DBG,"rmff_fix_header: no fileheader, creating one");

	h->fileheader = xmalloc(sizeof(struct 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) {
	display(MSDL_DBG,"rmff_fix_header: setting num_headers from %i to %i\n",
		h->fileheader->num_headers, num_headers); 

	h->fileheader->num_headers=num_headers;
    }

    if(h->prop) {
	if (h->prop->data_offset != header_size) {
	    display(MSDL_DBG,"rmff_fix_header: setting prop.data_offset from %i to %i\n",
		    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);

	    display(MSDL_DBG,"rmff_fix_header: assuming prop.num_packets=%i\n", p); 

	    h->prop->num_packets=p;
	}
	if (h->data->num_packets == 0) {
	    display(MSDL_DBG,"rmff_fix_header: assuming data.num_packets=%i\n",
		    h->prop->num_packets); 

	    h->data->num_packets=h->prop->num_packets;
	}
    
	display(MSDL_DBG,"rmff_fix_header: assuming data.size=%i\n",
		h->prop->num_packets*h->prop->avg_packet_size); 
    
	h->data->size=h->prop->num_packets*h->prop->avg_packet_size;
    }
}



int rmff_get_header_size(struct rmff_header_t *h)
{

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

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

void free_rmff_header_t(struct rmff_header_t *h)
{

    if (!h) return;

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

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