atomparse.cpp

mpeg4 demux 代码

/* <LIC_AMD_STD>
 * Copyright (C) 2003-2005 Advanced Micro Devices, Inc.  All Rights Reserved.
 *
 * Unless otherwise designated in writing, this software and any related
 * documentation are the confidential proprietary information of AMD.
 * THESE MATERIALS ARE PROVIDED "AS IS" WITHOUT ANY
 * UNLESS OTHERWISE NOTED IN WRITING, EXPRESS OR IMPLIED WARRANTY OF ANY
 * KIND, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY,
 * NONINFRINGEMENT, TITLE, FITNESS FOR ANY PARTICULAR PURPOSE AND IN NO
 * EVENT SHALL AMD OR ITS LICENSORS BE LIABLE FOR ANY DAMAGES WHATSOEVER.
 *
 * AMD does not assume any responsibility for any errors which may appear
 * in the Materials nor any responsibility to support or update the
 * Materials.  AMD retains the right to modify the Materials at any time,
 * without notice, and is not obligated to provide such modified
 * Materials to you. AMD is not obligated to furnish, support, or make
 * any further information available to you.
 * </LIC_AMD_STD>  */
/* <CTL_AMD_STD>
 * </CTL_AMD_STD>  */
/* <DOC_AMD_STD>
 * </DOC_AMD_STD>  */

#include "atomparse.h"
#include "mp4parse.h"


void CBox::ReadData(Byte_Stream &input_stream)
{
	size = input_stream.GetUINT();
	if (size==1) {
		  largesize = input_stream.GetUINT();
		   largesize <<= 32;
			largesize |= input_stream.GetUINT();
	   } else if (size==0) {
		  // box extends to end of file
	}
	   type = input_stream.GetUINT();

}

void CFullBox::ReadData(Byte_Stream &input_stream)
{
	UINT temp;

	version	= input_stream.GetByte();
	//BitField(temp,0,8);
	temp = input_stream.PeekUINT();
	flags	= BitField(temp,8,24);
	input_stream.Advance(3);
}

void CMediaDataBox::ReadData(Byte_Stream &input_stream,m_u32 size)
{
		data = (m_u8 *) malloc(size * sizeof(m_u8));
		if(data)
			memcpy(data,input_stream.GetBytePointer(),size);
}


void CMovieHeaderBox::ReadData(Byte_Stream &input_stream)
{
	int i;
	CFullBox::ReadData(input_stream);

	if (version==1) { // TODO: 64-bit values
			creation_time = input_stream.GetUINT();
			creation_time <<= 32;
			creation_time |= input_stream.GetUINT();
			modification_time = input_stream.GetUINT();
			modification_time <<= 32;
			modification_time |= input_stream.GetUINT();
			timescale = input_stream.GetUINT();
			duration = input_stream.GetUINT();
			duration <<= 32;
			duration |= input_stream.GetUINT();
	} else { // version==0, 32-bit vars
			creation_time = input_stream.GetUINT();
			modification_time = input_stream.GetUINT();
			timescale = input_stream.GetUINT();
			duration = input_stream.GetUINT();
	}
	rate = input_stream.GetUINT(); // typically 1.0
	volume = input_stream.GetWORD(); // typically, full volume
	reserved = input_stream.GetWORD(); // 0
	reservedar[0] = input_stream.GetUINT();
	reservedar[1] = input_stream.GetUINT();
		//template int(32)[9] matrix =
		//{ 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 };
		// Unity matrix
	for(i=0;i<9;i++)
		matirx[i] = input_stream.GetUINT();
	for(i=0;i<6;i++)
		pre_defined[i] = input_stream.GetUINT();;
	next_track_ID = input_stream.GetUINT();
}

void CTrackHeaderBox::ReadData(Byte_Stream &input_stream,long Len)
{
		int i;
		CFullBox::ReadData(input_stream);
		if(flags == 0) { // disabled track
			input_stream.Advance(Len - 4);
			return;
		}

		if (version==1) { // TODO: 64-bit values
			creation_time = input_stream.GetUINT();
			creation_time <<= 32;
			creation_time |= input_stream.GetUINT();
			modification_time = input_stream.GetUINT();
			modification_time <<= 32;
			modification_time |= input_stream.GetUINT();

			track_ID = input_stream.GetUINT();
			reserved = input_stream.GetUINT();
			duration = input_stream.GetUINT();
			duration <<= 32;
			duration |= input_stream.GetUINT();
		} else { // version==0, 32-bit vars
			creation_time = input_stream.GetUINT();
			modification_time = input_stream.GetUINT();
			track_ID = input_stream.GetUINT();
			reserved = input_stream.GetUINT();
			duration = input_stream.GetUINT();
		}
		reservedar[0] = input_stream.GetUINT();
		reservedar[1] = input_stream.GetUINT();
		layer = input_stream.GetWORD();
		alternate_group = input_stream.GetWORD();
		volume = input_stream.GetWORD(); // {if track_is_audio 0x0100 else 0};
		reserved1 = input_stream.GetWORD();
		for(i=0;i<9;i++)
			matirx[i] = input_stream.GetUINT();
		//matrix [9] =
		//{ 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 };
		// unity matrix
		width = input_stream.GetUINT();
		height = input_stream.GetUINT();
}

void CMediaHeaderBox::ReadData(Byte_Stream &input_stream)
{
		UINT temp =0;
		CFullBox::ReadData(input_stream);
		if (version==1) { // TODO: 64-bit values
			creation_time = input_stream.GetUINT();
			modification_time = input_stream.GetUINT();
			timescale = input_stream.GetUINT();
			duration = input_stream.GetUINT();
		} else { // version==0, 32-bit vars
			creation_time = input_stream.GetUINT();
			modification_time = input_stream.GetUINT();
			timescale = input_stream.GetUINT();
			duration = input_stream.GetUINT();
		}
		temp = input_stream.GetWORD();
		pad = BitField(temp,15,1);
		//TODO:
		//for(i=0;i<3;i++)
		//	language[i] = BitField(temp,i*5+1,5); // ISO-639-2/T language code
		pre_defined = input_stream.GetWORD();
}

void CHandlerBox::ReadData(Byte_Stream &input_stream,long len)
{
		int i;

		CFullBox::ReadData(input_stream);
		pre_defined  = input_stream.GetUINT();
		handler_type = input_stream.GetUINT(); /*?vide?Video track
												?soun?Audio track
												?hint?Hint track
												 */
		for(i=0;i<3;i++)
			reserved[i] = input_stream.GetUINT();
		//strncpy(name, (const char *)input_stream.GetBytePointer(),9);
		//i = strlen(name);
		len -= 24; // parsed 24 bytes
		if(len > 0) // skip remaining bytes
			input_stream.Advance(len);
}
m_u32 CHandlerBox::GetHandlerType()
{
	return handler_type;
}


void CDataReferenceBox::ReadData(Byte_Stream &input_stream, long Len)
{
		int i;
		CFullBox::ReadData(input_stream);
		entry_count = input_stream.GetUINT();
		//data_entry_list = (CDataEntryUrnBox *) malloc(sizeof(m_u32)*entry_count);
		for (i=0; i < entry_count; i++)
		{
			data_entry_list = new CDataEntryUrnBox(size,input_stream);
		};
}


void CTimeToSampleBox::ReadData(Byte_Stream &input_stream)
{
		int i;
		CFullBox::ReadData(input_stream);
		entry_count = input_stream.GetUINT();
		sample_count_list = (m_u32 *) malloc(sizeof(m_u32)*entry_count);
		sample_delta_list = (m_u32 *) malloc(sizeof(m_u32)*entry_count);
		for (i=0; i < entry_count; i++) {
			 sample_count_list[i] = input_stream.GetUINT();
			 sample_delta_list[i] = input_stream.GetUINT();
		}
}


void CCompositionOffsetBox::ReadData(Byte_Stream &input_stream)
{
		int i;
		CFullBox::ReadData(input_stream);
		entry_count = input_stream.GetUINT();
		sample_count_list = (m_u32 *) malloc(sizeof(m_u32)*entry_count);
		sample_offset_list = (m_u32 *) malloc(sizeof(m_u32)*entry_count);
		for (i=0; i < entry_count; i++) {
			 sample_count_list[i] = input_stream.GetUINT();
			 sample_offset_list[i] = input_stream.GetUINT();
		}
}
void CSampleEntry::ReadData(Byte_Stream &input_stream)
{
		CBox::ReadData(input_stream);
		input_stream.Advance(6);
		data_reference_index = input_stream.GetWORD();
}
void CVisualSampleEntry::ReadData(Byte_Stream &input_stream)
{
	CSampleEntry::ReadData(input_stream);
	pre_defined = input_stream.GetWORD() ;
	reserved = input_stream.GetWORD() ;
	pre_defined_list[0] = input_stream.GetUINT();
	pre_defined_list[1] = input_stream.GetUINT();
	pre_defined_list[2] = input_stream.GetUINT();
	width = input_stream.GetWORD() ;
	height = input_stream.GetWORD() ;
	horizresolution = input_stream.GetUINT();// template 0x00480000; // 72 dpi
	vertresolution  = input_stream.GetUINT();//template 0x00480000; // 72 dpi
	reserved1 = input_stream.GetUINT(); // const ?
	pre_defined  = input_stream.GetWORD() ; //1;
	memcpy(compressorname,input_stream.GetBytePointer(),32); // ?? string [32]
	input_stream.Advance(32);
	depth = input_stream.GetWORD() ; //template 0x0018;
	pre_defined1 = input_stream.GetWORD() ; //-1;
	if(!input_stream.EndOfStream())
	{
		long Len=0;
		unsigned int mid;
		Len = input_stream.GetUINT();
		mid = input_stream.GetUINT();
		if(mid == FOURCC('e','s','d','s') )
		{
			// TODO:parse ESD
			lConfigDataLen = Len - 8;
			pVideoDecConfigData = (m_u8 *) malloc(sizeof(m_u8)*lConfigDataLen);
			memcpy(pVideoDecConfigData,input_stream.GetBytePointer(),lConfigDataLen);
			input_stream.Advance(lConfigDataLen);
		}
		else
			input_stream.Retreat(8);

	}

}

// Audio Sequences

void CAudioSampleEntry::ReadData(Byte_Stream &input_stream)
{
	CSampleEntry::ReadData(input_stream);
	reserved[0] =  input_stream.GetUINT(); // 0
	reserved[1] =  input_stream.GetUINT();
	channelcount = input_stream.GetWORD() ;// template 2;
	samplesize = input_stream.GetWORD() ;// template 16;
	pre_defined = input_stream.GetWORD() ;// 0;
	reserved1= input_stream.GetWORD() ;//const 0
	//samplerate = input_stream.GetUINT(); //{timescale of media}<<16;
	samplerate = input_stream.GetWORD();
	input_stream.Advance(2);
#if 0
	if(!input_stream.EndOfStream())
	{
		long Len=0;
		unsigned int mid;
		Len = input_stream.GetUINT();
		mid = input_stream.GetUINT();
		if(mid == FOURCC('e','s','d','s') )
		{
			// TODO:parse ESD
			//ES.ReadData(input_stream);
		}
		else
			input_stream.Retreat(8);

	}
#endif

}

void CMP4AudioSampleEntry::ReadData(Byte_Stream &input_stream)
{
		CAudioSampleEntry::ReadData(input_stream);

		// TODO:parse ESD
		//ES.ReadData(input_stream);
}

void CSampleDescriptionBox::ReadData(Byte_Stream &input_stream,m_u32 index,m_bool bMP4File)
{	int i ;
		CFullBox::ReadData(input_stream);
		entry_count=  input_stream.GetUINT();
		for (i = 0 ; i < entry_count ; i++)
		{
		switch (index){
			case AUDIO: // for audio tracks
				AudioSampleEntry(input_stream);
				input_stream.Advance(size-44-8);
			break;
			case VIDEO: // for video tracks
				VisualSampleEntry(input_stream);
			break;
			case HINT: // Hint track, ignore for local file playback
			//HintSampleEntbry();
			break;
		}
		}
}


void CSampleSizeBox::ReadData(Byte_Stream &input_stream)
	{	int i ;
		CFullBox::ReadData(input_stream);
		sample_size = input_stream.GetUINT();
		sample_count = input_stream.GetUINT();
		if (sample_size==0)
		{
			entry_size_list = (m_u32 *) malloc(sizeof(m_u32)*sample_count);
			for (i=0; i < sample_count; i++) {
				entry_size_list[i]  = input_stream.GetUINT();
			}
		}
}

m_u32 CSampleSizeBox::GetSampleCount()
{
	return sample_count;
}
m_u32 CSampleSizeBox::GetSampleSize()
{
	return sample_size;
}
m_u32 CSampleSizeBox::GetEntrySize(m_u32 index)
{
	return entry_size_list[index];
}


void CSampleToChunkBox::ReadData(Byte_Stream &input_stream)
{	int i ;
		CFullBox::ReadData(input_stream);
		entry_count = input_stream.GetUINT();
		if(entry_count >= 0)
		{
			first_chunk_list = (m_u32 *) malloc(sizeof(m_u32)*entry_count );
			samples_per_chunk_list = (m_u32 *) malloc(sizeof(m_u32)*entry_count );
			sample_description_index_list = (m_u32 *) malloc(sizeof(m_u32)*entry_count );
			for (i=0; i < entry_count; i++)
			{
				first_chunk_list[i]					= input_stream.GetUINT();
				samples_per_chunk_list[i]			= input_stream.GetUINT();
				sample_description_index_list[i]	= input_stream.GetUINT();
			}
		}
}

m_u32 CSampleToChunkBox::GetEntryCount()
{
	return entry_count;
}

m_u32 CSampleToChunkBox::Getfirst_chunk(m_u32 index)
{
	return first_chunk_list[index];
}
m_u32 CSampleToChunkBox::Getsamples_per_chunk(m_u32 index)
{
	return samples_per_chunk_list[index];
}
m_u32 CSampleToChunkBox::Getsample_description_index(m_u32 index)
{
	return sample_description_index_list[index];
}

void CChunkOffsetBox::ReadData(Byte_Stream &input_stream)
{
	int i ;
	CFullBox::ReadData(input_stream);
	entry_count = input_stream.GetUINT();
	chunk_offset_list = (m_u32 *) malloc(sizeof(m_u32)*entry_count);
	for (i=0; i < entry_count; i++) {
		chunk_offset_list[i] = input_stream.GetUINT();
	}
}

m_u32 CChunkOffsetBox::GetEntryCount()
{
	return entry_count;
}

m_u32 CChunkOffsetBox::GetChunk_offset(m_u32 index)
{
	return chunk_offset_list[index];
}