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

#include "mp4compose.h"

#include "mp4currenttime.h"

#include "mp4utils.h"

#define MP4_INT_MAX		KMaxTInt32	

#define MDAT_HEADER_SIZE 16

// MACROS

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x)

#else

#define PRINT(x)

#endif

inline void updateChunkOffset(sampleTable *st, mp4_i32 index, mp4_i64 value) 

{

  if (value > MP4_INT_MAX) 

    st->stcoNeed64Bits = ETrue; 

  st->stcoChunkOffset[index] = value;

}

/* must be called after determineAudioTrakMetaDataSize and determineVideoTrakMetaDataSize */

size_t mvhdAtomSize(MP4HandleImp handle)

{

  if (handle->videoDuration > MP4_INT_MAX || handle->audioDuration > MP4_INT_MAX)

  {

    return 120;

  }

  else

  {

    return 108;

  }

}

/* helper functions */

mp4_i32 formatMdatHeader(mp4_u8 *buffer, mp4_i64 size);

/*

 * Function:

 *

 *   mp4_i32 updateVideoMetaData(MP4HandleImp handle,

 *                               mp4_u32 size,

 *                               mp4_u32 duration)

 *

 * Description:

 *

 *   This function updates sample table atom data.

 *

 *   One call of this function will generate one chunk in the MP4 file.

 *

 * Parameters:

 *

 *   handle    MP4 library handle

 *   size      Size of video frame to insert

 *   duration  Duration of the video frame (in media timescale)

 *

 * Return value:

 *

 *   0         Success

 *   -1        Error

 *

 */

mp4_i32 updateVideoMetaData(MP4HandleImp handle, mp4_u32 size, mp4_u32 duration, mp4_bool keyframe)

{

  if (handle->flags & MP4_FLAG_LONGCLIP)

  {

    if (handle->metaDataBlocks == BLOCK_LIMIT)

    {

      /* Write metadata to temporary files */

      if (writeMetaDataTmp(handle) < 0)

        return -1;

    }

    handle->metaDataBlocks++;

  }

  handle->videoSampleTable->currentChunk++;

  if (updateDecodingTimeToSample(handle, handle->videoSampleTable, duration) < 0)

    return -1;

  if (updateSampleSize(handle, handle->videoSampleTable, size) < 0)

    return -1;

  if (updateSampleToChunk(handle->videoSampleTable) < 0)

    return -1;

  if (updateChunkOffset(handle, handle->videoSampleTable) < 0)

    return -1;

  if (keyframe)

    if (updateSyncSample(handle, handle->videoSampleTable) < 0)

      return -1;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 updateAudioMetaData(MP4HandleImp handle,

 *                               mp4_u32 size,

 *                               mp4_u32 numberofframes)

 *

 * Description:

 *

 *   This function updates sample table atom data.

 *

 *   One call of this function will generate one chunk in the MP4 file.

 *

 * Parameters:

 *

 *   handle          MP4 library handle

 *   size            Size of video frame to insert

 *   duration        Duration of audio frames (in timescale,

 *                   see MP4ComposeAddAudioDescription)

 *

 * Return value:

 *

 *   0         Success

 *   -1        Error

 *

 */

mp4_i32 updateAudioMetaData(MP4HandleImp handle, mp4_u32 size, mp4_u32 duration)

{

  if (handle->flags & MP4_FLAG_LONGCLIP)

  {

    if (handle->metaDataBlocks == BLOCK_LIMIT)

    {

      /* Write metadata to temporary files */

      if (writeMetaDataTmp(handle) < 0)

        return -1;

    }

    handle->metaDataBlocks++;

  }

  handle->audioSampleTable->currentChunk++;

  if (updateDecodingTimeToSample(handle, handle->audioSampleTable, duration) < 0)

    return -1;

  if (updateSampleSize(handle, handle->audioSampleTable, size) < 0)

    return -1;

  if (updateSampleToChunk(handle->audioSampleTable) < 0)

    return -1;

  if (updateChunkOffset(handle, handle->audioSampleTable) < 0)

    return -1;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 writeFTYPAndMDATToFile(MP4HandleImp handle)

 *

 * Description:

 *

 *   This function writes FTYP box to a file. In addition, it writes MDAT box

 *   size and type to a file. The function is used when meta data is put to

 *   the end of file.

 *

 * Parameters:

 *

 *   handle     MP4 library handle

 *

 * Return value:

 *

 *   0          Success

 *   -1         Error

 *

 */

mp4_i32 writeFTYPAndMDATToFile(MP4HandleImp handle)

{

  mp4_u8  buf[32];

  mp4_u32 i = 0;

  if (writeFTYP(handle) < 0)

    return -1;

  handle->ftypWritten = MP4TRUE;

  i = formatMdatHeader(buf, (mp4_u32)0);

  if (writeFile(handle, buf, i) < 0)

    return -1;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 writeDataToFile(MP4HandleImp handle)

 *

 * Description:

 *

 *   This function writes meta and media data to a file.

 *

 * Parameters:

 *

 *   handle     MP4 library handle

 *

 * Return value:

 *

 *   0          Success

 *   -1         Error

 *

 */

mp4_i32 writeDataToFile(MP4HandleImp handle)

{

  PRINT((_L("e_writedatatofile 1")));

  mp4_u32   metaDataSize = 0;

  trakSize  *audioTrackSize;

  trakSize  *videoTrackSize;

  mp4_bool  haveAudio = MP4FALSE;

  mp4_bool  haveVideo = MP4FALSE;

  mp4_u8 ftypdelta = 0;

  if ((handle->type & MP4_TYPE_AMR_NB) ||

      (handle->type & MP4_TYPE_AMR_WB) ||

       (handle->type & MP4_TYPE_QCELP_13K) ||     

      (handle->type & MP4_TYPE_MPEG4_AUDIO))

    haveAudio = MP4TRUE;

  if ((handle->type & MP4_TYPE_H263_PROFILE_0) ||

      (handle->type & MP4_TYPE_H263_PROFILE_3) ||

      (handle->type & MP4_TYPE_MPEG4_VIDEO) ||

	  containsAvcVideo( handle->type ) )

    haveVideo = MP4TRUE;

  if ((handle->generate3G2 && !(handle->type &  MP4_TYPE_QCELP_13K)) ||

       (!handle->generate3G2 && !(handle->type &  MP4_TYPE_AMR_WB)))

     ftypdelta = 4; /* one more additional compatible brand */

  else

     ftypdelta = 0;

  if( containsAvcVideo( handle->type ) )

  {

    ftypdelta += 4;

  }  

  PRINT((_L("e_writedatatofile_alloc_audiotrk 1")));

  audioTrackSize = (trakSize *)mp4malloc(sizeof(trakSize));

  if (audioTrackSize == NULL)

    return -1;

  PRINT((_L("e_writedatatofile_alloc_audiotrk 0")));    

  PRINT((_L("e_writedatatofile_alloc_videotrk 1")));  

  videoTrackSize = (trakSize *)mp4malloc(sizeof(trakSize));

  if (videoTrackSize == NULL)

  {

    mp4free(audioTrackSize);

    return -1;

  }

  PRINT((_L("e_writedatatofile_alloc_videotrk 0")));  

  if (haveAudio)

  {

	PRINT((_L("e_writedatatofile_deter_audiotrk_metadatasize 1")));  

    if (determineAudioTrakMetaDataSize(handle, handle->audioSampleTable, audioTrackSize) < 0)

        {

        mp4free(audioTrackSize);

        mp4free(videoTrackSize);

        return -1;

        }

	PRINT((_L("e_writedatatofile_deter_audiotrk_metadatasize 0")));          

  }

  if (haveVideo)

  {

	PRINT((_L("e_writedatatofile_deter_videotrk_metadatasize 1")));

    if (determineVideoTrakMetaDataSize(handle, handle->videoSampleTable, videoTrackSize) < 0)

        {

        mp4free(audioTrackSize);

        mp4free(videoTrackSize);

        return -1;

        }

PRINT((_L("e_writedatatofile_deter_videotrk_metadatasize 0")));        

  }

  if (handle->flags & MP4_FLAG_METADATALAST)

  {

    metaDataSize += (FTYP_SIZE + ftypdelta);             /* ftyp */

    handle->metaDataSize = metaDataSize;

  }

  else

  {

    metaDataSize += (FTYP_SIZE + ftypdelta);             /* ftyp */

    metaDataSize += 8;                     /* moov atomheader */

    metaDataSize += mvhdAtomSize(handle);                   /* mvhd */

    if (handle->moovUDTA)

        {

        metaDataSize += 8 + (mp4_u32)handle->moovUDTA->atomcontentsize;

        }

    metaDataSize += audioTrackSize->trak;  /* Audio trak */

    metaDataSize += videoTrackSize->trak;  /* Video trak */

    handle->metaDataSize = metaDataSize;

  }

  if (!(handle->flags & MP4_FLAG_LONGCLIP))

  {

    /* Update metadata pointers only if metadata is in memory */

    if (haveAudio)

    {

	PRINT((_L("e_writedatatofile_reupdata_audiometadata 1")));     

      if (reUpdateAudioMetaData(handle->audioSampleTable, metaDataSize) < 0)

      {

        mp4free(audioTrackSize);

        mp4free(videoTrackSize);

        return -1;

      }

	PRINT((_L("e_writedatatofile_reupdata_audiometadata 0")));           

    }

    if (haveVideo)

    {

	PRINT((_L("e_writedatatofile_reupdata_videometadata 1")));               

      if (reUpdateVideoMetaData(handle->videoSampleTable, metaDataSize) < 0)

      {

        mp4free(audioTrackSize);

        mp4free(videoTrackSize);

        return -1;

      }

	PRINT((_L("e_writedatatofile_reupdata_videometadata 0")));      

    }

  }

  else

  {

    /* Write the rest of metadata to temporary files */

	PRINT((_L("e_writedatatofile_write_metadatablocks 1")));

    if (handle->metaDataBlocks)

      if (writeMetaDataTmp(handle) < 0)

          {

          mp4free(audioTrackSize);

          mp4free(videoTrackSize);

          return -1;

          }

	PRINT((_L("e_writedatatofile_write_metadatablocks 0")));          

  }

  if (handle->flags & MP4_FLAG_METADATALAST)

  {

    mp4_u8  buf[16];

    mp4_u32 moovSize = 0;

    moovSize += 8;                     /* moov atomheader */

    moovSize += mvhdAtomSize(handle);                   /* mvhd */

    moovSize += audioTrackSize->trak;  /* Audio trak */

    moovSize += videoTrackSize->trak;  /* Video trak */

    if (handle->moovUDTA)

        {

        moovSize += 8 + handle->moovUDTA->atomcontentsize;

        }    

	PRINT((_L("e_writedatatofile_write_moov 1")));

    if (writeMOOV(handle, moovSize, haveAudio, haveVideo, audioTrackSize, videoTrackSize) < 0)

    {

      mp4free(audioTrackSize);

      mp4free(videoTrackSize);

      return -1;

    }

    PRINT((_L("e_writedatatofile_write_moov 0")));

    /* Overwrite media data size */

	PRINT((_L("e_writedatatofile_update_moov_media_size 1")));

	if(!handle->bufferWrite)

	{

		if (seekFileAbsWrite(handle, (FTYP_SIZE + ftypdelta)) != 0)

			{

			mp4free(audioTrackSize);

			mp4free(videoTrackSize);

			return -1;

			}

	}

	//make sure the buf is large enough to hold the mdat header

	TInt i;

	i = formatMdatHeader(buf, handle->mediaDataBytes);

    if (writeFileUnbuffered(handle, buf, i) < 0)

        {

        mp4free(audioTrackSize);

        mp4free(videoTrackSize);

        return -1;

        }

	PRINT((_L("e_writedatatofile_update_moov_media_size 0")));        

  }

  else

  {

	PRINT((_L("e_writedatatofile_write_ftyp 1")));  

    if (writeFTYP(handle) < 0)

    {

      mp4free(audioTrackSize);

      mp4free(videoTrackSize);

      return -1;

    }

    PRINT((_L("e_writedatatofile_write_ftyp 0")));  

	PRINT((_L("e_writedatatofile_write_new_moov 1")));  

    if (writeMOOV(handle, metaDataSize - (FTYP_SIZE + ftypdelta), haveAudio, haveVideo, audioTrackSize, videoTrackSize) < 0)

    {

      mp4free(audioTrackSize);

      mp4free(videoTrackSize);

      return -1;

    }

    PRINT((_L("e_writedatatofile_write_new_moov 0")));

	PRINT((_L("e_writedatatofile_write_new_mdia 1")));

    if (writeMediaData(handle) < 0)

    {

      mp4free(audioTrackSize);

      mp4free(videoTrackSize);

      return -1;

    }

    PRINT((_L("e_writedatatofile_write_new_mdia 0")));

  }

PRINT((_L("e_writedatatofile_free_audioandvideotrks 1")));

  mp4free(audioTrackSize);

  mp4free(videoTrackSize);

PRINT((_L("e_writedatatofile_free_audioandvideotrks 0")));

PRINT((_L("e_writedatatofile 0")));

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 updateDecodingTimeToSample(MP4HandleImp handle,

 *                                      sampleTable *st,

 *                                      mp4_u32 duration)

 *

 * Description:

 *

 *   This function updates stts atom data.

 *

 * Parameters:

 *

 *   handle    MP4 library handle

 *   st        sampleTable

 *   duration  Duration of sample to insert (in media timescale)

 *

 * Return value:

 *

 *   0         Success

 *   -1        Error

 *

 */

mp4_i32 updateDecodingTimeToSample(MP4HandleImp handle, sampleTable *st, mp4_u32 duration)

{

  if (!handle)

    return -1;

  if (handle->flags & MP4_FLAG_LONGCLIP)

  {

    if (st->sttsCurrentEntryCount == 0)

    {

      st->sttsSampleCount[st->sttsCurrentEntryCount] = 1;

      st->sttsSampleDelta[st->sttsCurrentEntryCount] = duration;

      st->sttsCurrentEntryCount++;

      st->sttsEntryCount++;

      return 0;

    }

    if (st->sttsCurrentEntryCount == st->sttsMaxEntryCount)

    {

      void *p;

      p = mp4realloc(st->sttsSampleCount,

                     2 * sizeof(mp4_u32) * st->sttsMaxEntryCount,

                     sizeof(mp4_u32) * st->sttsMaxEntryCount);

      if (p == NULL)

        return -1;

      st->sttsSampleCount = (mp4_u32 *)p;

      p = mp4realloc(st->sttsSampleDelta,