/*

* Copyright (c) 2006 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:  Class definition for the DataSourceAdapter functions.

*

*/

//  INCLUDES

#include "3gpDataSourceAdapter.h"

#include "DebugMacros.h"

#include <mmfclip.h>

//#include <mmfdatabuffer.h>

#include <MultimediaDataSourceFactory.h>

#include <mmffile.h>

#include <caf/caf.h>

#include <mmfcontroller.h>

#include <oma2dcf.h> // EPeek

const TInt KDataSourceReadBufferSize = 16*1024; // read from source

const TInt KParserReadBufferSize = 2000; // read from parser - it only gives 1 frame

const TInt KMaxFrameSize = 1536;

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// C3gpDataSourceAdapter::C3gpDataSourceAdapter

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

C3gpDataSourceAdapter::C3gpDataSourceAdapter() :

    	MDataSink(KUidMmfFormatDecode)

    {

    }

// -----------------------------------------------------------------------------

// C3gpDataSourceAdapter::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void C3gpDataSourceAdapter::ConstructL()

    {

	// should end up doing this for all sources

	iMediaId = KUidMediaTypeAudio;

	iParserBuf = CreateSourceBufferOfSizeL(KParserReadBufferSize);

	iSrcBuf = CreateSourceBufferOfSizeL(KDataSourceReadBufferSize);

	iZeroBuffer = CMMFDataBuffer::NewL(0); // this is just for test to allow source seek

	iHdrBuffer = CMMFDataBuffer::NewL(20); // just enough to cover the header lengths create by recorder

    iAsyncProxyFillBuffer = new(ELeave) CAsyncProxyFillBuffer(*this);

	}

// -----------------------------------------------------------------------------

// C3gpDataSourceAdapter::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C C3gpDataSourceAdapter* C3gpDataSourceAdapter::NewL()

    {

    DP0(_L("C3gpDataSourceAdapter::NewL"));

    C3gpDataSourceAdapter* self = new(ELeave) C3gpDataSourceAdapter();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

EXPORT_C C3gpDataSourceAdapter::~C3gpDataSourceAdapter()

    {

    DP0(_L("C3gpDataSourceAdapter::~C3gpDataSourceAdapter"));

	MP4ParseClose(iMP4Handle);

	delete iParserBuf;

	delete iSrcBuf;

    delete iCafHandle;

    iQueuedAsyncBuffers.Close(); // this is different from one in base class

	delete iAsyncProxyFillBuffer; // this is different from one in base class

    }

// -----------------------------------------------------------------------------

// From MDataSource

// -----------------------------------------------------------------------------

//

EXPORT_C void C3gpDataSourceAdapter::FillBufferL(CMMFBuffer* aBuffer, MDataSink* aDataSink,TMediaId /*aMediaId*/)

	{

	TInt status = KErrNone;

    CMMFDataBuffer* buffer = static_cast<CMMFDataBuffer*>(aBuffer);

	DP1(_L("C3gpDataSourceAdapter::FillBufferL buffer[%x]"), buffer->Data().Ptr());

	if (aDataSink != this)

	    { // called from the controller

        iControllerMDataSink = aDataSink;

        iQueuedAsyncBuffers.Append(aBuffer);

	    if (iQueuedAsyncBuffers.Count() > 1)

	        {

			DP1(_L("C3gpDataSourceAdapter::FillBufferL buffer queued count[%d]"), iQueuedAsyncBuffers.Count());

    	    return;

	        }

	    }

    if (iParserBuf->Data().Length())

        {

		// Audio Frames previously read is appended first

        buffer->Data().Append(iParserBuf->Data().Ptr(), iParserBuf->Data().Length());

		iParserBuf->Data().SetLength(0);

        iParserBuf->SetPosition(0);

        }

    iFillingBuffer = aBuffer;

    if (iReadMp4LibSync)

    	{

	    iAsyncProxyFillBuffer->ReadSync();

    	}

    else

    	{

	    status = ReadAsync();

    	}	

    if (status == KErrNone)

        {

        // do nothing

        }

    else

        { // define the use case for this...

        DP1(_L("C3gpDataSourceAdapter::FillSharedBufferL, ReadAsync status[%d] calling frames available"), status);

        M3GPMP4LibAudioFramesAvailable(status, 0, 0,0,0);

        }

	}

EXPORT_C void C3gpDataSourceAdapter::SourcePrimeL()

	{

	DP0(_L("C3gpDataSourceAdapter::SourcePrimeL"));

	iDataSource->SourcePrimeL();

   	if (!iMP4Handle)

   		{

   		PrepareMP4ParserL();

   		}

	}

EXPORT_C void C3gpDataSourceAdapter::SourceStopL()

	{

	DP0(_L("C3gpDataSourceAdapter::SourceStopL"));

	ResetVariables();

	MP4ParseClose(iMP4Handle);

	iMP4Handle = NULL;

	iDataSource->SourceStopL();

	// Clear previously read Audio Frames  

	iParserBuf->Data().SetLength(0);

	iParserBuf->SetPosition(0);	

	}

// -----------------------------------------------------------------------------

// From MMultimediaDataSourceObserver

// -----------------------------------------------------------------------------

//

EXPORT_C void C3gpDataSourceAdapter::BufferFilled(CMMFBuffer* aBuffer)

	{

	TRAPD(err,BufferFilledL(aBuffer));

	if (err != KErrNone)

		{//send event to client to notify error in source adapter

	//	SendEvent(TMMFEvent(KMMFEventCategoryPlaybackComplete, err));		

		}

	}

EXPORT_C void C3gpDataSourceAdapter::Event(TUid aEvent)

	{

	iControllerMMultimediaDataSourceObserver->Event(aEvent);

	}

EXPORT_C TInt C3gpDataSourceAdapter::GetBitRate(TUint& aBitRate)

	{

	return iControllerMMultimediaDataSourceObserver->GetBitRate(aBitRate);

	}

// -----------------------------------------------------------------------------

// From CDataSourceAdapter

// -----------------------------------------------------------------------------

//

EXPORT_C TInt C3gpDataSourceAdapter::SeekToTime(TUint aTimeMs, TUint& aFoundTimeMs)

	{

	DP0(_L("C3gpDataSourceAdapter::SeekToTime"));

	TInt status = KErrNone;

    mp4_u32 audioTimeStamp, videoTimeStamp;

	MP4Err err = MP4ParseSeek(iMP4Handle, aTimeMs, &audioTimeStamp, &videoTimeStamp, EFalse);

	aFoundTimeMs = audioTimeStamp;

	DP3(_L("C3gpDataSourceAdapter::SeekToTime stat[%d] timeMs[%d] foundtimeMs[%d]"), err, aTimeMs,aFoundTimeMs);

	status = TranslateMP4Err(err);	

	return status;

	}

EXPORT_C void C3gpDataSourceAdapter::SetDataSourceL(MDataSource* aDataSource,

								 MMultimediaDataSourceObserver* aMMultimediaDataSourceObserver,

								 MAsyncEventHandler* aAsyncEventHandler)

	{

	DP0(_L("C3gpDataSourceAdapter::SetDataSource"));

	iHeaderOnly = EFalse;

	iControllerMMultimediaDataSourceObserver = aMMultimediaDataSourceObserver;

	iAsyncEventHandler = aAsyncEventHandler;

	ResetVariables();

   	if (iDataSource)

    	{

	    return;

   		}

    if (iCafHandle)

        {

        delete iCafHandle;

        iCafHandle = NULL;

        }

  	iDataSource = aDataSource;

    iSourceType = iDataSource->DataSourceType();

	DP1(_L("C3gpDataSourceAdapter::SetDataSource DataSourceType[0x%x]"), iSourceType);

    if ((iSourceType == KMmdsStreamingSourceUid) || (iSourceType == KMmdsProgDLSourceUid) ||

        (iSourceType == KS60AudioStreamingSourceUid) || (iSourceType == KMmdsDescriptorSourceUid) ||

        (iSourceType == KUidMmfDescriptorSource) || (iSourceType == KMmdsFileSourceUid))

		{ // data is streamed in buffers to parser and we read sync from parser - parser does not support seeking

		iReadMp4LibSync = ETrue;

		}

	else

		{ // parser has file handle and we read async from parser - parser supports seeking

		iReadMp4LibSync = EFalse;

    	iTimeSeekable = ETrue;

		}	

    if ((iSourceType == KMmdsStreamingSourceUid) || (iSourceType == KMmdsProgDLSourceUid) ||

        (iSourceType == KS60AudioStreamingSourceUid) || (iSourceType == KMmdsDescriptorSourceUid) ||

        (iSourceType == KMmdsFileSourceUid))

        { // data is written to parser

        TInt err = CMultimediaDataSourceFactory::CreateDataSource(*iDataSource, iMMDataSource);

        User::LeaveIfError(err);

//        iMMDataSource->SetObserver(*this);

        User::LeaveIfError(iMMDataSource->SetObserver(*this));

        User::LeaveIfError(iMMDataSource->Open());

        }

	if ((iSourceType == KUidMmfFileSource) || (iSourceType == KOldProgDLSourceUid))

    	{ // parser has file handle

		// read async from lib when it has a file handle

		iClip = static_cast<CMMFClip*>(iDataSource);

        iDataSource->SourcePrimeL();

   		iIsProtected = static_cast<CMMFFile*>(iDataSource)->IsProtectedL();

		iClip->SourceThreadLogon(*aAsyncEventHandler);

		iClip->ReadBufferL(iHdrBuffer,0);

		iClip->ReadBufferL(iZeroBuffer, 0); // seek back to 0 position

		const TUint8* ptr = iHdrBuffer->Data().Ptr();

    	if (iClip->Size() == 11)

    		{ // check for just the header from recorder

    		TUint32* w1p = (TUint32*)ptr;

    		TUint32* w2p = (TUint32*)(ptr+4);

    		TUint32* w3p = (TUint32*)(ptr+8);

    		if (((*w1p & 0x1C000000)==0x1C000000) && 

    			((*w2p & 0x70797466)==0x70797466) && 

    			((*w3p & 0x0034706D)==0x0034706D))

    			{

	    		iClip->SourceStopL();

    			iHeaderOnly = ETrue;

    			return;

    			}

    		}

        if (iSourceType == KUidMmfFileSource)

            {

            CMMFFile* File = static_cast<CMMFFile*>(iDataSource);                

            RFile rFile = File->FileL();

            iCafHandle = ContentAccess::CData::NewL(rFile, File->UniqueId(), EPeek);                

            }

    	}

	}

// -----------------------------------------------------------------------------

// From MDataSink

// -----------------------------------------------------------------------------

//

EXPORT_C void C3gpDataSourceAdapter::BufferFilledL(CMMFBuffer* aBuffer)

	{ // only talks to MMDataSource asynchronously using a single iSrcBuf

	// aBuffer here is just the one iSrcBuf

    CMMFDataBuffer* buffer = static_cast<CMMFDataBuffer*>(aBuffer);

    DP2(_L("C3gpDataSourceAdapter::BufferFilledL[%x], LastBuffer[%d]"), buffer->Data().Ptr(), aBuffer->LastBuffer());

	TUint bufferSize = buffer->Data().Length();

    DP1(_L("C3gpDataSourceAdapter::BufferFilledL, Length[%d]"), bufferSize);

	TUint8* bufPtr = const_cast<TUint8*>(buffer->Data().Ptr());

    TInt err = KErrNone;

/*	

	if ( bufferSize > 5 )

	{

	DP5(_L("C3gpDataSourceAdapter::BufferFilledL data[0x%x][0x%x][0x%x][0x%x][0x%x]"), \

	*bufPtr,*(bufPtr+1),*(bufPtr+2),*(bufPtr+3),*(bufPtr+4));

    }

*/	

    if (bufferSize > 0)

   	    {

   	    err = TranslateMP4Err(MP4ParseWriteData(iMP4Handle, bufPtr, bufferSize));

		//mp4_u32 audioLength, audioType, timeScale, averateBitRate;

		mp4_u32 audioLength, timeScale, averateBitRate;

		mp4_u8 framesPerSample;

		if (!iMp4HeaderAvail)

			{

			if (MP4_OK == MP4ParseRequestAudioDescription(iMP4Handle, &audioLength, &iAudioType,	&framesPerSample, &timeScale, &averateBitRate))

				{ // header is required to do anything.

				iMp4HeaderAvail = ETrue;

				}

			}

        DP3(_L("C3gpDataSourceAdapter::BufferFilledL, MP4ParseWriteData err[%d], bufferSize[%d] d0[%x]"), err, bufferSize, bufPtr[0]);

        if (err == MP4_OUT_OF_MEMORY)

        	{

	        DP0(_L("C3gpDataSourceAdapter::BufferFilledL, out of memory abort"));

	        User::Leave(KErrAbort);

        	}

    	if (err == MP4_OK)

    		{

	  	    if (!aBuffer->LastBuffer())

   		        {

	   	        // continue getting next buffer

		        DP1(_L("C3gpDataSourceAdapter::BufferFilledL, iMMDataSource->FillBuffer buffer[%x]"), iSrcBuf->Data().Ptr());

	       	    buffer->SetPosition(0);

			    buffer->Data().SetLength(0);

				iMMDataSource->FillBuffer(iSrcBuf);

	   	    	}

		    else

		        {

	    	    // do nothing, since the file has reach the end

            	DP0(_L("C3gpDataSourceAdapter::BufferFilledL, reach EOF"));

	            iLastBufferWrittenToMp4Lib = ETrue;

		        }

    		}

       	} // buffersize > 0

   	else

   	    { // buffersize <= 0

   	    // should never reach here, since no callback should occur if no data available for streaming

        DP0(_L("C3gpDataSourceAdapter::BufferFilledL, unexpected 0 length buffer"));

        User::Leave(KErrAbort);

   	    }

	if (iRestartSyncRead)

		{

		iRestartSyncRead = EFalse;

        DP0(_L("C3gpDataSourceAdapter::BufferFilledL, restarting parser read ReadSync()"));

	    iAsyncProxyFillBuffer->ReadSync();

		}

	}

EXPORT_C void C3gpDataSourceAdapter::EmptyBufferL(

	CMMFBuffer* /*aBuffer*/,

	MDataSource* /*aSupplier*/,

	TMediaId /*aMediaId*/ )

	{}

EXPORT_C TFourCC C3gpDataSourceAdapter::SinkDataTypeCode(

	TMediaId /*aMediaId*/ )

	{

	return KFourCCNULL;

	}

EXPORT_C TBool C3gpDataSourceAdapter::CanCreateSinkBuffer()

	{

	return EFalse;

	}

EXPORT_C CMMFBuffer* C3gpDataSourceAdapter::CreateSinkBufferL(

	TMediaId /*aMediaId*/,

	TBool& /*aReference*/ )

	{

	return NULL;

	}

EXPORT_C void C3gpDataSourceAdapter::ConstructSinkL(

	const TDesC8& /*aInitData*/ )

	{}

EXPORT_C TBool C3gpDataSourceAdapter::IsPositonSeekable()

    {

    DP1(_L("C3gpDataSourceAdapter::IsPositonSeekable DataSourceType[0x%x]"), iSourceType);

    if ((iSourceType == KMmdsStreamingSourceUid) || (iSourceType == KMmdsProgDLSourceUid) ||

        (iSourceType == KS60AudioStreamingSourceUid) || (iSourceType == KMmdsDescriptorSourceUid) ||

        (iSourceType == KUidMmfDescriptorSource) || (iSourceType == KMmdsFileSourceUid) ||

        (iSourceType == KOldProgDLSourceUid))

        {

        return EFalse;

        }

    else

        {

        return ETrue;

        }   

    }

// -----------------------------------------------------------------------------

// From M3GPMP4LibAsyncObserver

// -----------------------------------------------------------------------------

//

// -----------------------------------------------------------------------------

// C3gpDataSourceAdapter::M3GPMP4LibAudioFramesAvailable

// -----------------------------------------------------------------------------

//

void C3gpDataSourceAdapter::M3GPMP4LibAudioFramesAvailable(MP4Err aError,

                                                                mp4_u32 aAudioSize,

                                                                mp4_u32 /*aTimeStamp*/,

                                                                mp4_u32 /*aReturnedFrames*/,

                                                                mp4_u32 /*aTimestamp2*/)

    {

    DP2(_L("C3gpDataSourceAdapter::M3GPMP4LibAudioFramesAvailable, aError = %d, aAudioSize = %d"), aError, aAudioSize);

    DP2(_L("C3gpDataSourceAdapter::M3GPMP4LibAudioFramesAvailable, iParserBuf[%x] d0[%x]"), static_cast<CMMFDataBuffer*>(iParserBuf)->Data().Ptr(), static_cast<CMMFDataBuffer*>(iParserBuf)->Data().Ptr()[0]);

    TInt err = aError;

    if (err == MP4_OK)

        {

        TUint8* bufPtr = const_cast<TUint8*>(iParserBuf->Data().Ptr());

    	TInt requestSize = static_cast<CMMFDataBuffer*>(iFillingBuffer)->RequestSize();

    	TInt bufferlength = static_cast<CMMFDataBuffer*>(iFillingBuffer)->Data().Length()+aAudioSize;

        if (bufferlength <= requestSize)

            {

/*            TUint32 timePositionInMilliSecs = I64INT(iPlayWindowEndPosition.Int64())/1000;

            if ((iPlayWindowEndPosition != TTimeIntervalMicroSeconds(0)) && (aTimeStamp >= timePositionInMilliSecs))

                {

                iFillingBuffer->SetLastBuffer(ETrue);

                iFillingBuffer->SetStatus(EFull);

                }

            else // Not reached end of playwindow or no playwindow at all

*/                {

                static_cast<CMMFDataBuffer*>(iFillingBuffer)->Data().Append(iParserBuf->Data().Ptr(), aAudioSize);

                iParserBuf->Data().SetLength(0);

                iParserBuf->SetPosition(0);

                err = ReadAsync();

                // this error return value is handled below

                }

            }

        else

            {

            // Save this read for the next source buffer

            DP2(_L("C3gpDataSourceAdapter::M3GPMP4LibAudioFramesAvailable, iFillingBuffer[%x] - FULL, Length[%d]"),

            		static_cast<CMMFDataBuffer*>(iFillingBuffer)->Data().Ptr(), static_cast<CMMFDataBuffer*>(iFillingBuffer)->Data().Length());

            iParserBuf->Data().SetLength(aAudioSize);

            iQueValid = ETrue;

            TRAP(err,iControllerMDataSink->BufferFilledL(iFillingBuffer)); // setpos could come in here and clear the queue here and add another read

            // this error return value is handled below

            if (iQueValid)

                { // this detects if the que has been cleared and refilled

                // we don't want to do this with the new buffers in the queue

                iQueuedAsyncBuffers.Remove(0);

                if (iQueuedAsyncBuffers.Count() > 0)

                    {

                    DP0(_L("C3gpDataSourceAdapter::M3GPMP4LibAudioFramesAvailable calls FillBufferL"));

                    TRAP(err,FillBufferL(iQueuedAsyncBuffers[0],this,iMediaId));

                    // this error return value is handled below

                    }

                }

            }

        }

    if (err == MP4_NO_FRAME)

	    {

        DP0(_L("C3gpDataSourceAdapter::M3GPMP4LibAudioFramesAvailable sending last buffer"));

	    iFillingBuffer->SetLastBuffer(ETrue);

        TRAP(err,iControllerMDataSink->BufferFilledL(iFillingBuffer));

       	if (err != KErrNone)

           	{

           	DP1(_L("C3gpDataSourceAdapter::M3GPMP4LibAudioFramesAvailable, BufferFilledL err[%d]"), err);

//            	SendEvent(TMMFEvent(KMMFEventCategoryPlaybackComplete, err));

           	}          

	    }

    else if (err != MP4_OK)

        {

        DP1(_L("error %d..."), TranslateMP4Err(err));

        //send event to client to notify error in source adapter

        if(iAsyncEventHandler)

        	{

         	iAsyncEventHandler->SendEventToClient(TMMFEvent(KMMFEventCategoryPlaybackComplete, KErrSourceAdapter));

        	}

        }

    }

// -----------------------------------------------------------------------------

// C3gpDataSourceAdapter::M3GPMP4LibVideoFrameAvailable

// -----------------------------------------------------------------------------

//

void C3gpDataSourceAdapter::M3GPMP4LibVideoFrameAvailable(MP4Err /*aError*/,

                                                          mp4_u32 /*aFrameSize*/,

                                                          mp4_u32 /*aTimeStamp*/,

                                                          mp4_bool /*aKeyFrame*/,

                                                          mp4_u32 /*aTimestamp2*/)

    {

    // do nothing, not used

    }

// -----------------------------------------------------------------------------

// New

// -----------------------------------------------------------------------------

//

EXPORT_C TInt C3gpDataSourceAdapter::ReadHeader(TUint32& aAudioLength, TUint32& aAudioType, 

            TUint8& aFramesPerSample, TUint32& aTimeScale, TUint32& aAverateBitRate)

	{

	TInt err = MP4ParseRequestAudioDescription(iMP4Handle, &aAudioLength, &aAudioType, &aFramesPerSample, &aTimeScale, &aAverateBitRate);

    DP6(_L("C3gpDataSourceAdapter::ReadHeader stat[%d] aAudioLength[%d], aAudioType[%d], aFramesPerSample[%d], aTimeScale[%d], aAverateBitRate[%d]"), 

    	err, aAudioLength, aAudioType, aFramesPerSample, aTimeScale, aAverateBitRate);

	iAudioType = aAudioType;    	

	return(TranslateMP4Err(err));

	}

EXPORT_C TInt C3gpDataSourceAdapter::ReadAudioSpecificConfig(TUint8* aDecSpecInfo, TUint32 aDecSpecInfoSizeIn, TUint32* aDecSpecInfoSizeOut)

	{

	TInt err = KErrNone;

	MP4Err stat = MP4ParseReadAudioDecoderSpecificInfo(iMP4Handle, aDecSpecInfo, aDecSpecInfoSizeIn, aDecSpecInfoSizeOut);

	if ((stat == MP4_BUFFER_TOO_SMALL) && (aDecSpecInfo == NULL)) // This is valid Error as we are just getting the buffersize