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 <3gplibrary/mp4config.h>

    17 #include <3gplibrary/mp4lib.h>

    18 #include "mp4atom.h"

    19 #include "mp4memwrap.h"

    20 #include "mp4file.h"

    21 #include "mp4buffer.h"

    22 #include "mp4endian.h"

    23 #include "mp4utils.h"

    24 

    25 using namespace ContentAccess;

    26 

    27 extern EXPORT_C MP4Err MP4ParseOpen(MP4Handle *apihandle,

    28                                                  MP4FileName filename)

    29 {

    30   MP4HandleImp *handle = (MP4HandleStruct **)apihandle;

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

    32   if (*handle == NULL)

    33     return MP4_OUT_OF_MEMORY;

    34 

    35   (*handle)->file32Duplicate = NULL;

    36   (*handle)->FileHandleFromOutside = EFalse;

    37   (*handle)->sourceType = MP4_SOURCE_RFILE;

    38 

    39   if (filename)

    40     if (initFileRead(filename, *handle) == -1)

    41     {

    42       closeFile(*handle);

    43       mp4free(*handle);

    44       *handle = NULL;

    45       return MP4_FILE_ERROR;

    46     }

    47 

    48   (*handle)->mem = listCreate();

    49   if ((*handle)->mem == NULL)

    50   {

    51     closeFile(*handle);

    52     mp4free(*handle);

    53     *handle = NULL;

    54     return MP4_OUT_OF_MEMORY;

    55   }

    56 

    57   if (((*handle)->buf = (mp4_u8 *)mp4malloc(TMPBUFSIZE)) == NULL)

    58   {

    59     listDestroyList((*handle)->mem);

    60     closeFile(*handle);

    61     mp4free(*handle);

    62     *handle = NULL;

    63     return MP4_OUT_OF_MEMORY;

    64   }

    65 

    66   if (((*handle)->diskReadBuf = (mp4_u8 *)mp4malloc(READBUFSIZE)) == NULL)

    67   {

    68     mp4free((*handle)->buf);

    69     listDestroyList((*handle)->mem);

    70     closeFile(*handle);

    71     mp4free(*handle);

    72     *handle = NULL;

    73     return MP4_OUT_OF_MEMORY;

    74   }

    75 

    76   // register for stblib use 

    77   if (openStdlib() !=  MP4_OK)

    78 	  {

    79 	  mp4free((*handle)->diskReadBuf);	  

    80 	  mp4free((*handle)->buf);

    81 	  listDestroyList((*handle)->mem);

    82 	  closeFile(*handle);

    83 	  mp4free(*handle);

    84 	  *handle = NULL;

    85 	  

    86 	  return MP4_ERROR;

    87 	  }

    88   

    89   return MP4_OK;

    90 }

    91 

    92 extern EXPORT_C MP4Err MP4ParseOpenFileHandle(MP4Handle *apihandle,

    93                                                  RFile *inputfile)

    94 {

    95   MP4Err err;

    96   RFile64 *f64 = new RFile64;

    97   if (f64 == NULL)

    98   {

    99     return MP4_OUT_OF_MEMORY;

   100   }

   101   if  (f64->Duplicate(*inputfile) != KErrNone)

   102   {

   103     delete f64;

   104     return MP4_ERROR;

   105   }

   106   err = MP4ParseOpenFileHandle64(apihandle, f64);

   107   if (err == MP4_OK)

   108   {    

   109     MP4HandleImp* handle = (MP4HandleStruct **)apihandle;

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

   111   }

   112   return err;

   113 }

   114 

   115 extern EXPORT_C MP4Err MP4ParseOpenFileHandle64(MP4Handle *apihandle,

   116                                                  RFile64 *inputfile)

   117 {

   118   MP4HandleImp *handle = (MP4HandleStruct **)apihandle;

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

   120   if (*handle == NULL)

   121     return MP4_OUT_OF_MEMORY;

   122 

   123   (*handle)->file32Duplicate = NULL;

   124   (*handle)->rfile = (void *)inputfile;

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

   126   (*handle)->FileHandleFromOutside = ETrue;

   127   (*handle)->sourceType = MP4_SOURCE_RFILE;

   128   if (inputfile == NULL)

   129       {

   130       closeFile(*handle);

   131       mp4free(*handle);

   132       *handle = NULL;

   133       return MP4_FILE_ERROR;

   134       }

   135 

   136   (*handle)->mem = listCreate();

   137   if ((*handle)->mem == NULL)

   138   {

   139     closeFile(*handle);

   140     mp4free(*handle);

   141     *handle = NULL;

   142     return MP4_OUT_OF_MEMORY;

   143   }

   144 

   145   if (((*handle)->buf = (mp4_u8 *)mp4malloc(TMPBUFSIZE)) == NULL)

   146   {

   147     listDestroyList((*handle)->mem);

   148     closeFile(*handle);

   149     mp4free(*handle);

   150     *handle = NULL;

   151     return MP4_OUT_OF_MEMORY;

   152   }

   153 

   154   if (((*handle)->diskReadBuf = (mp4_u8 *)mp4malloc(READBUFSIZE)) == NULL)

   155   {

   156     mp4free((*handle)->buf);

   157     listDestroyList((*handle)->mem);

   158     closeFile(*handle);

   159     mp4free(*handle);

   160     *handle = NULL;

   161     return MP4_OUT_OF_MEMORY;

   162   }

   163 

   164   	// register for stblib use 

   165   	if (openStdlib() !=  MP4_OK)

   166   		{

   167   		// clean up

   168   		mp4free((*handle)->diskReadBuf);

   169 		mp4free((*handle)->buf);

   170 		listDestroyList((*handle)->mem);

   171 		closeFile(*handle);

   172 		mp4free(*handle);

   173 		*handle = NULL;

   174   

   175 		return MP4_ERROR;

   176   		} 

   177   

   178   return MP4_OK;

   179 }

   180 

   181 extern EXPORT_C MP4Err MP4ParseOpenCAF(MP4Handle *apihandle,

   182                                                     ContentAccess::CData *inputfile)

   183 {

   184   MP4HandleImp *handle = (MP4HandleStruct **)apihandle;

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

   186   if (*handle == NULL)

   187     return MP4_OUT_OF_MEMORY;

   188 

   189   (*handle)->file32Duplicate = NULL;

   190   (*handle)->cfile = inputfile;

   191   (*handle)->file = (*handle)->cfile;

   192   (*handle)->FileHandleFromOutside = ETrue;

   193   (*handle)->sourceType = MP4_SOURCE_CAF;

   194   

   195   if (inputfile == NULL)

   196       {

   197       closeFile(*handle);

   198       mp4free(*handle);

   199       *handle = NULL;

   200       return MP4_FILE_ERROR;

   201       }

   202 

   203   (*handle)->mem = listCreate();

   204   if ((*handle)->mem == NULL)

   205   {

   206     closeFile(*handle);

   207     mp4free(*handle);

   208     *handle = NULL;

   209     return MP4_OUT_OF_MEMORY;

   210   }

   211 

   212   if (((*handle)->buf = (mp4_u8 *)mp4malloc(TMPBUFSIZE)) == NULL)

   213   {

   214     listDestroyList((*handle)->mem);

   215     closeFile(*handle);

   216     mp4free(*handle);

   217     *handle = NULL;

   218     return MP4_OUT_OF_MEMORY;

   219   }

   220 

   221   if (((*handle)->diskReadBuf = (mp4_u8 *)mp4malloc(READBUFSIZE)) == NULL)

   222   {

   223     mp4free((*handle)->buf);

   224     listDestroyList((*handle)->mem);

   225     closeFile(*handle);

   226     mp4free(*handle);

   227     *handle = NULL;

   228     return MP4_OUT_OF_MEMORY;

   229   }

   230 

   231 	// register for stblib use 

   232 	if (openStdlib() !=  MP4_OK)

   233 		{

   234 		// clean up

   235 		mp4free((*handle)->diskReadBuf);

   236 		mp4free((*handle)->buf);

   237 		listDestroyList((*handle)->mem);

   238 		closeFile(*handle);

   239 		mp4free(*handle);

   240 		*handle = NULL;

   241 

   242 		return MP4_ERROR;

   243 		} 

   244   

   245   return MP4_OK;

   246 }

   247 

   248 extern EXPORT_C MP4Err MP4ParseClose(MP4Handle apihandle)

   249 {

   250   MP4HandleImp handle = (MP4HandleImp)apihandle;

   251 

   252   if (!handle)

   253     return MP4_ERROR;

   254 

   255   if (handle->file)

   256     closeFile(handle);

   257 

   258   closeStdlib(); /* Free memory allocated by stdlib wrapper functions */

   259 

   260   listDestroyList(handle->mem);

   261 

   262   if (handle->diskReadBuf)

   263     mp4free(handle->diskReadBuf);

   264 

   265   if (handle->buf)

   266     mp4free(handle->buf);

   267   

   268   if (freeMOOV(handle->moov) < 0)

   269    	return MP4_ERROR;

   270 

   271   if (freeFTYP(handle->ftyp) < 0)

   272    	return MP4_ERROR;

   273 

   274   if (handle->file32Duplicate)

   275       ((RFile64*)handle->file32Duplicate)->Close();

   276   

   277   if (handle)

   278     mp4free(handle);

   279 

   280   return MP4_OK;

   281 }

   282 

   283 extern EXPORT_C MP4Err MP4ParseRequestVideoDescription(MP4Handle apihandle,

   284                                                                     mp4_u32 *videolength,

   285                                                                     mp4_double *framerate,

   286                                                                     mp4_u32 *videotype,

   287                                                                     mp4_u32 *videowidth,

   288                                                                     mp4_u32 *videoheight,

   289                                                                     mp4_u32 *timescale)

   290 {

   291   MP4HandleImp handle = (MP4HandleImp)apihandle;

   292   if (!handle)

   293 	  {

   294 	  return MP4_ERROR;

   295 	  }

   296 

   297   if (!handle->metaDataComplete)

   298   {

   299     switch (metaDataAvailable(handle))

   300     {

   301     case 0:

   302       return MP4_NOT_AVAILABLE;

   303 

   304     case 1:

   305       handle->cafError = KErrNone;

   306       if (readMetaData(handle) < 0)

   307       {

   308       	// Reading of meta data failed, so free up any allocated memory

   309   		freeFTYP(handle->ftyp);

   310   		handle->ftyp = NULL;

   311 		freeMOOV(handle->moov);

   312 		handle->moov = NULL;

   313       

   314       	if ( handle->cafError != KErrNone )

   315       	{

   316       	  // if CAF/DRM caused the error return it instead of generic errorcode.

   317       	  return handle->cafError;

   318       	}

   319       	else

   320       	{

   321 	      return MP4_INVALID_INPUT_STREAM;

   322       	}

   323       }

   324       handle->metaDataComplete = MP4TRUE;

   325       break;

   326 

   327     case -2:

   328       // Reading of FTYP meta data failed, so free up any allocated memory

   329       freeFTYP(handle->ftyp);

   330       handle->ftyp = NULL;

   331       return MP4_ERROR;      

   332       

   333     case -1:

   334     default:

   335       return MP4_ERROR;

   336     }

   337   }

   338 

   339   if (!handle->moov)

   340     return MP4_ERROR;

   341   if (!handle->moov->trakVideo)

   342     return MP4_NO_VIDEO;

   343   

   344   mp4_i32 videoError = 0;

   345   videoError = determineVideoType(handle, videotype);

   346   if ( videoError == -2 )

   347   {

   348     return MP4_NO_VIDEO;

   349   }

   350   else if ( videoError < 0 )

   351   {

   352   	return MP4_ERROR;

   353   }

   354 

   355   if (determineVideoLength(handle, videolength) < 0)

   356     return MP4_ERROR;

   357 

   358   if (determineFrameRate(handle, framerate) < 0)

   359     return MP4_ERROR;

   360 

   361   if (determineVideoResolution(handle, videowidth, videoheight) < 0)

   362     return MP4_ERROR;

   363 

   364   if (determineVideoTimeScale(handle, timescale) < 0)

   365     return MP4_ERROR;

   366 

   367 

   368   return MP4_OK;

   369 }

   370 

   371 extern EXPORT_C MP4Err MP4ParseRequestAudioDescription(MP4Handle apihandle,

   372                                                                     mp4_u32 *audiolength,

   373                                                                     mp4_u32 *audiotype,

   374                                                                     mp4_u8 *framespersample,

   375                                                                     mp4_u32 *timescale,

   376                                                                     mp4_u32 *averagebitrate)

   377 {

   378   MP4HandleImp handle = (MP4HandleImp)apihandle;

   379   if (!handle)

   380 	  {

   381 	  return MP4_ERROR;

   382 	  }

   383 

   384   if (!handle->metaDataComplete)

   385   {

   386     switch (metaDataAvailable(handle))

   387     {

   388     case 0:

   389       return MP4_NOT_AVAILABLE;

   390 

   391     case 1:

   392       handle->cafError = KErrNone;

   393       if (readMetaData(handle) < 0)

   394       {

   395       	// Reading of meta data failed, so free up any allocated memory

   396   		freeFTYP(handle->ftyp);

   397   		handle->ftyp = NULL;

   398 		freeMOOV(handle->moov);

   399 		handle->moov = NULL;

   400       

   401       	if ( handle->cafError != KErrNone )

   402       	{

   403       	  // if CAF/DRM caused the error return it instead of generic errorcode.

   404       	  return handle->cafError;

   405       	}

   406       	else

   407       	{

   408 	      return MP4_INVALID_INPUT_STREAM;

   409       	}

   410       }

   411 

   412       handle->metaDataComplete = MP4TRUE;

   413       break;

   414 

   415     case -2:

   416       // Reading of FTYP meta data failed, so free up any allocated memory

   417       freeFTYP(handle->ftyp);

   418       handle->ftyp = NULL;

   419       return MP4_ERROR;      

   420 

   421     case -1:

   422     default:

   423       return MP4_ERROR;

   424     }

   425   }

   426 

   427   if (!handle->moov)

   428     return MP4_ERROR;

   429   if (!handle->moov->trakAudio)

   430     return MP4_NO_AUDIO;

   431 

   432   if (determineAudioLength(handle, audiolength) < 0)

   433     return MP4_ERROR;

   434   

   435   mp4_i32 audioError = 0;

   436   audioError = determineAudioType(handle, audiotype);

   437   if ( audioError == -2 )

   438   {

   439     return MP4_NO_AUDIO;

   440   }

   441   else if ( audioError < 0 )

   442   {

   443   	return MP4_ERROR;

   444   }

   445 

   446   if (determineAudioFramesPerSample(handle, framespersample) < 0)

   447     return MP4_ERROR;

   448 

   449   if (determineAudioTimeScale(handle, timescale) < 0)

   450     return MP4_ERROR;

   451 

   452   if (averagebitrate != NULL)

   453     if (determineAudioAverageBitRate(handle, averagebitrate) < 0)

   454       return MP4_ERROR;

   455 

   456 

   457   return MP4_OK;

   458 }

   459 

   460 extern EXPORT_C MP4Err MP4ParseRequestStreamDescription(MP4Handle apihandle,

   461                                                                      mp4_u32 *streamsize,

   462                                                                      mp4_u32 *streamaveragebitrate)

   463 {

   464   MP4HandleImp handle = (MP4HandleImp)apihandle;

   465 

   466   if (!handle->metaDataComplete)

   467   {

   468     switch (metaDataAvailable(handle))

   469     {

   470     case 0:

   471 

   472       return MP4_NOT_AVAILABLE;

   473 

   474     case 1:

   475       handle->cafError = KErrNone;

   476       if (readMetaData(handle) < 0)

   477       {

   478       	// Reading of meta data failed, so free up any allocated memory

   479   		freeFTYP(handle->ftyp);

   480   		handle->ftyp = NULL;

   481 		freeMOOV(handle->moov);

   482 		handle->moov = NULL;

   483       

   484       	if ( handle->cafError != KErrNone )

   485       	{

   486       	  // if CAF/DRM caused the error return it instead of generic errorcode.

   487       	  return handle->cafError;

   488       	}

   489       	else

   490       	{

   491 	      return MP4_INVALID_INPUT_STREAM;

   492       	}

   493       }

   494       handle->metaDataComplete = MP4TRUE;

   495       break;

   496 

   497     case -2:

   498       // Reading of FTYP meta data failed, so free up any allocated memory

   499       freeFTYP(handle->ftyp);

   500       handle->ftyp = NULL;

   501       return MP4_ERROR;      

   502       

   503     case -1:

   504     default:

   505       return MP4_ERROR;

   506     }

   507   }

   508 

   509   if (determineStreamSize(handle, streamsize) < 0)

   510     return MP4_ERROR;

   511 

   512   if (determineStreamAverageBitRate(handle, streamaveragebitrate, *streamsize) < 0)

   513     return MP4_ERROR;

   514 

   515 

   516   return MP4_OK;

   517 }

   518 

   519 extern EXPORT_C MP4Err MP4ParseWriteData(MP4Handle apihandle,

   520                                                       mp4_u8 *buffer,

   521                                                       mp4_u32 bytestowrite)

   522 {

   523   MP4HandleImp handle = (MP4HandleImp)apihandle;

   524 

   525   if (handle->file)

   526     return MP4_ERROR;

   527 

   528   if ((buffer == NULL) && (bytestowrite != 0))

   529       return MP4_ERROR;

   530 

   531   if (handle->LastWriteDataCalled == MP4TRUE)

   532       return MP4_ERROR;  // WriteData() call has been made before with bytestowrite=0, can not call again.

   533 

   534   if (bytestowrite != 0)

   535   {

   536       if (addData(handle, buffer, bytestowrite) == -1)

   537         return MP4_OUT_OF_MEMORY;

   538   }

   539   else  

   540       handle->LastWriteDataCalled = MP4TRUE;

   541 

   542 

   543   return MP4_OK;

   544 }

   545 

   546 extern EXPORT_C MP4Err MP4ParseGetBufferedBytes(MP4Handle apihandle,

   547                                                              mp4_u32 *bytes)

   548 {

   549   MP4HandleImp handle = (MP4HandleImp)apihandle;

   550 

   551   *bytes = getBufferedBytes(handle);

   552 

   553   if (handle->file)

   554     return MP4_FILE_MODE;

   555 

   556   return MP4_OK;

   557 }

   558 

   559 extern EXPORT_C MP4Err MP4ParseNextFrameType(MP4Handle apihandle,

   560                                                           mp4_u32 *type)

   561 	{

   562 	MP4HandleImp handle = (MP4HandleImp)apihandle;

   563 

   564 	if (!handle->metaDataComplete)

   565 		{

   566 		switch (metaDataAvailable(handle))

   567 			{

   568 			case 0:

   569 				return MP4_NOT_AVAILABLE;

   570 

   571 			case 1:

   572 				handle->cafError = KErrNone;

   573 				if (readMetaData(handle) < 0)

   574 					{

   575 			      	// Reading of meta data failed, so free up any allocated memory

   576 			  		freeFTYP(handle->ftyp);

   577 			  		handle->ftyp = NULL;

   578 					freeMOOV(handle->moov);

   579 					handle->moov = NULL;

   580 					

   581 					if ( handle->cafError != KErrNone )

   582 						{

   583 						// if CAF/DRM caused the error return it instead of generic errorcode.

   584 						return handle->cafError;

   585 						}

   586 					else

   587 						{

   588 						return MP4_INVALID_INPUT_STREAM;

   589 						}

   590 					}

   591 				handle->metaDataComplete = MP4TRUE;

   592 				break;

   593 

   594 		    case -2:

   595 		      // Reading of FTYP meta data failed, so free up any allocated memory

   596 		      freeFTYP(handle->ftyp);

   597 		      handle->ftyp = NULL;

   598 		      return MP4_ERROR;      

   599 				

   600 			case -1:

   601 			default:

   602 				return MP4_ERROR;

   603 			}

   604 		}

   605 

   606 	/* No audio nor video */

   607 	if ((!handle->moov->trakAudio) && (!handle->moov->trakVideo))

   608 		return MP4_ERROR;

   609   

   610 	mp4_u32 audiotype = 0;

   611 	mp4_i32 audioerror = 0; 

   612 	if (handle->moov->trakAudio)

   613 		{

   614 		audioerror = determineAudioType(handle, &audiotype);

   615 		}

   616   

   617 	mp4_u32 videotype = 0;

   618 	mp4_i32 videoerror = 0;

   619 	if (handle->moov->trakVideo)

   620 		{

   621 		videoerror = determineVideoType(handle, &videotype);

   622 		}

   623 

   624 	/* Audio track only */

   625 	if (handle->moov->trakAudio && !handle->moov->trakVideo)

   626 		{

   627 		if (audioerror == 0)

   628 			{

   629 			// if audio is of supported type, check if the last audio frame has been 

   630 			// retrieved

   631 			if (handle->audioLast)

   632 				{

   633 				return MP4_NO_FRAME;

   634 				}

   635 			else

   636 				{

   637 				*type = audiotype;

   638 				return MP4_OK;

   639 				}

   640 			}

   641 		else

   642 			{

   643 			return MP4_ERROR;

   644 			}

   645 		}

   646 

   647 	/* Video track only */

   648 	if (handle->moov->trakVideo && !handle->moov->trakAudio)

   649 		{

   650 		if (videoerror == 0)

   651 			{

   652 			// if video is of supported type, check if the last video frame has been 

   653 			// retrieved			

   654 			if (handle->videoLast)

   655 				{

   656 				return MP4_NO_FRAME;

   657 				}

   658 			else

   659 				{

   660 				*type = videotype;

   661 				return MP4_OK;

   662 				}

   663 			}

   664 		else

   665 			{

   666 			return MP4_ERROR;

   667 			}

   668 		}

   669 

   670 	/* All audio has been read, but there is video left */

   671 	if (handle->audioLast && !handle->videoLast)

   672 		{

   673 		if (videoerror == 0)

   674 			{

   675 			*type = videotype;

   676 			return MP4_OK;

   677 			}

   678 		else

   679 			{

   680 			return MP4_ERROR;

   681 			}

   682 		}

   683 

   684 	/* All video has been read, but there is audio left */

   685 	if (handle->videoLast && !handle->audioLast)

   686 		{

   687 		if (audioerror == 0)

   688 			{

   689 			*type = audiotype;

   690 			return MP4_OK;

   691 			}

   692 		else

   693 			{

   694 			return MP4_ERROR;

   695 			}

   696 		}

   697 

   698 	/* All data has been read */

   699 	if (handle->audioLast && handle->videoLast)

   700 		{

   701 		return MP4_NO_FRAME;

   702 		}

   703 

   704 	if (handle->audioSampleOffset < handle->videoFrameOffset)

   705 		{

   706 		/* Next frame is audio */

   707 		if (audioerror == 0)

   708 			{

   709 			*type = audiotype;

   710 			return MP4_OK;

   711 			}

   712 		else if ( (audioerror == -2) && (videoerror == 0) )

   713 			{

   714 			*type = videotype;

   715 			return MP4_OK;		

   716 			}

   717 		else

   718 			{

   719 			return MP4_ERROR;

   720 			}

   721 		}

   722 	else

   723 		{

   724 		/* Next frame is video */

   725 		if (videoerror == 0)

   726 			{

   727 			*type = videotype;

   728 			return MP4_OK;

   729 			}

   730 		else if ( (videoerror == -2) && (audioerror == 0) )

   731 			{

   732 			*type = audiotype;

   733 			return MP4_OK;		

   734 			}

   735 		else

   736 			{

   737 			return MP4_ERROR;

   738 			}

   739 		}

   740 	}

   741 

   742 extern EXPORT_C MP4Err MP4ParseNextFrameSize(MP4Handle apihandle,

   743                                                           mp4_u32 type,

   744                                                           mp4_u32 *framesize)

   745 {

   746   MP4HandleImp handle = (MP4HandleImp)apihandle;

   747 

   748   if (!handle->metaDataComplete)

   749   {

   750     switch (metaDataAvailable(handle))

   751     {

   752     case 0:

   753 

   754       return MP4_NOT_AVAILABLE;

   755 

   756     case 1:

   757       handle->cafError = KErrNone;

   758       if (readMetaData(handle) < 0)

   759       {

   760       	// Reading of meta data failed, so free up any allocated memory

   761   		freeFTYP(handle->ftyp);

   762   		handle->ftyp = NULL;

   763 		freeMOOV(handle->moov);

   764 		handle->moov = NULL;

   765       

   766       	if ( handle->cafError != KErrNone )

   767       	{

   768       	  // if CAF/DRM caused the error return it instead of generic errorcode.

   769       	  return handle->cafError;

   770       	}

   771       	else

   772       	{

   773 	      return MP4_INVALID_INPUT_STREAM;

   774       	}

   775       }

   776 

   777       handle->metaDataComplete = MP4TRUE;

   778       break;

   779 

   780     case -2:

   781       // Reading of FTYP meta data failed, so free up any allocated memory

   782       freeFTYP(handle->ftyp);

   783       handle->ftyp = NULL;

   784       return MP4_ERROR;            

   785       

   786     case -1:

   787     default:

   788       return MP4_ERROR;

   789     }

   790   }

   791 

   792   switch (type & handle->type)

   793   {

   794   case MP4_TYPE_MPEG4_VIDEO:

   795   case MP4_TYPE_H263_PROFILE_0:

   796   case MP4_TYPE_H263_PROFILE_3:

   797   case MP4_TYPE_AVC_PROFILE_BASELINE:

   798   case MP4_TYPE_AVC_PROFILE_MAIN:

   799   case MP4_TYPE_AVC_PROFILE_EXTENDED:

   800   case MP4_TYPE_AVC_PROFILE_HIGH:

   801   

   802     /* There is a next video frame */

   803 

   804     if (!handle->videoLast)

   805       *framesize = handle->videoFrameSize;

   806     else

   807     {

   808       *framesize = 0;

   809 

   810       return MP4_NO_REQUESTED_FRAME;

   811     }

   812 

   813     break;

   814 

   815   case MP4_TYPE_MPEG4_AUDIO:

   816   case MP4_TYPE_AMR_NB:

   817   case MP4_TYPE_AMR_WB:

   818   case MP4_TYPE_QCELP_13K:

   819 

   820     /* There is a next audio frame */

   821 

   822     if (!handle->audioLast)

   823       *framesize = handle->audioSampleSize;

   824     else

   825     {

   826       *framesize = 0;

   827 

   828       return MP4_NO_REQUESTED_FRAME;

   829     }

   830 

   831     break;

   832 

   833   case MP4_TYPE_NONE:

   834   default:

   835 

   836     if (type == MP4_TYPE_MPEG4_VIDEO ||

   837         type == MP4_TYPE_H263_PROFILE_0 ||

   838         type == MP4_TYPE_H263_PROFILE_3 ||

   839         type == MP4_TYPE_MPEG4_AUDIO ||

   840         type == MP4_TYPE_AMR_NB ||

   841         type == MP4_TYPE_AMR_WB ||

   842 		isAvcVideo(type) ||

   843         type == MP4_TYPE_QCELP_13K

   844         )

   845       return MP4_NO_REQUESTED_FRAME;

   846 

   847     return MP4_INVALID_TYPE;

   848   }

   849 

   850   return MP4_OK;

   851 }

   852 

   853 extern EXPORT_C MP4Err MP4ParseReadVideoFrame(MP4Handle apihandle,

   854                                                            mp4_u8 *buffer,

   855                                                            mp4_u32 buffersize,

   856                                                            mp4_u32 *framesize,

   857                                                            mp4_u32 *timestamp,

   858                                                            mp4_bool *keyframe,

   859                                                            mp4_u32 *timestamp2)

   860 {

   861   MP4HandleImp handle = (MP4HandleImp)apihandle;

   862 

   863   if (!handle->metaDataComplete)

   864   {

   865     switch (metaDataAvailable(handle))

   866     {

   867     case 0:

   868 

   869       return MP4_NOT_AVAILABLE;

   870 

   871     case 1:

   872       handle->cafError = KErrNone;

   873       if (readMetaData(handle) < 0)

   874       {

   875       	// Reading of meta data failed, so free up any allocated memory

   876   		freeFTYP(handle->ftyp);

   877   		handle->ftyp = NULL;

   878 		freeMOOV(handle->moov);

   879 		handle->moov = NULL;

   880       

   881       	if ( handle->cafError != KErrNone )

   882       	{

   883       	  // if CAF/DRM caused the error return it instead of generic errorcode.

   884       	  return handle->cafError;

   885       	}

   886       	else

   887       	{

   888 	      return MP4_INVALID_INPUT_STREAM;

   889       	}

   890       }

   891       handle->metaDataComplete = MP4TRUE;

   892       break;

   893 

   894     case -2:

   895       // Reading of FTYP meta data failed, so free up any allocated memory

   896       freeFTYP(handle->ftyp);

   897       handle->ftyp = NULL;

   898       return MP4_ERROR;      

   899       

   900     case -1:

   901     default:

   902       return MP4_ERROR;

   903     }

   904   }

   905 

   906   /* Is video available? */

   907 

   908   if (!((handle->type & MP4_TYPE_MPEG4_VIDEO) ||

   909         (handle->type & MP4_TYPE_H263_PROFILE_0) ||

   910         (handle->type & MP4_TYPE_H263_PROFILE_3) ||

   911 		containsAvcVideo( handle->type ) ))

   912     return MP4_ERROR;

   913 

   914   /* Are there samples left? */

   915 

   916   if (handle->videoLast)

   917     return MP4_NO_FRAME;

   918 

   919   if (!handle->moov)

   920     return MP4_ERROR;

   921   if (!handle->moov->trakVideo)

   922     return MP4_ERROR;

   923 

   924   switch (fetchVideoFrame(handle, handle->moov->trakVideo, buffer, buffersize, framesize, timestamp, keyframe, timestamp2))

   925   {

   926   case -1:

   927     return MP4_ERROR;

   928   case -2:

   929     return MP4_BUFFER_TOO_SMALL;

   930   case -3:

   931     return MP4_NOT_AVAILABLE;

   932   case -4:

   933     return MP4_INVALID_INPUT_STREAM;

   934   default:

   935     break;

   936   }

   937 

   938   switch (advanceVideoFrame(handle, handle->moov->trakVideo))

   939   {

   940   case -1:

   941     return MP4_ERROR;

   942   case -2:

   943     handle->videoLast = MP4TRUE;

   944     break;

   945   default:

   946     break;

   947   }

   948 

   949   return MP4_OK;

   950 }

   951 

   952 extern EXPORT_C MP4Err MP4ParseReadVideoDecoderSpecificInfo(MP4Handle apihandle,

   953                                                                          mp4_u8 *buffer,

   954                                                                          mp4_u32 buffersize,

   955                                                                          mp4_u32 *decspecinfosize)

   956 	{

   957 	MP4HandleImp handle = (MP4HandleImp)apihandle;

   958 	if (!handle->metaDataComplete)

   959 		{

   960 		switch (metaDataAvailable(handle))

   961 			{

   962 			case 0:

   963 				return MP4_NOT_AVAILABLE;

   964 

   965 			case 1:

   966 				handle->cafError = KErrNone;

   967 				if (readMetaData(handle) < 0)

   968 					{

   969 			      	// Reading of meta data failed, so free up any allocated memory

   970 			  		freeFTYP(handle->ftyp);

   971 			  		handle->ftyp = NULL;

   972 					freeMOOV(handle->moov);

   973 					handle->moov = NULL;

   974 					

   975 					if ( handle->cafError != KErrNone )

   976 						{

   977 						// if CAF/DRM caused the error return it instead of generic errorcode.

   978 						return handle->cafError;

   979 						}

   980 					else

   981 						{

   982 						return MP4_INVALID_INPUT_STREAM;

   983 						}

   984 					}

   985 				handle->metaDataComplete = MP4TRUE;

   986 				break;

   987 

   988 		    case -2:

   989 		      // Reading of FTYP meta data failed, so free up any allocated memory

   990 		      freeFTYP(handle->ftyp);

   991 		      handle->ftyp = NULL;

   992 		      return MP4_ERROR;      

   993 

   994 			case -1:

   995 			default:

   996 				return MP4_ERROR;

   997 			}

   998 		}

   999 

  1000 	/* Is video type MPEG or AVC? */

  1001 	if (!(handle->type & MP4_TYPE_MPEG4_VIDEO) && 

  1002 	   !(containsAvcVideo( handle->type )) )

  1003 		{

  1004 		return MP4_ERROR;

  1005 		}

  1006 

  1007 	if (!handle->moov)

  1008 		{

  1009 		return MP4_ERROR;

  1010 		}

  1011 	if (!handle->moov->trakVideo)

  1012 		{

  1013 		return MP4_ERROR;

  1014 		}

  1015 	if (!handle->moov->trakVideo->mdia)

  1016 		{

  1017 		return MP4_ERROR;

  1018 		}

  1019 	if (!handle->moov->trakVideo->mdia->minf)

  1020 		{

  1021 		return MP4_ERROR;

  1022 		}

  1023 	if (!handle->moov->trakVideo->mdia->minf->stbl)

  1024 		{

  1025 		return MP4_ERROR;

  1026 		}

  1027 	if (!handle->moov->trakVideo->mdia->minf->stbl->stsd)

  1028 		{

  1029 		return MP4_ERROR;

  1030 		}

  1031 	if (handle->videoSampleEntryIndex > handle->moov->trakVideo->mdia->minf->stbl->stsd->entryCount)

  1032 		{

  1033 		return MP4_ERROR;

  1034 		}			

  1035 

  1036 	TInt index = handle->videoSampleEntryIndex - 1;		  

  1037 	if (handle->videoSampleEntryIndex == 0)			  

  1038 		{

  1039 		// even though the video sample contains no actual data, if the video sample exist

  1040 		// and contains decoder specific info, return it anyway

  1041 		index = 0;

  1042 		}

  1043 	

  1044 	if (handle->type & MP4_TYPE_MPEG4_VIDEO)

  1045 		{

  1046 		/* Copy DecoderSpecificInfo into buffer */

  1047 		if (!handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index])

  1048 			{

  1049 			return MP4_ERROR;

  1050 			}

  1051 		if (!handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd)

  1052 			{

  1053 			return MP4_ERROR;

  1054 			}

  1055 

  1056 		*decspecinfosize = handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd->decSpecificInfoSize;

  1057 		if (buffersize < handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd->decSpecificInfoSize)

  1058 			{

  1059 			return MP4_BUFFER_TOO_SMALL;

  1060 			}

  1061 

  1062 		mp4memcpy(buffer, 

  1063 				  handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd->decSpecificInfo,

  1064 				  handle->moov->trakVideo->mdia->minf->stbl->stsd->mp4v[index]->esd->decSpecificInfoSize);

  1065 		}

  1066   	else if ( containsAvcVideo( handle->type ) )

  1067   		{

  1068   		/* Copy the AVCDecoderConfigurationRecord into buffer */

  1069   		if (!handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index])

  1070   			{

  1071   			return MP4_ERROR;

  1072   			}

  1073   		if (!handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc)

  1074   			{

  1075   			return MP4_ERROR;

  1076   			}

  1077 

  1078   		*decspecinfosize = handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc->avcConfigSize;

  1079   		if (buffersize < handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc->avcConfigSize)

  1080   			{

  1081   			return MP4_BUFFER_TOO_SMALL;

  1082   			}

  1083 

  1084   		mp4memcpy(buffer,

  1085   				  handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc->avcConfig,

  1086 				  handle->moov->trakVideo->mdia->minf->stbl->stsd->avc1[index]->avcc->avcConfigSize);

  1087   		}

  1088 

  1089 	return MP4_OK;

  1090 	}

  1091 

  1092 extern EXPORT_C MP4Err MP4ParseReadAudioFrames(MP4Handle apihandle,

  1093                                                             mp4_u8 *buffer,

  1094                                                             mp4_u32 buffersize,

  1095                                                             mp4_u32 *audiosize,

  1096                                                             mp4_u32 *timestamp,

  1097                                                             mp4_u32 *returnedframes,

  1098                                                             mp4_u32 *timestamp2)

  1099 {

  1100   MP4HandleImp handle = (MP4HandleImp)apihandle;

  1101 

  1102   if (!handle->metaDataComplete)

  1103   {

  1104     switch (metaDataAvailable(handle))

  1105     {

  1106     case 0:

  1107       return MP4_NOT_AVAILABLE;

  1108 

  1109     case 1:

  1110       handle->cafError = KErrNone;

  1111       if (readMetaData(handle) < 0)

  1112       {

  1113       	// Reading of meta data failed, so free up any allocated memory

  1114   		freeFTYP(handle->ftyp);

  1115   		handle->ftyp = NULL;

  1116 		freeMOOV(handle->moov);

  1117 		handle->moov = NULL;

  1118       

  1119       	if ( handle->cafError != KErrNone )

  1120       	{

  1121       	  // if CAF/DRM caused the error return it instead of generic errorcode.

  1122       	  return handle->cafError;

  1123       	}

  1124       	else

  1125       	{

  1126 	      return MP4_INVALID_INPUT_STREAM;

  1127       	}

  1128       }

  1129       handle->metaDataComplete = MP4TRUE;

  1130       break;

  1131 

  1132     case -2:

  1133       // Reading of FTYP meta data failed, so free up any allocated memory

  1134       freeFTYP(handle->ftyp);