// 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 "mp4compose.h"

#include "mp4utils.h"

// MACROS

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) 

#else

#define PRINT(x)

#endif

#define STTSMAXENTRYCOUNT  100

#define STSZMAXSAMPLECOUNT 100

#define STSCMAXENTRYCOUNT    2

#define STCOMAXENTRYCOUNT  100

#define STSSMAXENTRYCOUNT  100

#define SDTPMAXENTRYCOUNT  100

extern EXPORT_C MP4Err MP4ComposeOpen(MP4Handle *apihandle,

                                                   MP4FileName filename,

                                                   mp4_u32 type)

{

  MP4Err error = MP4_OK;

  MP4HandleImp* handle = (MP4HandleStruct **)apihandle;

  if ( filename != NULL )

      {

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

      if (*handle == NULL)

          {

          return MP4_OUT_OF_MEMORY;      

          }

      (*handle)->bufferWrite=MP4FALSE;

      }

  else

      {

      if ( *handle == NULL )

          {

          return MP4_ERROR;

          }

      }

  (*handle)->file32Duplicate = NULL;

  (*handle)->FileHandleFromOutside = EFalse;

  if(!(*handle)->bufferWrite)

  {

		if (!filename)

		    {

			error = MP4_FILE_ERROR;

		    }

		if ( error == MP4_OK )

		    {

    		if (saveFileName(filename, *handle) < 0)

	    		error = MP4_OUT_OF_MEMORY;

		    }

		if (error == MP4_OK)

		{

			if (createTmpFileName(filename, &((*handle)->tmpFileName)) == -1)

				error = MP4_OUT_OF_MEMORY;

		}

		if (error == MP4_OK)

		{

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

				error = MP4_FILE_ERROR;

		}

		if (error == MP4_OK)

		{

			if (initTmpFileWrite((*handle)->tmpFileName, *handle) == -1)

				error = MP4_FILE_ERROR;

		}

  }

  if (error == MP4_OK)

  {

    (*handle)->diskWriteBuf = (mp4_u8 *)mp4malloc(WRITEBUFSIZE);

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

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable = (sampleTable *)mp4malloc(sizeof(sampleTable));

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

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->sttsSampleCount = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STTSMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->sttsSampleCount == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->sttsSampleDelta = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STTSMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->sttsSampleDelta == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stszEntrySize = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSZMAXSAMPLECOUNT);

    if ((*handle)->audioSampleTable->stszEntrySize == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stscFirstChunk = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSCMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->stscFirstChunk == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stscSamplesPerChunk = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSCMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->stscSamplesPerChunk == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stscSampleDescriptionIndex = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSCMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->stscSampleDescriptionIndex == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stcoChunkOffset = (mp4_u64 *)mp4malloc(sizeof(mp4_u64) * STCOMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->stcoChunkOffset == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable = (sampleTable *)mp4malloc(sizeof(sampleTable));

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

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->sttsSampleCount = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STTSMAXENTRYCOUNT);

    if ((*handle)->videoSampleTable->sttsSampleCount == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->sttsSampleDelta = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STTSMAXENTRYCOUNT);

    if ((*handle)->videoSampleTable->sttsSampleDelta == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->stszEntrySize = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSZMAXSAMPLECOUNT);

    if ((*handle)->videoSampleTable->stszEntrySize == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->stscFirstChunk = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSCMAXENTRYCOUNT);

    if ((*handle)->videoSampleTable->stscFirstChunk == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->stscSamplesPerChunk = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSCMAXENTRYCOUNT);

    if ((*handle)->videoSampleTable->stscSamplesPerChunk == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->stscSampleDescriptionIndex = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSCMAXENTRYCOUNT);

    if ((*handle)->videoSampleTable->stscSampleDescriptionIndex == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->stcoChunkOffset = (mp4_u64 *)mp4malloc(sizeof(mp4_u64) * STCOMAXENTRYCOUNT);

    if ((*handle)->videoSampleTable->stcoChunkOffset == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->stssSampleNumber = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSSMAXENTRYCOUNT);

    if ((*handle)->videoSampleTable->stssSampleNumber == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->sdtpSampleDependency = (mp4_u8 *)mp4malloc(sizeof(mp4_u8) * SDTPMAXENTRYCOUNT);

    if ((*handle)->videoSampleTable->sdtpSampleDependency == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  // register for stblib use 

  if (error == MP4_OK)

	  {

	  if (openStdlib() !=  MP4_OK)

		  {

		  error = MP4_ERROR;

		  }

	  }

  if (error != MP4_OK)

  {

    if(!(*handle)->bufferWrite)

    {

        closeFile(*handle);

        closeTmpFile(*handle);

        freeTmpFileName((*handle)->tmpFileName);

    }

    if ((*handle)->diskWriteBuf)

      mp4free((*handle)->diskWriteBuf);

    if ((*handle)->videoSampleTable)

    {

      if ((*handle)->videoSampleTable->stssSampleNumber)

        mp4free((*handle)->videoSampleTable->stssSampleNumber);

      if ((*handle)->videoSampleTable->stcoChunkOffset)

        mp4free((*handle)->videoSampleTable->stcoChunkOffset);

      if ((*handle)->videoSampleTable->stscSampleDescriptionIndex)

        mp4free((*handle)->videoSampleTable->stscSampleDescriptionIndex);

      if ((*handle)->videoSampleTable->stscSamplesPerChunk)

        mp4free((*handle)->videoSampleTable->stscSamplesPerChunk);

      if ((*handle)->videoSampleTable->stscFirstChunk)

        mp4free((*handle)->videoSampleTable->stscFirstChunk);

      if ((*handle)->videoSampleTable->stszEntrySize)

        mp4free((*handle)->videoSampleTable->stszEntrySize);

      if ((*handle)->videoSampleTable->sttsSampleCount)

        mp4free((*handle)->videoSampleTable->sttsSampleCount);

      if ((*handle)->videoSampleTable->sttsSampleDelta)

        mp4free((*handle)->videoSampleTable->sttsSampleDelta);

      if ((*handle)->videoSampleTable->sdtpSampleDependency)

        mp4free((*handle)->videoSampleTable->sdtpSampleDependency);

      mp4free((*handle)->videoSampleTable);

    }

    if ((*handle)->audioSampleTable)

    {

      if ((*handle)->audioSampleTable->stcoChunkOffset)

        mp4free((*handle)->audioSampleTable->stcoChunkOffset);

      if ((*handle)->audioSampleTable->stscSampleDescriptionIndex)

        mp4free((*handle)->audioSampleTable->stscSampleDescriptionIndex);

      if ((*handle)->audioSampleTable->stscSamplesPerChunk)

        mp4free((*handle)->audioSampleTable->stscSamplesPerChunk);

      if ((*handle)->audioSampleTable->stscFirstChunk)

        mp4free((*handle)->audioSampleTable->stscFirstChunk);

      if ((*handle)->audioSampleTable->stszEntrySize)

        mp4free((*handle)->audioSampleTable->stszEntrySize);

      if ((*handle)->audioSampleTable->sttsSampleDelta)

        mp4free((*handle)->audioSampleTable->sttsSampleDelta);

      if ((*handle)->audioSampleTable->sttsSampleCount)

        mp4free((*handle)->audioSampleTable->sttsSampleCount);

      mp4free((*handle)->audioSampleTable);

    }

    if ((*handle)->fileName)

      mp4free((*handle)->fileName);

    mp4free(*handle);

    *handle = NULL;

    return error;

  }

  (*handle)->audioSampleTable->sttsMaxEntryCount  = STTSMAXENTRYCOUNT;

  (*handle)->audioSampleTable->stszMaxSampleCount = STSZMAXSAMPLECOUNT;

  (*handle)->audioSampleTable->stscMaxEntryCount  = STSCMAXENTRYCOUNT;

  (*handle)->audioSampleTable->stcoMaxEntryCount  = STCOMAXENTRYCOUNT;

  (*handle)->audioSampleTable->stcoNeed64Bits     = EFalse;

  (*handle)->videoSampleTable->sttsMaxEntryCount  = STTSMAXENTRYCOUNT;

  (*handle)->videoSampleTable->stszMaxSampleCount = STSZMAXSAMPLECOUNT;

  (*handle)->videoSampleTable->stscMaxEntryCount  = STSCMAXENTRYCOUNT;

  (*handle)->videoSampleTable->stcoMaxEntryCount  = STCOMAXENTRYCOUNT;

  (*handle)->videoSampleTable->stssMaxEntryCount  = STSSMAXENTRYCOUNT;

  (*handle)->videoSampleTable->sdtpMaxEntryCount  = SDTPMAXENTRYCOUNT;

  (*handle)->videoSampleTable->stcoNeed64Bits     = EFalse;

  (*handle)->type = type;

  /* Check if a 3GPP2 codec is being used */

  if ((*handle)->type & MP4_TYPE_QCELP_13K)

      {

      (*handle)->generate3G2 = MP4TRUE;

      }

  return MP4_OK;

}

extern EXPORT_C MP4Err MP4ComposeOpenToBuffer(MP4Handle *apihandle,

                                                   mp4_u32 type,

                                                   mp4_u8* composeBuffer, 

                                                   mp4_u32 *composedSize)

{

  MP4HandleImp* handle = (MP4HandleStruct **)apihandle;

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

  if (*handle == NULL)              

    return MP4_OUT_OF_MEMORY;

  (*handle)->file32Duplicate = NULL;

  (*handle)->bufferWrite=MP4TRUE;

  (*handle)->FileHandleFromOutside = EFalse;

  if(composeBuffer == NULL)

	{

	return MP4_NO_OUTPUT_BUFFER; //This is to indicate that compose buffer has not been initialized

	}

  (*handle)->composeBuffer=composeBuffer;

  (*handle)->composedSize=composedSize;

  return MP4ComposeOpen( apihandle, NULL, type );

}

extern EXPORT_C MP4Err MP4ComposeOpenFileHandle(MP4Handle *apihandle, 

                                                             RFile *composedfile, 

                                                             TDriveNumber metadataTempDrive, 

                                                             mp4_u32 type)

{

  MP4Err err;

  RFile64 *f64 = new RFile64;

  if (f64 == NULL)

  {

    return MP4_OUT_OF_MEMORY;

  }

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

  {

    delete f64;

    return MP4_ERROR;

  }

  err = MP4ComposeOpenFileHandle64(apihandle, f64, metadataTempDrive, type);

  if (err == MP4_OK)

  {    

    MP4HandleImp* handle = (MP4HandleStruct **)apihandle;

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

  }

  return err;

}

extern EXPORT_C MP4Err MP4ComposeOpenFileHandle64(MP4Handle *apihandle, 

                                                             RFile64 *composedfile, 

                                                             TDriveNumber metadataTempDrive, 

                                                             mp4_u32 type)

{

  MP4Err error = MP4_OK;

  MP4HandleImp* handle = (MP4HandleStruct **)apihandle;

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

  if (*handle == NULL)

      {

      return MP4_OUT_OF_MEMORY;      

      }

  (*handle)->bufferWrite=MP4FALSE;

  (*handle)->file32Duplicate = NULL;

  // since file handle we can´t use temporary file for mediadata safely.

  (*handle)->flags |= MP4_FLAG_METADATALAST;

  (*handle)->FileHandleFromOutside = ETrue;

  (*handle)->fileHandleDrive = metadataTempDrive;

  RFs   *fs;

  fs = new(RFs);

  (*handle)->fs = (void *)fs;

  if (fs == NULL)

    error = MP4_FILE_ERROR;

  if (error == MP4_OK)

    {

    if (fs->Connect() != KErrNone)

        error = MP4_FILE_ERROR;

    }

  if (error == MP4_OK)

    {

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

    if (composedfile == NULL)

        error = MP4_FILE_ERROR;

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

    TRAPD(traperror, (*handle)->filewriter = CFileWriter::NewL( *composedfile ));

    if ( traperror != KErrNone )

        {

        error = MP4_FILE_ERROR;

        }

    }

  if (error == MP4_OK)

  {

    (*handle)->diskWriteBuf = (mp4_u8 *)mp4malloc(WRITEBUFSIZE);

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

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable = (sampleTable *)mp4malloc(sizeof(sampleTable));

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

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->sttsSampleCount = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STTSMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->sttsSampleCount == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->sttsSampleDelta = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STTSMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->sttsSampleDelta == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stszEntrySize = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSZMAXSAMPLECOUNT);

    if ((*handle)->audioSampleTable->stszEntrySize == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stscFirstChunk = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSCMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->stscFirstChunk == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stscSamplesPerChunk = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSCMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->stscSamplesPerChunk == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stscSampleDescriptionIndex = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STSCMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->stscSampleDescriptionIndex == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->audioSampleTable->stcoChunkOffset = (mp4_u64 *)mp4malloc(sizeof(mp4_u64) * STCOMAXENTRYCOUNT);

    if ((*handle)->audioSampleTable->stcoChunkOffset == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable = (sampleTable *)mp4malloc(sizeof(sampleTable));

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

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->sttsSampleCount = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STTSMAXENTRYCOUNT);

    if ((*handle)->videoSampleTable->sttsSampleCount == NULL)

      error = MP4_OUT_OF_MEMORY;

  }

  if (error == MP4_OK)

  {

    (*handle)->videoSampleTable->sttsSampleDelta = (mp4_u32 *)mp4malloc(sizeof(mp4_u32) * STTSMAXENTRYCOUNT);