chunk_write.c

realmedia解压源码

/*****************************************************************************
 * libreal  -  A library for writing and extracting data streams to and from *
 *             RealMedia files.                                              *
 * Copyright (C) 2001 Leo Howell                                             *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the GNU General Public License as published by      *
 * the Free Software Foundation; either version 2 of the License, or         *
 * (at your option) and later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
 * GNU General Public License for more details.                              *
 *                                                                           *
 * You should have received a copy of the GNU General Public License         *
 * along with this program; if not, write to the Free Software               *
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston MA  02111-1307  USA  *
 *                                                                           *
 * You can contact me by email, [e-mail]             *
 *****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include "libreal.h"
#include "util.h"

/*
 * rm_write_chunk
 * Write appropriate chunk
 */
int rm_write_chunk(int fd, const RM_Chunk *chunk)
{
	if (rm_write_tagged_chunk_header(fd, &chunk->header))
		return -1;

	if (chunk->header.object_version != 0) {
#ifndef IGNORE_VERSION
		fprintf(stderr, "%s: This library only handles version 0.\n",
			"rm_write_chunk()");
		return -1;
#else
		fputs("Warning, ignoring version != 0\n", stderr);
#endif
	}

	switch (chunk->header.object_id) {
	case FILE_HEADER_ID:
		return rm_write_file_header(fd, &chunk->data.file_header);
	case PROPERTIES_ID:
		return rm_write_properties(fd, &chunk->data.properties);
	case MEDIA_PROPERTIES_ID:
		return rm_write_media_properties(fd, &chunk->data.media_properties);
	case CONTENT_HEADER_ID:
		return rm_write_content_description(fd, &chunk->data.content_description);
	case DATA_HEADER_ID:
		return rm_write_data_chunk_header(fd, &chunk->data.data_chunk_header);
	case INDEX_HEADER_ID:
		return rm_write_index_chunk_header(fd, &chunk->data.index_chunk_header);
	default:
		fputs("rm_write_chunk(): Unknown chunk\n", stderr);
		return -1;
	}
	return 0;
}

/*
 * rm_write_tagged_chunk_header
 * Write a Tagged Chunk Header to fd
 */
int rm_write_tagged_chunk_header(int fd, const RM_Tagged_Chunk_Header *header)
{
	return bwrite32(fd, header->object_id)
		|| bwrite32(fd, header->size)
		|| bwrite16(fd, header->object_version);
}

int rm_write_file_header(int fd, const RM_File_Header *header)
{
	return bwrite32(fd, header->file_version)
		|| bwrite32(fd, header->num_headers);
}

int rm_write_properties(int fd, const RM_Properties *properties)
{
	return bwrite32(fd, properties->max_bit_rate)
		|| bwrite32(fd, properties->avg_bit_rate)
		|| bwrite32(fd, properties->max_packet_size)
		|| bwrite32(fd, properties->avg_packet_size)
		|| bwrite32(fd, properties->num_packets)
		|| bwrite32(fd, properties->duration)
		|| bwrite32(fd, properties->preroll)
		|| bwrite32(fd, properties->index_offset)
		|| bwrite32(fd, properties->data_offset)
		|| bwrite16(fd, properties->num_streams)
		|| bwrite16(fd, properties->flags);
}

int rm_write_media_properties(int fd, const RM_Media_Properties *properties)
{
	return bwrite16(fd, properties->stream_number)
		|| bwrite32(fd, properties->max_bit_rate)
		|| bwrite32(fd, properties->avg_bit_rate)
		|| bwrite32(fd, properties->max_packet_size)
		|| bwrite32(fd, properties->avg_packet_size)
		|| bwrite32(fd, properties->start_time)
		|| bwrite32(fd, properties->preroll)
		|| bwrite32(fd, properties->duration)
		|| bwrite8(fd, properties->stream_name_size)
		|| bwrites(fd, properties->stream_name,
			   properties->stream_name_size)
		|| bwrite8(fd, properties->mime_type_size)
		|| bwrites(fd, properties->mime_type,
			   properties->mime_type_size)
		|| bwrite32(fd, properties->type_specific_len)
		|| bwrites(fd, properties->type_specific_data,
			   properties->type_specific_len);
}

int rm_write_content_description(int fd, const RM_Content_Description *desc)
{
	return bwrite16(fd, desc->title_len)
		|| bwrites(fd, desc->title, desc->title_len)
		|| bwrite16(fd, desc->author_len)
		|| bwrites(fd, desc->author, desc->author_len)
		|| bwrite16(fd, desc->copyright_len)
		|| bwrites(fd, desc->copyright, desc->copyright_len)
		|| bwrite16(fd, desc->comment_len)
		|| bwrites(fd, desc->comment, desc->comment_len);
}

int rm_write_data_chunk_header(int fd, const RM_Data_Chunk_Header *header)
{
	return bwrite32(fd, header->num_packets)
		|| bwrite32(fd, header->next_data_header);
}

int rm_write_media_packet_header(int fd, const RM_Media_Packet_Header *header)
{
	if (header->object_version != 0) {
#ifndef IGNORE_VERSION
		fprintf(stderr, "%s: This library only handles version 0.\n",
			"rm_write_media_packet_header()");
		return -1;
#else
		fputs("Warning, ignoring version != 0\n", stderr);
#endif
	}

	return bwrite16(fd, header->object_version)
		|| bwrite16(fd, header->length + 12) /* add field lengths */
		|| bwrite16(fd, header->stream_number)
		|| bwrite32(fd, header->timestamp)
		|| bwrite8(fd, header->reserved)
		|| bwrite8(fd, header->flags)
		|| bwrites(fd, header->data, header->length);
}

int rm_write_index_chunk_header(int fd, const RM_Index_Chunk_Header *header)
{
	return bwrite32(fd, header->num_indices)
		|| bwrite16(fd, header->stream_number)
		|| bwrite32(fd, header->next_index_header);
}

int rm_write_index_record(int fd, const RM_Index_Record *rec)
{
	if (rec->object_version != 0) {
#ifndef IGNORE_VERSION
		fprintf(stderr, "%s: This library only handles version 0.\n",
			"rm_write_index_record()");
		return -1;
#else
		fputs("Warning, ignoring version != 0\n", stderr);
#endif
	}

	return bwrite16(fd, rec->object_version)
		|| bwrite32(fd, rec->timestamp)
		|| bwrite32(fd, rec->offset)
		|| bwrite32(fd, rec->packet_count_for_this_packet);
}