/*

* 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:   TNE Video Clip Implementation

*

*/

#include "HXTNEVideoClipInfoImp.h"

#include <e32base.h>

#include <fbs.h>

#include <coemain.h>

#include <ecom/ecom.h>

#include "yuv2rgb12.h"

#include "yuv2rgb16.h"

#include "yuv2rgb24.h"

#include <flogger.h>

// PRINT macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

#ifdef _DEBUG

#define ENABLE_S60_TNE_LOGGING 1

#endif

//implementation

#ifdef ENABLE_S60_TNE_LOGGING

#define FLOG FileLog

inline static void FileLog(TRefByValue<const TDesC16> aFmt,...)

{

    VA_LIST  args;

    VA_START (args, aFmt);

    RFileLogger::WriteFormat(_L("tne"), _L("S60tne.log"), 

                        EFileLoggingModeAppend, aFmt, args);

}

#else // logging is disabled

#define FLOG LogFNull

inline static void LogFNull(TRefByValue<const TDesC16> aFmt,...){}

#endif // enable logging

//server details

const TUint kDefaultMessageSlots=4;

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

// CTNEVideoClipInfo::NewL

// API exposed by TNE to 

// TNEVideoClipInfo using RFile handle

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

EXPORT_C CTNEVideoClipInfo* CTNEVideoClipInfo::NewL(const RFile& aFileHandle,

                                                    MTNEVideoClipInfoObserver& aObserver)

{

    FLOG(_L("CTNEVideoClipInfo::NewL"));

     CHXTNEVideoClipInfoImp* self = ( CHXTNEVideoClipInfoImp*)NewLC(aFileHandle, aObserver);

    FLOG(_L("CTNEVideoClipInfo::NewL out"));

    return self;

}

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

// CTNEVideoClipInfo::NewL

// API exposed by TNE to create TNEVideoClipInfo using file name

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

EXPORT_C CTNEVideoClipInfo* CTNEVideoClipInfo::NewL(const TDesC& aFileName,

                                                    MTNEVideoClipInfoObserver& aObserver)

{

    FLOG(_L("CTNEVideoClipInfo::NewL"));

     CHXTNEVideoClipInfoImp* self = ( CHXTNEVideoClipInfoImp*)NewLC(aFileName, aObserver);

    FLOG(_L("CTNEVideoClipInfo::NewL out"));

    return self;

}

EXPORT_C CTNEVideoClipInfo* CTNEVideoClipInfo::NewLC(const RFile& aFileHandle,

                                                     MTNEVideoClipInfoObserver& aObserver)

{

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

    CleanupStack::PushL(self);

    self->ConstructL(aFileHandle, aObserver);   

    CleanupStack::Pop();

    return self;

}

EXPORT_C CTNEVideoClipInfo* CTNEVideoClipInfo::NewLC(const TDesC& aFileName,

                                                     MTNEVideoClipInfoObserver& aObserver)

{

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

    CleanupStack::PushL(self);

    self->ConstructL(aFileName, aObserver);   

     CleanupStack::Pop();

    return self;

}

CTNEVideoClipInfo*  CHXTNEVideoClipInfoImp::NewL(const RFile& aFileHandle, 

                                              MTNEVideoClipInfoObserver& aObserver)

{

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

    CleanupStack::PushL(self);

    self->ConstructL(aFileHandle, aObserver);

    CleanupStack::Pop(self);

    return self;

}

//constructor

 CHXTNEVideoClipInfoImp::CHXTNEVideoClipInfoImp()

 {

 	//empty constructor

 }

//destructor

 CHXTNEVideoClipInfoImp::~CHXTNEVideoClipInfoImp()

{

    FLOG(_L("CTNEVideoClipInfo::~ CHXTNEVideoClipInfoImp in"));

    RSessionBase::Close();

    iServerThread.Close(); 

    if (iServerName)

   {

    	delete iServerName;

    	iServerName = NULL;

    }

    if (iObserver)

    {

        delete iObserver;

        iObserver = NULL;

    }

    if (iCloseHandle)

    {    	

        iCloseHandle = EFalse;

    	iFileHandle.Close();	

    }

    if (iOutBitmap)

    {

        delete iOutBitmap;

        iOutBitmap = 0;

    }

    if(iFs)

    {

	    iFs->Close();

	    delete iFs;

	    iFs = NULL;

    }

    if (iEnhancer)

    {

        delete iEnhancer;

        iEnhancer = NULL;

    }

    FLOG(_L("CTNEVideoClipInfo::~ CHXTNEVideoClipInfoImp out"));    

}

void  CHXTNEVideoClipInfoImp::ConstructL(const RFile& aFileHandle,

                                      MTNEVideoClipInfoObserver& aObserver)

{

    FLOG(_L("CTNEVideoClipInfo::ConstructL in this=%x"), this);

    iObserver = CTNEClientObserver::NewL(this);

	iClipInfoObserver = &aObserver;

	User::LeaveIfError(CreateServer());

	iFileHandle.Duplicate(aFileHandle);

	iCloseHandle = ETrue;

	User::LeaveIfError(OpenFile(iFileHandle, 0));

    FLOG(_L("CTNEVideoClipInfo::ConstructL out this=%x"), this);

 }

void  CHXTNEVideoClipInfoImp::ConstructL(const TDesC& aFileName,

                                      MTNEVideoClipInfoObserver& aObserver)

{

    FLOG(_L("CTNEVideoClipInfo::ConstructL in this=%x"), this);

    iObserver = CTNEClientObserver::NewL(this);

   	iClipInfoObserver = &aObserver;

   	iFileName.Copy(aFileName);

    User::LeaveIfError(CreateServer());

    User::LeaveIfError(OpenFile(0));

    FLOG(_L("CTNEVideoClipInfo::ConstructL out this=%x"), this);

}

TInt  CHXTNEVideoClipInfoImp::CreateServer()

{

	TInt err = KErrNoMemory;	

	FLOG(_L("CHXTNEVideoClipInfoImp::CreateServer in"));    

	 TRAP(err,iServerName = HBufC::NewL(KMaxFileName));

	if (iServerName && err == KErrNone)

	{ 

		 TPtr ptr = iServerName->Des();

    ptr.Copy(KTneServerName);

    ptr.AppendNum(Math::Random(), EHex);

		err = StartThread(iServerThread, iServerName);

	}		

    if ( err == KErrNone)

    {

       //server name FIXME

       err = CreateSession(*iServerName, Version(), kDefaultMessageSlots);

    }

    FLOG(_L("CHXTNEVideoClipInfoImp::CreateServer out err=%d"), err);   

    return(err); 

}

TVersion CHXTNEVideoClipInfoImp::Version(void) const

    {

    return(TVersion(KTNEServMajorVersionNumber,KTNEServMinorVersionNumber,KTNEServBuildVersionNumber));

    }

//SendRecieve() commands to server

TInt CHXTNEVideoClipInfoImp::OpenFile(const RFile& aFileHandle, TInt aPosition)

{

   FLOG(_L("CHXTNEVideoClipInfoImp::OpenFile in"));

   c_State = EStartGettingMetadata;

   iObserver->Activate();

   SendReceive(EOpenFileRFmsg,TIpcArgs(&aFileHandle,aPosition), iObserver->iStatus);    

   FLOG(_L("CHXTNEVideoClipInfoImp::OpenFile out"));

   return KErrNone;

 }

TInt CHXTNEVideoClipInfoImp::OpenFile(TInt aPosition)

{

   FLOG(_L("CHXTNEVideoClipInfoImp::OpenFile in"));

   c_State = EStartGettingMetadata;

   iObserver->Activate();

   SendReceive(EOpenFIleNamemsg,TIpcArgs(&iFileName,aPosition), iObserver->iStatus);    

   FLOG(_L("CHXTNEVideoClipInfoImp::OpenFile out"));

   return KErrNone;

 }

void CHXTNEVideoClipInfoImp::GetThumbL(MTNEVideoClipThumbObserver& aObserver, 

                                     TInt aIndex,

                                     TSize* const aResolution,

                                     TDisplayMode aDisplayMode,

                                     TBool aEnhance,

                                     TInt aPriority)

{

        FLOG(_L("CHXTNEVideoClipInfoImp::GetThumbL in"));

        iThumbObserver               = &aObserver;

        iThumbIndex                    = aIndex;

        iThumbEnhance               = aEnhance;	

        iThumbDisplayMode         = aDisplayMode; 

        iPriority                            = aPriority;                

        iThumbRequestData.iIndex =  aIndex;

        if (aResolution)

        {    	    

            iOutputThumbResolution = *aResolution;

        }

        else

        {    	                            	

            iOutputThumbResolution.iHeight = iMetaData.iHeight;

            iOutputThumbResolution.iWidth = iMetaData.iWidth;         

        }

        iThumbRequestData.iYUVBuffer = NULL;                

        c_State = EStartGettingThumbNail;

        iObserver->Activate();

        SendReceive(EGetThumbmsg, TIpcArgs(&iThumbRequestData), iObserver->iStatus);    

        FLOG(_L("CHXTNEVideoClipInfoImp::GetThumbL out"));

 }

void CHXTNEVideoClipInfoImp::CancelThumb()

{

    FLOG(_L("CHXTNEVideoClipInfoImp::CancelThumb in"));

    c_State = ECancelling;

    SendReceive(ECancelThumbmsg);    

    FLOG(_L("CHXTNEVideoClipInfoImp::CancelThumb out"));

}

  TPtrC CHXTNEVideoClipInfoImp::FileName() const

{

    TFileName fileName;

	if (iCloseHandle)

	{

		iFileHandle.FullName(fileName);

	}

    return fileName;

}

TInt CHXTNEVideoClipInfoImp::VideoFrameCount() const

{

	return (TInt)iMetaData.iFrameCount ;

}

// Called from Observer after a Complete() from Server

void  CHXTNEVideoClipInfoImp::ServiceCompleted(TInt aError)

{

	FLOG(_L("CHXTNEVideoClipInfoImp::ServiceCompleted in aError=%d c_State=%d"),

	            aError, c_State);

    switch(c_State)

    {

        case EStartGettingMetadata:			                        

            FetchAndSendMetaData(aError);            

            break;

        case EStartGettingThumbNail:

            if (aError == KErrNone)

            {

                GenerateThumbNail();

            }

            else

            {

                if (iOutBitmap)

                {

                    delete iOutBitmap;

                    iOutBitmap = NULL;

                }

                m_LastError = aError;

            }

			NotifyIfGetThumbPending(m_LastError, iOutBitmap);

			break;

		case ECancelling:

        default:

            break;

    }

    FLOG(_L("CHXTNEVideoClipInfoImp::ServiceCompleted out"));

}

void CHXTNEVideoClipInfoImp::FetchAndSendMetaData(TInt aError)

{

    FLOG(_L("CHXTNEVideoClipInfoImp::FetchAndSendMetaData in"));

    if (aError == KErrNone)

    {

        aError = SendReceive(EGetMetaDatamsg, TIpcArgs(&iMetaData));

    }

    if(c_State== EStartGettingMetadata)

    {

    CTNEVideoClipInfo *pInfo = (CTNEVideoClipInfo *) this;

    iClipInfoObserver->NotifyVideoClipInfoReady(*pInfo, aError);  

    }

    FLOG(_L("CHXTNEVideoClipInfoImp::FetchAndSendMetaData out and state = %d"), c_State);

}

// ownership of pBitMap will be passed to Observer

void CHXTNEVideoClipInfoImp::NotifyIfGetThumbPending(TInt aError, CFbsBitmap *&pBitMap) 

{

    FLOG(_L("CHXTNEVideoClipInfoImp::NotifyIfGetThumbPending in"));

	if (iThumbObserver)

	{				

        CFbsBitmap* pTmpBitmap = pBitMap;

        pBitMap = NULL;

		iThumbObserver->NotifyVideoClipThumbCompleted(*this, aError, pTmpBitmap);

	}

	FLOG(_L("CHXTNEVideoClipInfoImp::NotifyIfGetThumbPending out"));

}

void CHXTNEVideoClipInfoImp::GenerateThumbNail()

{

	FLOG(_L("CHXTNEVideoClipInfoImp::GenerateThumbNail in"));

    TInt bytesPerPixel = 0;           

    TInt error = KErrNone;

    if ( !iRgbBuf )

    {

        TSize inputFrameResolution(iMetaData.iWidth,iMetaData.iHeight);

        // rgb specs

        TUint thumbLength = iMetaData.iWidth * iMetaData.iHeight; 

        TUint thumbUVLength = thumbLength>>2;	

       // VPASSERT(iYuvBuf);

        // assign yuv pointers 

        TUint8* yBuf = iThumbRequestData.iYUVBuffer;

        TUint8* uBuf = yBuf + thumbLength;

        TUint8* vBuf = uBuf + thumbUVLength;	

  	   // convert to no enhabnce if 64K is selected as thumb display mode

  	 	if(iThumbDisplayMode == EColor64K)

  	    iThumbEnhance = EFalse;

        // check validity of thumbnail and associated operation

        if(iThumbEnhance)		// for saving to file

        {			

                iThumbDisplayMode = EColor16M;				// 24-bit color image for enhancement

            // no enhancements if clip is too small.

            if (iOutputThumbResolution.iWidth < 16 || iOutputThumbResolution.iHeight < 16)

            {

            	iThumbEnhance = EFalse;            	

            }

        }

        else								// for screen display

        {

            if(iThumbDisplayMode == ENone)					// if no preference

                iThumbDisplayMode = EColor64K;				// 16-bit image

        }

        // determine proper bit depth for the bitmap

        if(iThumbDisplayMode == EColor16M)

            bytesPerPixel = 3; // 24-bit rgb takes 3 bytes, stored as bbbbbbbb gggggggg rrrrrrrr

        else if(iThumbDisplayMode == EColor64K || iThumbDisplayMode == EColor4K)

            bytesPerPixel = 2; // 12-bit rgb takes 2 bytes, stored as ggggbbbb xxxxrrrr                            

        else

        {

            HandleThumbnailError(KErrNotSupported);

            return;					// support for 12-, 16- and 24-bit color images only

        }

        // create output rgb buffer

        TRAP(error, iRgbBuf = (TUint8*) User::AllocL(thumbLength * bytesPerPixel));

        if (HandleThumbnailError(error))

            return;                                

        TInt scanLineLength;

        // convert yuv to rgb

        switch (iThumbDisplayMode)

        {

        case EColor4K:

            {

                TInt error;

                CYuv2Rgb12* yuvConverter = NULL; 

                TRAP(error, yuvConverter = new(ELeave) CYuv2Rgb12);

                if (HandleThumbnailError(error))

                    return;

                scanLineLength = inputFrameResolution.iWidth * bytesPerPixel;                 

                TRAP(error, yuvConverter->ConstructL(inputFrameResolution.iWidth, inputFrameResolution.iHeight, inputFrameResolution.iWidth, inputFrameResolution.iHeight));

                if (HandleThumbnailError(error))

                    return;

                yuvConverter->Convert(yBuf, uBuf, vBuf, inputFrameResolution.iWidth, inputFrameResolution.iHeight, iRgbBuf, scanLineLength);                

                delete yuvConverter;		

                yuvConverter=0;         

            }

            break;

        default:

        case EColor64K:

            {

                TInt error;

                CYuv2Rgb16* yuvConverter = NULL; 

                TRAP(error, yuvConverter = new(ELeave) CYuv2Rgb16);

                if (HandleThumbnailError(error))

                    return;                

                scanLineLength = inputFrameResolution.iWidth * bytesPerPixel; 

                TRAP(error, yuvConverter->ConstructL(inputFrameResolution.iWidth, inputFrameResolution.iHeight, inputFrameResolution.iWidth, inputFrameResolution.iHeight);)

                if (HandleThumbnailError(error))

                    return;

                yuvConverter->Convert(yBuf, uBuf, vBuf, inputFrameResolution.iWidth, inputFrameResolution.iHeight, iRgbBuf, scanLineLength);                

                delete yuvConverter;		

                yuvConverter=0; 

            }

            break;

        case EColor16M:

            {

                TInt error;

                CYuv2Rgb24* yuvConverter = NULL; 

                TRAP(error, yuvConverter = new(ELeave) CYuv2Rgb24);

                if (HandleThumbnailError(error))

                    return;