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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "mp4file.h"

    17 #include "mp4memwrap.h"

    18 #include "mp4atom.h"

    19 #include <stdio.h>

    20 #include <string.h>

    21 #include <sys/unistd.h>

    22 #include <sys/reent.h>

    23 #include <f32file.h>

    24 #include <f32file64.h>

    25 #include <e32des16.h>

    26 #include <caf/caf.h>

    27 

    28 using namespace ContentAccess;

    29 

    30 // Debug print macro

    31 #ifdef _DEBUG

    32 #include <e32svr.h>

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

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

    35 #else

    36 #define PRINT(x)

    37 #endif

    38 

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

    40 

    41 

    42 /*

    43  * Function:

    44  *

    45  *   mp4_i32 saveFileName(MP4FileName filename,

    46  *                        MP4HandleImp handle)

    47  *

    48  * Description:

    49  *

    50  *   Save file name for later use.

    51  *

    52  * Parameters:

    53  *

    54  *   filename   Filename

    55  *   handle     MP4 library handle

    56  *

    57  * Return value:

    58  *

    59  *   0          Success

    60  *   -1         Error

    61  *

    62  */

    63 mp4_i32 saveFileName(MP4FileName filename, MP4HandleImp handle)

    64 {

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

    66   if (handle->fileName == NULL)

    67     return -1;

    68 

    69   wcscat(handle->fileName, filename);

    70 

    71   return 0;

    72 }

    73 

    74 

    75 /*

    76  * Function:

    77  *

    78  *   mp4_i32 initFileRead(MP4FileName filename,

    79  *                        MP4HandleImp handle)

    80  *

    81  * Description:

    82  *

    83  *   Open a file for reading.

    84  *

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

    86  *

    87  * Parameters:

    88  *

    89  *   filename   Filename

    90  *   handle     MP4 library handle

    91  *

    92  * Return value:

    93  *

    94  *   0          Success

    95  *   -1         Error

    96  *

    97  */

    98 mp4_i32 initFileRead(MP4FileName filename, MP4HandleImp handle)

    99 {

   100   RFs   *fs;

   101   RFile64 *file;

   102 

   103 

   104   fs = new(RFs);

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

   106   if (fs == NULL)

   107     return -1;

   108 

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

   110     return -1;

   111 

   112   file = new(RFile64);

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

   114   if (file == NULL)

   115     return -1;

   116 

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

   118   {

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

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

   121     {

   122         fs->Close();

   123         return -1;

   124     }

   125   }

   126   handle->file = handle->rfile;

   127   return 0;

   128 }

   129 

   130 

   131 /*

   132  * Function:

   133  *

   134  *   mp4_i32 initFileWrite(MP4FileName filename,

   135  *                         MP4HandleImp handle)

   136  *

   137  * Description:

   138  *

   139  *   Open a file for writing.

   140  *

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

   142  *

   143  * Parameters:

   144  *

   145  *   filename   Filename

   146  *   handle     MP4 library handle

   147  *

   148  * Return value:

   149  *

   150  *   0          Success

   151  *   -1         Error

   152  *

   153  */

   154 mp4_i32 initFileWrite(MP4FileName filename, MP4HandleImp handle)

   155 {

   156   RFs   *fs;

   157   RFile64 *file;

   158   TParse fp;

   159   TFileName path;

   160   TInt error;

   161 

   162 

   163   fs = new(RFs);

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

   165   if (fs == NULL)

   166     return -1;

   167 

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

   169     return -1;

   170 

   171   file = new(RFile64);

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

   173   if (file == NULL)

   174     return -1;

   175 

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

   177     return -1;

   178 

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

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

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

   182     return -1;

   183 

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

   185   {

   186     fs->Close();

   187     return -1;

   188   }

   189 

   190   handle->file = handle->rfile;

   191 

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

   193   if ( error != KErrNone )

   194   {

   195     return -1;    

   196   }

   197 

   198   return 0;

   199 }

   200 

   201 

   202 /*

   203  * Function:

   204  *

   205  *   mp4_i32 initTmpFileWrite(MP4FileName filename,

   206  *                            MP4HandleImp handle)

   207  *

   208  * Description:

   209  *

   210  *   Open a temporary file for writing.

   211  *

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

   213  *

   214  * Parameters:

   215  *

   216  *   filename   Filename

   217  *   handle     MP4 library handle

   218  *

   219  * Return value:

   220  *

   221  *   0          Success

   222  *   -1         Error

   223  *

   224  */

   225 mp4_i32 initTmpFileWrite(MP4FileName filename, MP4HandleImp handle)

   226 {

   227   TInt err;

   228   RFile64 * file = new RFile64;

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

   230   ASSERT(handle->fs != NULL);

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

   232   if (err != KErrNone)

   233   {

   234 	delete file;

   235 	return -1;

   236   }

   237 

   238   handle->tmpfile = (void *)file;

   239   return 0;

   240 }

   241  

   242 

   243 /*

   244  * Function:

   245  *

   246  *   mp4_i32 closeFile(MP4HandleImp handle)

   247  *

   248  * Description:

   249  *

   250  *   Close a file.

   251  *

   252  * Parameters:

   253  *

   254  *   handle   MP4 library handle

   255  *

   256  * Return value:

   257  *

   258  *   0        Success

   259  *

   260  */

   261 mp4_i32 closeFile(MP4HandleImp handle)

   262 {

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

   264   if (handle->rfile)

   265   {

   266     if (handle->filewriter)

   267     {

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

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

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

   271       delete handle->filewriter;

   272       handle->filewriter = NULL;

   273     }

   274   }

   275 

   276   if (handle->asyncReader)

   277   {

   278 	delete handle->asyncReader;

   279 	handle->asyncReader = NULL;

   280   }

   281 

   282   if (handle->rfile)

   283   {

   284     if ( !handle->FileHandleFromOutside )

   285         {

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

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

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

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

   290         delete(handle->rfile);

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

   292         }

   293     handle->rfile = NULL;

   294   }

   295 

   296   if (handle->cfile)

   297   {

   298     if ( !handle->FileHandleFromOutside )

   299         {

   300         delete(handle->cfile);

   301         }

   302     handle->cfile = NULL;

   303   }

   304 

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

   306   if (handle->fs)

   307   {

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

   309 

   310     delete(handle->fs);

   311 

   312     handle->fs = NULL;

   313   }

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

   315 

   316   handle->file = NULL;

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

   318   return 0;

   319 }

   320 

   321 

   322 /*

   323  * Function:

   324  *

   325  *   mp4_i32 closeTmpFile(MP4HandleImp handle)

   326  *

   327  * Description:

   328  *

   329  *   Close a temporary file.

   330  *

   331  * Parameters:

   332  *

   333  *   handle   MP4 library handle

   334  *

   335  * Return value:

   336  *

   337  *   0        Success

   338  *

   339  */

   340 mp4_i32 closeTmpFile(MP4HandleImp handle)

   341 {

   342   if (handle->tmpfile)

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

   344 

   345   handle->tmpfile = NULL;

   346 

   347   return 0;

   348 }

   349 

   350 

   351 /*

   352  * Function:

   353  *

   354  *   mp4_i32 deleteTmpFile(MP4HandleImp handle)

   355  *

   356  * Description:

   357  *

   358  *   Remove a temporary file.

   359  *

   360  * Parameters:

   361  *

   362  *   handle   MP4 library handle

   363  *

   364  * Return value:

   365  *

   366  *   0        Success

   367  *   -1       Error

   368  *

   369  */

   370 mp4_i32 deleteTmpFile(MP4HandleImp handle)

   371 {

   372   if (handle->tmpFileName)

   373 	{

   374 	  TInt err;

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

   376 	  ASSERT(handle->fs != NULL);

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

   378 	  if (err != KErrNone)

   379 		return -1;

   380 	}

   381 

   382   return 0;

   383 }

   384 

   385 

   386 /*

   387  * Function:

   388  *

   389  *   mp4_i32 readFile(MP4HandleImp handle,

   390  *                    mp4_u8 *buffer,

   391  *                    mp4_u32 bytestoread)

   392  *

   393  * Description:

   394  *

   395  *   Read data from a file.

   396  *

   397  * Parameters:

   398  *

   399  *   handle       MP4 library handle

   400  *   buffer       Buffer to read data into

   401  *   bytestoread  Number of bytes to read from file

   402  *

   403  * Return value:

   404  *

   405  *   0            Success

   406  *   -1           File has not been opened

   407  *   -2           Requested number of bytes could not be read

   408  *

   409  */

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

   411 {

   412   return bufferedRead(handle, buffer, bytestoread);

   413 }

   414 

   415 /*

   416  * Function:

   417  *

   418  *   mp4_i32 readTmpFile(MP4HandleImp handle,

   419  *                       mp4_u8 *buffer,

   420  *                       mp4_u32 bytestoread)

   421  *

   422  * Description:

   423  *

   424  *   Read data from a temporary file.

   425  *

   426  * Parameters:

   427  *

   428  *   handle       MP4 library handle

   429  *   buffer       Buffer to read data into

   430  *   bytestoread  Number of bytes to read from file

   431  *

   432  * Return value:

   433  *

   434  *   0            Success

   435  *   -1           File has not been opened

   436  *   -2           Requested number of bytes could not be read

   437  *

   438  */

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

   440 {

   441   if (!handle->tmpfile)

   442     return -1;

   443 

   444   TInt err;

   445   TPtr8 ptrBuffer(buffer, bytestoread);

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

   447   if (err != KErrNone)

   448 	return -2;

   449 

   450   if (ptrBuffer.Length() != bytestoread)

   451 	return -2;

   452 

   453   return 0;

   454 }

   455 

   456 

   457 /*

   458  * Function:

   459  *

   460  *   mp4_i32 peekFile(MP4HandleImp handle,

   461  *                    mp4_u8 *buffer,

   462  *                    mp4_u32 bytestoread)

   463  *

   464  * Description:

   465  *

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

   467  *   forward.

   468  *

   469  * Parameters:

   470  *

   471  *   handle       MP4 library handle

   472  *   buffer       Buffer to read data into

   473  *   bytestoread  Number of bytes to read from file

   474  *

   475  * Return value:

   476  *

   477  *   0            Success

   478  *   -1           File has not been opened

   479  *   -2           Requested number of bytes could not be read

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

   481  *                value

   482  *

   483  */

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

   485 {

   486   mp4_i32 ret;

   487   mp4_i32 amount;

   488 

   489 

   490   ret = bufferedRead(handle, buffer, bytestoread);

   491   if (ret != 0)

   492     return ret;

   493 

   494   amount = -(mp4_i32)bytestoread;

   495 

   496   ret = bufferedSeek(handle, amount);

   497   if (ret != 0)

   498     return ret;

   499 

   500   return 0;

   501 }

   502 

   503 

   504 /*

   505  * Function:

   506  *

   507  *   mp4_i32 seekFile(MP4HandleImp handle,

   508  *                    mp4_i32 amount)

   509  *

   510  * Description:

   511  *

   512  *   Seek in a file.

   513  *

   514  * Parameters:

   515  *

   516  *   handle   MP4 library handle

   517  *   amount   Amount to seek from current position

   518  *

   519  * Return value:

   520  *

   521  *   0        Success

   522  *   -1       File has not been opened

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

   524  *

   525  */

   526 mp4_i32 seekFile(MP4HandleImp handle, mp4_i64 amount)

   527 {

   528   return bufferedSeek(handle, amount);

   529 }

   530 

   531 

   532 /*

   533  * Function:

   534  *

   535  *   mp4_i32 seekFileAbs(MP4HandleImp handle,

   536  *                       mp4_i32 amount)

   537  *

   538  * Description:

   539  *

   540  *   Seek from the beginning of a file.

   541  *

   542  * Parameters:

   543  *

   544  *   handle   MP4 library handle

   545  *   amount   Amount to seek from the beginning of the file

   546  *

   547  * Return value:

   548  *

   549  *   0        Success

   550  *   -1       File has not been opened

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

   552  *

   553  */

   554 mp4_i32 seekFileAbs(MP4HandleImp handle, mp4_i64 amount)

   555 {

   556   return bufferedSeekAbs(handle, amount);

   557 }

   558 

   559 

   560 /*

   561  * Function:

   562  *

   563  *   mp4_i32 seekFileWrite(MP4HandleImp handle,

   564  *                         mp4_i64 amount)

   565  *

   566  * Description:

   567  *

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

   569  *

   570  * Parameters:

   571  *

   572  *   handle   MP4 library handle

   573  *   amount   Amount to seek from current position

   574  *

   575  * Return value:

   576  *

   577  *   0        Success

   578  *   -1       File has not been opened

   579  *   -2       Can't write buffers to file

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

   581  *

   582  */

   583 mp4_i32 seekFileWrite(MP4HandleImp handle, mp4_i64 amount)

   584 {

   585 

   586   if (!handle->rfile)

   587     return -1;

   588 

   589   if ( handle->filewriter )

   590   {

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

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

   593     {

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

   595       return -2;

   596     }

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

   598   }

   599   else

   600   {

   601     return -1;

   602   }

   603 

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

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

   606   {

   607     return -3;

   608   }

   609   

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

   611 

   612   return 0;

   613 }

   614 

   615 

   616 /*

   617  * Function:

   618  *

   619  *   mp4_i32 seekFileAbsWrite(MP4HandleImp handle,

   620  *                            mp4_i32 amount)

   621  *

   622  * Description:

   623  *

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

   625  *

   626  * Parameters:

   627  *

   628  *   handle   MP4 library handle

   629  *   amount   Amount to seek from the beginning of the file

   630  *

   631  * Return value:

   632  *

   633  *   0        Success

   634  *   -1       File has not been opened

   635  *   -2       Can't write buffers to file

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

   637  *

   638  */

   639 mp4_i32 seekFileAbsWrite(MP4HandleImp handle, mp4_i64 amount)

   640 {

   641   if (!handle->rfile)

   642     return -1;

   643 

   644   if ( handle->filewriter )

   645   {

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

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

   648     {

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

   650       return -2;

   651     }

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

   653   }

   654   else

   655   {

   656     return -1;

   657   }

   658 

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

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

   661   {

   662     return -3;

   663   }

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

   665 

   666   return 0;

   667 }

   668 

   669 

   670 /*

   671  * Function:

   672  *

   673  *   mp4_i32 seekTmpFileAbs(MP4HandleImp handle,

   674  *                          mp4_i32 amount)

   675  *

   676  * Description:

   677  *

   678  *   Seek from the beginning of a temporary file.

   679  *

   680  * Parameters:

   681  *

   682  *   handle   MP4 library handle

   683  *   amount   Amount to seek from the beginning of the file

   684  *

   685  * Return value:

   686  *

   687  *   0        Success

   688  *   -1       File has not been opened

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

   690  *

   691  */

   692 mp4_i32 seekTmpFileAbs(MP4HandleImp handle, mp4_i64 amount)

   693 {

   694   if (!handle->tmpfile)

   695     return -1;

   696 

   697   TInt err;

   698   TInt64 amount64 = amount;

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

   700   if (err != KErrNone)

   701 	return -3;

   702 

   703   return 0;

   704 }

   705 

   706 

   707 /*

   708  * Function:

   709  *

   710  *   mp4_i32 writeFile(MP4HandleImp handle,

   711  *                     mp4_u8 *buffer,

   712  *                     mp4_u32 bytestowrite)

   713  *

   714  * Description:

   715  *

   716  *   Write data into a file.

   717  *

   718  * Parameters:

   719  *

   720  *   handle        MP4 library handle

   721  *   buffer        Buffer containing the data

   722  *   bytestowrite  Number of bytes to write

   723  *

   724  * Return value:

   725  *

   726  *   0             Success

   727  *   -1            File has not been opened

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

   729  *

   730  */

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

   732 {

   733   return bufferedWrite(handle, buffer, bytestowrite);

   734 }

   735 

   736 

   737 /*

   738  * Function:

   739  *

   740  *   mp4_i32 writeFileUnbuffered(MP4HandleImp handle,

   741  *                               mp4_u8 *buffer,

   742  *                               mp4_u32 bytestowrite)

   743  *

   744  * Description:

   745  *

   746  *   Write data into a file without buffering.

   747  *

   748  * Parameters:

   749  *

   750  *   handle        MP4 library handle

   751  *   buffer        Buffer containing the data

   752  *   bytestowrite  Number of bytes to write

   753  *

   754  * Return value:

   755  *

   756  *   0             Success

   757  *   -1            File has not been opened

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

   759  *

   760  */

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

   762 {

   763   if(handle->bufferWrite)

   764   {

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

   766 	return 0;

   767   }

   768   if (!handle->rfile)

   769     return -1;

   770 

   771   if ( handle->filewriter )

   772   {

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

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

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

   776     {

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

   778       return -2;

   779     }

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

   781   }

   782   else

   783   {

   784     return -1;

   785   }

   786 

   787   return 0;

   788 }

   789 

   790 

   791 /*

   792  * Function:

   793  *

   794  *   mp4_i32 writeTmpFile(MP4HandleImp handle,

   795  *                        mp4_u8 *buffer,

   796  *                        mp4_u32 bytestowrite)

   797  *

   798  * Description:

   799  *

   800  *   Write data into a temporary file.

   801  *

   802  * Parameters:

   803  *

   804  *   handle        MP4 library handle

   805  *   buffer        Buffer containing the data

   806  *   bytestowrite  Number of bytes to write

   807  *

   808  * Return value:

   809  *

   810  *   0             Success

   811  *   -1            File has not been opened

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

   813  *

   814  */

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

   816 {

   817   if (!handle->tmpfile)

   818     return -1;

   819 

   820   TInt err;

   821   TPtrC8 ptrBuffer(buffer, bytestowrite);

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

   823   if (err != KErrNone)

   824 	return -2;

   825 

   826   if (ptrBuffer.Length() != bytestowrite)

   827 	return -2;

   828 

   829   handle->bytesInTmpFile += bytestowrite;

   830 

   831   return 0;

   832 }

   833 

   834 

   835 /*

   836  * Function:

   837  *

   838  *   mp4_i32 createTmpFileName(MP4FileName filename,

   839  *                             MP4FileName *tmpfilename)

   840  *

   841  * Description:

   842  *

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

   844  *

   845  * Parameters:

   846  *

   847  *   filename     Original file name

   848  *   tmpfilename  Temporary file name is returned here

   849  *

   850  * Return value:

   851  *

   852  *   0            Success

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

   854  *

   855  */

   856 mp4_i32 createTmpFileName(MP4FileName filename, MP4FileName *tmpfilename)

   857 {

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

   859   if (*tmpfilename == NULL)

   860     return -1;

   861 

   862   wcscat(*tmpfilename, filename);

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

   864 

   865   return 0;

   866 }

   867 

   868 

   869 /*

   870  * Function:

   871  *

   872  *   mp4_i32 freeTmpFileName(MP4FileName filename)

   873  *

   874  * Description:

   875  *

   876  *   Free memory allocated for the temporary file name.

   877  *

   878  * Parameters:

   879  *

   880  *   filename   Buffer containing file name

   881  *

   882  * Return value:

   883  *

   884  *   0          Success

   885  *

   886  */

   887 mp4_i32 freeTmpFileName(MP4FileName filename)

   888 {

   889   if (filename)

   890     mp4free(filename);

   891 

   892   return 0;

   893 }

   894 

   895 

   896 /*

   897  * Function:

   898  *

   899  *   void closeStdlib()

   900  *

   901  * Description:

   902  *

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

   904  *

   905  * Parameters:

   906  *

   907  *   None

   908  *

   909  * Return value:

   910  *

   911  *   None

   912  *

   913  */

   914 void closeStdlib()

   915 	{

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

   917 	// composer/parser

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

   919 	

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

   921 	p--;

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

   923 

   924 	if (p == 0)

   925 		{

   926 		// Since memory allocated for stdlib is shared amongst all composers and/or parsers  

   927 		// within a thread, stdlib close should ONLY be called for the last instance of   

   928 		// composer / parser.

   929 		//

   930 		// If there are no other active instances other than this,

   931 		// the memory allocated for stdlib for this thread can now be released.

   932 		Dll::FreeTls();

   933 		CloseSTDLIB();

   934 		}

   935 	}

   936 

   937 /*

   938  * Function:

   939  *

   940  *   void openStdlib()

   941  *

   942  * Description:

   943  *

   944  *   Register the use of stdlib.  

   945  *

   946  * Parameters:

   947  *

   948  *   None

   949  *

   950  * Return value:

   951  *

   952  *   0 			Success

   953  *

   954  */

   955 mp4_i32 openStdlib()

   956 	{

   957 	// retrieve the the value stored in TLS for this DLL 

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

   959 	

   960 	// increment it.  This becomes a reference counter of 

   961 	// how many instances of the composer/parser is currently active 

   962 	p++;

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

   964 	}

   965 

   966 /*

   967  * Function:

   968  *

   969  *   mp4_i32 bufferedRead(MP4HandleImp handle,

   970  *                        mp4_u8 *buffer,

   971  *                        mp4_u32 bytestoread)

   972  *

   973  * Description:

   974  *

   975  *   Read data from a file in a buffered manner.

   976  *

   977  * Parameters:

   978  *

   979  *   handle       MP4 library handle

   980  *   buffer       Buffer to read data into

   981  *   bytestoread  Number of bytes to read from file

   982  *

   983  * Return value:

   984  *

   985  *   0            Success

   986  *   -1           File has not been opened

   987  *   -2           Requested number of bytes could not be read

   988  *

   989  */

   990 mp4_i32 bufferedRead(MP4HandleImp handle, mp4_u8 *buffer, mp4_u32 bytestoread)

   991 {

   992   mp4_u32 bytesread = 0;

   993 

   994   if (!handle->file)

   995     return -1;

   996 

   997   while (bytesread < bytestoread)

   998   {

   999     mp4_u32 available;

  1000 

  1001 

  1002     available = handle->diskReadSize - handle->diskReadBufPos;

  1003     if (available > bytestoread - bytesread)

  1004       available = bytestoread - bytesread;

  1005 

  1006     if (available > 0) /* Copy data from memory buffer */

  1007     {

  1008       mp4memcpy(buffer + bytesread, handle->diskReadBuf + handle->diskReadBufPos, available);

  1009       handle->diskReadBufPos += available;

  1010       bytesread += available;

  1011     }

  1012     else /* Read more data from file into memory buffer */

  1013     {

  1014       TInt readBufferSize = 0;

  1015       if ( handle->readBufferSize == 0)

  1016         {

  1017         readBufferSize = READBUFSIZE;

  1018         }

  1019       else

  1020         {

  1021         readBufferSize = handle->readBufferSize;

  1022         }

  1023 

  1024       TPtr8 buf = TPtr8((TUint8 *)(handle->diskReadBuf), readBufferSize);

  1025 

  1026       switch (handle->sourceType)

  1027       {

  1028         case MP4_SOURCE_RFILE:

  1029           if (((RFile64 *)(handle->rfile))->Read(buf, readBufferSize) != KErrNone)

  1030             return -2;

  1031           break;

  1032         case MP4_SOURCE_CAF:

  1033           handle->cafError = handle->cfile->Read(buf, readBufferSize);

  1034           if ( handle->cafError != KErrNone)

  1035             return -2;

  1036           break;

  1037         default:

  1038           return -1;

  1039       }

  1040 

  1041       if ((mp4_u32)buf.Length() == 0) /* EOF or error */

  1042         return -2;

  1043 

  1044       handle->diskReadBufPos = 0;

  1045       handle->diskReadSize = (mp4_u32)buf.Length();

  1046       handle->diskReadBufStart = handle->diskReadPos;

  1047       handle->diskReadPos += handle->diskReadSize;

  1048     }

  1049   }

  1050 

  1051   return 0;

  1052 }

  1053 

  1054 /*

  1055  * Function:

  1056  *

  1057  *   mp4_i32 bufferedSeek(MP4HandleImp handle,

  1058  *                        mp4_i32 amount)

  1059  *

  1060  * Description:

  1061  *

  1062  *   Seek in a buffered file.

  1063  *

  1064  * Parameters:

  1065  *

  1066  *   handle   MP4 library handle

  1067  *   amount   Amount to seek from current position

  1068  *

  1069  * Return value:

  1070  *

  1071  *   0        Success

  1072  *   -1       File has not been opened

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

  1074  *

  1075  */

  1076 mp4_i32 bufferedSeek(MP4HandleImp handle, mp4_i64 amount)

  1077 {

  1078   if (!handle->file)

  1079     return -1;

  1080 

  1081   /* Is the new seek point inside the current memory buffer? */

  1082   if ((mp4_i32)handle->diskReadBufPos + amount >= 0 &&

  1083       handle->diskReadBufPos + amount < handle->diskReadSize)

  1084   {

  1085     /* Yes */

  1086 

  1087     handle->diskReadBufPos += amount;

  1088   }

  1089   else

  1090   {

  1091     /* No */

  1092 

  1093     TInt64 am;

  1094 

  1095 

  1096     am = amount - ((mp4_i32)handle->diskReadSize - (mp4_i32)handle->diskReadBufPos);

  1097 

  1098     if ( handle->rfile )

  1099         {

  1100         mp4_i64 maxsize = 0;

  1101         ((RFile64 *)(handle->rfile))->Size(maxsize);

  1102         maxsize -= (mp4_i64)handle->diskReadPos;

  1103         

  1104         if (am > maxsize)

  1105             {

  1106             return -3;

  1107             }

  1108         }

  1109 	// Coverity thinks that cfile can never be not NULL, which is incorrect; it can be a proper value. The comment below silences the Coverity warning

  1110 	//coverity[var_compare_op]

  1111     else if ( handle->cfile )

  1112         {

  1113         mp4_i64 maxsize = 0;

  1114         TRAPD(caferr, handle->cfile->DataSize64L(maxsize));

  1115         maxsize -= (mp4_i64)handle->diskReadPos;

  1116         

  1117         if (!caferr && am > maxsize)

  1118             {

  1119             return -3;

  1120             }

  1121         }

  1122 

  1123     switch (handle->sourceType)

  1124     {

  1125       case MP4_SOURCE_RFILE:

  1126 		{

  1127         PRINT((_L("e_bufferedseek_seek_rfile 1")));        

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

  1129 		  {

  1130 		    return -3;

  1131 		  }

  1132         PRINT((_L("e_bufferedseek_seek_rfile 0")));        

  1133         break;

  1134 		}