// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <3gplibrary/mp4config.h>

#include <3gplibrary/mp4lib.h>

#include "mp4atom.h"

#include "mp4memwrap.h"

#include "mp4file.h"

#include "mp4buffer.h"

#include "mp4endian.h"

#include "mp4utils.h"

using namespace ContentAccess;

extern EXPORT_C MP4Err MP4ParseOpen(MP4Handle *apihandle,

                                                 MP4FileName filename)

{

  MP4HandleImp *handle = (MP4HandleStruct **)apihandle;

  *handle = (MP4HandleImp)mp4malloc(sizeof(MP4HandleStruct));

  if (*handle == NULL)

    return MP4_OUT_OF_MEMORY;

  (*handle)->file32Duplicate = NULL;

  (*handle)->FileHandleFromOutside = EFalse;

  (*handle)->sourceType = MP4_SOURCE_RFILE;

  if (filename)

    if (initFileRead(filename, *handle) == -1)

    {

      closeFile(*handle);

      mp4free(*handle);

      *handle = NULL;

      return MP4_FILE_ERROR;

    }

  (*handle)->mem = listCreate();

  if ((*handle)->mem == NULL)

  {

    closeFile(*handle);

    mp4free(*handle);

    *handle = NULL;

    return MP4_OUT_OF_MEMORY;

  }

  if (((*handle)->buf = (mp4_u8 *)mp4malloc(TMPBUFSIZE)) == NULL)

  {

    listDestroyList((*handle)->mem);

    closeFile(*handle);

    mp4free(*handle);

    *handle = NULL;

    return MP4_OUT_OF_MEMORY;

  }

  if (((*handle)->diskReadBuf = (mp4_u8 *)mp4malloc(READBUFSIZE)) == NULL)

  {

    mp4free((*handle)->buf);

    listDestroyList((*handle)->mem);

    closeFile(*handle);

    mp4free(*handle);

    *handle = NULL;

    return MP4_OUT_OF_MEMORY;

  }

  // register for stblib use 

  if (openStdlib() !=  MP4_OK)

	  {

	  mp4free((*handle)->diskReadBuf);	  

	  mp4free((*handle)->buf);

	  listDestroyList((*handle)->mem);

	  closeFile(*handle);

	  mp4free(*handle);

	  *handle = NULL;

	  return MP4_ERROR;

	  }

  return MP4_OK;

}

extern EXPORT_C MP4Err MP4ParseOpenFileHandle(MP4Handle *apihandle,

                                                 RFile *inputfile)

{

  MP4Err err;

  RFile64 *f64 = new RFile64;

  if (f64 == NULL)

  {

    return MP4_OUT_OF_MEMORY;

  }

  if  (f64->Duplicate(*inputfile) != KErrNone)

  {

    delete f64;

    return MP4_ERROR;

  }

  err = MP4ParseOpenFileHandle64(apihandle, f64);

  if (err == MP4_OK)

  {    

    MP4HandleImp* handle = (MP4HandleStruct **)apihandle;

    (*handle)->file32Duplicate = (void*)(f64);

  }

  return err;

}

extern EXPORT_C MP4Err MP4ParseOpenFileHandle64(MP4Handle *apihandle,

                                                 RFile64 *inputfile)

{

  MP4HandleImp *handle = (MP4HandleStruct **)apihandle;

  *handle = (MP4HandleImp)mp4malloc(sizeof(MP4HandleStruct));

  if (*handle == NULL)

    return MP4_OUT_OF_MEMORY;

  (*handle)->file32Duplicate = NULL;

  (*handle)->rfile = (void *)inputfile;

  (*handle)->file = (*handle)->rfile;

  (*handle)->FileHandleFromOutside = ETrue;

  (*handle)->sourceType = MP4_SOURCE_RFILE;

  if (inputfile == NULL)

      {

      closeFile(*handle);

      mp4free(*handle);

      *handle = NULL;

      return MP4_FILE_ERROR;

      }

  (*handle)->mem = listCreate();

  if ((*handle)->mem == NULL)

  {

    closeFile(*handle);

    mp4free(*handle);

    *handle = NULL;

    return MP4_OUT_OF_MEMORY;

  }

  if (((*handle)->buf = (mp4_u8 *)mp4malloc(TMPBUFSIZE)) == NULL)

  {

    listDestroyList((*handle)->mem);

    closeFile(*handle);

    mp4free(*handle);

    *handle = NULL;

    return MP4_OUT_OF_MEMORY;

  }

  if (((*handle)->diskReadBuf = (mp4_u8 *)mp4malloc(READBUFSIZE)) == NULL)

  {

    mp4free((*handle)->buf);

    listDestroyList((*handle)->mem);

    closeFile(*handle);

    mp4free(*handle);

    *handle = NULL;

    return MP4_OUT_OF_MEMORY;

  }

  	// register for stblib use 

  	if (openStdlib() !=  MP4_OK)

  		{

  		// clean up

		mp4free((*handle)->buf);

		listDestroyList((*handle)->mem);

		closeFile(*handle);

		mp4free(*handle);

		*handle = NULL;

		return MP4_ERROR;

  		} 

  return MP4_OK;

}

extern EXPORT_C MP4Err MP4ParseOpenCAF(MP4Handle *apihandle,

                                                    ContentAccess::CData *inputfile)

{

  MP4HandleImp *handle = (MP4HandleStruct **)apihandle;

  *handle = (MP4HandleImp)mp4malloc(sizeof(MP4HandleStruct));

  if (*handle == NULL)

    return MP4_OUT_OF_MEMORY;

  (*handle)->file32Duplicate = NULL;

  (*handle)->cfile = inputfile;

  (*handle)->file = (*handle)->cfile;

  (*handle)->FileHandleFromOutside = ETrue;

  (*handle)->sourceType = MP4_SOURCE_CAF;

  if (inputfile == NULL)

      {

      closeFile(*handle);

      mp4free(*handle);

      *handle = NULL;

      return MP4_FILE_ERROR;

      }

  (*handle)->mem = listCreate();

  if ((*handle)->mem == NULL)

  {

    closeFile(*handle);

    mp4free(*handle);

    *handle = NULL;

    return MP4_OUT_OF_MEMORY;

  }

  if (((*handle)->buf = (mp4_u8 *)mp4malloc(TMPBUFSIZE)) == NULL)

  {

    listDestroyList((*handle)->mem);

    closeFile(*handle);

    mp4free(*handle);

    *handle = NULL;

    return MP4_OUT_OF_MEMORY;

  }

  if (((*handle)->diskReadBuf = (mp4_u8 *)mp4malloc(READBUFSIZE)) == NULL)

  {

    mp4free((*handle)->buf);

    listDestroyList((*handle)->mem);

    closeFile(*handle);

    mp4free(*handle);

    *handle = NULL;

    return MP4_OUT_OF_MEMORY;

  }

	// register for stblib use 

	if (openStdlib() !=  MP4_OK)

		{

		// clean up

		mp4free((*handle)->diskReadBuf);

		mp4free((*handle)->buf);

		listDestroyList((*handle)->mem);

		closeFile(*handle);

		mp4free(*handle);

		*handle = NULL;

		return MP4_ERROR;

		} 

  return MP4_OK;

}

extern EXPORT_C MP4Err MP4ParseClose(MP4Handle apihandle)

{

  MP4HandleImp handle = (MP4HandleImp)apihandle;

  if (!handle)

    return MP4_ERROR;

  if (handle->file)

    closeFile(handle);

  closeStdlib(); /* Free memory allocated by stdlib wrapper functions */

  listDestroyList(handle->mem);

  if (handle->diskReadBuf)

    mp4free(handle->diskReadBuf);

  if (handle->buf)

    mp4free(handle->buf);

  if (freeMOOV(handle->moov) < 0)

   	return MP4_ERROR;

  if (freeFTYP(handle->ftyp) < 0)

   	return MP4_ERROR;

  if (handle->file32Duplicate)

      ((RFile64*)handle->file32Duplicate)->Close();

  if (handle)

    mp4free(handle);

  return MP4_OK;

}

extern EXPORT_C MP4Err MP4ParseRequestVideoDescription(MP4Handle apihandle,

                                                                    mp4_u32 *videolength,

                                                                    mp4_double *framerate,

                                                                    mp4_u32 *videotype,

                                                                    mp4_u32 *videowidth,

                                                                    mp4_u32 *videoheight,

                                                                    mp4_u32 *timescale)

{

  MP4HandleImp handle = (MP4HandleImp)apihandle;

  if (!handle)

	  {

	  return MP4_ERROR;

	  }

  if (!handle->metaDataComplete)

  {

    switch (metaDataAvailable(handle))

    {

    case 0:

      return MP4_NOT_AVAILABLE;

    case 1:

      handle->cafError = KErrNone;

      if (readMetaData(handle) < 0)

      {

      	// Reading of meta data failed, so free up any allocated memory

  		freeFTYP(handle->ftyp);

  		handle->ftyp = NULL;

		freeMOOV(handle->moov);

		handle->moov = NULL;

      	if ( handle->cafError != KErrNone )

      	{

      	  // if CAF/DRM caused the error return it instead of generic errorcode.

      	  return handle->cafError;

      	}

      	else

      	{

	      return MP4_INVALID_INPUT_STREAM;

      	}

      }

      handle->metaDataComplete = MP4TRUE;

      break;

    case -2:

      // Reading of FTYP meta data failed, so free up any allocated memory

      freeFTYP(handle->ftyp);

      handle->ftyp = NULL;

      return MP4_ERROR;      

    case -1:

    default:

      return MP4_ERROR;

    }

  }

  if (!handle->moov)

    return MP4_ERROR;

  if (!handle->moov->trakVideo)

    return MP4_NO_VIDEO;

  mp4_i32 videoError = 0;

  videoError = determineVideoType(handle, videotype);

  if ( videoError == -2 )

  {

    return MP4_NO_VIDEO;

  }

  else if ( videoError < 0 )

  {

  	return MP4_ERROR;

  }

  if (determineVideoLength(handle, videolength) < 0)

    return MP4_ERROR;

  if (determineFrameRate(handle, framerate) < 0)

    return MP4_ERROR;

  if (determineVideoResolution(handle, videowidth, videoheight) < 0)

    return MP4_ERROR;

  if (determineVideoTimeScale(handle, timescale) < 0)

    return MP4_ERROR;

  return MP4_OK;

}

extern EXPORT_C MP4Err MP4ParseRequestAudioDescription(MP4Handle apihandle,

                                                                    mp4_u32 *audiolength,

                                                                    mp4_u32 *audiotype,

                                                                    mp4_u8 *framespersample,

                                                                    mp4_u32 *timescale,

                                                                    mp4_u32 *averagebitrate)

{

  MP4HandleImp handle = (MP4HandleImp)apihandle;

  if (!handle)

	  {

	  return MP4_ERROR;

	  }

  if (!handle->metaDataComplete)

  {

    switch (metaDataAvailable(handle))

    {

    case 0:

      return MP4_NOT_AVAILABLE;

    case 1:

      handle->cafError = KErrNone;

      if (readMetaData(handle) < 0)

      {

      	// Reading of meta data failed, so free up any allocated memory

  		freeFTYP(handle->ftyp);

  		handle->ftyp = NULL;

		freeMOOV(handle->moov);

		handle->moov = NULL;

      	if ( handle->cafError != KErrNone )

      	{

      	  // if CAF/DRM caused the error return it instead of generic errorcode.

      	  return handle->cafError;

      	}

      	else

      	{

	      return MP4_INVALID_INPUT_STREAM;

      	}

      }

      handle->metaDataComplete = MP4TRUE;

      break;

    case -2:

      // Reading of FTYP meta data failed, so free up any allocated memory

      freeFTYP(handle->ftyp);

      handle->ftyp = NULL;

      return MP4_ERROR;      

    case -1:

    default:

      return MP4_ERROR;

    }

  }

  if (!handle->moov)

    return MP4_ERROR;

  if (!handle->moov->trakAudio)

    return MP4_NO_AUDIO;

  if (determineAudioLength(handle, audiolength) < 0)

    return MP4_ERROR;

  mp4_i32 audioError = 0;

  audioError = determineAudioType(handle, audiotype);

  if ( audioError == -2 )

  {

    return MP4_NO_AUDIO;

  }

  else if ( audioError < 0 )

  {

  	return MP4_ERROR;

  }

  if (determineAudioFramesPerSample(handle, framespersample) < 0)

    return MP4_ERROR;

  if (determineAudioTimeScale(handle, timescale) < 0)

    return MP4_ERROR;

  if (averagebitrate != NULL)

    if (determineAudioAverageBitRate(handle, averagebitrate) < 0)

      return MP4_ERROR;

  return MP4_OK;

}

extern EXPORT_C MP4Err MP4ParseRequestStreamDescription(MP4Handle apihandle,

                                                                     mp4_u32 *streamsize,

                                                                     mp4_u32 *streamaveragebitrate)

{

  MP4HandleImp handle = (MP4HandleImp)apihandle;

  if (!handle->metaDataComplete)

  {

    switch (metaDataAvailable(handle))

    {

    case 0:

      return MP4_NOT_AVAILABLE;

    case 1:

      handle->cafError = KErrNone;

      if (readMetaData(handle) < 0)

      {

      	// Reading of meta data failed, so free up any allocated memory

  		freeFTYP(handle->ftyp);

  		handle->ftyp = NULL;

		freeMOOV(handle->moov);

		handle->moov = NULL;

      	if ( handle->cafError != KErrNone )

      	{

      	  // if CAF/DRM caused the error return it instead of generic errorcode.

      	  return handle->cafError;

      	}

      	else

      	{

	      return MP4_INVALID_INPUT_STREAM;

      	}

      }

      handle->metaDataComplete = MP4TRUE;

      break;

    case -2:

      // Reading of FTYP meta data failed, so free up any allocated memory

      freeFTYP(handle->ftyp);

      handle->ftyp = NULL;

      return MP4_ERROR;      

    case -1:

    default:

      return MP4_ERROR;

    }

  }

  if (determineStreamSize(handle, streamsize) < 0)

    return MP4_ERROR;

  if (determineStreamAverageBitRate(handle, streamaveragebitrate, *streamsize) < 0)

    return MP4_ERROR;

  return MP4_OK;

}

extern EXPORT_C MP4Err MP4ParseWriteData(MP4Handle apihandle,

                                                      mp4_u8 *buffer,

                                                      mp4_u32 bytestowrite)

{

  MP4HandleImp handle = (MP4HandleImp)apihandle;

  if (handle->file)

    return MP4_ERROR;

  if ((buffer == NULL) && (bytestowrite != 0))