Symaptic: os/mm/mmplugins/lib3gp/impl/src/mp4parse.cpp@260cb5ec6c19 (annotated)

sl@0	1	// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	//
sl@0	15
sl@0	16	#include <3gplibrary/mp4config.h>
sl@0	17	#include <3gplibrary/mp4lib.h>
sl@0	18	#include "mp4atom.h"
sl@0	19	#include "mp4memwrap.h"
sl@0	20	#include "mp4file.h"
sl@0	21	#include "mp4buffer.h"
sl@0	22	#include "mp4endian.h"
sl@0	23	#include "mp4utils.h"
sl@0	24
sl@0	25	using namespace ContentAccess;
sl@0	26
sl@0	27	extern EXPORT_C MP4Err MP4ParseOpen(MP4Handle *apihandle,
sl@0	28	MP4FileName filename)
sl@0	29	{
sl@0	30	MP4HandleImp handle = (MP4HandleStruct *)apihandle;
sl@0	31	*handle = (MP4HandleImp)mp4malloc(sizeof(MP4HandleStruct));
sl@0	32	if (*handle == NULL)
sl@0	33	return MP4_OUT_OF_MEMORY;
sl@0	34
sl@0	35	(*handle)->file32Duplicate = NULL;
sl@0	36	(*handle)->FileHandleFromOutside = EFalse;
sl@0	37	(*handle)->sourceType = MP4_SOURCE_RFILE;
sl@0	38
sl@0	39	if (filename)
sl@0	40	if (initFileRead(filename, *handle) == -1)
sl@0	41	{
sl@0	42	closeFile(*handle);
sl@0	43	mp4free(*handle);
sl@0	44	*handle = NULL;
sl@0	45	return MP4_FILE_ERROR;
sl@0	46	}
sl@0	47
sl@0	48	(*handle)->mem = listCreate();
sl@0	49	if ((*handle)->mem == NULL)
sl@0	50	{
sl@0	51	closeFile(*handle);
sl@0	52	mp4free(*handle);
sl@0	53	*handle = NULL;
sl@0	54	return MP4_OUT_OF_MEMORY;
sl@0	55	}
sl@0	56
sl@0	57	if (((handle)->buf = (mp4_u8 )mp4malloc(TMPBUFSIZE)) == NULL)
sl@0	58	{
sl@0	59	listDestroyList((*handle)->mem);
sl@0	60	closeFile(*handle);
sl@0	61	mp4free(*handle);
sl@0	62	*handle = NULL;
sl@0	63	return MP4_OUT_OF_MEMORY;
sl@0	64	}
sl@0	65
sl@0	66	if (((handle)->diskReadBuf = (mp4_u8 )mp4malloc(READBUFSIZE)) == NULL)
sl@0	67	{
sl@0	68	mp4free((*handle)->buf);
sl@0	69	listDestroyList((*handle)->mem);
sl@0	70	closeFile(*handle);
sl@0	71	mp4free(*handle);
sl@0	72	*handle = NULL;
sl@0	73	return MP4_OUT_OF_MEMORY;
sl@0	74	}
sl@0	75
sl@0	76	// register for stblib use
sl@0	77	if (openStdlib() != MP4_OK)
sl@0	78	{
sl@0	79	mp4free((*handle)->diskReadBuf);
sl@0	80	mp4free((*handle)->buf);
sl@0	81	listDestroyList((*handle)->mem);
sl@0	82	closeFile(*handle);
sl@0	83	mp4free(*handle);
sl@0	84	*handle = NULL;
sl@0	85
sl@0	86	return MP4_ERROR;
sl@0	87	}
sl@0	88
sl@0	89	return MP4_OK;
sl@0	90	}
sl@0	91
sl@0	92	extern EXPORT_C MP4Err MP4ParseOpenFileHandle(MP4Handle *apihandle,
sl@0	93	RFile *inputfile)
sl@0	94	{
sl@0	95	MP4Err err;
sl@0	96	RFile64 *f64 = new RFile64;
sl@0	97	if (f64 == NULL)
sl@0	98	{
sl@0	99	return MP4_OUT_OF_MEMORY;
sl@0	100	}
sl@0	101	if (f64->Duplicate(*inputfile) != KErrNone)
sl@0	102	{
sl@0	103	delete f64;
sl@0	104	return MP4_ERROR;
sl@0	105	}
sl@0	106	err = MP4ParseOpenFileHandle64(apihandle, f64);
sl@0	107	if (err == MP4_OK)
sl@0	108	{
sl@0	109	MP4HandleImp* handle = (MP4HandleStruct **)apihandle;
sl@0	110	(handle)->file32Duplicate = (void)(f64);
sl@0	111	}
sl@0	112	return err;
sl@0	113	}
sl@0	114
sl@0	115	extern EXPORT_C MP4Err MP4ParseOpenFileHandle64(MP4Handle *apihandle,
sl@0	116	RFile64 *inputfile)
sl@0	117	{
sl@0	118	MP4HandleImp handle = (MP4HandleStruct *)apihandle;
sl@0	119	*handle = (MP4HandleImp)mp4malloc(sizeof(MP4HandleStruct));
sl@0	120	if (*handle == NULL)
sl@0	121	return MP4_OUT_OF_MEMORY;
sl@0	122
sl@0	123	(*handle)->file32Duplicate = NULL;
sl@0	124	(handle)->rfile = (void )inputfile;
sl@0	125	(handle)->file = (handle)->rfile;
sl@0	126	(*handle)->FileHandleFromOutside = ETrue;
sl@0	127	(*handle)->sourceType = MP4_SOURCE_RFILE;
sl@0	128	if (inputfile == NULL)
sl@0	129	{
sl@0	130	closeFile(*handle);
sl@0	131	mp4free(*handle);
sl@0	132	*handle = NULL;
sl@0	133	return MP4_FILE_ERROR;
sl@0	134	}
sl@0	135
sl@0	136	(*handle)->mem = listCreate();
sl@0	137	if ((*handle)->mem == NULL)
sl@0	138	{
sl@0	139	closeFile(*handle);
sl@0	140	mp4free(*handle);
sl@0	141	*handle = NULL;
sl@0	142	return MP4_OUT_OF_MEMORY;
sl@0	143	}
sl@0	144
sl@0	145	if (((handle)->buf = (mp4_u8 )mp4malloc(TMPBUFSIZE)) == NULL)
sl@0	146	{
sl@0	147	listDestroyList((*handle)->mem);
sl@0	148	closeFile(*handle);
sl@0	149	mp4free(*handle);
sl@0	150	*handle = NULL;
sl@0	151	return MP4_OUT_OF_MEMORY;
sl@0	152	}
sl@0	153
sl@0	154	if (((handle)->diskReadBuf = (mp4_u8 )mp4malloc(READBUFSIZE)) == NULL)
sl@0	155	{
sl@0	156	mp4free((*handle)->buf);
sl@0	157	listDestroyList((*handle)->mem);
sl@0	158	closeFile(*handle);
sl@0	159	mp4free(*handle);
sl@0	160	*handle = NULL;
sl@0	161	return MP4_OUT_OF_MEMORY;
sl@0	162	}
sl@0	163
sl@0	164	// register for stblib use
sl@0	165	if (openStdlib() != MP4_OK)
sl@0	166	{
sl@0	167	// clean up
sl@0	168	mp4free((*handle)->diskReadBuf);
sl@0	169	mp4free((*handle)->buf);
sl@0	170	listDestroyList((*handle)->mem);
sl@0	171	closeFile(*handle);
sl@0	172	mp4free(*handle);
sl@0	173	*handle = NULL;
sl@0	174
sl@0	175	return MP4_ERROR;
sl@0	176	}
sl@0	177
sl@0	178	return MP4_OK;
sl@0	179	}
sl@0	180
sl@0	181	extern EXPORT_C MP4Err MP4ParseOpenCAF(MP4Handle *apihandle,
sl@0	182	ContentAccess::CData *inputfile)
sl@0	183	{
sl@0	184	MP4HandleImp handle = (MP4HandleStruct *)apihandle;
sl@0	185	*handle = (MP4HandleImp)mp4malloc(sizeof(MP4HandleStruct));
sl@0	186	if (*handle == NULL)
sl@0	187	return MP4_OUT_OF_MEMORY;
sl@0	188
sl@0	189	(*handle)->file32Duplicate = NULL;
sl@0	190	(*handle)->cfile = inputfile;
sl@0	191	(handle)->file = (handle)->cfile;
sl@0	192	(*handle)->FileHandleFromOutside = ETrue;
sl@0	193	(*handle)->sourceType = MP4_SOURCE_CAF;
sl@0	194
sl@0	195	if (inputfile == NULL)
sl@0	196	{
sl@0	197	closeFile(*handle);
sl@0	198	mp4free(*handle);
sl@0	199	*handle = NULL;
sl@0	200	return MP4_FILE_ERROR;
sl@0	201	}
sl@0	202
sl@0	203	(*handle)->mem = listCreate();
sl@0	204	if ((*handle)->mem == NULL)
sl@0	205	{
sl@0	206	closeFile(*handle);
sl@0	207	mp4free(*handle);
sl@0	208	*handle = NULL;
sl@0	209	return MP4_OUT_OF_MEMORY;
sl@0	210	}
sl@0	211
sl@0	212	if (((handle)->buf = (mp4_u8 )mp4malloc(TMPBUFSIZE)) == NULL)
sl@0	213	{
sl@0	214	listDestroyList((*handle)->mem);
sl@0	215	closeFile(*handle);
sl@0	216	mp4free(*handle);
sl@0	217	*handle = NULL;
sl@0	218	return MP4_OUT_OF_MEMORY;
sl@0	219	}
sl@0	220
sl@0	221	if (((handle)->diskReadBuf = (mp4_u8 )mp4malloc(READBUFSIZE)) == NULL)
sl@0	222	{
sl@0	223	mp4free((*handle)->buf);
sl@0	224	listDestroyList((*handle)->mem);
sl@0	225	closeFile(*handle);
sl@0	226	mp4free(*handle);
sl@0	227	*handle = NULL;
sl@0	228	return MP4_OUT_OF_MEMORY;
sl@0	229	}
sl@0	230
sl@0	231	// register for stblib use
sl@0	232	if (openStdlib() != MP4_OK)
sl@0	233	{
sl@0	234	// clean up
sl@0	235	mp4free((*handle)->diskReadBuf);
sl@0	236	mp4free((*handle)->buf);
sl@0	237	listDestroyList((*handle)->mem);
sl@0	238	closeFile(*handle);
sl@0	239	mp4free(*handle);
sl@0	240	*handle = NULL;
sl@0	241
sl@0	242	return MP4_ERROR;
sl@0	243	}
sl@0	244
sl@0	245	return MP4_OK;
sl@0	246	}
sl@0	247
sl@0	248	extern EXPORT_C MP4Err MP4ParseClose(MP4Handle apihandle)
sl@0	249	{
sl@0	250	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	251
sl@0	252	if (!handle)
sl@0	253	return MP4_ERROR;
sl@0	254
sl@0	255	if (handle->file)
sl@0	256	closeFile(handle);
sl@0	257
sl@0	258	closeStdlib(); /* Free memory allocated by stdlib wrapper functions */
sl@0	259
sl@0	260	listDestroyList(handle->mem);
sl@0	261
sl@0	262	if (handle->diskReadBuf)
sl@0	263	mp4free(handle->diskReadBuf);
sl@0	264
sl@0	265	if (handle->buf)
sl@0	266	mp4free(handle->buf);
sl@0	267
sl@0	268	if (freeMOOV(handle->moov) < 0)
sl@0	269	return MP4_ERROR;
sl@0	270
sl@0	271	if (freeFTYP(handle->ftyp) < 0)
sl@0	272	return MP4_ERROR;
sl@0	273
sl@0	274	if (handle->file32Duplicate)
sl@0	275	((RFile64*)handle->file32Duplicate)->Close();
sl@0	276
sl@0	277	if (handle)
sl@0	278	mp4free(handle);
sl@0	279
sl@0	280	return MP4_OK;
sl@0	281	}
sl@0	282
sl@0	283	extern EXPORT_C MP4Err MP4ParseRequestVideoDescription(MP4Handle apihandle,
sl@0	284	mp4_u32 *videolength,
sl@0	285	mp4_double *framerate,
sl@0	286	mp4_u32 *videotype,
sl@0	287	mp4_u32 *videowidth,
sl@0	288	mp4_u32 *videoheight,
sl@0	289	mp4_u32 *timescale)
sl@0	290	{
sl@0	291	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	292	if (!handle)
sl@0	293	{
sl@0	294	return MP4_ERROR;
sl@0	295	}
sl@0	296
sl@0	297	if (!handle->metaDataComplete)
sl@0	298	{
sl@0	299	switch (metaDataAvailable(handle))
sl@0	300	{
sl@0	301	case 0:
sl@0	302	return MP4_NOT_AVAILABLE;
sl@0	303
sl@0	304	case 1:
sl@0	305	handle->cafError = KErrNone;
sl@0	306	if (readMetaData(handle) < 0)
sl@0	307	{
sl@0	308	// Reading of meta data failed, so free up any allocated memory
sl@0	309	freeFTYP(handle->ftyp);
sl@0	310	handle->ftyp = NULL;
sl@0	311	freeMOOV(handle->moov);
sl@0	312	handle->moov = NULL;
sl@0	313
sl@0	314	if ( handle->cafError != KErrNone )
sl@0	315	{
sl@0	316	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	317	return handle->cafError;
sl@0	318	}
sl@0	319	else
sl@0	320	{
sl@0	321	return MP4_INVALID_INPUT_STREAM;
sl@0	322	}
sl@0	323	}
sl@0	324	handle->metaDataComplete = MP4TRUE;
sl@0	325	break;
sl@0	326
sl@0	327	case -2:
sl@0	328	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	329	freeFTYP(handle->ftyp);
sl@0	330	handle->ftyp = NULL;
sl@0	331	return MP4_ERROR;
sl@0	332
sl@0	333	case -1:
sl@0	334	default:
sl@0	335	return MP4_ERROR;
sl@0	336	}
sl@0	337	}
sl@0	338
sl@0	339	if (!handle->moov)
sl@0	340	return MP4_ERROR;
sl@0	341	if (!handle->moov->trakVideo)
sl@0	342	return MP4_NO_VIDEO;
sl@0	343
sl@0	344	mp4_i32 videoError = 0;
sl@0	345	videoError = determineVideoType(handle, videotype);
sl@0	346	if ( videoError == -2 )
sl@0	347	{
sl@0	348	return MP4_NO_VIDEO;
sl@0	349	}
sl@0	350	else if ( videoError < 0 )
sl@0	351	{
sl@0	352	return MP4_ERROR;
sl@0	353	}
sl@0	354
sl@0	355	if (determineVideoLength(handle, videolength) < 0)
sl@0	356	return MP4_ERROR;
sl@0	357
sl@0	358	if (determineFrameRate(handle, framerate) < 0)
sl@0	359	return MP4_ERROR;
sl@0	360
sl@0	361	if (determineVideoResolution(handle, videowidth, videoheight) < 0)
sl@0	362	return MP4_ERROR;
sl@0	363
sl@0	364	if (determineVideoTimeScale(handle, timescale) < 0)
sl@0	365	return MP4_ERROR;
sl@0	366
sl@0	367
sl@0	368	return MP4_OK;
sl@0	369	}
sl@0	370
sl@0	371	extern EXPORT_C MP4Err MP4ParseRequestAudioDescription(MP4Handle apihandle,
sl@0	372	mp4_u32 *audiolength,
sl@0	373	mp4_u32 *audiotype,
sl@0	374	mp4_u8 *framespersample,
sl@0	375	mp4_u32 *timescale,
sl@0	376	mp4_u32 *averagebitrate)
sl@0	377	{
sl@0	378	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	379	if (!handle)
sl@0	380	{
sl@0	381	return MP4_ERROR;
sl@0	382	}
sl@0	383
sl@0	384	if (!handle->metaDataComplete)
sl@0	385	{
sl@0	386	switch (metaDataAvailable(handle))
sl@0	387	{
sl@0	388	case 0:
sl@0	389	return MP4_NOT_AVAILABLE;
sl@0	390
sl@0	391	case 1:
sl@0	392	handle->cafError = KErrNone;
sl@0	393	if (readMetaData(handle) < 0)
sl@0	394	{
sl@0	395	// Reading of meta data failed, so free up any allocated memory
sl@0	396	freeFTYP(handle->ftyp);
sl@0	397	handle->ftyp = NULL;
sl@0	398	freeMOOV(handle->moov);
sl@0	399	handle->moov = NULL;
sl@0	400
sl@0	401	if ( handle->cafError != KErrNone )
sl@0	402	{
sl@0	403	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	404	return handle->cafError;
sl@0	405	}
sl@0	406	else
sl@0	407	{
sl@0	408	return MP4_INVALID_INPUT_STREAM;
sl@0	409	}
sl@0	410	}
sl@0	411
sl@0	412	handle->metaDataComplete = MP4TRUE;
sl@0	413	break;
sl@0	414
sl@0	415	case -2:
sl@0	416	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	417	freeFTYP(handle->ftyp);
sl@0	418	handle->ftyp = NULL;
sl@0	419	return MP4_ERROR;
sl@0	420
sl@0	421	case -1:
sl@0	422	default:
sl@0	423	return MP4_ERROR;
sl@0	424	}
sl@0	425	}
sl@0	426
sl@0	427	if (!handle->moov)
sl@0	428	return MP4_ERROR;
sl@0	429	if (!handle->moov->trakAudio)
sl@0	430	return MP4_NO_AUDIO;
sl@0	431
sl@0	432	if (determineAudioLength(handle, audiolength) < 0)
sl@0	433	return MP4_ERROR;
sl@0	434
sl@0	435	mp4_i32 audioError = 0;
sl@0	436	audioError = determineAudioType(handle, audiotype);
sl@0	437	if ( audioError == -2 )
sl@0	438	{
sl@0	439	return MP4_NO_AUDIO;
sl@0	440	}
sl@0	441	else if ( audioError < 0 )
sl@0	442	{
sl@0	443	return MP4_ERROR;
sl@0	444	}
sl@0	445
sl@0	446	if (determineAudioFramesPerSample(handle, framespersample) < 0)
sl@0	447	return MP4_ERROR;
sl@0	448
sl@0	449	if (determineAudioTimeScale(handle, timescale) < 0)
sl@0	450	return MP4_ERROR;
sl@0	451
sl@0	452	if (averagebitrate != NULL)
sl@0	453	if (determineAudioAverageBitRate(handle, averagebitrate) < 0)
sl@0	454	return MP4_ERROR;
sl@0	455
sl@0	456
sl@0	457	return MP4_OK;
sl@0	458	}
sl@0	459
sl@0	460	extern EXPORT_C MP4Err MP4ParseRequestStreamDescription(MP4Handle apihandle,
sl@0	461	mp4_u32 *streamsize,
sl@0	462	mp4_u32 *streamaveragebitrate)
sl@0	463	{
sl@0	464	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	465
sl@0	466	if (!handle->metaDataComplete)
sl@0	467	{
sl@0	468	switch (metaDataAvailable(handle))
sl@0	469	{
sl@0	470	case 0:
sl@0	471
sl@0	472	return MP4_NOT_AVAILABLE;
sl@0	473
sl@0	474	case 1:
sl@0	475	handle->cafError = KErrNone;
sl@0	476	if (readMetaData(handle) < 0)
sl@0	477	{
sl@0	478	// Reading of meta data failed, so free up any allocated memory
sl@0	479	freeFTYP(handle->ftyp);
sl@0	480	handle->ftyp = NULL;
sl@0	481	freeMOOV(handle->moov);
sl@0	482	handle->moov = NULL;
sl@0	483
sl@0	484	if ( handle->cafError != KErrNone )
sl@0	485	{
sl@0	486	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	487	return handle->cafError;
sl@0	488	}
sl@0	489	else
sl@0	490	{
sl@0	491	return MP4_INVALID_INPUT_STREAM;
sl@0	492	}
sl@0	493	}
sl@0	494	handle->metaDataComplete = MP4TRUE;
sl@0	495	break;
sl@0	496
sl@0	497	case -2:
sl@0	498	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	499	freeFTYP(handle->ftyp);
sl@0	500	handle->ftyp = NULL;
sl@0	501	return MP4_ERROR;
sl@0	502
sl@0	503	case -1:
sl@0	504	default:
sl@0	505	return MP4_ERROR;
sl@0	506	}
sl@0	507	}
sl@0	508
sl@0	509	if (determineStreamSize(handle, streamsize) < 0)
sl@0	510	return MP4_ERROR;
sl@0	511
sl@0	512	if (determineStreamAverageBitRate(handle, streamaveragebitrate, *streamsize) < 0)
sl@0	513	return MP4_ERROR;
sl@0	514
sl@0	515
sl@0	516	return MP4_OK;
sl@0	517	}
sl@0	518
sl@0	519	extern EXPORT_C MP4Err MP4ParseWriteData(MP4Handle apihandle,
sl@0	520	mp4_u8 *buffer,
sl@0	521	mp4_u32 bytestowrite)
sl@0	522	{
sl@0	523	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	524
sl@0	525	if (handle->file)
sl@0	526	return MP4_ERROR;
sl@0	527
sl@0	528	if ((buffer == NULL) && (bytestowrite != 0))
sl@0	529	return MP4_ERROR;
sl@0	530
sl@0	531	if (handle->LastWriteDataCalled == MP4TRUE)
sl@0	532	return MP4_ERROR; // WriteData() call has been made before with bytestowrite=0, can not call again.
sl@0	533
sl@0	534	if (bytestowrite != 0)
sl@0	535	{
sl@0	536	if (addData(handle, buffer, bytestowrite) == -1)
sl@0	537	return MP4_OUT_OF_MEMORY;
sl@0	538	}
sl@0	539	else
sl@0	540	handle->LastWriteDataCalled = MP4TRUE;
sl@0	541
sl@0	542
sl@0	543	return MP4_OK;
sl@0	544	}
sl@0	545
sl@0	546	extern EXPORT_C MP4Err MP4ParseGetBufferedBytes(MP4Handle apihandle,
sl@0	547	mp4_u32 *bytes)
sl@0	548	{
sl@0	549	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	550
sl@0	551	*bytes = getBufferedBytes(handle);
sl@0	552
sl@0	553	if (handle->file)
sl@0	554	return MP4_FILE_MODE;
sl@0	555
sl@0	556	return MP4_OK;
sl@0	557	}
sl@0	558
sl@0	559	extern EXPORT_C MP4Err MP4ParseNextFrameType(MP4Handle apihandle,
sl@0	560	mp4_u32 *type)
sl@0	561	{
sl@0	562	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	563
sl@0	564	if (!handle->metaDataComplete)
sl@0	565	{
sl@0	566	switch (metaDataAvailable(handle))
sl@0	567	{
sl@0	568	case 0:
sl@0	569	return MP4_NOT_AVAILABLE;
sl@0	570
sl@0	571	case 1:
sl@0	572	handle->cafError = KErrNone;
sl@0	573	if (readMetaData(handle) < 0)
sl@0	574	{
sl@0	575	// Reading of meta data failed, so free up any allocated memory
sl@0	576	freeFTYP(handle->ftyp);
sl@0	577	handle->ftyp = NULL;
sl@0	578	freeMOOV(handle->moov);
sl@0	579	handle->moov = NULL;
sl@0	580
sl@0	581	if ( handle->cafError != KErrNone )
sl@0	582	{
sl@0	583	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	584	return handle->cafError;
sl@0	585	}
sl@0	586	else
sl@0	587	{
sl@0	588	return MP4_INVALID_INPUT_STREAM;
sl@0	589	}
sl@0	590	}
sl@0	591	handle->metaDataComplete = MP4TRUE;
sl@0	592	break;
sl@0	593
sl@0	594	case -2:
sl@0	595	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	596	freeFTYP(handle->ftyp);
sl@0	597	handle->ftyp = NULL;
sl@0	598	return MP4_ERROR;
sl@0	599
sl@0	600	case -1:
sl@0	601	default:
sl@0	602	return MP4_ERROR;
sl@0	603	}
sl@0	604	}
sl@0	605
sl@0	606	/* No audio nor video */
sl@0	607	if ((!handle->moov->trakAudio) && (!handle->moov->trakVideo))
sl@0	608	return MP4_ERROR;
sl@0	609
sl@0	610	mp4_u32 audiotype = 0;
sl@0	611	mp4_i32 audioerror = 0;
sl@0	612	if (handle->moov->trakAudio)
sl@0	613	{
sl@0	614	audioerror = determineAudioType(handle, &audiotype);
sl@0	615	}
sl@0	616
sl@0	617	mp4_u32 videotype = 0;
sl@0	618	mp4_i32 videoerror = 0;
sl@0	619	if (handle->moov->trakVideo)
sl@0	620	{
sl@0	621	videoerror = determineVideoType(handle, &videotype);
sl@0	622	}
sl@0	623
sl@0	624	/* Audio track only */
sl@0	625	if (handle->moov->trakAudio && !handle->moov->trakVideo)
sl@0	626	{
sl@0	627	if (audioerror == 0)
sl@0	628	{
sl@0	629	// if audio is of supported type, check if the last audio frame has been
sl@0	630	// retrieved
sl@0	631	if (handle->audioLast)
sl@0	632	{
sl@0	633	return MP4_NO_FRAME;
sl@0	634	}
sl@0	635	else
sl@0	636	{
sl@0	637	*type = audiotype;
sl@0	638	return MP4_OK;
sl@0	639	}
sl@0	640	}
sl@0	641	else
sl@0	642	{
sl@0	643	return MP4_ERROR;
sl@0	644	}
sl@0	645	}
sl@0	646
sl@0	647	/* Video track only */
sl@0	648	if (handle->moov->trakVideo && !handle->moov->trakAudio)
sl@0	649	{
sl@0	650	if (videoerror == 0)
sl@0	651	{
sl@0	652	// if video is of supported type, check if the last video frame has been
sl@0	653	// retrieved
sl@0	654	if (handle->videoLast)
sl@0	655	{
sl@0	656	return MP4_NO_FRAME;
sl@0	657	}
sl@0	658	else
sl@0	659	{
sl@0	660	*type = videotype;
sl@0	661	return MP4_OK;
sl@0	662	}
sl@0	663	}
sl@0	664	else
sl@0	665	{
sl@0	666	return MP4_ERROR;
sl@0	667	}
sl@0	668	}
sl@0	669
sl@0	670	/* All audio has been read, but there is video left */
sl@0	671	if (handle->audioLast && !handle->videoLast)
sl@0	672	{
sl@0	673	if (videoerror == 0)
sl@0	674	{
sl@0	675	*type = videotype;
sl@0	676	return MP4_OK;
sl@0	677	}
sl@0	678	else
sl@0	679	{
sl@0	680	return MP4_ERROR;
sl@0	681	}
sl@0	682	}
sl@0	683
sl@0	684	/* All video has been read, but there is audio left */
sl@0	685	if (handle->videoLast && !handle->audioLast)
sl@0	686	{
sl@0	687	if (audioerror == 0)
sl@0	688	{
sl@0	689	*type = audiotype;
sl@0	690	return MP4_OK;
sl@0	691	}
sl@0	692	else
sl@0	693	{
sl@0	694	return MP4_ERROR;
sl@0	695	}
sl@0	696	}
sl@0	697
sl@0	698	/* All data has been read */
sl@0	699	if (handle->audioLast && handle->videoLast)
sl@0	700	{
sl@0	701	return MP4_NO_FRAME;
sl@0	702	}
sl@0	703
sl@0	704	if (handle->audioSampleOffset < handle->videoFrameOffset)
sl@0	705	{
sl@0	706	/* Next frame is audio */
sl@0	707	if (audioerror == 0)
sl@0	708	{
sl@0	709	*type = audiotype;
sl@0	710	return MP4_OK;
sl@0	711	}
sl@0	712	else if ( (audioerror == -2) && (videoerror == 0) )
sl@0	713	{
sl@0	714	*type = videotype;
sl@0	715	return MP4_OK;
sl@0	716	}
sl@0	717	else
sl@0	718	{
sl@0	719	return MP4_ERROR;
sl@0	720	}
sl@0	721	}
sl@0	722	else
sl@0	723	{
sl@0	724	/* Next frame is video */
sl@0	725	if (videoerror == 0)
sl@0	726	{
sl@0	727	*type = videotype;
sl@0	728	return MP4_OK;
sl@0	729	}
sl@0	730	else if ( (videoerror == -2) && (audioerror == 0) )
sl@0	731	{
sl@0	732	*type = audiotype;
sl@0	733	return MP4_OK;
sl@0	734	}
sl@0	735	else
sl@0	736	{
sl@0	737	return MP4_ERROR;
sl@0	738	}
sl@0	739	}
sl@0	740	}
sl@0	741
sl@0	742	extern EXPORT_C MP4Err MP4ParseNextFrameSize(MP4Handle apihandle,
sl@0	743	mp4_u32 type,
sl@0	744	mp4_u32 *framesize)
sl@0	745	{
sl@0	746	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	747
sl@0	748	if (!handle->metaDataComplete)
sl@0	749	{
sl@0	750	switch (metaDataAvailable(handle))
sl@0	751	{
sl@0	752	case 0:
sl@0	753
sl@0	754	return MP4_NOT_AVAILABLE;
sl@0	755
sl@0	756	case 1:
sl@0	757	handle->cafError = KErrNone;
sl@0	758	if (readMetaData(handle) < 0)
sl@0	759	{
sl@0	760	// Reading of meta data failed, so free up any allocated memory
sl@0	761	freeFTYP(handle->ftyp);
sl@0	762	handle->ftyp = NULL;
sl@0	763	freeMOOV(handle->moov);
sl@0	764	handle->moov = NULL;
sl@0	765
sl@0	766	if ( handle->cafError != KErrNone )
sl@0	767	{
sl@0	768	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	769	return handle->cafError;
sl@0	770	}
sl@0	771	else
sl@0	772	{
sl@0	773	return MP4_INVALID_INPUT_STREAM;
sl@0	774	}
sl@0	775	}
sl@0	776
sl@0	777	handle->metaDataComplete = MP4TRUE;
sl@0	778	break;
sl@0	779
sl@0	780	case -2:
sl@0	781	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	782	freeFTYP(handle->ftyp);
sl@0	783	handle->ftyp = NULL;
sl@0	784	return MP4_ERROR;
sl@0	785
sl@0	786	case -1:
sl@0	787	default:
sl@0	788	return MP4_ERROR;
sl@0	789	}
sl@0	790	}
sl@0	791
sl@0	792	switch (type & handle->type)
sl@0	793	{
sl@0	794	case MP4_TYPE_MPEG4_VIDEO:
sl@0	795	case MP4_TYPE_H263_PROFILE_0:
sl@0	796	case MP4_TYPE_H263_PROFILE_3:
sl@0	797	case MP4_TYPE_AVC_PROFILE_BASELINE:
sl@0	798	case MP4_TYPE_AVC_PROFILE_MAIN:
sl@0	799	case MP4_TYPE_AVC_PROFILE_EXTENDED:
sl@0	800	case MP4_TYPE_AVC_PROFILE_HIGH:
sl@0	801
sl@0	802	/* There is a next video frame */
sl@0	803
sl@0	804	if (!handle->videoLast)
sl@0	805	*framesize = handle->videoFrameSize;
sl@0	806	else
sl@0	807	{
sl@0	808	*framesize = 0;
sl@0	809
sl@0	810	return MP4_NO_REQUESTED_FRAME;
sl@0	811	}
sl@0	812
sl@0	813	break;
sl@0	814
sl@0	815	case MP4_TYPE_MPEG4_AUDIO:
sl@0	816	case MP4_TYPE_AMR_NB:
sl@0	817	case MP4_TYPE_AMR_WB:
sl@0	818	case MP4_TYPE_QCELP_13K:
sl@0	819
sl@0	820	/* There is a next audio frame */
sl@0	821
sl@0	822	if (!handle->audioLast)
sl@0	823	*framesize = handle->audioSampleSize;
sl@0	824	else
sl@0	825	{
sl@0	826	*framesize = 0;
sl@0	827
sl@0	828	return MP4_NO_REQUESTED_FRAME;
sl@0	829	}
sl@0	830
sl@0	831	break;
sl@0	832
sl@0	833	case MP4_TYPE_NONE:
sl@0	834	default:
sl@0	835
sl@0	836	if (type == MP4_TYPE_MPEG4_VIDEO \|\|
sl@0	837	type == MP4_TYPE_H263_PROFILE_0 \|\|
sl@0	838	type == MP4_TYPE_H263_PROFILE_3 \|\|
sl@0	839	type == MP4_TYPE_MPEG4_AUDIO \|\|
sl@0	840	type == MP4_TYPE_AMR_NB \|\|
sl@0	841	type == MP4_TYPE_AMR_WB \|\|
sl@0	842	isAvcVideo(type) \|\|
sl@0	843	type == MP4_TYPE_QCELP_13K
sl@0	844	)
sl@0	845	return MP4_NO_REQUESTED_FRAME;
sl@0	846
sl@0	847	return MP4_INVALID_TYPE;
sl@0	848	}
sl@0	849
sl@0	850	return MP4_OK;
sl@0	851	}
sl@0	852
sl@0	853	extern EXPORT_C MP4Err MP4ParseReadVideoFrame(MP4Handle apihandle,
sl@0	854	mp4_u8 *buffer,
sl@0	855	mp4_u32 buffersize,
sl@0	856	mp4_u32 *framesize,
sl@0	857	mp4_u32 *timestamp,
sl@0	858	mp4_bool *keyframe,
sl@0	859	mp4_u32 *timestamp2)
sl@0	860	{
sl@0	861	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	862
sl@0	863	if (!handle->metaDataComplete)
sl@0	864	{
sl@0	865	switch (metaDataAvailable(handle))
sl@0	866	{
sl@0	867	case 0:
sl@0	868
sl@0	869	return MP4_NOT_AVAILABLE;
sl@0	870
sl@0	871	case 1:
sl@0	872	handle->cafError = KErrNone;
sl@0	873	if (readMetaData(handle) < 0)
sl@0	874	{
sl@0	875	// Reading of meta data failed, so free up any allocated memory
sl@0	876	freeFTYP(handle->ftyp);
sl@0	877	handle->ftyp = NULL;
sl@0	878	freeMOOV(handle->moov);
sl@0	879	handle->moov = NULL;
sl@0	880
sl@0	881	if ( handle->cafError != KErrNone )
sl@0	882	{
sl@0	883	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	884	return handle->cafError;
sl@0	885	}
sl@0	886	else
sl@0	887	{
sl@0	888	return MP4_INVALID_INPUT_STREAM;
sl@0	889	}
sl@0	890	}
sl@0	891	handle->metaDataComplete = MP4TRUE;
sl@0	892	break;
sl@0	893
sl@0	894	case -2:
sl@0	895	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	896	freeFTYP(handle->ftyp);
sl@0	897	handle->ftyp = NULL;
sl@0	898	return MP4_ERROR;
sl@0	899
sl@0	900	case -1:
sl@0	901	default:
sl@0	902	return MP4_ERROR;
sl@0	903	}
sl@0	904	}
sl@0	905
sl@0	906	/* Is video available? */
sl@0	907
sl@0	908	if (!((handle->type & MP4_TYPE_MPEG4_VIDEO) \|\|
sl@0	909	(handle->type & MP4_TYPE_H263_PROFILE_0) \|\|
sl@0	910	(handle->type & MP4_TYPE_H263_PROFILE_3) \|\|
sl@0	911	containsAvcVideo( handle->type ) ))
sl@0	912	return MP4_ERROR;
sl@0	913
sl@0	914	/* Are there samples left? */
sl@0	915
sl@0	916	if (handle->videoLast)
sl@0	917	return MP4_NO_FRAME;
sl@0	918
sl@0	919	if (!handle->moov)
sl@0	920	return MP4_ERROR;
sl@0	921	if (!handle->moov->trakVideo)
sl@0	922	return MP4_ERROR;
sl@0	923
sl@0	924	switch (fetchVideoFrame(handle, handle->moov->trakVideo, buffer, buffersize, framesize, timestamp, keyframe, timestamp2))
sl@0	925	{
sl@0	926	case -1:
sl@0	927	return MP4_ERROR;
sl@0	928	case -2:
sl@0	929	return MP4_BUFFER_TOO_SMALL;
sl@0	930	case -3:
sl@0	931	return MP4_NOT_AVAILABLE;
sl@0	932	case -4:
sl@0	933	return MP4_INVALID_INPUT_STREAM;
sl@0	934	default:
sl@0	935	break;
sl@0	936	}
sl@0	937
sl@0	938	switch (advanceVideoFrame(handle, handle->moov->trakVideo))
sl@0	939	{
sl@0	940	case -1:
sl@0	941	return MP4_ERROR;
sl@0	942	case -2:
sl@0	943	handle->videoLast = MP4TRUE;
sl@0	944	break;
sl@0	945	default:
sl@0	946	break;
sl@0	947	}
sl@0	948
sl@0	949	return MP4_OK;
sl@0	950	}
sl@0	951
sl@0	952	extern EXPORT_C MP4Err MP4ParseReadVideoDecoderSpecificInfo(MP4Handle apihandle,
sl@0	953	mp4_u8 *buffer,
sl@0	954	mp4_u32 buffersize,
sl@0	955	mp4_u32 *decspecinfosize)
sl@0	956	{
sl@0	957	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	958	if (!handle->metaDataComplete)
sl@0	959	{
sl@0	960	switch (metaDataAvailable(handle))
sl@0	961	{
sl@0	962	case 0:
sl@0	963	return MP4_NOT_AVAILABLE;
sl@0	964
sl@0	965	case 1:
sl@0	966	handle->cafError = KErrNone;
sl@0	967	if (readMetaData(handle) < 0)
sl@0	968	{
sl@0	969	// Reading of meta data failed, so free up any allocated memory
sl@0	970	freeFTYP(handle->ftyp);
sl@0	971	handle->ftyp = NULL;
sl@0	972	freeMOOV(handle->moov);
sl@0	973	handle->moov = NULL;
sl@0	974
sl@0	975	if ( handle->cafError != KErrNone )
sl@0	976	{
sl@0	977	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	978	return handle->cafError;
sl@0	979	}
sl@0	980	else
sl@0	981	{
sl@0	982	return MP4_INVALID_INPUT_STREAM;
sl@0	983	}
sl@0	984	}
sl@0	985	handle->metaDataComplete = MP4TRUE;
sl@0	986	break;
sl@0	987
sl@0	988	case -2:
sl@0	989	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	990	freeFTYP(handle->ftyp);
sl@0	991	handle->ftyp = NULL;
sl@0	992	return MP4_ERROR;
sl@0	993
sl@0	994	case -1:
sl@0	995	default:
sl@0	996	return MP4_ERROR;
sl@0	997	}
sl@0	998	}
sl@0	999
sl@0	1000	/* Is video type MPEG or AVC? */
sl@0	1001	if (!(handle->type & MP4_TYPE_MPEG4_VIDEO) &&
sl@0	1002	!(containsAvcVideo( handle->type )) )
sl@0	1003	{
sl@0	1004	return MP4_ERROR;
sl@0	1005	}
sl@0	1006
sl@0	1007	if (!handle->moov)
sl@0	1008	{
sl@0	1009	return MP4_ERROR;
sl@0	1010	}
sl@0	1011	if (!handle->moov->trakVideo)
sl@0	1012	{
sl@0	1013	return MP4_ERROR;
sl@0	1014	}
sl@0	1015	if (!handle->moov->trakVideo->mdia)
sl@0	1016	{
sl@0	1017	return MP4_ERROR;
sl@0	1018	}
sl@0	1019	if (!handle->moov->trakVideo->mdia->minf)
sl@0	1020	{
sl@0	1021	return MP4_ERROR;
sl@0	1022	}
sl@0	1023	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	1024	{
sl@0	1025	return MP4_ERROR;
sl@0	1026	}
sl@0	1027	if (!handle->moov->trakVideo->mdia->minf->stbl->stsd)
sl@0	1028	{
sl@0	1029	return MP4_ERROR;
sl@0	1030	}
sl@0	1031	if (handle->videoSampleEntryIndex > handle->moov->trakVideo->mdia->minf->stbl->stsd->entryCount)
sl@0	1032	{
sl@0	1033	return MP4_ERROR;
sl@0	1034	}
sl@0	1035
sl@0	1036	TInt index = handle->videoSampleEntryIndex - 1;
sl@0	1037	if (handle->videoSampleEntryIndex == 0)
sl@0	1038	{
sl@0	1039	// even though the video sample contains no actual data, if the video sample exist
sl@0	1040	// and contains decoder specific info, return it anyway
sl@0	1041	index = 0;
sl@0	1042	}
sl@0	1043
sl@0	1044	if (handle->type & MP4_TYPE_MPEG4_VIDEO)
sl@0	1045	{
sl@0	1046	/* Copy DecoderSpecificInfo into buffer */
sl@0	1047	if (!handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index])
sl@0	1048	{
sl@0	1049	return MP4_ERROR;
sl@0	1050	}
sl@0	1051	if (!handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd)
sl@0	1052	{
sl@0	1053	return MP4_ERROR;
sl@0	1054	}
sl@0	1055
sl@0	1056	*decspecinfosize = handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd->decSpecificInfoSize;
sl@0	1057	if (buffersize < handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd->decSpecificInfoSize)
sl@0	1058	{
sl@0	1059	return MP4_BUFFER_TOO_SMALL;
sl@0	1060	}
sl@0	1061
sl@0	1062	mp4memcpy(buffer,
sl@0	1063	handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd->decSpecificInfo,
sl@0	1064	handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd->decSpecificInfoSize);
sl@0	1065	}
sl@0	1066	else if ( containsAvcVideo( handle->type ) )
sl@0	1067	{
sl@0	1068	/* Copy the AVCDecoderConfigurationRecord into buffer */
sl@0	1069	if (!handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index])
sl@0	1070	{
sl@0	1071	return MP4_ERROR;
sl@0	1072	}
sl@0	1073	if (!handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc)
sl@0	1074	{
sl@0	1075	return MP4_ERROR;
sl@0	1076	}
sl@0	1077
sl@0	1078	*decspecinfosize = handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc->avcConfigSize;
sl@0	1079	if (buffersize < handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc->avcConfigSize)
sl@0	1080	{
sl@0	1081	return MP4_BUFFER_TOO_SMALL;
sl@0	1082	}
sl@0	1083
sl@0	1084	mp4memcpy(buffer,
sl@0	1085	handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc->avcConfig,
sl@0	1086	handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc->avcConfigSize);
sl@0	1087	}
sl@0	1088
sl@0	1089	return MP4_OK;
sl@0	1090	}
sl@0	1091
sl@0	1092	extern EXPORT_C MP4Err MP4ParseReadAudioFrames(MP4Handle apihandle,
sl@0	1093	mp4_u8 *buffer,
sl@0	1094	mp4_u32 buffersize,
sl@0	1095	mp4_u32 *audiosize,
sl@0	1096	mp4_u32 *timestamp,
sl@0	1097	mp4_u32 *returnedframes,
sl@0	1098	mp4_u32 *timestamp2)
sl@0	1099	{
sl@0	1100	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	1101
sl@0	1102	if (!handle->metaDataComplete)
sl@0	1103	{
sl@0	1104	switch (metaDataAvailable(handle))
sl@0	1105	{
sl@0	1106	case 0:
sl@0	1107	return MP4_NOT_AVAILABLE;
sl@0	1108
sl@0	1109	case 1:
sl@0	1110	handle->cafError = KErrNone;
sl@0	1111	if (readMetaData(handle) < 0)
sl@0	1112	{
sl@0	1113	// Reading of meta data failed, so free up any allocated memory
sl@0	1114	freeFTYP(handle->ftyp);
sl@0	1115	handle->ftyp = NULL;
sl@0	1116	freeMOOV(handle->moov);
sl@0	1117	handle->moov = NULL;
sl@0	1118
sl@0	1119	if ( handle->cafError != KErrNone )
sl@0	1120	{
sl@0	1121	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	1122	return handle->cafError;
sl@0	1123	}
sl@0	1124	else
sl@0	1125	{
sl@0	1126	return MP4_INVALID_INPUT_STREAM;
sl@0	1127	}
sl@0	1128	}
sl@0	1129	handle->metaDataComplete = MP4TRUE;
sl@0	1130	break;
sl@0	1131
sl@0	1132	case -2:
sl@0	1133	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	1134	freeFTYP(handle->ftyp);
sl@0	1135	handle->ftyp = NULL;
sl@0	1136	return MP4_ERROR;
sl@0	1137
sl@0	1138	case -1:
sl@0	1139	default:
sl@0	1140	return MP4_ERROR;
sl@0	1141	}
sl@0	1142	}
sl@0	1143
sl@0	1144	/* Is audio available? */
sl@0	1145
sl@0	1146	if (!((handle->type & MP4_TYPE_MPEG4_AUDIO) \|\|
sl@0	1147	(handle->type & MP4_TYPE_AMR_NB) \|\|
sl@0	1148	(handle->type & MP4_TYPE_AMR_WB) \|\|
sl@0	1149	(handle->type & MP4_TYPE_QCELP_13K)))
sl@0	1150	return MP4_ERROR;
sl@0	1151
sl@0	1152	/* Are there samples left? */
sl@0	1153
sl@0	1154	if (handle->audioLast)
sl@0	1155	return MP4_NO_FRAME;
sl@0	1156
sl@0	1157	if (!handle->moov)
sl@0	1158	return MP4_ERROR;
sl@0	1159	if (!handle->moov->trakAudio)
sl@0	1160	return MP4_ERROR;
sl@0	1161
sl@0	1162	switch (fetchAudioSample(handle, handle->moov->trakAudio, buffer, buffersize, audiosize, timestamp, returnedframes, timestamp2))
sl@0	1163	{
sl@0	1164	case -1:
sl@0	1165	return MP4_ERROR;
sl@0	1166	case -2:
sl@0	1167	return MP4_BUFFER_TOO_SMALL;
sl@0	1168	case -3:
sl@0	1169	return MP4_NOT_AVAILABLE;
sl@0	1170	case -4:
sl@0	1171	return MP4_INVALID_INPUT_STREAM;
sl@0	1172	default:
sl@0	1173	break;
sl@0	1174	}
sl@0	1175
sl@0	1176	switch (advanceAudioSample(handle, handle->moov->trakAudio))
sl@0	1177	{
sl@0	1178	case -1:
sl@0	1179	return MP4_ERROR;
sl@0	1180	case -2:
sl@0	1181	handle->audioLast = MP4TRUE;
sl@0	1182	break;
sl@0	1183	default:
sl@0	1184	break;
sl@0	1185	}
sl@0	1186
sl@0	1187	return MP4_OK;
sl@0	1188	}
sl@0	1189
sl@0	1190	extern EXPORT_C MP4Err MP4ParseReadAudioDecoderSpecificInfo(MP4Handle apihandle,
sl@0	1191	mp4_u8 *buffer,
sl@0	1192	mp4_u32 buffersize,
sl@0	1193	mp4_u32 *decspecinfosize)
sl@0	1194	{
sl@0	1195	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	1196
sl@0	1197	if (!handle->metaDataComplete)
sl@0	1198	{
sl@0	1199	switch (metaDataAvailable(handle))
sl@0	1200	{
sl@0	1201	case 0:
sl@0	1202	return MP4_NOT_AVAILABLE;
sl@0	1203
sl@0	1204	case 1:
sl@0	1205	handle->cafError = KErrNone;
sl@0	1206	if (readMetaData(handle) < 0)
sl@0	1207	{
sl@0	1208	// Reading of meta data failed, so free up any allocated memory
sl@0	1209	freeFTYP(handle->ftyp);
sl@0	1210	handle->ftyp = NULL;
sl@0	1211	freeMOOV(handle->moov);
sl@0	1212	handle->moov = NULL;
sl@0	1213
sl@0	1214	if ( handle->cafError != KErrNone )
sl@0	1215	{
sl@0	1216	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	1217	return handle->cafError;
sl@0	1218	}
sl@0	1219	else
sl@0	1220	{
sl@0	1221	return MP4_INVALID_INPUT_STREAM;
sl@0	1222	}
sl@0	1223	}
sl@0	1224	handle->metaDataComplete = MP4TRUE;
sl@0	1225	break;
sl@0	1226
sl@0	1227	case -2:
sl@0	1228	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	1229	freeFTYP(handle->ftyp);
sl@0	1230	handle->ftyp = NULL;
sl@0	1231	return MP4_ERROR;
sl@0	1232
sl@0	1233	case -1:
sl@0	1234	default:
sl@0	1235	return MP4_ERROR;
sl@0	1236	}
sl@0	1237	}
sl@0	1238
sl@0	1239	if (!handle->moov)
sl@0	1240	{
sl@0	1241	return MP4_ERROR;
sl@0	1242	}
sl@0	1243	if (!handle->moov->trakAudio)
sl@0	1244	{
sl@0	1245	return MP4_ERROR;
sl@0	1246	}
sl@0	1247	if (!handle->moov->trakAudio->mdia)
sl@0	1248	{
sl@0	1249	return MP4_ERROR;
sl@0	1250	}
sl@0	1251	if (!handle->moov->trakAudio->mdia->minf)
sl@0	1252	{
sl@0	1253	return MP4_ERROR;
sl@0	1254	}
sl@0	1255	if (!handle->moov->trakAudio->mdia->minf->stbl)
sl@0	1256	{
sl@0	1257	return MP4_ERROR;
sl@0	1258	}
sl@0	1259	if (!handle->moov->trakAudio->mdia->minf->stbl->stsd)
sl@0	1260	{
sl@0	1261	return MP4_ERROR;
sl@0	1262	}
sl@0	1263
sl@0	1264
sl@0	1265	TInt index = handle->audioSampleEntryIndex - 1;
sl@0	1266	if (handle->audioSampleEntryIndex == 0)
sl@0	1267	{
sl@0	1268	// even though the audio sample contains no actual data, if the audio sample exist
sl@0	1269	// and contains decoder specific info, return it anyway
sl@0	1270	index = 0;
sl@0	1271	}
sl@0	1272
sl@0	1273	/* Audio type */
sl@0	1274	if ((handle->type & MP4_TYPE_MPEG4_AUDIO) \|\|
sl@0	1275	((handle->type & MP4_TYPE_QCELP_13K) && (handle->qcelpStoredAsMPEGAudio)))
sl@0	1276	{
sl@0	1277	/* Copy DecoderSpecificInfo into buffer */
sl@0	1278	if (!handle->moov->trakAudio->mdia->minf->stbl->stsd->mp4a[index])
sl@0	1279	{
sl@0	1280	return MP4_ERROR;
sl@0	1281	}
sl@0	1282	if (!handle->moov->trakAudio->mdia->minf->stbl->stsd->mp4a[index]->esd)
sl@0	1283	{
sl@0	1284	return MP4_ERROR;
sl@0	1285	}
sl@0	1286
sl@0	1287	*decspecinfosize = handle->moov->trakAudio->mdia->minf->stbl->stsd->mp4a[index]->esd->decSpecificInfoSize;
sl@0	1288	if (buffersize < handle->moov->trakAudio->mdia->minf->stbl->stsd->mp4a[index]->esd->decSpecificInfoSize)
sl@0	1289	{
sl@0	1290	return MP4_BUFFER_TOO_SMALL;
sl@0	1291	}
sl@0	1292
sl@0	1293	mp4memcpy(buffer,
sl@0	1294	handle->moov->trakAudio->mdia->minf->stbl->stsd->mp4a[index]->esd->decSpecificInfo,
sl@0	1295	handle->moov->trakAudio->mdia->minf->stbl->stsd->mp4a[index]->esd->decSpecificInfoSize);
sl@0	1296	}
sl@0	1297	else if ((handle->type & MP4_TYPE_AMR_NB) \|\|
sl@0	1298	(handle->type & MP4_TYPE_AMR_WB) \|\|
sl@0	1299	((handle->type & MP4_TYPE_QCELP_13K) && (!handle->qcelpStoredAsMPEGAudio)))
sl@0	1300	{
sl@0	1301	/* Copy DecoderSpecificInfo into buffer */
sl@0	1302	if (handle->moov->trakAudio->mdia->minf->stbl->stsd->samr[index] == NULL &&
sl@0	1303	handle->moov->trakAudio->mdia->minf->stbl->stsd->sawb[index] == NULL &&
sl@0	1304	handle->moov->trakAudio->mdia->minf->stbl->stsd->sqcp[index] == NULL)
sl@0	1305	{
sl@0	1306	return MP4_ERROR;
sl@0	1307	}
sl@0	1308
sl@0	1309	if (handle->moov->trakAudio->mdia->minf->stbl->stsd->samr[index])
sl@0	1310	{
sl@0	1311	if (!handle->moov->trakAudio->mdia->minf->stbl->stsd->samr[index]->damr)
sl@0	1312	{
sl@0	1313	return MP4_ERROR;
sl@0	1314	}
sl@0	1315
sl@0	1316	*decspecinfosize = 9;
sl@0	1317	if (buffersize < *decspecinfosize)
sl@0	1318	{
sl@0	1319	return MP4_BUFFER_TOO_SMALL;
sl@0	1320	}
sl@0	1321
sl@0	1322	mp4memcpy(buffer, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->samr[index]->damr->vendor), 4);
sl@0	1323	mp4memcpy(buffer+4, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->samr[index]->damr->decoderVersion), 1);
sl@0	1324	mp4memcpy(buffer+5, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->samr[index]->damr->modeSet), 2);
sl@0	1325	mp4memcpy(buffer+7, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->samr[index]->damr->modeChangePeriod), 1);
sl@0	1326	mp4memcpy(buffer+8, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->samr[index]->damr->framesPerSample), 1);
sl@0	1327	}
sl@0	1328
sl@0	1329	if (handle->moov->trakAudio->mdia->minf->stbl->stsd->sawb[index])
sl@0	1330	{
sl@0	1331	if (!handle->moov->trakAudio->mdia->minf->stbl->stsd->sawb[index]->damr)
sl@0	1332	{
sl@0	1333	return MP4_ERROR;
sl@0	1334	}
sl@0	1335
sl@0	1336	*decspecinfosize = 9;
sl@0	1337	if (buffersize < *decspecinfosize)
sl@0	1338	{
sl@0	1339	return MP4_BUFFER_TOO_SMALL;
sl@0	1340	}
sl@0	1341
sl@0	1342	mp4memcpy(buffer, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->sawb[index]->damr->vendor), 4);
sl@0	1343	mp4memcpy(buffer+4, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->sawb[index]->damr->decoderVersion), 1);
sl@0	1344	mp4memcpy(buffer+5, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->sawb[index]->damr->modeSet), 2);
sl@0	1345	mp4memcpy(buffer+7, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->sawb[index]->damr->modeChangePeriod), 1);
sl@0	1346	mp4memcpy(buffer+8, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->sawb[index]->damr->framesPerSample), 1);
sl@0	1347	}
sl@0	1348
sl@0	1349	if (handle->moov->trakAudio->mdia->minf->stbl->stsd->sqcp[index])
sl@0	1350	{
sl@0	1351	if (!handle->moov->trakAudio->mdia->minf->stbl->stsd->sqcp[index]->dqcp)
sl@0	1352	{
sl@0	1353	return MP4_ERROR;
sl@0	1354	}
sl@0	1355
sl@0	1356	*decspecinfosize = 6;
sl@0	1357	if (buffersize < *decspecinfosize)
sl@0	1358	{
sl@0	1359	return MP4_BUFFER_TOO_SMALL;
sl@0	1360	}
sl@0	1361
sl@0	1362	mp4memcpy(buffer, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->sqcp[index]->dqcp->vendor), 4);
sl@0	1363	mp4memcpy(buffer+4, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->sqcp[index]->dqcp->decoderVersion), 1);
sl@0	1364	mp4memcpy(buffer+5, &(handle->moov->trakAudio->mdia->minf->stbl->stsd->sqcp[index]->dqcp->framesPerSample), 1);
sl@0	1365	}
sl@0	1366	}
sl@0	1367	else
sl@0	1368	{
sl@0	1369	return MP4_ERROR;
sl@0	1370	}
sl@0	1371
sl@0	1372	return MP4_OK;
sl@0	1373	}
sl@0	1374
sl@0	1375	extern EXPORT_C MP4Err MP4ParseGetNextVideoTimestamp(MP4Handle apihandle,
sl@0	1376	mp4_u32 *timestamp,
sl@0	1377	mp4_u32 *timestamp2)
sl@0	1378	{
sl@0	1379	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	1380
sl@0	1381	if (!handle->metaDataComplete)
sl@0	1382	{
sl@0	1383	switch (metaDataAvailable(handle))
sl@0	1384	{
sl@0	1385	case 0:
sl@0	1386
sl@0	1387	return MP4_NOT_AVAILABLE;
sl@0	1388
sl@0	1389	case 1:
sl@0	1390	handle->cafError = KErrNone;
sl@0	1391	if (readMetaData(handle) < 0)
sl@0	1392	{
sl@0	1393	// Reading of meta data failed, so free up any allocated memory
sl@0	1394	freeFTYP(handle->ftyp);
sl@0	1395	handle->ftyp = NULL;
sl@0	1396	freeMOOV(handle->moov);
sl@0	1397	handle->moov = NULL;
sl@0	1398
sl@0	1399	if ( handle->cafError != KErrNone )
sl@0	1400	{
sl@0	1401	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	1402	return handle->cafError;
sl@0	1403	}
sl@0	1404	else
sl@0	1405	{
sl@0	1406	return MP4_INVALID_INPUT_STREAM;
sl@0	1407	}
sl@0	1408	}
sl@0	1409	handle->metaDataComplete = MP4TRUE;
sl@0	1410	break;
sl@0	1411
sl@0	1412	case -2:
sl@0	1413	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	1414	freeFTYP(handle->ftyp);
sl@0	1415	handle->ftyp = NULL;
sl@0	1416	return MP4_ERROR;
sl@0	1417
sl@0	1418	case -1:
sl@0	1419	default:
sl@0	1420	return MP4_ERROR;
sl@0	1421	}
sl@0	1422	}
sl@0	1423
sl@0	1424	if (!handle->moov)
sl@0	1425	return MP4_ERROR;
sl@0	1426
sl@0	1427	if (!handle->moov->trakVideo)
sl@0	1428	return MP4_ERROR;
sl@0	1429
sl@0	1430	if (!handle->moov->trakVideo->mdia)
sl@0	1431	return MP4_ERROR;
sl@0	1432
sl@0	1433	if (handle->videoLast)
sl@0	1434	return MP4_END_OF_VIDEO;
sl@0	1435
sl@0	1436	if (convertVideoSampleToTime(handle, handle->moov->trakVideo->mdia, timestamp, timestamp2) < 0)
sl@0	1437	return MP4_ERROR;
sl@0	1438
sl@0	1439	switch (advanceVideoFrame(handle, handle->moov->trakVideo))
sl@0	1440	{
sl@0	1441	case -1:
sl@0	1442	return MP4_ERROR;
sl@0	1443	case -2:
sl@0	1444	handle->videoLast = MP4TRUE;
sl@0	1445	break;
sl@0	1446	default:
sl@0	1447	break;
sl@0	1448	}
sl@0	1449
sl@0	1450	return MP4_OK;
sl@0	1451	}
sl@0	1452
sl@0	1453	extern EXPORT_C MP4Err MP4ParseIsStreamable(MP4Handle apihandle)
sl@0	1454	{
sl@0	1455	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	1456
sl@0	1457	if (!handle->metaDataComplete)
sl@0	1458	{
sl@0	1459	switch (metaDataAvailable(handle))
sl@0	1460	{
sl@0	1461	case 0:
sl@0	1462
sl@0	1463	return MP4_NOT_AVAILABLE;
sl@0	1464
sl@0	1465	case 1:
sl@0	1466	handle->cafError = KErrNone;
sl@0	1467	if (readMetaData(handle) < 0)
sl@0	1468	{
sl@0	1469	// Reading of meta data failed, so free up any allocated memory
sl@0	1470	freeFTYP(handle->ftyp);
sl@0	1471	handle->ftyp = NULL;
sl@0	1472	freeMOOV(handle->moov);
sl@0	1473	handle->moov = NULL;
sl@0	1474
sl@0	1475	if ( handle->cafError != KErrNone )
sl@0	1476	{
sl@0	1477	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	1478	return handle->cafError;
sl@0	1479	}
sl@0	1480	else
sl@0	1481	{
sl@0	1482	return MP4_INVALID_INPUT_STREAM;
sl@0	1483	}
sl@0	1484	}
sl@0	1485	handle->metaDataComplete = MP4TRUE;
sl@0	1486	break;
sl@0	1487
sl@0	1488	case -2:
sl@0	1489	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	1490	freeFTYP(handle->ftyp);
sl@0	1491	handle->ftyp = NULL;
sl@0	1492	return MP4_ERROR;
sl@0	1493
sl@0	1494	case -1:
sl@0	1495	default:
sl@0	1496	return MP4_ERROR;
sl@0	1497	}
sl@0	1498	}
sl@0	1499
sl@0	1500	/* There is no audio nor video */
sl@0	1501
sl@0	1502	if (!handle->audioSampleNum && !handle->videoSampleNum)
sl@0	1503	return MP4_ERROR;
sl@0	1504
sl@0	1505	/* There is audio, but no video */
sl@0	1506
sl@0	1507	if (handle->audioSampleNum && !handle->videoSampleNum)
sl@0	1508	{
sl@0	1509	if (!handle->moov)
sl@0	1510	return MP4_ERROR;
sl@0	1511
sl@0	1512	if (!handle->moov->trakAudio)
sl@0	1513	return MP4_ERROR;
sl@0	1514
sl@0	1515	if (!handle->moov->trakAudio->mdia)
sl@0	1516	return MP4_ERROR;
sl@0	1517
sl@0	1518	if (!handle->moov->trakAudio->mdia->minf)
sl@0	1519	return MP4_ERROR;
sl@0	1520
sl@0	1521	if (!handle->moov->trakAudio->mdia->minf->stbl)
sl@0	1522	return MP4_ERROR;
sl@0	1523
sl@0	1524	if (!handle->moov->trakAudio->mdia->minf->stbl->stco)
sl@0	1525	return MP4_ERROR;
sl@0	1526
sl@0	1527	if (handle->moov->trakAudio->mdia->minf->stbl->stco->entryCount < 2)
sl@0	1528	return MP4_OK;
sl@0	1529
sl@0	1530	if (getChunkOffset(handle->moov->trakAudio->mdia->minf->stbl, 0) <
sl@0	1531	getChunkOffset(handle->moov->trakAudio->mdia->minf->stbl, 1))
sl@0	1532	return MP4_OK;
sl@0	1533
sl@0	1534	return MP4_NOT_STREAMABLE;
sl@0	1535	}
sl@0	1536
sl@0	1537	/* There is video, but no audio */
sl@0	1538
sl@0	1539	if (handle->videoSampleNum && !handle->audioSampleNum)
sl@0	1540	{
sl@0	1541	if (!handle->moov)
sl@0	1542	return MP4_ERROR;
sl@0	1543
sl@0	1544	if (!handle->moov->trakVideo)
sl@0	1545	return MP4_ERROR;
sl@0	1546
sl@0	1547	if (!handle->moov->trakVideo->mdia)
sl@0	1548	return MP4_ERROR;
sl@0	1549
sl@0	1550	if (!handle->moov->trakVideo->mdia->minf)
sl@0	1551	return MP4_ERROR;
sl@0	1552
sl@0	1553	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	1554	return MP4_ERROR;
sl@0	1555
sl@0	1556	if (!handle->moov->trakVideo->mdia->minf->stbl->stco)
sl@0	1557	return MP4_ERROR;
sl@0	1558
sl@0	1559	if (handle->moov->trakVideo->mdia->minf->stbl->stco->entryCount < 2)
sl@0	1560	return MP4_OK;
sl@0	1561
sl@0	1562	if (getChunkOffset(handle->moov->trakVideo->mdia->minf->stbl, 0) <
sl@0	1563	getChunkOffset(handle->moov->trakVideo->mdia->minf->stbl, 1))
sl@0	1564	return MP4_OK;
sl@0	1565
sl@0	1566	return MP4_NOT_STREAMABLE;
sl@0	1567	}
sl@0	1568
sl@0	1569	/* There are both audio and video */
sl@0	1570
sl@0	1571	if (handle->videoSampleNum && handle->audioSampleNum)
sl@0	1572	{
sl@0	1573	mp4_i64 diff;
sl@0	1574
sl@0	1575
sl@0	1576	if (!handle->moov)
sl@0	1577	return MP4_ERROR;
sl@0	1578
sl@0	1579	if (!handle->moov->trakAudio)
sl@0	1580	return MP4_ERROR;
sl@0	1581
sl@0	1582	if (!handle->moov->trakAudio->mdia)
sl@0	1583	return MP4_ERROR;
sl@0	1584
sl@0	1585	if (!handle->moov->trakAudio->mdia->minf)
sl@0	1586	return MP4_ERROR;
sl@0	1587
sl@0	1588	if (!handle->moov->trakAudio->mdia->minf->stbl)
sl@0	1589	return MP4_ERROR;
sl@0	1590
sl@0	1591	if (!handle->moov->trakAudio->mdia->minf->stbl->stco)
sl@0	1592	return MP4_ERROR;
sl@0	1593
sl@0	1594	if (!handle->moov->trakAudio->mdia->minf->stbl->stco->entryCount)
sl@0	1595	return MP4_ERROR;
sl@0	1596
sl@0	1597	if (!handle->moov->trakVideo)
sl@0	1598	return MP4_ERROR;
sl@0	1599
sl@0	1600	if (!handle->moov->trakVideo->mdia)
sl@0	1601	return MP4_ERROR;
sl@0	1602
sl@0	1603	if (!handle->moov->trakVideo->mdia->minf)
sl@0	1604	return MP4_ERROR;
sl@0	1605
sl@0	1606	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	1607	return MP4_ERROR;
sl@0	1608
sl@0	1609	if (!handle->moov->trakVideo->mdia->minf->stbl->stco)
sl@0	1610	return MP4_ERROR;
sl@0	1611
sl@0	1612	if (!handle->moov->trakVideo->mdia->minf->stbl->stco->entryCount)
sl@0	1613	return MP4_ERROR;
sl@0	1614
sl@0	1615	diff = getChunkOffset(handle->moov->trakAudio->mdia->minf->stbl, 0) -
sl@0	1616	getChunkOffset(handle->moov->trakVideo->mdia->minf->stbl, 0);
sl@0	1617
sl@0	1618	/* If the distance between 1st audio and video chunk offsets is larger
sl@0	1619	than 50000, MP4 is not streamable. */
sl@0	1620
sl@0	1621	if (diff < -50000 \|\| diff > 50000)
sl@0	1622	return MP4_NOT_STREAMABLE;
sl@0	1623
sl@0	1624	return MP4_OK;
sl@0	1625	}
sl@0	1626
sl@0	1627	return MP4_OK;
sl@0	1628	}
sl@0	1629
sl@0	1630	extern EXPORT_C MP4Err MP4ParseSeek(MP4Handle apihandle,
sl@0	1631	mp4_u32 position,
sl@0	1632	mp4_u32 *audioPosition,
sl@0	1633	mp4_u32 *videoPosition,
sl@0	1634	mp4_bool keyframe)
sl@0	1635	{
sl@0	1636	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	1637	if (!handle->metaDataComplete)
sl@0	1638	{
sl@0	1639	switch (metaDataAvailable(handle))
sl@0	1640	{
sl@0	1641	case 0:
sl@0	1642	return MP4_NOT_AVAILABLE;
sl@0	1643	case 1:
sl@0	1644	handle->cafError = KErrNone;
sl@0	1645	if (readMetaData(handle) < 0)
sl@0	1646	{
sl@0	1647	// Reading of meta data failed, so free up any allocated memory
sl@0	1648	freeFTYP(handle->ftyp);
sl@0	1649	handle->ftyp = NULL;
sl@0	1650	freeMOOV(handle->moov);
sl@0	1651	handle->moov = NULL;
sl@0	1652
sl@0	1653	if ( handle->cafError != KErrNone )
sl@0	1654	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	1655	return handle->cafError;
sl@0	1656	}
sl@0	1657	else
sl@0	1658	{
sl@0	1659	return MP4_INVALID_INPUT_STREAM;
sl@0	1660	}
sl@0	1661	}
sl@0	1662	handle->metaDataComplete = MP4TRUE;
sl@0	1663	break;
sl@0	1664
sl@0	1665	case -2:
sl@0	1666	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	1667	freeFTYP(handle->ftyp);
sl@0	1668	handle->ftyp = NULL;
sl@0	1669	return MP4_ERROR;
sl@0	1670
sl@0	1671	case -1:
sl@0	1672	default:
sl@0	1673	return MP4_ERROR;
sl@0	1674	}
sl@0	1675	}
sl@0	1676
sl@0	1677	if (!handle->moov)
sl@0	1678	return MP4_ERROR;
sl@0	1679
sl@0	1680	handle->audioLast = MP4FALSE;
sl@0	1681	handle->videoLast = MP4FALSE;
sl@0	1682
sl@0	1683	/* There is no audio nor video */
sl@0	1684
sl@0	1685	if (!handle->audioSampleNum && !handle->videoSampleNum)
sl@0	1686	return MP4_ERROR;
sl@0	1687
sl@0	1688	/* There is only audio */
sl@0	1689
sl@0	1690	if (handle->audioSampleNum && !handle->videoSampleNum)
sl@0	1691	{
sl@0	1692	mp4_u32 audioSample;
sl@0	1693
sl@0	1694	if (!handle->moov->trakAudio)
sl@0	1695	return MP4_ERROR;
sl@0	1696	if (!handle->moov->trakAudio->mdia)
sl@0	1697	return MP4_ERROR;
sl@0	1698
sl@0	1699	if (convertTimeToSample(handle, handle->moov->trakAudio, position, &audioSample) < 0)
sl@0	1700	return MP4_CANT_SEEK;
sl@0	1701
sl@0	1702	if (goToAudioSample(handle, handle->moov->trakAudio, audioSample) < 0)
sl@0	1703	return MP4_ERROR;
sl@0	1704
sl@0	1705	if (convertAudioSampleToTime(handle, handle->moov->trakAudio->mdia, audioPosition, NULL) < 0)
sl@0	1706	return MP4_ERROR;
sl@0	1707
sl@0	1708	if (handle->file)
sl@0	1709	{
sl@0	1710	handle->lastAccessedPosInFile = handle->audioSampleOffset + handle->audioSampleSize - 1;
sl@0	1711	}
sl@0	1712	else
sl@0	1713	{
sl@0	1714	// check if there is enough data in the buffers
sl@0	1715	if (handle->audioSampleOffset + handle->audioSampleSize - 1 > getCumulativeBufferedBytes(handle))
sl@0	1716	{
sl@0	1717	if (handle->LastWriteDataCalled)
sl@0	1718	{
sl@0	1719	// user has indicated that no more data will be available
sl@0	1720	return MP4_CANT_SEEK;
sl@0	1721	}
sl@0	1722	else
sl@0	1723	{
sl@0	1724	// signal to user that more data needed
sl@0	1725	return MP4_NOT_AVAILABLE;
sl@0	1726	}
sl@0	1727	}
sl@0	1728	else if (handle->audioSampleOffset < handle->absPosition)
sl@0	1729	{
sl@0	1730	handle->absPosition = handle->audioSampleOffset;
sl@0	1731	}
sl@0	1732	}
sl@0	1733
sl@0	1734	return MP4_OK;
sl@0	1735	}
sl@0	1736
sl@0	1737	/* There is only video */
sl@0	1738	if (handle->videoSampleNum && !handle->audioSampleNum)
sl@0	1739	{
sl@0	1740	mp4_u32 videoSample;
sl@0	1741	mp4_u32 newVideoSample;
sl@0	1742
sl@0	1743	if (!handle->moov->trakVideo)
sl@0	1744	return MP4_ERROR;
sl@0	1745	if (!handle->moov->trakVideo->mdia)
sl@0	1746	return MP4_ERROR;
sl@0	1747
sl@0	1748	if (convertTimeToSample(handle, handle->moov->trakVideo, position, &videoSample) < 0)
sl@0	1749	return MP4_CANT_SEEK;
sl@0	1750
sl@0	1751	if (keyframe)
sl@0	1752	{
sl@0	1753	if (findVideoKeyFrame(handle, handle->moov->trakVideo, videoSample, &newVideoSample) < 0)
sl@0	1754	{
sl@0	1755	return MP4_CANT_SEEK;
sl@0	1756	}
sl@0	1757	videoSample = newVideoSample;
sl@0	1758	}
sl@0	1759
sl@0	1760	if (goToVideoSample(handle, handle->moov->trakVideo, videoSample) < 0)
sl@0	1761	{
sl@0	1762	return MP4_ERROR;
sl@0	1763	}
sl@0	1764
sl@0	1765	if (convertVideoSampleToTime(handle, handle->moov->trakVideo->mdia, videoPosition, NULL) < 0)
sl@0	1766	{
sl@0	1767	return MP4_ERROR;
sl@0	1768	}
sl@0	1769
sl@0	1770	if (handle->file)
sl@0	1771	{
sl@0	1772	handle->lastAccessedPosInFile = handle->videoFrameOffset + handle->videoFrameSize - 1;
sl@0	1773	}
sl@0	1774	else // input is a stream
sl@0	1775	{
sl@0	1776	// check if there is enough data in the buffers
sl@0	1777	if (handle->videoFrameOffset + handle->videoFrameSize > getCumulativeBufferedBytes(handle))
sl@0	1778	{
sl@0	1779	if (handle->LastWriteDataCalled)
sl@0	1780	{
sl@0	1781	// user has indicated that no more data will be available
sl@0	1782	return MP4_CANT_SEEK;
sl@0	1783	}
sl@0	1784	else
sl@0	1785	{
sl@0	1786	// signal to user that more data needed
sl@0	1787	return MP4_NOT_AVAILABLE;
sl@0	1788	}
sl@0	1789	}
sl@0	1790	else
sl@0	1791	{
sl@0	1792	handle->absPosition = handle->videoFrameOffset;
sl@0	1793	}
sl@0	1794	}
sl@0	1795
sl@0	1796	return MP4_OK;
sl@0	1797	}
sl@0	1798
sl@0	1799	/* There is audio and video */
sl@0	1800
sl@0	1801	if (handle->videoSampleNum && handle->audioSampleNum)
sl@0	1802	{
sl@0	1803	mp4_u32 audioSample;
sl@0	1804	mp4_u32 videoSample;
sl@0	1805	mp4_u32 newVideoSample;
sl@0	1806
sl@0	1807
sl@0	1808	if (!handle->moov->trakAudio)
sl@0	1809	return MP4_ERROR;
sl@0	1810	if (!handle->moov->trakAudio->mdia)
sl@0	1811	return MP4_ERROR;
sl@0	1812	if (!handle->moov->trakVideo)
sl@0	1813	return MP4_ERROR;
sl@0	1814	if (!handle->moov->trakVideo->mdia)
sl@0	1815	return MP4_ERROR;
sl@0	1816
sl@0	1817	if (convertTimeToSample(handle, handle->moov->trakVideo, position, &videoSample) < 0)
sl@0	1818	return MP4_CANT_SEEK;
sl@0	1819
sl@0	1820	if (keyframe)
sl@0	1821	{
sl@0	1822	if (findVideoKeyFrame(handle, handle->moov->trakVideo, videoSample, &newVideoSample) < 0)
sl@0	1823	return MP4_CANT_SEEK;
sl@0	1824
sl@0	1825	videoSample = newVideoSample;
sl@0	1826	}
sl@0	1827
sl@0	1828	if (goToVideoSample(handle, handle->moov->trakVideo, videoSample) < 0)
sl@0	1829	return MP4_ERROR;
sl@0	1830
sl@0	1831	if (convertVideoSampleToTime(handle, handle->moov->trakVideo->mdia, videoPosition, NULL) < 0)
sl@0	1832	return MP4_ERROR;
sl@0	1833
sl@0	1834	if (handle->file)
sl@0	1835	{
sl@0	1836	handle->lastAccessedPosInFile = handle->videoFrameOffset + handle->videoFrameSize - 1;
sl@0	1837	}
sl@0	1838	else // input is a stream
sl@0	1839	{
sl@0	1840	// check if there is enough data in the buffers
sl@0	1841	if (handle->videoFrameOffset + handle->videoFrameSize > getCumulativeBufferedBytes(handle))
sl@0	1842	{
sl@0	1843	if (handle->LastWriteDataCalled)
sl@0	1844	{
sl@0	1845	// user has indicated that no more data will be available
sl@0	1846	return MP4_CANT_SEEK;
sl@0	1847	}
sl@0	1848	else
sl@0	1849	{
sl@0	1850	// signal to user that more data needed
sl@0	1851	return MP4_NOT_AVAILABLE;
sl@0	1852	}
sl@0	1853	}
sl@0	1854	else
sl@0	1855	{
sl@0	1856	handle->absPosition = handle->videoFrameOffset;
sl@0	1857	}
sl@0	1858	}
sl@0	1859
sl@0	1860	/* Audio */
sl@0	1861
sl@0	1862	if (convertTimeToSample(handle, handle->moov->trakAudio, *videoPosition, &audioSample) < 0)
sl@0	1863	return MP4_CANT_SEEK;
sl@0	1864
sl@0	1865	if (goToAudioSample(handle, handle->moov->trakAudio, audioSample) < 0)
sl@0	1866	return MP4_ERROR;
sl@0	1867
sl@0	1868	if (convertAudioSampleToTime(handle, handle->moov->trakAudio->mdia, audioPosition, NULL) < 0)
sl@0	1869	return MP4_ERROR;
sl@0	1870
sl@0	1871	if (handle->file)
sl@0	1872	{
sl@0	1873	if (handle->audioSampleOffset + handle->audioSampleSize - 1 > handle->lastAccessedPosInFile)
sl@0	1874	{
sl@0	1875	handle->lastAccessedPosInFile = handle->audioSampleOffset + handle->audioSampleSize - 1;
sl@0	1876	}
sl@0	1877	}
sl@0	1878	else // input is a stream
sl@0	1879	{
sl@0	1880	// check if there is enough data in the buffers
sl@0	1881	if (handle->audioSampleOffset + handle->audioSampleSize - 1 > getCumulativeBufferedBytes(handle))
sl@0	1882	{
sl@0	1883	if (handle->LastWriteDataCalled)
sl@0	1884	{
sl@0	1885	// user has indicated that no more data will be available
sl@0	1886	return MP4_CANT_SEEK;
sl@0	1887	}
sl@0	1888	else
sl@0	1889	{
sl@0	1890	// signal to user that more data needed
sl@0	1891	return MP4_NOT_AVAILABLE;
sl@0	1892	}
sl@0	1893	}
sl@0	1894	else if (handle->audioSampleOffset < handle->absPosition)
sl@0	1895	{
sl@0	1896	handle->absPosition = handle->audioSampleOffset;
sl@0	1897	}
sl@0	1898	}
sl@0	1899
sl@0	1900	return MP4_OK;
sl@0	1901	}
sl@0	1902
sl@0	1903	return MP4_OK;
sl@0	1904	}
sl@0	1905
sl@0	1906	extern EXPORT_C MP4Err MP4ParseIsFrameAvailable(MP4Handle apihandle,
sl@0	1907	mp4_u32 type)
sl@0	1908	{
sl@0	1909	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	1910	if (!handle->metaDataComplete)
sl@0	1911	{
sl@0	1912	switch (metaDataAvailable(handle))
sl@0	1913	{
sl@0	1914	case 0:
sl@0	1915	return MP4_NOT_AVAILABLE;
sl@0	1916	case 1:
sl@0	1917	handle->cafError = KErrNone;
sl@0	1918	if (readMetaData(handle) < 0)
sl@0	1919	{
sl@0	1920	// Reading of meta data failed, so free up any allocated memory
sl@0	1921	freeFTYP(handle->ftyp);
sl@0	1922	handle->ftyp = NULL;
sl@0	1923	freeMOOV(handle->moov);
sl@0	1924	handle->moov = NULL;
sl@0	1925
sl@0	1926	if ( handle->cafError != KErrNone )
sl@0	1927	{
sl@0	1928	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	1929
sl@0	1930	return handle->cafError;
sl@0	1931	}
sl@0	1932	else
sl@0	1933	{
sl@0	1934	return MP4_INVALID_INPUT_STREAM;
sl@0	1935	}
sl@0	1936	}
sl@0	1937	handle->metaDataComplete = MP4TRUE;
sl@0	1938	break;
sl@0	1939
sl@0	1940	case -2:
sl@0	1941	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	1942	freeFTYP(handle->ftyp);
sl@0	1943	handle->ftyp = NULL;
sl@0	1944	return MP4_ERROR;
sl@0	1945
sl@0	1946	case -1:
sl@0	1947	default:
sl@0	1948	return MP4_ERROR;
sl@0	1949	}
sl@0	1950	}
sl@0	1951
sl@0	1952	switch (type & handle->type)
sl@0	1953	{
sl@0	1954	case MP4_TYPE_MPEG4_VIDEO:
sl@0	1955	case MP4_TYPE_H263_PROFILE_0:
sl@0	1956	case MP4_TYPE_H263_PROFILE_3:
sl@0	1957	case MP4_TYPE_AVC_PROFILE_BASELINE:
sl@0	1958	case MP4_TYPE_AVC_PROFILE_MAIN:
sl@0	1959	case MP4_TYPE_AVC_PROFILE_EXTENDED:
sl@0	1960	case MP4_TYPE_AVC_PROFILE_HIGH:
sl@0	1961
sl@0	1962	/* There is no frame available if last sample has been reached */
sl@0	1963
sl@0	1964	if (handle->videoLast)
sl@0	1965	return MP4_NO_REQUESTED_FRAME;
sl@0	1966
sl@0	1967	/* Input in a file => it is available */
sl@0	1968
sl@0	1969	if (handle->file)
sl@0	1970	return MP4_OK;
sl@0	1971
sl@0	1972	/* If frame has been buffered, it is available */
sl@0	1973
sl@0	1974	if (handle->videoFrameOffset + handle->videoFrameSize <=
sl@0	1975	getCumulativeBufferedBytes(handle))
sl@0	1976	return MP4_OK;
sl@0	1977	else
sl@0	1978	return MP4_NOT_AVAILABLE;
sl@0	1979
sl@0	1980	case MP4_TYPE_MPEG4_AUDIO:
sl@0	1981	case MP4_TYPE_AMR_NB:
sl@0	1982	case MP4_TYPE_AMR_WB:
sl@0	1983	case MP4_TYPE_QCELP_13K:
sl@0	1984
sl@0	1985	/* There is no frame available if last sample has been reached */
sl@0	1986
sl@0	1987	if (handle->audioLast)
sl@0	1988	return MP4_NO_REQUESTED_FRAME;
sl@0	1989
sl@0	1990	/* Input in a file => it is available */
sl@0	1991
sl@0	1992	if (handle->file)
sl@0	1993	return MP4_OK;
sl@0	1994
sl@0	1995	/* If frame has been buffered, it is available */
sl@0	1996
sl@0	1997	if (handle->audioSampleOffset + handle->audioSampleSize <=
sl@0	1998	getCumulativeBufferedBytes(handle))
sl@0	1999	return MP4_OK;
sl@0	2000	else
sl@0	2001	return MP4_NOT_AVAILABLE;
sl@0	2002
sl@0	2003	case MP4_TYPE_NONE:
sl@0	2004	default:
sl@0	2005
sl@0	2006	return MP4_NO_REQUESTED_FRAME;
sl@0	2007	}
sl@0	2008	}
sl@0	2009
sl@0	2010	extern EXPORT_C MP4Err MP4ParseGetLastPosition(MP4Handle apihandle,
sl@0	2011	mp4_u32 *position)
sl@0	2012	{
sl@0	2013	return MP4ParseGetLastPosition64(apihandle, (mp4_u64 *)position);
sl@0	2014	}
sl@0	2015
sl@0	2016	extern EXPORT_C MP4Err MP4ParseGetLastPosition64(MP4Handle apihandle,
sl@0	2017	mp4_u64 *position)
sl@0	2018	{
sl@0	2019	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2020	if (!handle->file)
sl@0	2021	{
sl@0	2022	*position = handle->absPosition; // return the latest accessed absolute byte location of the stream.
sl@0	2023	return MP4_OK;
sl@0	2024	}
sl@0	2025	*position = handle->lastAccessedPosInFile;
sl@0	2026
sl@0	2027	return MP4_OK;
sl@0	2028	}
sl@0	2029
sl@0	2030	extern EXPORT_C MP4Err MP4ParseGetNumberOfVideoFrames(MP4Handle apihandle,
sl@0	2031	mp4_u32 *numberOfFrames)
sl@0	2032	{
sl@0	2033	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2034	if (!handle->metaDataComplete)
sl@0	2035	{
sl@0	2036	switch (metaDataAvailable(handle))
sl@0	2037	{
sl@0	2038	case 0:
sl@0	2039	return MP4_NOT_AVAILABLE;
sl@0	2040	case 1:
sl@0	2041	handle->cafError = KErrNone;
sl@0	2042	if (readMetaData(handle) < 0)
sl@0	2043	{
sl@0	2044	// Reading of meta data failed, so free up any allocated memory
sl@0	2045	freeFTYP(handle->ftyp);
sl@0	2046	handle->ftyp = NULL;
sl@0	2047	freeMOOV(handle->moov);
sl@0	2048	handle->moov = NULL;
sl@0	2049
sl@0	2050	if ( handle->cafError != KErrNone )
sl@0	2051	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2052	return handle->cafError;
sl@0	2053	}
sl@0	2054	else
sl@0	2055	{
sl@0	2056	return MP4_INVALID_INPUT_STREAM;
sl@0	2057	}
sl@0	2058	}
sl@0	2059	handle->metaDataComplete = MP4TRUE;
sl@0	2060	break;
sl@0	2061
sl@0	2062	case -2:
sl@0	2063	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2064	freeFTYP(handle->ftyp);
sl@0	2065	handle->ftyp = NULL;
sl@0	2066	return MP4_ERROR;
sl@0	2067
sl@0	2068	case -1:
sl@0	2069	default:
sl@0	2070	return MP4_ERROR;
sl@0	2071	}
sl@0	2072	}
sl@0	2073
sl@0	2074	if (!handle->moov)
sl@0	2075	return MP4_ERROR;
sl@0	2076
sl@0	2077	if (handle->moov->trakVideo)
sl@0	2078	{
sl@0	2079	if (!handle->moov->trakVideo->mdia)
sl@0	2080	return MP4_ERROR;
sl@0	2081
sl@0	2082	if (!handle->moov->trakVideo->mdia->minf)
sl@0	2083	return MP4_ERROR;
sl@0	2084
sl@0	2085	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	2086	return MP4_ERROR;
sl@0	2087
sl@0	2088	if (!handle->moov->trakVideo->mdia->minf->stbl->stsz)
sl@0	2089	return MP4_ERROR;
sl@0	2090	}
sl@0	2091	else
sl@0	2092	{
sl@0	2093	return MP4_ERROR;
sl@0	2094	}
sl@0	2095
sl@0	2096	*numberOfFrames = handle->moov->trakVideo->mdia->minf->stbl->stsz->sampleCount;
sl@0	2097	return MP4_OK;
sl@0	2098	}
sl@0	2099
sl@0	2100	extern EXPORT_C MP4Err MP4ParseGetVideoFrameSize(MP4Handle apihandle,
sl@0	2101	mp4_u32 index,
sl@0	2102	mp4_u32 *frameSize)
sl@0	2103	{
sl@0	2104	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2105	if (!handle->metaDataComplete)
sl@0	2106	{
sl@0	2107	switch (metaDataAvailable(handle))
sl@0	2108	{
sl@0	2109	case 0:
sl@0	2110	return MP4_NOT_AVAILABLE;
sl@0	2111	case 1:
sl@0	2112	handle->cafError = KErrNone;
sl@0	2113	if (readMetaData(handle) < 0)
sl@0	2114	{
sl@0	2115	// Reading of meta data failed, so free up any allocated memory
sl@0	2116	freeFTYP(handle->ftyp);
sl@0	2117	handle->ftyp = NULL;
sl@0	2118	freeMOOV(handle->moov);
sl@0	2119	handle->moov = NULL;
sl@0	2120
sl@0	2121	if ( handle->cafError != KErrNone )
sl@0	2122	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2123	return handle->cafError;
sl@0	2124	}
sl@0	2125	else
sl@0	2126	{
sl@0	2127	return MP4_INVALID_INPUT_STREAM;
sl@0	2128	}
sl@0	2129	}
sl@0	2130	handle->metaDataComplete = MP4TRUE;
sl@0	2131	break;
sl@0	2132
sl@0	2133	case -2:
sl@0	2134	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2135	freeFTYP(handle->ftyp);
sl@0	2136	handle->ftyp = NULL;
sl@0	2137	return MP4_ERROR;
sl@0	2138
sl@0	2139	case -1:
sl@0	2140	default:
sl@0	2141	return MP4_ERROR;
sl@0	2142	}
sl@0	2143	}
sl@0	2144
sl@0	2145	if (!handle->moov)
sl@0	2146	return MP4_ERROR;
sl@0	2147
sl@0	2148	if (handle->moov->trakVideo)
sl@0	2149	{
sl@0	2150	if (!handle->moov->trakVideo->mdia)
sl@0	2151	return MP4_ERROR;
sl@0	2152
sl@0	2153	if (!handle->moov->trakVideo->mdia->minf)
sl@0	2154	return MP4_ERROR;
sl@0	2155
sl@0	2156	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	2157	return MP4_ERROR;
sl@0	2158
sl@0	2159	if (!handle->moov->trakVideo->mdia->minf->stbl->stsz)
sl@0	2160	return MP4_ERROR;
sl@0	2161
sl@0	2162	// ensure the index entered is within bound
sl@0	2163	if (index >= handle->moov->trakVideo->mdia->minf->stbl->stsz->sampleCount)
sl@0	2164	return MP4_ERROR;
sl@0	2165	}
sl@0	2166	else
sl@0	2167	{
sl@0	2168	return MP4_ERROR;
sl@0	2169	}
sl@0	2170
sl@0	2171	*frameSize = handle->moov->trakVideo->mdia->minf->stbl->stsz->entrySize[index];
sl@0	2172	return MP4_OK;
sl@0	2173	}
sl@0	2174
sl@0	2175	extern EXPORT_C MP4Err MP4ParseGetVideoFrameStartTime(MP4Handle apihandle,
sl@0	2176	mp4_u32 index,
sl@0	2177	mp4_u32 *timestamp,
sl@0	2178	mp4_u32 *timestampms)
sl@0	2179	{
sl@0	2180	mp4_u32 tmptime=0;
sl@0	2181	mp4_u32 sample=0;
sl@0	2182	mp4_u32 entry=0;
sl@0	2183	mp4_u32 videoSampleNumber = index+1;
sl@0	2184
sl@0	2185	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2186	if (!handle->metaDataComplete)
sl@0	2187	{
sl@0	2188	switch (metaDataAvailable(handle))
sl@0	2189	{
sl@0	2190	case 0:
sl@0	2191	return MP4_NOT_AVAILABLE;
sl@0	2192	case 1:
sl@0	2193	handle->cafError = KErrNone;
sl@0	2194	if (readMetaData(handle) < 0)
sl@0	2195	{
sl@0	2196	// Reading of meta data failed, so free up any allocated memory
sl@0	2197	freeFTYP(handle->ftyp);
sl@0	2198	handle->ftyp = NULL;
sl@0	2199	freeMOOV(handle->moov);
sl@0	2200	handle->moov = NULL;
sl@0	2201
sl@0	2202	if ( handle->cafError != KErrNone )
sl@0	2203	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2204	return handle->cafError;
sl@0	2205	}
sl@0	2206	else
sl@0	2207	{
sl@0	2208	return MP4_INVALID_INPUT_STREAM;
sl@0	2209	}
sl@0	2210	}
sl@0	2211	handle->metaDataComplete = MP4TRUE;
sl@0	2212	break;
sl@0	2213
sl@0	2214	case -2:
sl@0	2215	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2216	freeFTYP(handle->ftyp);
sl@0	2217	handle->ftyp = NULL;
sl@0	2218	return MP4_ERROR;
sl@0	2219
sl@0	2220	case -1:
sl@0	2221	default:
sl@0	2222	return MP4_ERROR;
sl@0	2223	}
sl@0	2224	}
sl@0	2225
sl@0	2226	if (!handle->moov)
sl@0	2227	{
sl@0	2228	return MP4_ERROR;
sl@0	2229	}
sl@0	2230
sl@0	2231	if (handle->moov->trakVideo)
sl@0	2232	{
sl@0	2233	if (!handle->moov->trakVideo->mdia)
sl@0	2234	return MP4_ERROR;
sl@0	2235
sl@0	2236	if (!handle->moov->trakVideo->mdia->minf)
sl@0	2237	return MP4_ERROR;
sl@0	2238
sl@0	2239	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	2240	return MP4_ERROR;
sl@0	2241
sl@0	2242	if (!handle->moov->trakVideo->mdia->minf->stbl->stts)
sl@0	2243	return MP4_ERROR;
sl@0	2244	}
sl@0	2245	else
sl@0	2246	{
sl@0	2247	return MP4_ERROR;
sl@0	2248	}
sl@0	2249
sl@0	2250	for (;;)
sl@0	2251	{
sl@0	2252	if (sample + handle->moov->trakVideo->mdia->minf->stbl->stts->sampleCount[entry] < videoSampleNumber)
sl@0	2253	{
sl@0	2254	sample += handle->moov->trakVideo->mdia->minf->stbl->stts->sampleCount[entry];
sl@0	2255	tmptime += (handle->moov->trakVideo->mdia->minf->stbl->stts->sampleCount[entry] *
sl@0	2256	handle->moov->trakVideo->mdia->minf->stbl->stts->sampleDelta[entry]);
sl@0	2257	entry++;
sl@0	2258	if (entry == handle->moov->trakVideo->mdia->minf->stbl->stts->entryCount)
sl@0	2259	return MP4_ERROR;
sl@0	2260	}
sl@0	2261	else
sl@0	2262	{
sl@0	2263	tmptime += ((videoSampleNumber - sample - 1) * handle->moov->trakVideo->mdia->minf->stbl->stts->sampleDelta[entry]);
sl@0	2264	break;
sl@0	2265	}
sl@0	2266	}
sl@0	2267	if (handle->moov->trakVideo->mdia->mdhd->timeScale == 0)
sl@0	2268	{
sl@0	2269	return MP4_ERROR;
sl@0	2270	}
sl@0	2271
sl@0	2272	*timestamp = tmptime;
sl@0	2273
sl@0	2274	timestampms =(mp4_u32)((mp4_double)tmptime (mp4_double)1000 /
sl@0	2275	(mp4_double)handle->moov->trakVideo->mdia->mdhd->timeScale + (mp4_double)0.5);
sl@0	2276
sl@0	2277	return MP4_OK;
sl@0	2278	}
sl@0	2279
sl@0	2280	extern EXPORT_C MP4Err MP4ParseGetVideoFrameType(MP4Handle apihandle,
sl@0	2281	mp4_u32 index,
sl@0	2282	mp4_bool *frametype)
sl@0	2283	{
sl@0	2284	mp4_u32 i;
sl@0	2285	mp4_u32 videoSampleNumber = index+1;
sl@0	2286	mp4_bool keyFrame = MP4FALSE;
sl@0	2287
sl@0	2288	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2289	if (!handle->metaDataComplete)
sl@0	2290	{
sl@0	2291	switch (metaDataAvailable(handle))
sl@0	2292	{
sl@0	2293	case 0:
sl@0	2294	return MP4_NOT_AVAILABLE;
sl@0	2295	case 1:
sl@0	2296	handle->cafError = KErrNone;
sl@0	2297	if (readMetaData(handle) < 0)
sl@0	2298	{
sl@0	2299	// Reading of meta data failed, so free up any allocated memory
sl@0	2300	freeFTYP(handle->ftyp);
sl@0	2301	handle->ftyp = NULL;
sl@0	2302	freeMOOV(handle->moov);
sl@0	2303	handle->moov = NULL;
sl@0	2304
sl@0	2305	if ( handle->cafError != KErrNone )
sl@0	2306	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2307	return handle->cafError;
sl@0	2308	}
sl@0	2309	else
sl@0	2310	{
sl@0	2311	return MP4_INVALID_INPUT_STREAM;
sl@0	2312	}
sl@0	2313	}
sl@0	2314	handle->metaDataComplete = MP4TRUE;
sl@0	2315	break;
sl@0	2316
sl@0	2317	case -2:
sl@0	2318	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2319	freeFTYP(handle->ftyp);
sl@0	2320	handle->ftyp = NULL;
sl@0	2321	return MP4_ERROR;
sl@0	2322
sl@0	2323	case -1:
sl@0	2324	default:
sl@0	2325	return MP4_ERROR;
sl@0	2326	}
sl@0	2327	}
sl@0	2328
sl@0	2329	if (!handle->moov)
sl@0	2330	return MP4_ERROR;
sl@0	2331
sl@0	2332	if (handle->moov->trakVideo)
sl@0	2333	{
sl@0	2334	if (!handle->moov->trakVideo->mdia)
sl@0	2335	return MP4_ERROR;
sl@0	2336
sl@0	2337	if (!handle->moov->trakVideo->mdia->minf)
sl@0	2338	return MP4_ERROR;
sl@0	2339
sl@0	2340	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	2341	return MP4_ERROR;
sl@0	2342
sl@0	2343	if (!handle->moov->trakVideo->mdia->minf->stbl->stss)
sl@0	2344	return MP4_ERROR;
sl@0	2345
sl@0	2346	// if the video frame index is out of bounds
sl@0	2347	if (!handle->moov->trakVideo->mdia->minf->stbl->stsz \|\|
sl@0	2348	videoSampleNumber > handle->moov->trakVideo->mdia->minf->stbl->stsz->sampleCount)
sl@0	2349	return MP4_ERROR;
sl@0	2350	}
sl@0	2351	else
sl@0	2352	{
sl@0	2353	return MP4_ERROR;
sl@0	2354	}
sl@0	2355
sl@0	2356	for (i=0; i < handle->moov->trakVideo->mdia->minf->stbl->stss->entryCount; i++)
sl@0	2357	{
sl@0	2358	if (handle->moov->trakVideo->mdia->minf->stbl->stss->sampleNumber[i] == videoSampleNumber)
sl@0	2359	{
sl@0	2360	keyFrame = MP4TRUE;
sl@0	2361	break;
sl@0	2362	}
sl@0	2363	}
sl@0	2364
sl@0	2365	*frametype = keyFrame;
sl@0	2366	return MP4_OK;
sl@0	2367	}
sl@0	2368
sl@0	2369	extern EXPORT_C MP4Err MP4ParseGetVideoSampleEntryIndex(MP4Handle apihandle, mp4_u32 *videosampleentryindex)
sl@0	2370	{
sl@0	2371	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2372	if (!handle->metaDataComplete)
sl@0	2373	{
sl@0	2374	switch (metaDataAvailable(handle))
sl@0	2375	{
sl@0	2376	case 0:
sl@0	2377	return MP4_NOT_AVAILABLE;
sl@0	2378	case 1:
sl@0	2379	handle->cafError = KErrNone;
sl@0	2380	if (readMetaData(handle) < 0)
sl@0	2381	{
sl@0	2382	// Reading of meta data failed, so free up any allocated memory
sl@0	2383	freeFTYP(handle->ftyp);
sl@0	2384	handle->ftyp = NULL;
sl@0	2385	freeMOOV(handle->moov);
sl@0	2386	handle->moov = NULL;
sl@0	2387
sl@0	2388	if ( handle->cafError != KErrNone )
sl@0	2389	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2390	return handle->cafError;
sl@0	2391	}
sl@0	2392	else
sl@0	2393	{
sl@0	2394	return MP4_INVALID_INPUT_STREAM;
sl@0	2395	}
sl@0	2396	}
sl@0	2397	handle->metaDataComplete = MP4TRUE;
sl@0	2398	break;
sl@0	2399
sl@0	2400	case -2:
sl@0	2401	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2402	freeFTYP(handle->ftyp);
sl@0	2403	handle->ftyp = NULL;
sl@0	2404	return MP4_ERROR;
sl@0	2405
sl@0	2406	case -1:
sl@0	2407	default:
sl@0	2408	return MP4_ERROR;
sl@0	2409	}
sl@0	2410	}
sl@0	2411
sl@0	2412	if (!handle->moov->trakVideo)
sl@0	2413	return MP4_ERROR;
sl@0	2414	if (!handle->moov->trakVideo->mdia)
sl@0	2415	return MP4_ERROR;
sl@0	2416
sl@0	2417	if (handle->videoSampleEntryIndex == 0) /* can't be zero. Sample Entry index must be at least 1*/
sl@0	2418	return MP4_ERROR;
sl@0	2419	else
sl@0	2420	*videosampleentryindex = handle->videoSampleEntryIndex;
sl@0	2421
sl@0	2422	return MP4_OK;
sl@0	2423	}
sl@0	2424
sl@0	2425	extern EXPORT_C MP4Err MP4ParseGetAudioSampleEntryIndex(MP4Handle apihandle, mp4_u32 *audiosampleentryindex)
sl@0	2426	{
sl@0	2427	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2428	if (!handle->metaDataComplete)
sl@0	2429	{
sl@0	2430	switch (metaDataAvailable(handle))
sl@0	2431	{
sl@0	2432	case 0:
sl@0	2433	return MP4_NOT_AVAILABLE;
sl@0	2434	case 1:
sl@0	2435	handle->cafError = KErrNone;
sl@0	2436	if (readMetaData(handle) < 0)
sl@0	2437	{
sl@0	2438	// Reading of meta data failed, so free up any allocated memory
sl@0	2439	freeFTYP(handle->ftyp);
sl@0	2440	handle->ftyp = NULL;
sl@0	2441	freeMOOV(handle->moov);
sl@0	2442	handle->moov = NULL;
sl@0	2443
sl@0	2444	if ( handle->cafError != KErrNone )
sl@0	2445	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2446	return handle->cafError;
sl@0	2447	}
sl@0	2448	else
sl@0	2449	{
sl@0	2450	return MP4_INVALID_INPUT_STREAM;
sl@0	2451	}
sl@0	2452	}
sl@0	2453	handle->metaDataComplete = MP4TRUE;
sl@0	2454	break;
sl@0	2455
sl@0	2456	case -2:
sl@0	2457	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2458	freeFTYP(handle->ftyp);
sl@0	2459	handle->ftyp = NULL;
sl@0	2460	return MP4_ERROR;
sl@0	2461
sl@0	2462	case -1:
sl@0	2463	default:
sl@0	2464	return MP4_ERROR;
sl@0	2465	}
sl@0	2466	}
sl@0	2467
sl@0	2468	if (!handle->moov->trakAudio)
sl@0	2469	return MP4_ERROR;
sl@0	2470	if (!handle->moov->trakAudio->mdia)
sl@0	2471	return MP4_ERROR;
sl@0	2472
sl@0	2473	if (handle->audioSampleEntryIndex == 0) /* can't be zero. Sample Entry index must be at least 1*/
sl@0	2474	return MP4_ERROR;
sl@0	2475	else
sl@0	2476	*audiosampleentryindex = handle->audioSampleEntryIndex;
sl@0	2477
sl@0	2478	return MP4_OK;
sl@0	2479	}
sl@0	2480
sl@0	2481	extern EXPORT_C MP4Err MP4ParseGetQCELPStorageMode(MP4Handle apihandle, mp4_u8 *qcelpStorageMode)
sl@0	2482	{
sl@0	2483	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2484	if (!handle->metaDataComplete)
sl@0	2485	{
sl@0	2486	switch (metaDataAvailable(handle))
sl@0	2487	{
sl@0	2488	case 0:
sl@0	2489	return MP4_NOT_AVAILABLE;
sl@0	2490	case 1:
sl@0	2491	handle->cafError = KErrNone;
sl@0	2492	if (readMetaData(handle) < 0)
sl@0	2493	{
sl@0	2494	// Reading of meta data failed, so free up any allocated memory
sl@0	2495	freeFTYP(handle->ftyp);
sl@0	2496	handle->ftyp = NULL;
sl@0	2497	freeMOOV(handle->moov);
sl@0	2498	handle->moov = NULL;
sl@0	2499
sl@0	2500	if ( handle->cafError != KErrNone )
sl@0	2501	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2502	return handle->cafError;
sl@0	2503	}
sl@0	2504	else
sl@0	2505	{
sl@0	2506	return MP4_INVALID_INPUT_STREAM;
sl@0	2507	}
sl@0	2508	}
sl@0	2509	handle->metaDataComplete = MP4TRUE;
sl@0	2510	break;
sl@0	2511
sl@0	2512	case -2:
sl@0	2513	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2514	freeFTYP(handle->ftyp);
sl@0	2515	handle->ftyp = NULL;
sl@0	2516	return MP4_ERROR;
sl@0	2517
sl@0	2518	case -1:
sl@0	2519	default:
sl@0	2520	return MP4_ERROR;
sl@0	2521	}
sl@0	2522	}
sl@0	2523
sl@0	2524	if (!handle->moov->trakAudio)
sl@0	2525	return MP4_ERROR;
sl@0	2526	if (!handle->moov->trakAudio->mdia)
sl@0	2527	return MP4_ERROR;
sl@0	2528	if (!(handle->type & MP4_TYPE_QCELP_13K))
sl@0	2529	return MP4_ERROR;
sl@0	2530
sl@0	2531	if(handle->qcelpStoredAsMPEGAudio)
sl@0	2532	*qcelpStorageMode = 1;
sl@0	2533	else
sl@0	2534	*qcelpStorageMode = 0;
sl@0	2535
sl@0	2536	return MP4_OK;
sl@0	2537	}
sl@0	2538
sl@0	2539	extern EXPORT_C MP4Err MP4GetVideoFrameProperties(MP4Handle apihandle,mp4_u32 startindex,mp4_u32 sizeofarray,TFrameInfoParameters* aFrameInfoArray)
sl@0	2540	{
sl@0	2541
sl@0	2542	mp4_u32 tmptime=0;
sl@0	2543	mp4_u32 sample=0;
sl@0	2544	mp4_u32 entry=0;
sl@0	2545	mp4_u32 videoSampleNumber = (startindex+sizeofarray)+1;
sl@0	2546	mp4_u32 i;
sl@0	2547	mp4_u32 j;
sl@0	2548	mp4_u32 index;
sl@0	2549	mp4_u32 actualIndex;
sl@0	2550
sl@0	2551	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2552
sl@0	2553	TBool sampleSyncTableExists = ETrue;
sl@0	2554	if (!handle->metaDataComplete)
sl@0	2555	{
sl@0	2556	switch (metaDataAvailable(handle))
sl@0	2557	{
sl@0	2558	case 0:
sl@0	2559	return MP4_NOT_AVAILABLE;
sl@0	2560	case 1:
sl@0	2561	handle->cafError = KErrNone;
sl@0	2562	if (readMetaData(handle) < 0)
sl@0	2563	{
sl@0	2564	// Reading of meta data failed, so free up any allocated memory
sl@0	2565	freeFTYP(handle->ftyp);
sl@0	2566	handle->ftyp = NULL;
sl@0	2567	freeMOOV(handle->moov);
sl@0	2568	handle->moov = NULL;
sl@0	2569
sl@0	2570	if ( handle->cafError != KErrNone )
sl@0	2571	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2572	return handle->cafError;
sl@0	2573	}
sl@0	2574	else
sl@0	2575	{
sl@0	2576	return MP4_INVALID_INPUT_STREAM;
sl@0	2577	}
sl@0	2578	}
sl@0	2579	handle->metaDataComplete = MP4TRUE;
sl@0	2580	break;
sl@0	2581
sl@0	2582	case -2:
sl@0	2583	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2584	freeFTYP(handle->ftyp);
sl@0	2585	handle->ftyp = NULL;
sl@0	2586	return MP4_ERROR;
sl@0	2587
sl@0	2588	case -1:
sl@0	2589	default:
sl@0	2590	return MP4_ERROR;
sl@0	2591	}
sl@0	2592	}
sl@0	2593
sl@0	2594
sl@0	2595	if (!handle->moov)
sl@0	2596	return MP4_ERROR;
sl@0	2597
sl@0	2598	if (handle->moov->trakVideo)
sl@0	2599	{
sl@0	2600	if (!handle->moov->trakVideo->mdia)
sl@0	2601	return MP4_ERROR;
sl@0	2602
sl@0	2603	if (!handle->moov->trakVideo->mdia->minf)
sl@0	2604	return MP4_ERROR;
sl@0	2605
sl@0	2606	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	2607	return MP4_ERROR;
sl@0	2608
sl@0	2609	if (!handle->moov->trakVideo->mdia->minf->stbl->stsz) //for size
sl@0	2610	return MP4_ERROR;
sl@0	2611
sl@0	2612	if (!handle->moov->trakVideo->mdia->minf->stbl->stss) //for type
sl@0	2613	{
sl@0	2614	// If sample sync table doesn't exist mark all frames as intra / random access point
sl@0	2615	sampleSyncTableExists = EFalse;
sl@0	2616	}
sl@0	2617
sl@0	2618	if (!handle->moov->trakVideo->mdia->minf->stbl->stts) //For timeStamp
sl@0	2619	return MP4_ERROR;
sl@0	2620	}
sl@0	2621	else
sl@0	2622	{
sl@0	2623	return MP4_ERROR;
sl@0	2624	}
sl@0	2625
sl@0	2626
sl@0	2627	if (handle->moov->trakVideo->mdia->mdhd->timeScale == 0) //For timeStamp
sl@0	2628	{
sl@0	2629	return MP4_ERROR;
sl@0	2630	}
sl@0	2631
sl@0	2632	if((startindex+sizeofarray) > handle->moov->trakVideo->mdia->minf->stbl->stsz->sampleCount) //more than number of frames
sl@0	2633	{
sl@0	2634	return MP4_ERROR;
sl@0	2635	}
sl@0	2636
sl@0	2637	if(aFrameInfoArray == NULL)
sl@0	2638	{
sl@0	2639	return MP4_NO_OUTPUT_BUFFER;
sl@0	2640	}
sl@0	2641
sl@0	2642	if ( sampleSyncTableExists )
sl@0	2643	{
sl@0	2644	for (i=0; i < handle->moov->trakVideo->mdia->minf->stbl->stss->entryCount; i++) //set all types to true
sl@0	2645	{
sl@0	2646	//because counting is stored from 1 but index from 0
sl@0	2647	mp4_u32 currFrame = handle->moov->trakVideo->mdia->minf->stbl->stss->sampleNumber[i] - 1;
sl@0	2648
sl@0	2649	if ((currFrame >= startindex) && (currFrame < (startindex + sizeofarray)))
sl@0	2650	{
sl@0	2651	aFrameInfoArray[currFrame - startindex].iType = MP4TRUE;
sl@0	2652	}
sl@0	2653	}
sl@0	2654	}
sl@0	2655
sl@0	2656	index=0; //initialize to beginning
sl@0	2657	actualIndex=0;//array indexer
sl@0	2658
sl@0	2659	for(;;)
sl@0	2660	{
sl@0	2661	if(index< videoSampleNumber)
sl@0	2662	{
sl@0	2663	for(j=0;j<handle->moov->trakVideo->mdia->minf->stbl->stts->sampleCount[entry];j++)
sl@0	2664	{
sl@0	2665	if(index >=startindex)
sl@0	2666	{
sl@0	2667	//first initialize flag to false if not previously set to true.
sl@0	2668	if(aFrameInfoArray[actualIndex].iType != MP4TRUE)
sl@0	2669	{
sl@0	2670	aFrameInfoArray[actualIndex].iType = MP4FALSE;
sl@0	2671	}
sl@0	2672	//aFrameInfoArray[index].iStartTime = tmptime + handle->moov->trakVideo->mdia->minf->stbl->stts->sampleDelta[entry];
sl@0	2673	if(index==0) //so first frame of entire clip
sl@0	2674	{
sl@0	2675	aFrameInfoArray[actualIndex].iStartTime =0;
sl@0	2676	}
sl@0	2677	else
sl@0	2678	{
sl@0	2679	aFrameInfoArray[actualIndex].iStartTime = (mp4_u32)((mp4_double)tmptime * (mp4_double)1000 /
sl@0	2680	(mp4_double)handle->moov->trakVideo->mdia->mdhd->timeScale + (mp4_double)0.5);
sl@0	2681	}
sl@0	2682	aFrameInfoArray[actualIndex].iSize = handle->moov->trakVideo->mdia->minf->stbl->stsz->entrySize[index];
sl@0	2683	// If sample sync table doesn't exist mark all frames as intra / random access point
sl@0	2684	if (!sampleSyncTableExists)
sl@0	2685	{
sl@0	2686	aFrameInfoArray[actualIndex].iType = MP4TRUE;
sl@0	2687	}
sl@0	2688	actualIndex++; //point to next index in array
sl@0	2689	}
sl@0	2690	tmptime += handle->moov->trakVideo->mdia->minf->stbl->stts->sampleDelta[entry];
sl@0	2691	//Now insert size before incrementing index
sl@0	2692	if(index == videoSampleNumber-2)
sl@0	2693	break;
sl@0	2694	index++;
sl@0	2695	}
sl@0	2696	if(index==videoSampleNumber-2)
sl@0	2697	break;
sl@0	2698	sample += handle->moov->trakVideo->mdia->minf->stbl->stts->sampleCount[entry];
sl@0	2699	entry++;
sl@0	2700	}
sl@0	2701	else
sl@0	2702	{
sl@0	2703	break;
sl@0	2704	}
sl@0	2705	}
sl@0	2706	return MP4_OK;
sl@0	2707	}
sl@0	2708
sl@0	2709	extern EXPORT_C MP4Err MP4ParseGetVideoClipProperties(MP4Handle apihandle, TVideoClipProperties& aVideoClipProperties)
sl@0	2710	{
sl@0	2711	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2712	if (!handle)
sl@0	2713	{
sl@0	2714	return MP4_ERROR;
sl@0	2715	}
sl@0	2716
sl@0	2717	if (!handle->metaDataComplete)
sl@0	2718	{
sl@0	2719	switch (metaDataAvailable(handle))
sl@0	2720	{
sl@0	2721	case 0:
sl@0	2722	return MP4_NOT_AVAILABLE;
sl@0	2723	case 1:
sl@0	2724	handle->cafError = KErrNone;
sl@0	2725	if (readMetaData(handle) < 0)
sl@0	2726	{
sl@0	2727	// Reading of meta data failed, so free up any allocated memory
sl@0	2728	freeFTYP(handle->ftyp);
sl@0	2729	handle->ftyp = NULL;
sl@0	2730	freeMOOV(handle->moov);
sl@0	2731	handle->moov = NULL;
sl@0	2732
sl@0	2733	if ( handle->cafError != KErrNone )
sl@0	2734	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2735	return handle->cafError;
sl@0	2736	}
sl@0	2737	else
sl@0	2738	{
sl@0	2739	return MP4_INVALID_INPUT_STREAM;
sl@0	2740	}
sl@0	2741	}
sl@0	2742	handle->metaDataComplete = MP4TRUE;
sl@0	2743	break;
sl@0	2744
sl@0	2745	case -2:
sl@0	2746	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2747	freeFTYP(handle->ftyp);
sl@0	2748	handle->ftyp = NULL;
sl@0	2749	return MP4_ERROR;
sl@0	2750
sl@0	2751	case -1:
sl@0	2752	default:
sl@0	2753	return MP4_ERROR;
sl@0	2754	}
sl@0	2755	}
sl@0	2756
sl@0	2757	if (!handle->moov)
sl@0	2758	return MP4_ERROR;
sl@0	2759	if (!handle->moov->trakVideo)
sl@0	2760	return MP4_ERROR;
sl@0	2761	if (!handle->moov->trakVideo->mdia)
sl@0	2762	return MP4_ERROR;
sl@0	2763	if (!handle->moov->trakVideo->mdia->minf)
sl@0	2764	return MP4_ERROR;
sl@0	2765	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	2766	return MP4_ERROR;
sl@0	2767	if (!handle->moov->trakVideo->mdia->minf->stbl->stsd)
sl@0	2768	return MP4_ERROR;
sl@0	2769
sl@0	2770	/* Assume that the video type is the same for all sample entries. Just get the video type from the first one */
sl@0	2771	if (handle->moov->trakVideo->mdia->minf->stbl->stsd->s263[0])
sl@0	2772	{
sl@0	2773	if (!handle->moov->trakVideo->mdia->minf->stbl->stsd->s263[0]->d263)
sl@0	2774	return MP4_ERROR;
sl@0	2775
sl@0	2776	if (handle->moov->trakVideo->mdia->minf->stbl->stsd->s263[0]->d263->h263Level)
sl@0	2777	{
sl@0	2778	aVideoClipProperties.iH263Level = handle->moov->trakVideo->mdia->minf->stbl->stsd->s263[0]->d263->h263Level;
sl@0	2779	return MP4_OK;
sl@0	2780	}
sl@0	2781	else
sl@0	2782	{
sl@0	2783	return MP4_ERROR;
sl@0	2784	}
sl@0	2785	}
sl@0	2786	else
sl@0	2787	{
sl@0	2788	return MP4_ERROR;
sl@0	2789	}
sl@0	2790	}
sl@0	2791
sl@0	2792	extern EXPORT_C MP4Err MP4ParseGetUserDataAtom(MP4Handle apihandle,
sl@0	2793	mp4_u8& udtaLocation,
sl@0	2794	mp4_u32 udtaAtomType,
sl@0	2795	mp4_u8* buffer,
sl@0	2796	mp4_u32& bufferSize,
sl@0	2797	mp4_u32& atomIndex )
sl@0	2798	{
sl@0	2799	mp4_u32 size = 0;
sl@0	2800	mp4_u64 largesize = 0;
sl@0	2801	mp4_u32 type = 0;
sl@0	2802	mp4_i32 bytesread = 0;
sl@0	2803	mp4_i32 totalbytesread = 0;
sl@0	2804	MP4Err retError = MP4_OK;
sl@0	2805	userDataAtom* udta = NULL;
sl@0	2806	mp4_bool found = MP4FALSE;
sl@0	2807	mp4_u32 foundIndex = 0;
sl@0	2808
sl@0	2809	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	2810
sl@0	2811	if (!handle)
sl@0	2812	{
sl@0	2813	return MP4_ERROR;
sl@0	2814	}
sl@0	2815
sl@0	2816	if (!handle->metaDataComplete)
sl@0	2817	{
sl@0	2818	switch (metaDataAvailable(handle))
sl@0	2819	{
sl@0	2820	case 0:
sl@0	2821	return MP4_NOT_AVAILABLE;
sl@0	2822	case 1:
sl@0	2823	handle->cafError = KErrNone;
sl@0	2824	if (readMetaData(handle) < 0)
sl@0	2825	{
sl@0	2826	// Reading of meta data failed, so free up any allocated memory
sl@0	2827	freeFTYP(handle->ftyp);
sl@0	2828	handle->ftyp = NULL;
sl@0	2829	freeMOOV(handle->moov);
sl@0	2830	handle->moov = NULL;
sl@0	2831
sl@0	2832	if ( handle->cafError != KErrNone )
sl@0	2833	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	2834	return handle->cafError;
sl@0	2835	}
sl@0	2836	else
sl@0	2837	{
sl@0	2838	return MP4_INVALID_INPUT_STREAM;
sl@0	2839	}
sl@0	2840	}
sl@0	2841	handle->metaDataComplete = MP4TRUE;
sl@0	2842	break;
sl@0	2843
sl@0	2844	case -2:
sl@0	2845	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	2846	freeFTYP(handle->ftyp);
sl@0	2847	handle->ftyp = NULL;
sl@0	2848	return MP4_ERROR;
sl@0	2849
sl@0	2850	case -1:
sl@0	2851	default:
sl@0	2852	return MP4_ERROR;
sl@0	2853	}
sl@0	2854	}
sl@0	2855
sl@0	2856	if (!handle->moov)
sl@0	2857	return MP4_ERROR;
sl@0	2858
sl@0	2859	// Check where to read udta from.
sl@0	2860	switch ( udtaLocation )
sl@0	2861	{
sl@0	2862	case MP4_UDTA_NONE:
sl@0	2863	{
sl@0	2864	retError = MP4_UDTA_NOT_FOUND;
sl@0	2865	break;
sl@0	2866	}
sl@0	2867	case MP4_UDTA_MOOV:
sl@0	2868	{
sl@0	2869	if ( !handle->moov->udta )
sl@0	2870	{
sl@0	2871	retError = MP4_UDTA_NOT_FOUND;
sl@0	2872	break;
sl@0	2873	}
sl@0	2874	else
sl@0	2875	{
sl@0	2876	udta = handle->moov->udta;
sl@0	2877	}
sl@0	2878	break;
sl@0	2879	}
sl@0	2880	case MP4_UDTA_VIDEOTRAK:
sl@0	2881	{
sl@0	2882	if ( !handle->moov->trakVideo )
sl@0	2883	{
sl@0	2884	retError = MP4_UDTA_NOT_FOUND;
sl@0	2885	break;
sl@0	2886	}
sl@0	2887	if ( !handle->moov->trakVideo->udta )
sl@0	2888	{
sl@0	2889	retError = MP4_UDTA_NOT_FOUND;
sl@0	2890	}
sl@0	2891	else
sl@0	2892	{
sl@0	2893	udta = handle->moov->trakVideo->udta;
sl@0	2894	}
sl@0	2895	break;
sl@0	2896	}
sl@0	2897	case MP4_UDTA_AUDIOTRAK:
sl@0	2898	{
sl@0	2899	if (!handle->moov->trakAudio)
sl@0	2900	{
sl@0	2901	retError = MP4_UDTA_NOT_FOUND;
sl@0	2902	break;
sl@0	2903	}
sl@0	2904	if ( !handle->moov->trakAudio->udta )
sl@0	2905	{
sl@0	2906	retError = MP4_UDTA_NOT_FOUND;
sl@0	2907	}
sl@0	2908	else
sl@0	2909	{
sl@0	2910	udta = handle->moov->trakAudio->udta;
sl@0	2911	}
sl@0	2912	break;
sl@0	2913	}
sl@0	2914	default:
sl@0	2915	{
sl@0	2916	retError = MP4_INVALID_TYPE;
sl@0	2917	}
sl@0	2918	}
sl@0	2919
sl@0	2920	if ( retError == MP4_OK ) // valid UDTA found.
sl@0	2921	{
sl@0	2922	if ( !udta->atomhdr )
sl@0	2923	{
sl@0	2924	retError = MP4_UDTA_NOT_FOUND;
sl@0	2925	}
sl@0	2926	if ( !udta->atomcontentloc \|\| (udta->atomcontentsize == 0) )
sl@0	2927	{
sl@0	2928	retError = MP4_UDTA_NOT_FOUND;
sl@0	2929	}
sl@0	2930
sl@0	2931	// seek to UDTA atom in memory structure or file.
sl@0	2932	if (handle->file) /* Input is in a file */
sl@0	2933	{
sl@0	2934	if (seekFileAbs(handle, udta->atomcontentloc) != 0)
sl@0	2935	return MP4_CANT_SEEK;
sl@0	2936	}
sl@0	2937	else
sl@0	2938	{
sl@0	2939	handle->absPosition = udta->atomcontentloc;
sl@0	2940	}
sl@0	2941
sl@0	2942	// search for wanted atom from UDTA and read it to buffer
sl@0	2943	while ( totalbytesread < (mp4_i32)udta->atomcontentsize )
sl@0	2944	{
sl@0	2945	if (peekData(handle, handle->buf, 16) < 0)
sl@0	2946	return MP4_ERROR;
sl@0	2947
sl@0	2948	size = u32endian(((mp4_u32 )handle->buf));
sl@0	2949	type = u32endian(((mp4_u32 )(handle->buf+4)));
sl@0	2950
sl@0	2951	if ( type == udtaAtomType )
sl@0	2952	{
sl@0	2953	if ( atomIndex == foundIndex )
sl@0	2954	{
sl@0	2955	if ( size == 1 )
sl@0	2956	{
sl@0	2957	largesize = u64endian(((mp4_u64)(handle->buf+8)));
sl@0	2958	size = (mp4_u32)I64INT(largesize);
sl@0	2959	}
sl@0	2960	if ( size > bufferSize )
sl@0	2961	{
sl@0	2962	// Although the output buffer supplied by the caller is
sl@0	2963	// not large enough to store the sub user atom's content, keep
sl@0	2964	// parsing thru the whole user data to retrieve the highest index
sl@0	2965	// to be returned thru the atomIndex parameter
sl@0	2966	bufferSize = size;
sl@0	2967	retError = MP4_OUTPUT_BUFFER_TOO_SMALL;
sl@0	2968	bytesread = readUnknown(handle);
sl@0	2969	if (bytesread < 0)
sl@0	2970	return MP4_ERROR;
sl@0	2971	}
sl@0	2972	else
sl@0	2973	{
sl@0	2974	bytesread = readData(handle, buffer, size);
sl@0	2975	if (bytesread < 0)
sl@0	2976	return MP4_ERROR;
sl@0	2977	bufferSize = bytesread;
sl@0	2978	}
sl@0	2979
sl@0	2980	totalbytesread += bytesread;
sl@0	2981	foundIndex += 1;
sl@0	2982	found = MP4TRUE;
sl@0	2983	}
sl@0	2984	else
sl@0	2985	{
sl@0	2986	bytesread = readUnknown(handle);
sl@0	2987	if (bytesread < 0)
sl@0	2988	return MP4_ERROR;
sl@0	2989	totalbytesread += bytesread;
sl@0	2990	foundIndex += 1;
sl@0	2991	}
sl@0	2992	}
sl@0	2993	else
sl@0	2994	{
sl@0	2995	bytesread = readUnknown(handle);
sl@0	2996	if (bytesread < 0)
sl@0	2997	return MP4_ERROR;
sl@0	2998	totalbytesread += bytesread;
sl@0	2999	}
sl@0	3000	}
sl@0	3001	}
sl@0	3002
sl@0	3003	if ( ( atomIndex > foundIndex ) \|\| !found )
sl@0	3004	{
sl@0	3005	retError = MP4_UDTA_NOT_FOUND;
sl@0	3006	}
sl@0	3007
sl@0	3008	// fill how many wanted type atom there is in asked UDTA.
sl@0	3009	if ( found )
sl@0	3010	{
sl@0	3011	atomIndex = foundIndex - 1;
sl@0	3012	}
sl@0	3013	else
sl@0	3014	{
sl@0	3015	atomIndex = 0;
sl@0	3016	}
sl@0	3017
sl@0	3018	// fill udtaLocation
sl@0	3019	udtaLocation = MP4_UDTA_NONE;
sl@0	3020
sl@0	3021	if ( handle->moov->udta )
sl@0	3022	{
sl@0	3023	udtaLocation \|= MP4_UDTA_MOOV;
sl@0	3024	}
sl@0	3025	if ( handle->moov->trakVideo )
sl@0	3026	{
sl@0	3027	if ( handle->moov->trakVideo->udta )
sl@0	3028	{
sl@0	3029	udtaLocation \|= MP4_UDTA_VIDEOTRAK;
sl@0	3030	}
sl@0	3031	}
sl@0	3032	if ( handle->moov->trakAudio )
sl@0	3033	{
sl@0	3034	if ( handle->moov->trakAudio->udta )
sl@0	3035	{
sl@0	3036	udtaLocation \|= MP4_UDTA_AUDIOTRAK;
sl@0	3037	}
sl@0	3038	}
sl@0	3039
sl@0	3040	return retError;
sl@0	3041	}
sl@0	3042
sl@0	3043	extern EXPORT_C MP4Err MP4ParseNextVideoFrameDependencies(MP4Handle apihandle, mp4_u8* aDependsOn, mp4_u8* aIsDependentOn, mp4_u8* aHasRedundancy)
sl@0	3044	{
sl@0	3045	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	3046	mp4_u32 type = 0;
sl@0	3047
sl@0	3048	if (!handle)
sl@0	3049	{
sl@0	3050	return MP4_ERROR;
sl@0	3051	}
sl@0	3052	if(!aDependsOn \|\| !aIsDependentOn \|\| !aHasRedundancy)
sl@0	3053	{
sl@0	3054	return MP4_NO_OUTPUT_BUFFER;
sl@0	3055	}
sl@0	3056	if (!handle->metaDataComplete)
sl@0	3057	{
sl@0	3058	switch (metaDataAvailable(handle))
sl@0	3059	{
sl@0	3060	case 0:
sl@0	3061	return MP4_NOT_AVAILABLE;
sl@0	3062
sl@0	3063	case 1:
sl@0	3064	if (readMetaData(handle) < 0)
sl@0	3065	{
sl@0	3066	// Reading of meta data failed, so free up any allocated memory
sl@0	3067	freeFTYP(handle->ftyp);
sl@0	3068	handle->ftyp = NULL;
sl@0	3069	freeMOOV(handle->moov);
sl@0	3070	handle->moov = NULL;
sl@0	3071
sl@0	3072	return MP4_INVALID_INPUT_STREAM;
sl@0	3073	}
sl@0	3074
sl@0	3075	handle->metaDataComplete = MP4TRUE;
sl@0	3076	break;
sl@0	3077
sl@0	3078	case -2:
sl@0	3079	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	3080	freeFTYP(handle->ftyp);
sl@0	3081	handle->ftyp = NULL;
sl@0	3082	return MP4_ERROR;
sl@0	3083
sl@0	3084	case -1:
sl@0	3085	default:
sl@0	3086	return MP4_ERROR;
sl@0	3087	}
sl@0	3088	}
sl@0	3089
sl@0	3090	if (determineVideoType(handle, &type) < 0)
sl@0	3091	{
sl@0	3092	return MP4_ERROR;
sl@0	3093	}
sl@0	3094	if( !isAvcVideo(type) )
sl@0	3095	{
sl@0	3096	*aDependsOn = 0; // Unknown
sl@0	3097	*aIsDependentOn = 0; // Unknown
sl@0	3098	*aHasRedundancy = 0; // Unknown
sl@0	3099	return MP4_OK;
sl@0	3100	}
sl@0	3101
sl@0	3102	if (!handle->moov)
sl@0	3103	return MP4_ERROR;
sl@0	3104	if (!handle->moov->trakVideo)
sl@0	3105	return MP4_ERROR;
sl@0	3106	if (!handle->moov->trakVideo->mdia)
sl@0	3107	return MP4_ERROR;
sl@0	3108	if (!handle->moov->trakVideo->mdia->minf)
sl@0	3109	return MP4_ERROR;
sl@0	3110	if (!handle->moov->trakVideo->mdia->minf->stbl)
sl@0	3111	return MP4_ERROR;
sl@0	3112	if (!handle->moov->trakVideo->mdia->minf->stbl->sdtp)
sl@0	3113	{
sl@0	3114	*aDependsOn = 0; // Unknown
sl@0	3115	*aIsDependentOn = 0; // Unknown
sl@0	3116	*aHasRedundancy = 0; // Unknown
sl@0	3117	return MP4_OK;
sl@0	3118	}
sl@0	3119	if (!handle->moov->trakVideo->mdia->minf->stbl->sdtp->dep)
sl@0	3120	{
sl@0	3121	return MP4_ERROR;
sl@0	3122	}
sl@0	3123
sl@0	3124	if (handle->videoSampleNum <= 0)
sl@0	3125	{
sl@0	3126	return MP4_ERROR;
sl@0	3127	}
sl@0	3128
sl@0	3129	if(handle->moov->trakVideo->mdia->minf->stbl->sdtp->dep[handle->videoSampleNum - 1].sDependsOn > 2 \|\|
sl@0	3130	handle->moov->trakVideo->mdia->minf->stbl->sdtp->dep[handle->videoSampleNum - 1].sIsDependentOn > 2 \|\|
sl@0	3131	handle->moov->trakVideo->mdia->minf->stbl->sdtp->dep[handle->videoSampleNum - 1].sHasRedundancy > 2)
sl@0	3132	{
sl@0	3133	return MP4_ERROR;
sl@0	3134	}
sl@0	3135	*aDependsOn = handle->moov->trakVideo->mdia->minf->stbl->sdtp->dep[handle->videoSampleNum - 1].sDependsOn;
sl@0	3136	*aIsDependentOn = handle->moov->trakVideo->mdia->minf->stbl->sdtp->dep[handle->videoSampleNum - 1].sIsDependentOn;
sl@0	3137	*aHasRedundancy = handle->moov->trakVideo->mdia->minf->stbl->sdtp->dep[handle->videoSampleNum - 1].sHasRedundancy;
sl@0	3138	return MP4_OK;
sl@0	3139	}
sl@0	3140
sl@0	3141	extern EXPORT_C MP4Err MP4ParseReadAudioFramesAsync(MP4Handle apihandle, M3GPMP4LibAsyncObserver* aObserver, mp4_u8 buffer, mp4_u32 buffersize)
sl@0	3142	{
sl@0	3143	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	3144
sl@0	3145	if (!handle->file)
sl@0	3146	{
sl@0	3147	// async operation is only supported for files.
sl@0	3148	return MP4_FILE_ERROR;
sl@0	3149	}
sl@0	3150
sl@0	3151	if (!handle->metaDataComplete)
sl@0	3152	{
sl@0	3153	switch (metaDataAvailable(handle))
sl@0	3154	{
sl@0	3155	case 0:
sl@0	3156	return MP4_NOT_AVAILABLE;
sl@0	3157	case 1:
sl@0	3158	handle->cafError = KErrNone;
sl@0	3159	if (readMetaData(handle) < 0)
sl@0	3160	{
sl@0	3161	// Reading of meta data failed, so free up any allocated memory
sl@0	3162	freeFTYP(handle->ftyp);
sl@0	3163	handle->ftyp = NULL;
sl@0	3164	freeMOOV(handle->moov);
sl@0	3165	handle->moov = NULL;
sl@0	3166
sl@0	3167	if ( handle->cafError != KErrNone )
sl@0	3168	{
sl@0	3169	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	3170	return handle->cafError;
sl@0	3171	}
sl@0	3172	else
sl@0	3173	{
sl@0	3174	return MP4_INVALID_INPUT_STREAM;
sl@0	3175	}
sl@0	3176	}
sl@0	3177	handle->metaDataComplete = MP4TRUE;
sl@0	3178	break;
sl@0	3179
sl@0	3180	case -2:
sl@0	3181	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	3182	freeFTYP(handle->ftyp);
sl@0	3183	handle->ftyp = NULL;
sl@0	3184	return MP4_ERROR;
sl@0	3185
sl@0	3186	case -1:
sl@0	3187	default:
sl@0	3188	return MP4_ERROR;
sl@0	3189	}
sl@0	3190	}
sl@0	3191
sl@0	3192	handle->asyncObserver = aObserver;
sl@0	3193
sl@0	3194	/* Is audio available? */
sl@0	3195	if (!((handle->type & MP4_TYPE_MPEG4_AUDIO) \|\|
sl@0	3196	(handle->type & MP4_TYPE_AMR_NB) \|\|
sl@0	3197	(handle->type & MP4_TYPE_AMR_WB) \|\|
sl@0	3198	(handle->type & MP4_TYPE_QCELP_13K)))
sl@0	3199	return MP4_ERROR;
sl@0	3200
sl@0	3201	/* Are there samples left? */
sl@0	3202	if (handle->audioLast)
sl@0	3203	return MP4_NO_FRAME;
sl@0	3204
sl@0	3205	if (!handle->moov)
sl@0	3206	return MP4_ERROR;
sl@0	3207	if (!handle->moov->trakAudio)
sl@0	3208	return MP4_ERROR;
sl@0	3209
sl@0	3210	switch (fetchAudioSampleAsync(handle, handle->moov->trakAudio, buffer, buffersize))
sl@0	3211	{
sl@0	3212	case -1:
sl@0	3213	return MP4_ERROR;
sl@0	3214	case -2:
sl@0	3215	return MP4_BUFFER_TOO_SMALL;
sl@0	3216	case -4:
sl@0	3217	return MP4_INVALID_INPUT_STREAM;
sl@0	3218	case MP4_OUT_OF_MEMORY:
sl@0	3219	return MP4_OUT_OF_MEMORY;
sl@0	3220	default:
sl@0	3221	break;
sl@0	3222	}
sl@0	3223	return MP4_OK;
sl@0	3224	}
sl@0	3225
sl@0	3226	extern EXPORT_C MP4Err MP4ParseReadVideoFrameAsync(MP4Handle apihandle,
sl@0	3227	M3GPMP4LibAsyncObserver* aObserver,
sl@0	3228	mp4_u8* buffer,
sl@0	3229	mp4_u32* buffersize)
sl@0	3230	{
sl@0	3231	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	3232
sl@0	3233	if (!handle->file)
sl@0	3234	{
sl@0	3235	// async operation is only supported for files.
sl@0	3236	return MP4_FILE_ERROR;
sl@0	3237	}
sl@0	3238
sl@0	3239	if (!handle->metaDataComplete)
sl@0	3240	{
sl@0	3241	switch (metaDataAvailable(handle))
sl@0	3242	{
sl@0	3243	case 0:
sl@0	3244
sl@0	3245	return MP4_NOT_AVAILABLE;
sl@0	3246
sl@0	3247	case 1:
sl@0	3248	handle->cafError = KErrNone;
sl@0	3249	if (readMetaData(handle) < 0)
sl@0	3250	{
sl@0	3251	// Reading of meta data failed, so free up any allocated memory
sl@0	3252	freeFTYP(handle->ftyp);
sl@0	3253	handle->ftyp = NULL;
sl@0	3254	freeMOOV(handle->moov);
sl@0	3255	handle->moov = NULL;
sl@0	3256
sl@0	3257	if ( handle->cafError != KErrNone )
sl@0	3258	{
sl@0	3259	// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	3260	return handle->cafError;
sl@0	3261	}
sl@0	3262	else
sl@0	3263	{
sl@0	3264	return MP4_INVALID_INPUT_STREAM;
sl@0	3265	}
sl@0	3266	}
sl@0	3267	handle->metaDataComplete = MP4TRUE;
sl@0	3268	break;
sl@0	3269
sl@0	3270	case -2:
sl@0	3271	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	3272	freeFTYP(handle->ftyp);
sl@0	3273	handle->ftyp = NULL;
sl@0	3274	return MP4_ERROR;
sl@0	3275
sl@0	3276	case -1:
sl@0	3277	default:
sl@0	3278	return MP4_ERROR;
sl@0	3279	}
sl@0	3280	}
sl@0	3281
sl@0	3282	/* Is video available? */
sl@0	3283	if (!((handle->type & MP4_TYPE_MPEG4_VIDEO) \|\|
sl@0	3284	(handle->type & MP4_TYPE_H263_PROFILE_0) \|\|
sl@0	3285	(handle->type & MP4_TYPE_H263_PROFILE_3) \|\|
sl@0	3286	containsAvcVideo( handle->type ) ))
sl@0	3287	return MP4_ERROR;
sl@0	3288
sl@0	3289	/* Are there samples left? */
sl@0	3290	if (handle->videoLast)
sl@0	3291	return MP4_NO_FRAME;
sl@0	3292
sl@0	3293	handle->asyncObserver = aObserver;
sl@0	3294
sl@0	3295	if (!handle->moov)
sl@0	3296	return MP4_ERROR;
sl@0	3297	if (!handle->moov->trakVideo)
sl@0	3298	return MP4_ERROR;
sl@0	3299
sl@0	3300	switch (fetchVideoFrameAsync(handle, handle->moov->trakVideo, buffer, buffersize ))
sl@0	3301	{
sl@0	3302	case -1:
sl@0	3303	return MP4_ERROR;
sl@0	3304	case -2:
sl@0	3305	return MP4_BUFFER_TOO_SMALL;
sl@0	3306	case -3:
sl@0	3307	return MP4_NOT_AVAILABLE;
sl@0	3308	case -4:
sl@0	3309	return MP4_INVALID_INPUT_STREAM;
sl@0	3310	case MP4_OUT_OF_MEMORY:
sl@0	3311	return MP4_OUT_OF_MEMORY;
sl@0	3312	default:
sl@0	3313	break;
sl@0	3314	}
sl@0	3315
sl@0	3316	return MP4_OK;
sl@0	3317	}
sl@0	3318
sl@0	3319	extern EXPORT_C void MP4CancelReadFrame(MP4Handle ahandle)
sl@0	3320	{
sl@0	3321	MP4HandleImp handle = (MP4HandleImp)ahandle;
sl@0	3322
sl@0	3323	if (handle->asyncReader)
sl@0	3324	{
sl@0	3325	handle->asyncReader->Cancel();
sl@0	3326	}
sl@0	3327	}
sl@0	3328
sl@0	3329	extern EXPORT_C MP4Err MP4ParseGetID32Location(MP4Handle apihandle, mp4_u32& location)
sl@0	3330	{
sl@0	3331	MP4HandleImp handle = (MP4HandleImp)apihandle;
sl@0	3332
sl@0	3333	if (!handle)
sl@0	3334	{
sl@0	3335	return MP4_ERROR;
sl@0	3336	}
sl@0	3337
sl@0	3338	if (!handle->metaDataComplete)
sl@0	3339	{
sl@0	3340	switch (metaDataAvailable(handle))
sl@0	3341	{
sl@0	3342	case 0:
sl@0	3343	return MP4_NOT_AVAILABLE;
sl@0	3344	case 1:
sl@0	3345	handle->cafError = KErrNone;
sl@0	3346	if (readMetaData(handle) < 0)
sl@0	3347	{
sl@0	3348	// Reading of meta data failed, so free up any allocated memory
sl@0	3349	freeFTYP(handle->ftyp);
sl@0	3350	handle->ftyp = NULL;
sl@0	3351	freeMOOV(handle->moov);
sl@0	3352	handle->moov = NULL;
sl@0	3353	if (handle->cafError != KErrNone)
sl@0	3354	{// if CAF/DRM caused the error return it instead of generic errorcode.
sl@0	3355	return handle->cafError;
sl@0	3356	}
sl@0	3357	else
sl@0	3358	{
sl@0	3359	return MP4_INVALID_INPUT_STREAM;
sl@0	3360	}
sl@0	3361	}
sl@0	3362	handle->metaDataComplete = MP4TRUE;
sl@0	3363	break;
sl@0	3364
sl@0	3365	case -2:
sl@0	3366	// Reading of FTYP meta data failed, so free up any allocated memory
sl@0	3367	freeFTYP(handle->ftyp);
sl@0	3368	handle->ftyp = NULL;
sl@0	3369	return MP4_ERROR;
sl@0	3370
sl@0	3371	case -1:
sl@0	3372	default:
sl@0	3373	return MP4_ERROR;
sl@0	3374	}
sl@0	3375	}
sl@0	3376
sl@0	3377	if (!handle->moov)
sl@0	3378	return MP4_ERROR;
sl@0	3379
sl@0	3380	metaAtom* meta = handle->moov->meta;
sl@0	3381	if (!meta)
sl@0	3382	return MP4_NOT_AVAILABLE;
sl@0	3383
sl@0	3384	if (!meta->atomhdr)
sl@0	3385	return MP4_NOT_AVAILABLE;
sl@0	3386
sl@0	3387	if(meta->ID32)
sl@0	3388	{
sl@0	3389	location = meta->ID32->atomcontentloc;
sl@0	3390	}
sl@0	3391	else
sl@0	3392	{
sl@0	3393	return MP4_NOT_AVAILABLE;
sl@0	3394	}
sl@0	3395
sl@0	3396	return MP4_OK;
sl@0	3397	}
sl@0	3398	// End of File

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--