chunk_read.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_read_chunk
 * Read chunk header, then appropriate chunk data.
 * Does *not* read actual media data.
 */
int rm_read_chunk(int fd, RM_Chunk *chunk)
{
	if (rm_read_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_read_chunk()");
		return -1;
#else
		fputs("Warning, ignoring version != 0\n", stderr);
#endif
	}

	switch (chunk->header.object_id) {
	case FILE_HEADER_ID:
		return rm_read_file_header(fd, &chunk->data.file_header);
	case PROPERTIES_ID:
		return rm_read_properties(fd, &chunk->data.properties);
	case MEDIA_PROPERTIES_ID:
		return rm_read_media_properties(fd, &chunk->data.media_properties);
	case CONTENT_HEADER_ID:
		return rm_read_content_description(fd, &chunk->data.content_description);
	case DATA_HEADER_ID:
		return rm_read_data_chunk_header(fd, &chunk->data.data_chunk_header);
	case INDEX_HEADER_ID:
		return rm_read_index_chunk_header(fd, &chunk->data.index_chunk_header);
	default:
		fputs("rm_read_chunk(): Unknown chunk.\n", stderr);
		return -1;
	}
	return 0;
}

/*
 * rm_read_tagged_chunk_header
 * Read in Tagged Chunk Header header from fd
 */
int rm_read_tagged_chunk_header(int fd, RM_Tagged_Chunk_Header *header)
{
	return bread32(fd, &header->object_id)
		|| bread32(fd, &header->size)
		|| bread16(fd, &header->object_version);
}

int rm_read_file_header(int fd, RM_File_Header *header)
{
	return bread32(fd, &header->file_version)
		|| bread32(fd, &header->num_headers);
}

int rm_read_properties(int fd, RM_Properties *properties)
{
	return bread32(fd, &properties->max_bit_rate)
		|| bread32(fd, &properties->avg_bit_rate)
		|| bread32(fd, &properties->max_packet_size)
		|| bread32(fd, &properties->avg_packet_size)
		|| bread32(fd, &properties->num_packets)
		|| bread32(fd, &properties->duration)
		|| bread32(fd, &properties->preroll)
		|| bread32(fd, &properties->index_offset)
		|| bread32(fd, &properties->data_offset)
		|| bread16(fd, &properties->num_streams)
		|| bread16(fd, &properties->flags);
}

int rm_read_media_properties(int fd, RM_Media_Properties *properties)
{
	return bread16(fd, &properties->stream_number)
		|| bread32(fd, &properties->max_bit_rate)
		|| bread32(fd, &properties->avg_bit_rate)
		|| bread32(fd, &properties->max_packet_size)
		|| bread32(fd, &properties->avg_packet_size)
		|| bread32(fd, &properties->start_time)
		|| bread32(fd, &properties->preroll)
		|| bread32(fd, &properties->duration)
		|| bread8(fd, &properties->stream_name_size)
		|| breads(fd, &properties->stream_name,
			  properties->stream_name_size)
		|| bread8(fd, &properties->mime_type_size)
		|| breads(fd, &properties->mime_type,
			  properties->mime_type_size)
		|| bread32(fd, &properties->type_specific_len)
		|| breads(fd, &properties->type_specific_data,
			  properties->type_specific_len);
}

int rm_read_content_description(int fd, RM_Content_Description *desc)
{
	return bread16(fd, &desc->title_len)
		|| breads(fd, &desc->title, desc->title_len)
		|| bread16(fd, &desc->author_len)
		|| breads(fd, &desc->author, desc->author_len)
		|| bread16(fd, &desc->copyright_len)
		|| breads(fd, &desc->copyright, desc->copyright_len)
		|| bread16(fd, &desc->comment_len)
		|| breads(fd, &desc->comment, desc->comment_len);
}

int rm_read_data_chunk_header(int fd, RM_Data_Chunk_Header *header)
{
	return bread32(fd, &header->num_packets)
		|| bread32(fd, &header->next_data_header);
}

int rm_read_media_packet_header(int fd, RM_Media_Packet_Header *header)
{
	if (bread16(fd, &header->object_version))
		return -1;

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

	if (bread16(fd, &header->length)
	    || bread16(fd, &header->stream_number)
	    || bread32(fd, &header->timestamp)
	    || bread8(fd, &header->reserved)
	    || bread8(fd, &header->flags))
		return -1;

	header->length -= 12; /* Remove fields from count */
	return breads(fd, &header->data, header->length);
}

int rm_read_index_chunk_header(int fd, RM_Index_Chunk_Header *header)
{
	return bread32(fd, &header->num_indices)
		|| bread16(fd, &header->stream_number)
		|| bread32(fd, &header->next_index_header);
}

int rm_read_index_record(int fd, RM_Index_Record *rec)
{
	if (bread16(fd, &rec->object_version))
		return -1;

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

	return bread32(fd, &rec->timestamp)
		|| bread32(fd, &rec->offset)
		|| bread32(fd, &rec->packet_count_for_this_packet);
}