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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <3gplibrary/mp4config.h>

#include <3gplibrary/mp4lib.h>

#include "mp4atom.h"

#include "mp4memwrap.h"

#include "mp4buffer.h"

#include "mp4endian.h"

#include "mp4file.h"

#include "mp4utils.h"

// MACROS

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

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

#define PRINT(x)

#else

#define PRINT(x)

#endif

mp4_i32 readBoxHeader(MP4HandleImp handle, mp4_i64* size, mp4_u32* type);

/*

 * Function:

 *

 *   mp4_i32 metaDataAvailable(MP4HandleImp handle)

 *

 * Description:

 *

 *   This function determines whether meta data is available for reading

 *   or not.

 *

 *   Meta data is available if the input is in a file.

 *

 *   When reading from a stream, meta data is considered available if

 *   it is in the beginning of the stream and the entire Moov atom has

 *   been received. FTYP atom is allowed before MOOV atom.

 *

 * Parameters:

 *

 *   handle   MP4 library handle

 *

 * Return value:

 *

 *   0                Meta data is not available because enough data has not

 *                    been inserted into the library

 *   1                Meta data is available

 *   Negative value   Meta data is not available because of fatal error

 *

 */

mp4_i32 metaDataAvailable(MP4HandleImp handle)

{

  mp4_u32 size;

  mp4_u32 type;

  /* Meta data is available if the input is in a file or if a complete file has been inputted as a stream*/

  if (handle->file)

    return 1;

  /* When reading from a stream, meta data is considered available if

     it is in the beginning of the stream and the entire MOOV atom has

     been received. FTYP atom is allowed before MOOV atom. */

  if (!handle->ftypRead)

  {

    if (peekData(handle, handle->buf, 8) < 0) /* 8 bytes are not available */

        return 0;

    size = u32endian(*((mp4_u32 *)handle->buf));

    type = u32endian(*((mp4_u32 *)(handle->buf+4)));

    if (type == ATOMTYPE_FTYP)

    {

      if (getBufferedBytes(handle) - handle->position < size) /* FTYP is not available */

        return 0;

      if ((handle->ftyp = (fileTypeAtom *)mp4malloc(sizeof(fileTypeAtom))) == NULL)

        return -100;

      if (readFTYP(handle, handle->ftyp) < 0)

        return -2;

    }

  }

  // Now the ftyp is read. No need to chedk MOOV presence for full files in the memory.

  if (handle->LastWriteDataCalled == MP4TRUE)

      return 1;

  if (handle->LastWriteDataCalled == MP4FALSE)

  {//Whole stream is not fed to the internal memory yet. 

   for (;;)

    {

      if (peekData(handle, handle->buf, 8) < 0)

        return 0;

      size = u32endian(*((mp4_u32 *)handle->buf));

      type = u32endian(*((mp4_u32 *)(handle->buf+4)));

      if (type == ATOMTYPE_MOOV)

        {

        if (getBufferedBytes(handle) - handle->absPosition >= size) /* Entire Moov is available */

            {

            return 1;        

            }

        else

            {

            return 0;

            }

        }

      if ((mp4_i32)size <= 0)

        return -1;

      handle->absPosition+=size;

    }

  }

  return 0;

}

/*

 * Function:

 *

 *   mp4_i32 readFTYP(MP4HandleImp handle,

 *                    fileTypeAtom *ftyp)

 *

 * Description:

 *

 *   This function parses one FTYP atom.

 *

 * Parameters:

 *

 *   handle             MP4 library handle

 *   ftyp               FTYP pointer

 *

 * Return value:

 *

 *   Negative integer   Error

 *   >= 0               Success. Value tells how many bytes were read.

 *

 */

mp4_i32 readFTYP(MP4HandleImp handle, fileTypeAtom *ftyp)

{

  mp4_i32 bytesread;

  mp4_i32 totalbytesread = 0;

  mp4_u32 n = 0;

  mp4_i32 compatiblebrandsize = 0;

  if ((ftyp->atomhdr = (atomHeader *)mp4malloc(sizeof(atomHeader))) == NULL)

    return -100;

  bytesread = readAtomHeader(handle, ftyp->atomhdr);

  if (bytesread < 0)

    return -1;

  totalbytesread += bytesread;

  if (ftyp->atomhdr->type != ATOMTYPE_FTYP)

    return -1;

  if (ftyp->atomhdr->size < 16) // 8(header)+8bytes needed for major and minor brand

    return -1;

  bytesread = readData(handle, handle->buf, 4);

  if (bytesread < 0)

    return -1;

  ftyp->majorBrand = u32endian(*((mp4_u32 *)handle->buf));

  totalbytesread += bytesread;

  bytesread = readData(handle, handle->buf, 4);

  if (bytesread < 0)

    return -1;

  ftyp->minorVersion = u32endian(*((mp4_u32 *)handle->buf));

  totalbytesread += bytesread;

  if (ftyp->atomhdr->size == (mp4_u32)totalbytesread)

    return totalbytesread;

  compatiblebrandsize = (mp4_i32)ftyp->atomhdr->size - totalbytesread;

  if ( compatiblebrandsize < 4 )   // at this point we must have at least 1 compatible brand

    return -1;

  if ( compatiblebrandsize > 20*4) // maximum of 20 compatible brands 4byte entries

    return -1;

  if ( compatiblebrandsize % 4 ) // must be able to divide by 4

    return -1;

  ftyp->compatibleBrands = (mp4_u32 *)mp4malloc( compatiblebrandsize );

  if (ftyp->compatibleBrands == NULL)

    return -1;

  while ((mp4_u32)totalbytesread < ftyp->atomhdr->size)

  {

    bytesread = readData(handle, handle->buf, 4);

    if (bytesread < 0)

      return -1;

    ftyp->compatibleBrands[n] = u32endian(*((mp4_u32 *)handle->buf));

    n++;

    totalbytesread += bytesread;

  }

  return totalbytesread;

}

/*

 * Function:

 *

 *   mp4_i32 readMetaData(MP4HandleImp handle)

 *

 * Description:

 *

 *   This function reads the meta data from the file/stream and stores

 *   the information in the atom structures available via handle.

 *

 * Parameters:

 *

 *   handle  MP4 library handle

 *

 * Return value:

 *

 *   Negative value   Error

 *   >= 0             Success. Value tells the number of bytes read.

 *

 */

mp4_i32 readMetaData(MP4HandleImp handle)

{

  mp4_i32 bytesread;

  mp4_i32 totalbytesread = 0;

  if (handle->file)

  {

    mp4_u64 size;

    mp4_u32 type;

    if (seekFileAbs(handle, 0) < 0)

      return -1;

    /* Seek to the start of FTYP atom */

    for (;;)

    {

      if (readBoxHeader(handle, &size, &type) <0)

        return -1;

      if (type == ATOMTYPE_FTYP)

      {

        /* Read FTYP */

        if ((handle->ftyp = (fileTypeAtom *)mp4malloc(sizeof(fileTypeAtom))) == NULL)

          return -100;

        bytesread = readFTYP(handle, handle->ftyp);

        if (bytesread < 0)

          return -3;

        totalbytesread += bytesread;

        break;

      }

      if (size <= 0)

        return -1;

      if (seekFile(handle, size) != 0)

        return -1;

    }

    if (seekFileAbs(handle, 0) < 0)

      return -1;

    /* Seek to the start of MOOV atom */

    for (;;)

    {

      if (readBoxHeader(handle, &size, &type) <0)

        return -1;

      if (type == ATOMTYPE_MOOV)

        break;

      if (size <= 0)

        return -1;

      if (seekFile(handle, size) != 0)

        return -1;

    }

  }

  // If all data of a file is in the memory and the file does not have MOOV box right after FTYP, 

  // then we need to seek for the location of the MOOV first

  if (handle->LastWriteDataCalled == MP4TRUE)

  { 

    mp4_u32 size;

    mp4_u32 type;

    // Seek until the beginning of MOOV box.

    for(;;)

    {

        if (peekData(handle, handle->buf, 8) < 0)

            return -1;

        size = u32endian(*((mp4_u32 *)handle->buf));

        type = u32endian(*((mp4_u32 *)(handle->buf+4)));

        if (type == ATOMTYPE_MOOV)

          break;

        if ((mp4_i32)size <= 0)

          return -1;

        if (discardData(handle, size) < 0)

          return -1;

    }

  }

  if ((handle->moov = (movieAtom *)mp4malloc(sizeof(movieAtom))) == NULL)

    return -100;

  bytesread = readMoov(handle, handle->moov);

  if (bytesread < 0)

    return -3;

  totalbytesread += bytesread;

  if (handle->moov->trakAudio)

  {

    mp4_u32 audiotype;

	mp4_i32 errorAudio = 0;

	errorAudio = determineAudioType(handle, &audiotype);

    if ( errorAudio == 0 )

    {

	   	handle->type |= audiotype;    	

	    /* Move to the beginning of the 1st audio frame */

	    switch (advanceAudioSample(handle, handle->moov->trakAudio))

	    {

	    case -1:

	      return -1;

	    case -2:

	      handle->audioLast = MP4TRUE;

	      break;

	    default:

	      break;

	    }

	}

	else if (errorAudio == -2)

	{

		handle->type |= audiotype;	

	}

	else

	{

		return -1;

	}

  }

  if (handle->moov->trakVideo)

  {

    mp4_u32 videotype;

    mp4_i32 errorVideo = 0;

	errorVideo = determineVideoType(handle, &videotype);

    if ( errorVideo == 0 )

    {

	   	handle->type |= videotype;    	

    	/* Move to the beginning of the 1st video frame */

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

	    {

	    case -1:

	      return -1;

	    case -2:

	       handle->videoLast = MP4TRUE;

	      break;

	    default:

	      break;

	    }

	}

	else if (errorVideo == -2)

	{

	   	handle->type |= videotype;	

	}

	else

	{

		return -1;

	}

  }

  return totalbytesread;

}

/*

 * Function:

 *

 *   mp4_i32 readMoov(MP4HandleImp handle,

 *                    movieAtom *moov)

 *

 * Description:

 *

 *   This function parses one MOOV atom.

 *

 * Parameters:

 *

 *   handle             MP4 library handle

 *   moov               MOOV pointer

 *

 * Return value:

 *

 *   Negative integer   Error

 *   >= 0               Success. Value tells how many bytes were read.

 *

 */

mp4_i32 readMoov(MP4HandleImp handle, movieAtom *moov)

{

  mp4_i32 bytesread;

  mp4_i32 totalbytesread = 0;

  if ((moov->atomhdr = (atomHeader *)mp4malloc(sizeof(atomHeader))) == NULL)

    return -100;

  bytesread = readAtomHeader(handle, moov->atomhdr);

  if (bytesread < 0)

    return -1;

  totalbytesread += bytesread;

  if (moov->atomhdr->type != ATOMTYPE_MOOV)

    return -1;

  while ((mp4_u32)totalbytesread < handle->moov->atomhdr->size)

  {

    mp4_u32 type;

    if (peekData(handle, handle->buf, 8) < 0)

      return -1;

    type = u32endian(*((mp4_u32 *)(handle->buf+4)));

    switch (type)

    {

    case ATOMTYPE_MVHD:

      if (moov->mvhd) /* MVHD has already been read, more than one is not allowed */

        return -1;

      if ((moov->mvhd = (movieHeaderAtom *)mp4malloc(sizeof(movieHeaderAtom))) == NULL)

        return -100;

      bytesread = readMVHD(handle, moov->mvhd);

      if (bytesread < 0)

        return -1;

      totalbytesread += bytesread;

      break;

    case ATOMTYPE_IODS:

      if (moov->iods) /* IODS has already been read, more than one is not allowed */

        return -1;

      if ((moov->iods = (objectDescriptorAtom *)mp4malloc(sizeof(objectDescriptorAtom))) == NULL)

        return -100;

      bytesread = readIODS(handle, moov->iods);

      if (bytesread < 0)

        return -1;

      totalbytesread += bytesread;

      break;

    case ATOMTYPE_TRAK:

      {

        trackAtom *ta;

        if ((ta = (trackAtom *)mp4malloc(sizeof(trackAtom))) == NULL)

          return -100;

        bytesread = readTRAK(handle, ta);

        if (bytesread < 0)

        {

          if (freeTRAK(ta) < 0)

            return -1;

          return -1;

        }

        totalbytesread += bytesread;

        if (!ta->mdia)

        {

          if (freeTRAK(ta) < 0)

            return -1;

          return -1;

        }

        if (!ta->mdia->hdlr)

        {

          if (freeTRAK(ta) < 0)

            return -1;

          return -1;

        }

        if (ta->mdia->hdlr->handlerType != HANDLERTYPE_VIDE &&

            ta->mdia->hdlr->handlerType != HANDLERTYPE_SOUN) /* Track is neither video nor audio */

        {

          /* Do nothing with the unknown track */

          if (freeTRAK(ta) < 0)

            return -1;

          break;

        }

        if (ta->mdia->hdlr->handlerType == HANDLERTYPE_VIDE)

        {

	        if (moov->trakVideo) /* Video Track already read */