/*

* Copyright (c) 2008-2010 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:  CSConVideoParser implementation

*

*/

#include <coedef.h> 

#include <bautils.h>

#include <imageconversion.h>

#include "sconvideoparser.h"

#include "debug.h"

_LIT( KMimeType, "MimeType" );

_LIT8( KImageEncoderMimeType, "image/jpeg" );

_LIT( KMimeTypeAudio, "audio/*" );

_LIT( KMimeTypeVideo, "video/*" );

const TInt KRequestTimeOut( 20000000 ); // 20 sec.

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

// CSConVideoParser::CSConVideoParser()

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

//

CSConVideoParser::CSConVideoParser()

    {

    }

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

// CSConVideoParser::~CSConVideoParser()

// Destructor

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

//

CSConVideoParser::~CSConVideoParser()

    {

    TRACE_FUNC_ENTRY;

    delete iTimeOut;

    if ( iVideoClip )

        {

        iVideoClip->CancelThumb();

        }

    delete iVideoClip;

    if ( iVideoUtil )

        {

        iVideoUtil->Close();

        }

    delete iVideoUtil;

    if ( iWindow )

        {

        iWindow->Close();

        }

    delete iWindow;

    iRootWindow.Close();

    delete iScreen;

    iWsSession.Close();

    delete iThumbnail;

    delete iVideoMimeType;

    delete iAudioMimeType;

    TRACE_FUNC_EXIT;

    }

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

// CSConVideoParser::NewLC()

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

//

CSConVideoParser* CSConVideoParser::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CSConVideoParser::ConstructL()

// Constructor

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

//

void CSConVideoParser::ConstructL()

    {

    TRACE_FUNC_ENTRY;

    User::LeaveIfError( iWsSession.Connect() );

    iScreen = new(ELeave) CWsScreenDevice( iWsSession );

    User::LeaveIfError( iScreen->Construct() );

    iRootWindow = RWindowGroup(iWsSession);

    User::LeaveIfError( iRootWindow.Construct(reinterpret_cast<TUint32>(&iWsSession), EFalse) );

    iWindow = new(ELeave) RWindow( iWsSession );

    User::LeaveIfError( iWindow->Construct(iRootWindow, reinterpret_cast<TUint32>(&iRootWindow) + 1) );

    TRect temp(0,0,320,240); // dummy parameter

    iVideoUtil = CVideoPlayerUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceNone, iWsSession, *iScreen, *iWindow, temp, temp);

    iTimeOut = CSconTimeOut::NewL( *this );

    TRACE_FUNC_EXIT;

    }

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

// CSConVideoParser::OpenFileL( const RFs& aFs, const TDesC& aFileName )

// Opens video file

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

//

void CSConVideoParser::OpenFileL( const RFs& aFs, const TDesC& aFileName )

    {

    TRACE_FUNC_ENTRY;

    iVideoUtilReady = EFalse;

    iVideoClipReady = EFalse;

    iVideoUtilErr = KErrNone;

    iVideoClipErr = KErrNone;

    delete iThumbnail;

    iThumbnail = NULL;

    delete iVideoMimeType;

    iVideoMimeType=NULL;

    delete iAudioMimeType;

    iAudioMimeType=NULL;

    if ( iVideoClip )

        {

        iVideoClip->CancelThumb();

        delete iVideoClip;

        iVideoClip = NULL;

        }

    if ( iVideoUtil )

        {

        iVideoUtil->Close();

        }

    TBool fileExist = BaflUtils::FileExists( aFs, aFileName );

    if ( !fileExist )

        {

        User::Leave( KErrNotFound );

        }

    iAsyncStopCalled = EFalse;

    iVideoClip = CTNEVideoClipInfo::NewL( aFileName, *this );

    iVideoUtil->OpenFileL( aFileName );

    LOGGER_WRITE("Start timeout");

    iTimeOut->Start( KRequestTimeOut );

    LOGGER_WRITE("iWait.Start()");

    iWait.Start();

    TRACE_FUNC_EXIT;

    }

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

// CSConVideoParser::Thumbnail()

// returns video thumbnail in jpg format

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

//

const TDesC8& CSConVideoParser::Thumbnail() const

    {

    TRACE_FUNC;

    if ( !iThumbnail )

        {

        return KNullDesC8;

        }

    return *iThumbnail;

    }

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

// CSConVideoParser::VideoFrameRateL()

// returns video frame rate

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

//

TReal32 CSConVideoParser::VideoFrameRateL() const

    {

    TRACE_FUNC;

    if ( !iVideoUtil )

        {

        User::Leave( KErrNotReady );

        }

    return iVideoUtil->VideoFrameRateL();

    }

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

// CSConVideoParser::VideoFrameSizeL()

// returns video frame size

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

//

void CSConVideoParser::VideoFrameSizeL(TSize& aSize) const

    {

    TRACE_FUNC;

    if ( !iVideoUtil )

        {

        User::Leave( KErrNotReady );

        }

    return iVideoUtil->VideoFrameSizeL( aSize );

    }

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

// CSConVideoParser::VideoFormatMimeTypeL()

// returns video format

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

//

const TDesC8& CSConVideoParser::VideoFormatMimeTypeL() const 

    {

    TRACE_FUNC;

    if ( !iVideoUtil )

        {

        User::Leave( KErrNotReady );

        }

    return iVideoUtil->VideoFormatMimeType();

    }

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

// CSConVideoParser::VideoBitRateL()

// returns videostream bitrate

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

//

TInt CSConVideoParser::VideoBitRateL() const

    {

    TRACE_FUNC;

    if ( !iVideoUtil )

        {

        User::Leave( KErrNotReady );

        }

    return iVideoUtil->VideoBitRateL();

    }

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

// CSConVideoParser::AudioBitRateL()

// returns audiostream bitrate

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

//

TInt CSConVideoParser::AudioBitRateL() const

    {

    TRACE_FUNC;

    if ( !iVideoUtil )

        {

        User::Leave( KErrNotReady );

        }

    return iVideoUtil->AudioBitRateL();

    }

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

// CSConVideoParser::DurationL()

// returns video duration in milliseconds

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

//

TInt CSConVideoParser::DurationL() const

    {

    TRACE_FUNC;

    if ( !iVideoUtil )

        {

        User::Leave( KErrNotReady );

        }

    return iVideoUtil->DurationL().Int64()/1000;

    }

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

// CSConVideoParser::VideoMimeTypeL()

// returns video mime type

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

//

const TDesC& CSConVideoParser::VideoMimeTypeL()

    {

    TRACE_FUNC;

    if ( !iVideoUtil )

        {

        User::Leave( KErrNotReady );

        }

    delete iVideoMimeType;

    iVideoMimeType = NULL;

    TInt metadataEntries = iVideoUtil->NumberOfMetaDataEntriesL();

    LOGGER_WRITE_1( "metadataEntries: %d", metadataEntries);

    for (TInt i=0; i < metadataEntries ; i++)

        {

        CMMFMetaDataEntry* entry = iVideoUtil->MetaDataEntryL(i);

        CleanupStack::PushL( entry );

        if ( entry->Name().Compare( KMimeType ) == 0 )

            {

            if ( entry->Value().MatchF( KMimeTypeVideo ) == 0 )

                {

                LOGGER_WRITE_1( "video mimetype found: %S", &entry->Value());

                iVideoMimeType = HBufC::NewL(entry->Value().Length());

                TPtr videoMimeTypePtr = iVideoMimeType->Des();

                videoMimeTypePtr.Copy( entry->Value() );

                CleanupStack::PopAndDestroy( entry );

                return *iVideoMimeType;

                }

            }

        CleanupStack::PopAndDestroy( entry );

        }

    return KNullDesC;

    }

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

// CSConVideoParser::AudioMimeTypeL()

// returns audio mime type

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

//

const TDesC& CSConVideoParser::AudioMimeTypeL()

    {

    TRACE_FUNC;

    if ( !iVideoUtil )

        {

        User::Leave( KErrNotReady );

        }

    delete iAudioMimeType;

    iAudioMimeType = NULL;

    TInt metadataEntries = iVideoUtil->NumberOfMetaDataEntriesL();

    LOGGER_WRITE_1( "metadataEntries: %d", metadataEntries);

    for (TInt i=0; i < metadataEntries ; i++)

        {

        CMMFMetaDataEntry* entry = iVideoUtil->MetaDataEntryL(i);

        CleanupStack::PushL( entry );

        if ( entry->Name().Compare( KMimeType ) == 0 )

            {

            if ( entry->Value().MatchF( KMimeTypeAudio ) == 0 )

                {

                LOGGER_WRITE_1( "video mimetype found: %S", &entry->Value());

                iAudioMimeType = HBufC::NewL(entry->Value().Length());

                TPtr audioMimeTypePtr = iAudioMimeType->Des();

                audioMimeTypePtr.Copy( entry->Value() );

                CleanupStack::PopAndDestroy( entry );

                return *iAudioMimeType;

                }

            }

        CleanupStack::PopAndDestroy( entry );

        }

    return KNullDesC;

    }

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

// CSConVideoParser::MvpuoOpenComplete( TInt aError )

// MVideoPlayerUtilityObserver implementation

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

//

void CSConVideoParser::MvpuoOpenComplete( TInt aError )

    {

    TRACE_FUNC_ENTRY;

    if ( iVideoUtilReady )

        {

        // already timeout

        LOGGER_WRITE("Already timeout");

        return;

        }

    LOGGER_WRITE_1( "aError: %d", aError );

    if ( aError == KErrNone )

        {

        iVideoUtil->Prepare();

        }

    else

        {

        iVideoUtilReady = ETrue;

        iVideoUtilErr = aError;

        }

    if ( iVideoUtilReady && iVideoClipReady && !iAsyncStopCalled )

        {

        iAsyncStopCalled = ETrue;

        iTimeOut->Cancel();

        LOGGER_WRITE("AsyncStop");

        iWait.AsyncStop();

        }

    TRACE_FUNC_EXIT;

    }

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

// CSConVideoParser::MvpuoPrepareComplete( TInt aError )

// MVideoPlayerUtilityObserver implementation

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

//

void CSConVideoParser::MvpuoPrepareComplete( TInt aError )

    {

    TRACE_FUNC_ENTRY;

    if ( iVideoUtilReady )

        {

        // already timeout

        LOGGER_WRITE("Already timeout");

        return;

        }

    LOGGER_WRITE_1( "aError: %d", aError );

    iVideoUtilReady = ETrue;

    iVideoUtilErr = aError;

    if ( iVideoUtilReady && iVideoClipReady && !iAsyncStopCalled )

        {

        iAsyncStopCalled = ETrue;

        iTimeOut->Cancel();

        LOGGER_WRITE("AsyncStop");

        iWait.AsyncStop();

        }

    TRACE_FUNC_EXIT;

    }

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

// CSConVideoParser::MvpuoFrameReady()

// MVideoPlayerUtilityObserver implementation

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

//

void CSConVideoParser::MvpuoFrameReady( CFbsBitmap& /*aFrame*/,TInt /*aError*/ )

    {

    }

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

// CSConVideoParser::MvpuoPlayComplete()

// MVideoPlayerUtilityObserver implementation

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

//

void CSConVideoParser::MvpuoPlayComplete( TInt /*aError*/ )

    {

    }

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

// CSConVideoParser::MvpuoEvent()

// MVideoPlayerUtilityObserver implementation

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

//

void CSConVideoParser::MvpuoEvent( const TMMFEvent& /*aEvent*/ )

    {

    }

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

// CSConVideoParser::NotifyVideoClipInfoReady(CTNEVideoClipInfo& aInfo, TInt aError)

// MTNEVideoClipInfoObserver implementation

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

//

void CSConVideoParser::NotifyVideoClipInfoReady(CTNEVideoClipInfo& aInfo, TInt aError)

    {

    TRACE_FUNC_ENTRY;

    if ( iVideoClipReady )

        {

        // already timeout

        LOGGER_WRITE("Already timeout");

        return;

        }

    LOGGER_WRITE_1("aError: %d", aError);

    if ( aError == KErrNone )

        {

        TSize resolution(320,240);

        TRAPD( err, aInfo.GetThumbL(*this,KBestThumbIndex, &resolution ) );

        if ( err )

            {

            LOGGER_WRITE_1("aInfo.GetThumbL err: %d", err);

            iVideoClipReady = ETrue;

            iVideoClipErr = err;

            }

        }

    else

        {

        iVideoClipReady = ETrue;

        iVideoClipErr = aError;

        }

    if ( iVideoUtilReady && iVideoClipReady && !iAsyncStopCalled )

        {

        iAsyncStopCalled = ETrue;

        iTimeOut->Cancel();

        LOGGER_WRITE("AsyncStop");

        iWait.AsyncStop();

        }

    TRACE_FUNC_EXIT;

    }

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

// CSConVideoParser::NotifyVideoClipThumbCompleted()

// MTNEVideoClipInfoObserver implementation

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

//

void CSConVideoParser::NotifyVideoClipThumbCompleted(CTNEVideoClipInfo& /*aInfo*/, 

        TInt aError, 

        CFbsBitmap* aThumb)

    {

    TRACE_FUNC_ENTRY;

    if ( iVideoClipReady )

        {

        // already timeout

        LOGGER_WRITE("Already timeout");

        delete aThumb;

        return;

        }

    LOGGER_WRITE_1("aError: %d", aError);

    if ( aError == KErrNone)

        {

        delete iThumbnail;

        iThumbnail = NULL;

        LOGGER_WRITE("create CImageEncoder");

        CImageEncoder* encoder = NULL;

        TRAPD( err, encoder = CImageEncoder::DataNewL( iThumbnail, KImageEncoderMimeType, CImageEncoder::EOptionAlwaysThread ) );

        LOGGER_WRITE_1("err: %d", err );

        if ( err == KErrNone )

            {

            LOGGER_WRITE("Start Convert");

            TRequestStatus status;

            encoder->Convert( &status, *aThumb, NULL );

            User::WaitForRequest( status );

            LOGGER_WRITE_1("Convert status: %d", status.Int());

            LOGGER_WRITE_1("buf Length: %d", iThumbnail->Length());

            err = status.Int();

            }

        delete encoder;

        }

    delete aThumb;

    iVideoClipReady = ETrue;

    iVideoClipErr = aError;

    if ( iVideoUtilReady && iVideoClipReady && !iAsyncStopCalled )

        {