// 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)

    {

        fs->Close();

        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 ) != KErrNone)

  {

    fs->Close();

    return -1;

  }

  handle->file = handle->rfile;

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

  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);

  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")));        

      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);