/*

* 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:   Implementation for TNE processor

*

*/

//  Include Files

#include "TNEProcessorImpl.h"

#include "yuv2rgb12.h"

#include "yuv2rgb16.h"

#include "yuv2rgb24.h"

#include "DisplayChain.h"

#include "TNEVideosettings.h"

#include "ctrsettings.h"

#include "mp4parser.h"

#include "TNEDecoderWrap.h"

//  Local Constants

const TUint KReadBufInitSize = 512; // stream start buffer initial size

const TUint KInitialDataBufferSize = 8192; // initial frame data buffer size

const TUint KH263StartCodeLength = 3;  // H.263 picture start code length

const TUint KMPEG4StartCodeLength = 4; // MPEG4 picture start code length

// An assertion macro wrapper to clean up the code a bit

#define VPASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CTNEProcessorImpl"), EInvalidInternalState))

// An assertion macro wrapper to clean up the code a bit

#define VDASSERT(x, n) __ASSERT_DEBUG(x, User::Panic(_L("CTNEProcessorImpl"), EInternalAssertionFailure+n)) 

#ifdef _DEBUG

#include <e32svr.h>

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

#else

#define PRINT(x)

#endif

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

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

// CTNEProcessorImpl::NewL

// Two-phased constructor.

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

//

CTNEProcessorImpl* CTNEProcessorImpl::NewL() 

{

	CTNEProcessorImpl* self = NewLC();

	CleanupStack::Pop(self);

	return self;

}

CTNEProcessorImpl* CTNEProcessorImpl::NewLC()

{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

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

// CTNEProcessorImpl::CTNEProcessorImpl

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

// might leave.

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

//

CTNEProcessorImpl::CTNEProcessorImpl()

: CActive(EPriorityNormal), iReadDes(0, 0)

{

    // Reset state

    iState = EStateIdle;

	iFileFormat = EDataAutoDetect;	

}

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

// CTNEProcessorImpl::~CTNEProcessorImpl

// Destructor.

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

//

CTNEProcessorImpl::~CTNEProcessorImpl()

{

    Cancel();

    TInt error = KErrNone;

	TRAP(error, DoCloseVideoL());	

	if(iParser)

    {

        delete iParser;

        iParser = 0;

    }

	// Deallocate buffers

	// This is allocated in the clip startFrame() method

	if (iFrameBuffer)

	{

		User::Free(iFrameBuffer);

		iFrameBuffer = 0;		

	}

	// Deallocate buffers

	if (iDataBuffer)

	{

		User::Free(iDataBuffer);

		iDataBuffer = 0;		

	}

    if (iRgbBuf)

    {

        delete iRgbBuf;

        iRgbBuf = 0;

    }        

    if (iOutBitmap)

    {

        delete iOutBitmap;

        iOutBitmap = 0;

    }

    if (iReadBuf)

    {

		User::Free(iReadBuf);

		iReadBuf = 0;		

	}

	if (iMediaBuffer)

	{

		delete iMediaBuffer;

		iMediaBuffer = 0;

	}

}

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

// CTNEProcessorImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTNEProcessorImpl::ConstructL()

{

    // Add to active scheduler

    CActiveScheduler::Add(this);

	// Allocate buffer

	iDataBuffer = (TUint8*) User::AllocL(KInitialDataBufferSize);

	iBufferLength = KInitialDataBufferSize; 

	// Allocate stream reading buffer

	iReadBuf = (TUint8*) User::AllocL(KReadBufInitSize);

	iBufLength = KReadBufInitSize;

    iMediaBuffer = new (ELeave)TVideoBuffer;

    iDecodePending = EFalse; 

	iDecoding = EFalse; 

    // Flag to indicate if the frame has been decoded

	iThumbFrameDecoded = EFalse;

    iState = EStateIdle;

}

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

// CTNEProcessorImpl::Reset

// Resets the processor for processing a new movie

// (other items were commented in a header).

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

//

void CTNEProcessorImpl::Reset()

{

	iFileFormat = EDataAutoDetect;

	iVideoType = EVideoH263Profile0Level10;

    iFirstFrameOfClip = EFalse;

    iFirstFrameFlagSet = EFalse;

	iProcessingCancelled = EFalse;

    iWaitSchedulerStarted = EFalse;

    iVideoFrameNumber = 0;

    iFrameBuffered = EFalse;

    iVideoIntraFrameNumber = 0;

    iStartThumbIndex = 0;

	iVideoClipDuration = 0; 

	iDecoderInitPending = EFalse;   

    // @@ YHK HARI AVC frame number flag

    // need to have a more inclusive approach for 

    // all the different encoded streams

    iAVCDecodedFrameNumber = 0;

    // We are now properly initialized

    iState = EStateIdle;

}

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

// CTNEProcessorImpl::GetClipPropertiesL

// Retrieves parameters for a clip

// (other items were commented in a header).

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

//

void CTNEProcessorImpl::GetClipPropertiesL(RFile& aFileHandle, 

                                             TTNEVideoFormat& aFormat,

                                             TTNEVideoType& aVideoType,

                                             TSize& aResolution,

                                             TInt& aVideoFrameCount)

{	

    PRINT((_L("CTNEProcessorImpl::GetClipPropertiesL() begin")))

	// parse clip header

	CParser::TStreamParameters iStreamParams;	

	// parse header 

	TRAPD(error, ParseHeaderOnlyL(iStreamParams, aFileHandle));

    if (error != KErrNone && error != KErrNotSupported)

        User::Leave(error);

	/* pass back clip properties */

	// video format (file format actually)

	if (iStreamParams.iFileFormat == CParser::EFileFormat3GP)

		aFormat = ETNEVideoFormat3GPP;

	else if (iStreamParams.iFileFormat == CParser::EFileFormatMP4)

		aFormat = ETNEVideoFormatMP4;

	else

		aFormat = ETNEVideoFormatUnrecognized;

	// video type	

	if(iStreamParams.iVideoFormat == CParser::EVideoFormatNone)

		aVideoType = ETNEVideoTypeNoVideo;

	else if (iStreamParams.iVideoFormat == CParser::EVideoFormatH263Profile0Level10)

		aVideoType = ETNEVideoTypeH263Profile0Level10;

	else if (iStreamParams.iVideoFormat == CParser::EVideoFormatH263Profile0Level45)

		aVideoType = ETNEVideoTypeH263Profile0Level45;

	else if(iStreamParams.iVideoFormat == CParser::EVideoFormatMPEG4)

		aVideoType = ETNEVideoTypeMPEG4SimpleProfile;

	else if(iStreamParams.iVideoFormat == CParser::EVideoFormatAVCProfileBaseline)

		aVideoType = ETNEVideoTypeAVCProfileBaseline;

	else

		aVideoType = ETNEVideoTypeUnrecognized;

	// resolution

	aResolution.iWidth = iStreamParams.iVideoWidth; 

	aResolution.iHeight = iStreamParams.iVideoHeight; 

	// get total number of video frames

	aVideoFrameCount = iParser->GetNumberOfVideoFrames();

    PRINT((_L("CTNEProcessorImpl::GetClipPropertiesL() end")))

}

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

// CTNEProcessorImpl::StartThumbL

// Initiates thumbnail extraction from clip (full resolution raw is reutrned)

// (other items were commented in a header).

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

//

void CTNEProcessorImpl::StartThumbL(RFile& aFileHandle, 

									  TInt aIndex, 

									  TSize aResolution,

									  TDisplayMode aDisplayMode, 

									  TBool aEnhance)

{

	PRINT((_L("CTNEProcessorImpl::StartThumbL() begin, aIndex = %d, enhance = %d"), aIndex, aEnhance))

	// Get thumbnail parameters

	iOutputThumbResolution.SetSize(aResolution.iWidth, aResolution.iHeight);

	iThumbIndex = aIndex;

	iThumbDisplayMode = aDisplayMode;

	iThumbEnhance = aEnhance;

    // opens the file & parses header

	InitializeClipL(aFileHandle); 

	// Allocate memory for iFrameBuffer

    TInt length = iVideoParameters.iWidth * iVideoParameters.iHeight;

    length += (length>>1);

    iFrameBuffer = (TUint8*)User::AllocL(length);

	PRINT((_L("CTNEProcessorImpl::StartThumbL() end")))

}

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

// CTNEProcessorImpl::ProcessThumbL

// Generates thumbnail from clip (actually, full resolution raw is returned)

// (other items were commented in a header).

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

//

void CTNEProcessorImpl::ProcessThumbL(TRequestStatus &aStatus)

{				

	PRINT((_L("CTNEProcessorImpl::ProcessThumbL() begin")))

    iState = EStateProcessing;	

    iThumbnailRequestStatus = &aStatus;

    // seek to the last intra frame before desired frame 

    TTimeIntervalMicroSeconds startTime(0);

    if ( iThumbIndex > 0 )

    {            

        TInt time = 0;

        TUint inMs = TUint( iParser->GetVideoFrameStartTime(iThumbIndex, &time) );

        TInt64 inMicroS = TInt64( inMs ) * TInt64( 1000 );            

        startTime = TTimeIntervalMicroSeconds( inMicroS );

    }

    TInt error = iParser->SeekOptimalIntraFrame(startTime, iThumbIndex);

    if (error != KErrNone)

    { 

        iThumbnailRequestStatus = 0;

        User::Leave(KErrGeneral);

    }

    iStartThumbIndex = iParser->GetStartFrameIndex();

    // @@ YHK: Try to handle this more inclusively

    iAVCDecodedFrameNumber = iStartThumbIndex;

    VPASSERT(iStartThumbIndex >= 0);                  

    // determine input stream type    

    TRAP(error, GetFrameL());

	iDecoding = ETrue;

	// Create and Initialize the Decoders

	TRAP(error, CreateAndInitializeDecoderL());

    if (error != KErrNone)

    {

    	// @@ YHK Do we want to use this flag ??

        iThumbnailRequestStatus = 0;

        User::Leave(KErrGeneral);

    }        

}

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

// CH263Decoder::DecodeThumb

// Decode a thumbnail frame internally

// (other items were commented in a header).

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

//

void CTNEProcessorImpl::DecodeThumb(TBool aFirstFrame)

{

    if (aFirstFrame)

    {

        // frame read in iDataBuffer, decode

        TVideoBuffer::TBufferType bt = 

            (iDataFormat == EDataH263) ? TVideoBuffer::EVideoH263 : TVideoBuffer::EVideoMPEG4;                        

        TInt startTimeInTicks=0;

        TInt startTimeInMs = 0;

        startTimeInMs = iParser->GetVideoFrameStartTime(iStartThumbIndex,&startTimeInTicks);

        TTimeIntervalMicroSeconds ts = 

            TTimeIntervalMicroSeconds(startTimeInMs * TInt64(1000) );

        iMediaBuffer->Set( TPtrC8(iDataBuffer, iBufferLength), 

                                  bt, 

                                  iCurrentFrameLength, 

                                  ETrue, // keyFrame

                                  ts

                                  );

        iPreviousTimeStamp = ts;

        iDecodePending = ETrue;

        if (!IsActive())

        {

            SetActive();

            iStatus = KRequestPending;                                

        }

        TRAPD( err, iDecoder->WriteCodedBufferL(iMediaBuffer) );

        if (err != KErrNone)

        {

            // ready

            MNotifyThumbnailReady(err);

            return;            

        }

		TUint freeInputBuffers = iDecoder->GetNumInputFreeBuffers();

        // @@ YHK: AVC hack is there a better way of doing this ??

        if(iDataFormat == EDataAVC)

        {

	        if (freeInputBuffers != 0)

	        {

	            // activate object to end processing

	            TRequestStatus *status = &iStatus;

	            User::RequestComplete(status, KErrNone);                   	

	        }

        }

        return;

    }

    if ((iThumbIndex == 0) && iThumbFrameDecoded)

    {        

        MNotifyThumbnailReady(KErrNone);

        return;

    }

    iStartThumbIndex++;

    if ((iThumbIndex < 0) && iThumbFrameDecoded)

    {       	     

        if (iFramesToSkip == 0)

        {            

             PRINT((_L("CH263Decoder::ProcessThumb() frameskip done %d times"), iNumThumbFrameSkips));

             // limit the number of frame skip cycles to 3, because with

		     // near-black or near-white videos we may never find a good thumb.

		     // => max. 30 frames are decoded to get the thumb

             // check quality & frame skip cycles

             if ( CheckFrameQuality(iFrameBuffer) || iNumThumbFrameSkips >= 3 )

             {

                 // quality ok or searched long enough, return

                 MNotifyThumbnailReady(KErrNone);

                 return;              

             }

             iFramesToSkip = 10;

             iNumThumbFrameSkips++;

        }

        else

            iFramesToSkip--;

        // read new frame & decode                           

    }

    if (iThumbFrameDecoded)

    {

    	iAVCDecodedFrameNumber++;

    	iThumbFrameDecoded = EFalse;

    }

    if (iThumbIndex > 0)

    {            

    	// HARI AVC IMP THUMB

    	TInt decodedFrameNumber = (iDataFormat == EDataAVC) ? iAVCDecodedFrameNumber : iStartThumbIndex;

        if (decodedFrameNumber > iThumbIndex)        

        {

         	// ready

            MNotifyThumbnailReady(KErrNone);

            return; 

        }

        // read new frame & decode

    }

    TInt error;

    if(iStartThumbIndex < iParser->GetNumberOfVideoFrames()) // do not read last frame (already read!)

    {   

        error = ReadVideoFrame();

        if (error != KErrNone)

        {

            MNotifyThumbnailReady(error);

            return;

        }

    }

    else

    {

        // no frames left, return

        MNotifyThumbnailReady(KErrNone);

        return;

    }

    iCurrentFrameLength = 0;

    iDataFormat = EDataUnknown;

    if (ReadAndUpdateFrame())

    {

        // frame read in iDataBuffer, decode

        TVideoBuffer::TBufferType bt = 

            (iDataFormat == EDataH263) ? TVideoBuffer::EVideoH263 : TVideoBuffer::EVideoMPEG4;

        TInt startTimeInTicks=0;

        TInt startTimeInMs = 0;

        startTimeInMs = iParser->GetVideoFrameStartTime(iStartThumbIndex,&startTimeInTicks);

        TTimeIntervalMicroSeconds ts = 

            TTimeIntervalMicroSeconds(startTimeInMs * TInt64(1000) );

        if (ts <= iPreviousTimeStamp)

        {            

            // adjust timestamp so that its bigger than ts of previous frame

            TReal frameRate = GetVideoClipFrameRate();

            TInt64 durationMs =  TInt64( ( 1000.0 / frameRate ) + 0.5 );

            durationMs /= 2;  // add half the duration of one frame

            ts = TTimeIntervalMicroSeconds( iPreviousTimeStamp.Int64() + durationMs*1000 );

        }

        iPreviousTimeStamp = ts;

        iMediaBuffer->Set( TPtrC8(iDataBuffer, iBufferLength), 

                                  bt, 

                                  iCurrentFrameLength, 

                                  GetVideoFrameType(iStartThumbIndex),

                                  ts );                                                                            

        iDecodePending = ETrue;

        if (!IsActive())

        {

            SetActive();

            iStatus = KRequestPending;                                

        }

        TRAPD( err, iDecoder->WriteCodedBufferL(iMediaBuffer) );