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

#include "mp4memwrap.h"

#include "mp4atom.h"

#include <stdio.h>

#include <string.h>

#include <sys/unistd.h>

#include <sys/reent.h>

#include <f32file.h>

#include <f32file64.h>

#include <e32des16.h>

#include <caf/caf.h>

using namespace ContentAccess;

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x)     //comment this line and uncomment the line below to enable logging for this file

//#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

_LIT(KTmpDirectoryName, "\\System\\Temp\\3GPLibTmpDir\\"); // Temporary output directory name

/*

 * Function:

 *

 *   mp4_i32 saveFileName(MP4FileName filename,

 *                        MP4HandleImp handle)

 *

 * Description:

 *

 *   Save file name for later use.

 *

 * Parameters:

 *

 *   filename   Filename

 *   handle     MP4 library handle

 *

 * Return value:

 *

 *   0          Success

 *   -1         Error

 *

 */

mp4_i32 saveFileName(MP4FileName filename, MP4HandleImp handle)

{

  handle->fileName = (MP4FileName)mp4malloc(2 * wcslen(filename) + 2);

  if (handle->fileName == NULL)

    return -1;

  wcscat(handle->fileName, filename);

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 initFileRead(MP4FileName filename,

 *                        MP4HandleImp handle)

 *

 * Description:

 *

 *   Open a file for reading.

 *

 *   Note: filename is a Unicode string in Symbian OS.

 *

 * Parameters:

 *

 *   filename   Filename

 *   handle     MP4 library handle

 *

 * Return value:

 *

 *   0          Success

 *   -1         Error

 *

 */

mp4_i32 initFileRead(MP4FileName filename, MP4HandleImp handle)

{

  RFs   *fs;

  RFile64 *file;

  fs = new(RFs);

  handle->fs = (void *)fs;

  if (fs == NULL)

    return -1;

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

    return -1;

  file = new(RFile64);

  handle->rfile = (void *)file;

  if (file == NULL)

    return -1;

  if (file->Open(*fs, TPtrC((const TUint16 *)filename), EFileRead | EFileShareAny) != KErrNone)

  {

    // for compatibility, if opening in Any mode fails try more restrictive approach.

    if (file->Open(*fs, TPtrC((const TUint16 *)filename), EFileRead | EFileShareReadersOnly) != KErrNone)

    {

        return -1;

    }

  }

  handle->file = handle->rfile;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 initFileWrite(MP4FileName filename,

 *                         MP4HandleImp handle)

 *

 * Description:

 *

 *   Open a file for writing.

 *

 *   Note: filename is a Unicode string in Symbian OS.

 *

 * Parameters:

 *

 *   filename   Filename

 *   handle     MP4 library handle

 *

 * Return value:

 *

 *   0          Success

 *   -1         Error

 *

 */

mp4_i32 initFileWrite(MP4FileName filename, MP4HandleImp handle)

{

  RFs   *fs;

  RFile64 *file;

  TParse fp;

  TFileName path;

  TInt error;

  fs = new(RFs);

  handle->fs = (void *)fs;

  if (fs == NULL)

    return -1;

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

    return -1;

  file = new(RFile64);

  handle->rfile = (void *)file;

  if (file == NULL)

    return -1;

  if (((RFs *)(handle->fs))->Parse(TPtrC((const TUint16 *)filename), fp) != KErrNone)

    return -1;

  path.Insert(0, fp.DriveAndPath() );

  error = ((RFs *)(handle->fs))->MkDirAll(path);

  if (error != KErrNone && error != KErrAlreadyExists)

    return -1;

  if (file->Replace(*fs, TPtrC((const TUint16 *)filename), EFileWrite|EFileShareExclusive|EFileWriteDirectIO ) != KErrNone)

  {

    return -1;

  }

  TBuf8<16> buf;

  buf.Copy(fp.Drive());

  buf.LowerCase();

  TInt drvNum = (*buf.Ptr()) - 'a';

  PRINT((_L("drvNum = %d"), drvNum));

  TVolumeInfo volInfo;

  error = fs->Volume(volInfo, drvNum);

  if (error != KErrNone) 

      {

      return -1;

      }

  PRINT((_L("volInfo.iFree = %Ld"), volInfo.iFree));

  PRINT((_L("volInfo.iSize = %Ld"), volInfo.iSize));    

  TVolumeIOParamInfo ioInfo;

  error = fs->VolumeIOParam(drvNum, ioInfo);

  if (error != KErrNone) 

      {

      return -1;

      }

  PRINT((_L("ioInfo.iBlockSize = %d"), ioInfo.iBlockSize));

  PRINT((_L("ioInfo.iClusterSize = %d"), ioInfo.iClusterSize));

  if (ioInfo.iClusterSize <= 0 || (ioInfo.iClusterSize & 0x1)) // if for some reason we got wrong value for the cluster - ignore it 

     {

     PRINT(_L("Wrong cluster size, set 0x8000"));

     ioInfo.iClusterSize = 0x8000;

     }

  // We want to have size of writing buffer to be a multiple of cluster size. Small buffer should be 1 cluster, large buffer should be 8 clusters.

  TInt writeBufferSizeSmall = ioInfo.iClusterSize;

  TInt writeBufferSizeLarge = ioInfo.iClusterSize * 8;

  // Now need to make sure that writeBufferSizeLarge is not too small (<128K) or too big (>256K) whilst keeping it a multiple of cluster size

  if (writeBufferSizeLarge < KFileWriterBufferSizeLarge/2)

      {

      writeBufferSizeLarge = KFileWriterBufferSizeLarge/2;

      }

  if (writeBufferSizeLarge > KFileWriterBufferSizeLarge)

	  {

	  writeBufferSizeLarge = (KFileWriterBufferSizeLarge / ioInfo.iClusterSize) * ioInfo.iClusterSize;

  	  }

  if (writeBufferSizeLarge < ioInfo.iClusterSize) 

      {

      writeBufferSizeLarge = ioInfo.iClusterSize;

      }

  PRINT((_L("writeBufferSizeLarge = %d"), writeBufferSizeLarge));

  TInt incSetSize = writeBufferSizeLarge * (KFileWriterHardBufLimit >> 1); // 2Mb if cluster size if 32767

  TInt initSetSize = incSetSize * 1; // set initial set size for 2Mb

  if (initSetSize > volInfo.iFree) 

      {

      initSetSize = (volInfo.iFree / incSetSize) * incSetSize;

      }

  PRINT((_L("initSetSize = %d"), initSetSize));

  PRINT((_L("e_SetSize 1")));  

  file->SetSize(initSetSize);

  PRINT((_L("e_SetSize 0")));  

  handle->file = handle->rfile;

  TRAP(error, handle->filewriter = CFileWriter::NewL( *file, initSetSize, writeBufferSizeSmall, writeBufferSizeLarge));

  if ( error != KErrNone )

  {

    return -1;    

  }

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 initTmpFileWrite(MP4FileName filename,

 *                            MP4HandleImp handle)

 *

 * Description:

 *

 *   Open a temporary file for writing.

 *

 *   Note: filename is a Unicode string in Symbian OS.

 *

 * Parameters:

 *

 *   filename   Filename

 *   handle     MP4 library handle

 *

 * Return value:

 *

 *   0          Success

 *   -1         Error

 *

 */

mp4_i32 initTmpFileWrite(MP4FileName filename, MP4HandleImp handle)

{

  TInt err;

  RFile64 * file = new RFile64;

  TBuf16<KMaxFileName> name(reinterpret_cast<const TUint16*>(filename));

  ASSERT(handle->fs != NULL);

  err = file->Replace(*(RFs*)(handle->fs), name, EFileStream | EFileRead | EFileWrite | EFileWriteDirectIO);

  if (err != KErrNone)

  {

	delete file;

	return -1;

  }

  handle->tmpfile = (void *)file;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 closeFile(MP4HandleImp handle)

 *

 * Description:

 *

 *   Close a file.

 *

 * Parameters:

 *

 *   handle   MP4 library handle

 *

 * Return value:

 *

 *   0        Success

 *

 */

mp4_i32 closeFile(MP4HandleImp handle)

{

  PRINT((_L("e_closefile 1")));

  if (handle->rfile)

  {

    if (handle->filewriter)

    {

      PRINT((_L("e_closefile_flush_filewriter 1")));        

      (handle->filewriter)->Flush(KNullDesC8);

      PRINT((_L("e_closefile_flush_filewriter 0")));        

      PRINT((_L("e_SetSize 1")));  

      ((RFile64 *)(handle->file))->SetSize((handle->filewriter)->OutputFileSize());

      PRINT((_L("e_SetSize 0: iOutputFileSize = %Ld"), (handle->filewriter)->OutputFileSize()));  

	  delete handle->filewriter;

      handle->filewriter = NULL;

    }

  }

  if (handle->asyncReader)

  {

	delete handle->asyncReader;

	handle->asyncReader = NULL;

  }

  if (handle->rfile)

  {

    if ( !handle->FileHandleFromOutside )

        {

  		PRINT((_L("e_closefile_close_file 1")));        

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

  		PRINT((_L("e_closefile_close_file 0"))); 

		PRINT((_L("e_closefile_delete_fileptr 1")));  		

        delete(handle->rfile);

		PRINT((_L("e_closefile_delete_fileptr 0")));        

        }

    handle->rfile = NULL;

  }

  if (handle->cfile)

  {

    if ( !handle->FileHandleFromOutside )

        {

        delete(handle->cfile);

        }

    handle->cfile = NULL;

  }

  PRINT((_L("e_closefile_close_rfs 1")));

  if (handle->fs)

  {

    ((RFs *)(handle->fs))->Close();

    delete(handle->fs);

    handle->fs = NULL;

  }

  PRINT((_L("e_closefile_close_rfs 0")));  

  handle->file = NULL;

  PRINT((_L("e_closefile 0")));

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 closeTmpFile(MP4HandleImp handle)

 *

 * Description:

 *

 *   Close a temporary file.

 *

 * Parameters:

 *

 *   handle   MP4 library handle

 *

 * Return value:

 *

 *   0        Success

 *

 */

mp4_i32 closeTmpFile(MP4HandleImp handle)

{

  if (handle->tmpfile)

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

  handle->tmpfile = NULL;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 deleteTmpFile(MP4HandleImp handle)

 *

 * Description:

 *

 *   Remove a temporary file.

 *

 * Parameters:

 *

 *   handle   MP4 library handle

 *

 * Return value:

 *

 *   0        Success

 *   -1       Error

 *

 */

mp4_i32 deleteTmpFile(MP4HandleImp handle)

{

  if (handle->tmpFileName)

	{

	  TInt err;

	  TBuf<KMaxFileName> name(reinterpret_cast<const TUint16*>(handle->tmpFileName));

	  ASSERT(handle->fs != NULL);

	  err = ((RFs*)handle->fs)->Delete(name);

	  if (err != KErrNone)

		return -1;

	}

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 readFile(MP4HandleImp handle,

 *                    mp4_u8 *buffer,

 *                    mp4_u32 bytestoread)

 *

 * Description:

 *

 *   Read data from a file.

 *

 * Parameters:

 *

 *   handle       MP4 library handle

 *   buffer       Buffer to read data into

 *   bytestoread  Number of bytes to read from file

 *

 * Return value:

 *

 *   0            Success

 *   -1           File has not been opened

 *   -2           Requested number of bytes could not be read

 *

 */

mp4_i32 readFile(MP4HandleImp handle, mp4_u8 *buffer, mp4_u32 bytestoread)

{

  return bufferedRead(handle, buffer, bytestoread);

}

/*

 * Function:

 *

 *   mp4_i32 readTmpFile(MP4HandleImp handle,

 *                       mp4_u8 *buffer,

 *                       mp4_u32 bytestoread)

 *

 * Description:

 *

 *   Read data from a temporary file.

 *

 * Parameters:

 *

 *   handle       MP4 library handle

 *   buffer       Buffer to read data into

 *   bytestoread  Number of bytes to read from file

 *

 * Return value:

 *

 *   0            Success

 *   -1           File has not been opened

 *   -2           Requested number of bytes could not be read

 *

 */

mp4_i32 readTmpFile(MP4HandleImp handle, mp4_u8 *buffer, mp4_u32 bytestoread)

{

  if (!handle->tmpfile)

    return -1;

  TInt err;

  TPtr8 ptrBuffer(buffer, bytestoread);

  err = ((RFile64*)handle->tmpfile)->Read(ptrBuffer, bytestoread);

  if (err != KErrNone)

	return -2;

  if (ptrBuffer.Length() != bytestoread)

	return -2;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 peekFile(MP4HandleImp handle,

 *                    mp4_u8 *buffer,

 *                    mp4_u32 bytestoread)

 *

 * Description:

 *

 *   Read data from a file but don't move the current position in the file

 *   forward.

 *

 * Parameters:

 *

 *   handle       MP4 library handle

 *   buffer       Buffer to read data into

 *   bytestoread  Number of bytes to read from file

 *

 * Return value:

 *

 *   0            Success

 *   -1           File has not been opened

 *   -2           Requested number of bytes could not be read

 *   -3           Current position in the file could not be set to original

 *                value

 *

 */

mp4_i32 peekFile(MP4HandleImp handle, mp4_u8 *buffer, mp4_u32 bytestoread)

{

  mp4_i32 ret;

  mp4_i32 amount;

  ret = bufferedRead(handle, buffer, bytestoread);

  if (ret != 0)

    return ret;

  amount = -(mp4_i32)bytestoread;

  ret = bufferedSeek(handle, amount);

  if (ret != 0)

    return ret;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 seekFile(MP4HandleImp handle,

 *                    mp4_i32 amount)

 *

 * Description:

 *

 *   Seek in a file.

 *

 * Parameters:

 *

 *   handle   MP4 library handle

 *   amount   Amount to seek from current position

 *

 * Return value:

 *

 *   0        Success

 *   -1       File has not been opened

 *   -3       Current position in the file could not be set

 *

 */

mp4_i32 seekFile(MP4HandleImp handle, mp4_i64 amount)

{

  return bufferedSeek(handle, amount);

}

/*

 * Function:

 *

 *   mp4_i32 seekFileAbs(MP4HandleImp handle,

 *                       mp4_i32 amount)

 *

 * Description:

 *

 *   Seek from the beginning of a file.

 *

 * Parameters:

 *

 *   handle   MP4 library handle

 *   amount   Amount to seek from the beginning of the file

 *

 * Return value:

 *

 *   0        Success

 *   -1       File has not been opened

 *   -3       Current position in the file could not be set

 *

 */

mp4_i32 seekFileAbs(MP4HandleImp handle, mp4_i64 amount)

{

  return bufferedSeekAbs(handle, amount);

}

/*

 * Function:

 *

 *   mp4_i32 seekFileWrite(MP4HandleImp handle,

 *                         mp4_i64 amount)

 *

 * Description:

 *

 *   Seek in a file that has been opened for writing.

 *

 * Parameters:

 *

 *   handle   MP4 library handle

 *   amount   Amount to seek from current position

 *

 * Return value:

 *

 *   0        Success

 *   -1       File has not been opened

 *   -2       Can't write buffers to file

 *   -3       Current position in the file could not be set

 *

 */

mp4_i32 seekFileWrite(MP4HandleImp handle, mp4_i64 amount)

{

  if (!handle->rfile)

    return -1;

  if ( handle->filewriter )

  {

    PRINT((_L("e_seekfilewrite_flush_filewriter 1")));        

    if ( (handle->filewriter)->Flush(KNullDesC8) != KErrNone )

    {

      PRINT((_L("e_seekfilewrite_flush_filewriter 0")));        

      return -2;

    }

    PRINT((_L("e_seekfilewrite_flush_filewriter 0")));        

  }

  else

  {

    return -1;

  }

  PRINT((_L("e_seekfilewrite_seek_rfile 1")));        

  if (((RFile64 *)(handle->rfile))->Seek(ESeekCurrent,amount) != KErrNone)

  {

    return -3;

  }

  PRINT((_L("e_seekfilewrite_seek_rfile 0")));        

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 seekFileAbsWrite(MP4HandleImp handle,

 *                            mp4_i32 amount)

 *

 * Description:

 *

 *   Seek from the beginning of a file that has been opened for writing.

 *

 * Parameters:

 *

 *   handle   MP4 library handle

 *   amount   Amount to seek from the beginning of the file

 *

 * Return value:

 *

 *   0        Success

 *   -1       File has not been opened

 *   -2       Can't write buffers to file

 *   -3       Current position in the file could not be set

 *

 */

mp4_i32 seekFileAbsWrite(MP4HandleImp handle, mp4_i64 amount)

{

  if (!handle->rfile)

    return -1;

  if ( handle->filewriter )

  {

    PRINT((_L("e_seekfileabswrite_flush 1")));        

    if ( (handle->filewriter)->Flush(KNullDesC8) != KErrNone )

    {

      PRINT((_L("e_seekfileabswrite_flush 0")));        

      return -2;

    }

    PRINT((_L("e_seekfileabswrite_flush 0")));        

  }

  else

  {

    return -1;

  }

  PRINT((_L("e_seekfileabswrite_seek 1")));  

  if (((RFile64 *)(handle->rfile))->Seek(ESeekStart, amount) != KErrNone)

  {

    return -3;

  }

  PRINT((_L("e_seekfileabswrite_seek 0")));        

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 seekTmpFileAbs(MP4HandleImp handle,

 *                          mp4_i32 amount)

 *

 * Description:

 *

 *   Seek from the beginning of a temporary file.

 *

 * Parameters:

 *

 *   handle   MP4 library handle

 *   amount   Amount to seek from the beginning of the file

 *

 * Return value:

 *

 *   0        Success

 *   -1       File has not been opened

 *   -3       Current position in the file could not be set

 *

 */

mp4_i32 seekTmpFileAbs(MP4HandleImp handle, mp4_i64 amount)

{

  if (!handle->tmpfile)

    return -1;

  TInt err;

  TInt64 amount64 = amount;

  err = ((RFile64*)handle->tmpfile)->Seek(ESeekStart, amount64);

  if (err != KErrNone)

	return -3;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 writeFile(MP4HandleImp handle,

 *                     mp4_u8 *buffer,

 *                     mp4_u32 bytestowrite)

 *

 * Description:

 *

 *   Write data into a file.

 *

 * Parameters:

 *

 *   handle        MP4 library handle

 *   buffer        Buffer containing the data

 *   bytestowrite  Number of bytes to write

 *

 * Return value:

 *

 *   0             Success

 *   -1            File has not been opened

 *   -2            Number of bytes written is not equal to bytestowrite

 *

 */

mp4_i32 writeFile(MP4HandleImp handle, mp4_u8 *buffer, mp4_u32 bytestowrite)

{

  return bufferedWrite(handle, buffer, bytestowrite);

}

/*

 * Function:

 *

 *   mp4_i32 writeFileUnbuffered(MP4HandleImp handle,

 *                               mp4_u8 *buffer,

 *                               mp4_u32 bytestowrite)

 *

 * Description:

 *

 *   Write data into a file without buffering.

 *

 * Parameters:

 *

 *   handle        MP4 library handle

 *   buffer        Buffer containing the data

 *   bytestowrite  Number of bytes to write

 *

 * Return value:

 *

 *   0             Success

 *   -1            File has not been opened

 *   -2            Number of bytes written is not equal to bytestowrite

 *

 */

mp4_i32 writeFileUnbuffered(MP4HandleImp handle, mp4_u8 *buffer, mp4_u32 bytestowrite)

{

  if(handle->bufferWrite)

  {

	mp4memcpy(handle->composeBuffer+FTYP_SIZE + handle->ftypdelta,buffer,bytestowrite);

	return 0;

  }

  if (!handle->rfile)

    return -1;

  if ( handle->filewriter )

  {

    TPtrC8 buf = TPtrC8((TUint8 *)(buffer), bytestowrite);

    PRINT((_L("e_writefileunbuffered_flush 1")));        

    if ( (handle->filewriter)->Flush( buf ) != KErrNone )

    {

      PRINT((_L("e_writefileunbuffered_flush 0")));        

      return -2;

    }

    PRINT((_L("e_writefileunbuffered_flush 0")));        

  }

  else

  {

    return -1;

  }

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 writeTmpFile(MP4HandleImp handle,

 *                        mp4_u8 *buffer,

 *                        mp4_u32 bytestowrite)

 *

 * Description:

 *

 *   Write data into a temporary file.

 *

 * Parameters:

 *

 *   handle        MP4 library handle

 *   buffer        Buffer containing the data

 *   bytestowrite  Number of bytes to write

 *

 * Return value:

 *

 *   0             Success

 *   -1            File has not been opened

 *   -2            Number of bytes written is not equal to bytestowrite

 *

 */

mp4_i32 writeTmpFile(MP4HandleImp handle, mp4_u8 *buffer, mp4_u32 bytestowrite)

{

  if (!handle->tmpfile)

    return -1;

  TInt err;

  TPtrC8 ptrBuffer(buffer, bytestowrite);

  err = ((RFile64*)handle->tmpfile)->Write(ptrBuffer, bytestowrite);

  if (err != KErrNone)

	return -2;

  if (ptrBuffer.Length() != bytestowrite)

	return -2;

  handle->bytesInTmpFile += bytestowrite;

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 createTmpFileName(MP4FileName filename,

 *                             MP4FileName *tmpfilename)

 *

 * Description:

 *

 *   Create a temporary file name by adding .tmp to the end of a file name.

 *

 * Parameters:

 *

 *   filename     Original file name

 *   tmpfilename  Temporary file name is returned here

 *

 * Return value:

 *

 *   0            Success

 *   -1           Memory could not be allocated for the new name

 *

 */

mp4_i32 createTmpFileName(MP4FileName filename, MP4FileName *tmpfilename)

{

  *tmpfilename = (MP4FileName)mp4malloc(2 * wcslen(filename) + 10);

  if (*tmpfilename == NULL)

    return -1;

  wcscat(*tmpfilename, filename);

  wcscat(*tmpfilename, L".tmp");

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 freeTmpFileName(MP4FileName filename)

 *

 * Description:

 *

 *   Free memory allocated for the temporary file name.

 *

 * Parameters:

 *

 *   filename   Buffer containing file name

 *

 * Return value:

 *

 *   0          Success

 *

 */

mp4_i32 freeTmpFileName(MP4FileName filename)

{

  if (filename)

    mp4free(filename);

  return 0;

}

/*

 * Function:

 *

 *   void closeStdlib()

 *

 * Description:

 *

 *   Free memory allocated by stdlib wrapper functions (Symbian OS only).

 *

 * Parameters:

 *

 *   None

 *

 * Return value:

 *

 *   None

 *

 */

void closeStdlib()

	{

	// retrieves the TLS which stores the number of currently active instances of 

	// composer/parser

	TInt p = (TInt) Dll::Tls();

	// decrement the counter as one instance is being closed at this point

	p--;

	Dll::SetTls((TAny*) p);		

	if (p == 0)