/*

* Copyright (c) 2002-2005 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 FILES

#include <mmcccodecinformation.h>

#include "transcoderimpl.h"

#include "mcctranscoderlogs.h"

const TInt KMccTranscodingCompletedPercentage = 100;

const TInt KMccTranscoderCleanupTimerMicrosecs = 10000; // 10ms

const TInt KMccTranscoderProgressNotifFreq = 10;

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CMccTranscoderImplImpl::CMccTranscoderImpl

//

// CMccTranscoderImpl default constructor, can NOT contain any code,

// that might leave

// Phase #1 of 2-phase constructor

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

//

CMccTranscoderImpl::CMccTranscoderImpl() :

    iDeltaTimerCallBack( AsyncTimerExpired, this )

    {

    iDeltaTimerEntry.Set( iDeltaTimerCallBack );   

    }

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

// CMccTranscoderImpl::NewL

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

//

CMccTranscoderImpl* CMccTranscoderImpl::NewL()

    {

    CMccTranscoderImpl* self = new ( ELeave ) CMccTranscoderImpl;

	CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;   

    }

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

// CMccTranscoderImpl::ConstructL

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

//

void CMccTranscoderImpl::ConstructL()

    {

    __TRANSCODER( "CMccTranscoderImpl::ConstructL" )

    iDeltaTimer = CDeltaTimer::NewL( CActive::EPriorityStandard );

    __TRANSCODER( "CMccTranscoderImpl::ConstructL, exit" )

    }

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

// CMccTranscoderImpl::~CMccTranscoderImpl

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

//

CMccTranscoderImpl::~CMccTranscoderImpl()

    {

    __TRANSCODER( "CMccTranscoderImpl::~CMccTranscoderImpl" )

    // Stop cleanup timer

    if ( iDeltaTimer )

        {

        iDeltaTimer->Remove( iDeltaTimerEntry );

        }

    delete iDeltaTimer;

    // Delete sessions

    TInt sessionCount = iSessionArray.Count();

    for ( TInt i = ( sessionCount - 1 ); i >= 0 ; i-- )

        {

        CMccTranscoderSessionInfo* session = iSessionArray[i];

        CVedMovie* movie = &(session->Movie());

        if ( movie && !session->IsRemoved() )

            {

            movie->UnregisterMovieObserver( this );

            }

        }

    iSessionArray.ResetAndDestroy(); 

    iSessionArray.Close(); 

    __TRANSCODER( "CMccTranscoderImpl::~CMccTranscoderImpl, exit" )

    }

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

// CMccTranscoderImpl::RegisterEventObserver

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

//

void CMccTranscoderImpl::RegisterEventObserver( MMccTranscoderObserver& aObserver )

    {

    __TRANSCODER( "CMccTranscoderImpl::RegisterEventObserver" )

    iEventObserver = &aObserver;

    }

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

// CMccTranscoderImpl::UnregisterEventObserver

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

//    

void CMccTranscoderImpl::UnregisterEventObserver()

    {

    __TRANSCODER( "CMccTranscoderImpl::UnregisterEventObserver" )

    iEventObserver = NULL;    

    }

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

// CMccTranscoderImpl::TranscodeFile

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

//  

void CMccTranscoderImpl::TranscodeFileL( 

    TUint32& aSessionId, const TDesC8& aVal )

    {

    __TRANSCODER( "CMccTranscoderImpl::TranscodeFileL" )

    Cleanup();

    const TMccTranscodeFileMsg& transcodeMsg = 

        reinterpret_cast<const TMccTranscodeFileMsgBuffer&>( aVal )();

    CMccTranscoderSessionInfo* session = CMccTranscoderSessionInfo::NewLC();

    // Create session id

    session->GenerateSessionId();

    // Save quality info

    session->SetQuality( transcodeMsg.iQuality );

    // Save destination file info

    session->SetDesFileL( transcodeMsg.iDesFile );

    // CVedMovie object is created

    session->CreateMovieL();

    // Check if video code info is not empty, save it

    session->CheckVideoCodecL( transcodeMsg.iVideoCodec ); 

    // Check if audio code info is not empty, save it

    session->CheckAudioCodecL( transcodeMsg.iAudioCodec );

    __TRANSCODER( "CMccTranscoderImpl::RegisterMovieObserverL..." )

    session->Movie().RegisterMovieObserverL( this );

   	User::LeaveIfError( iSessionArray.Append( session ) );

   	CleanupStack::Pop( session );

    __TRANSCODER( "CMccTranscoderImpl::InsertVideoClipL..." )

    session->Movie().InsertVideoClipL( transcodeMsg.iSourceFile, 0 );

    // Callback function ::NotifyVideoClipAdded will be called later

    aSessionId = session->SessionId();

    __TRANSCODER( "CMccTranscoderImpl::TranscodeFileL, exit" )

    }

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

// CMccTranscoderImpl::CancelTranscodeFile

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

// 

void CMccTranscoderImpl::CancelTranscodeFileL( TUint32 aSessionId )

    {

    __TRANSCODER( "CMccTranscoderImpl::CancelTranscodeFileL" )

    Cleanup();

    TInt session = FindSession( aSessionId );

    __ASSERT_ALWAYS( session >= 0 , User::Leave( KErrNotFound) );

    __ASSERT_ALWAYS( &( iSessionArray[session]->Movie() ), 

        User::Leave( KErrNotFound) );

    TUint32 sessionId = iSessionArray[session]->SessionId();

    iSessionArray[session]->Movie().UnregisterMovieObserver( this );

    iSessionArray[session]->Movie().CancelProcessing();

    SendTranscodeEventToClient( KMccTranscodeCancelled, KErrNone, sessionId );

    }

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

// CMccTranscoderImpl::FindSessionL

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

// 

TInt CMccTranscoderImpl::FindSession( CVedMovie& aMovie )

    {

    TInt sessionCount = iSessionArray.Count();

    TInt err = KErrNotFound;

    TInt sessionIndex = 0;

    for ( TInt i = 0; (i < sessionCount && err != KErrNone ); i++ )

        {

        if ( &iSessionArray[i]->Movie() == &aMovie )

            {

            sessionIndex = i;

            err = KErrNone;

            }

        }

    if ( err )

        {

        return err;   

        }

    else

        {

        return sessionIndex;

        }

    }

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

// CMccTranscoderImpl::FindSession

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

// 

TInt CMccTranscoderImpl::FindSession( TUint32 aSessionID )

    {

    TInt sessionCount = iSessionArray.Count();

    TInt err = KErrNotFound;

    TInt sessionIndex = 0;

    for ( TInt i = 0; (i < sessionCount && err != KErrNone ); i++ )

        {

        if ( iSessionArray[i]->SessionId() == aSessionID )

            {

            sessionIndex = i;

            err = KErrNone;

            }

        }

    if ( err )

        {

        return err;   

        }

    else

        {

        return sessionIndex; 

        }

    }

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

// CMccTranscoderImpl::RemoveSession

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

// 

void CMccTranscoderImpl::RemoveSession( const TInt aIndex )

    {

    TInt sessionCount = iSessionArray.Count();

    if ( aIndex < sessionCount )

        {

        iSessionArray[aIndex]->Movie().UnregisterMovieObserver( this );

        // Can be deleted on next cleanup

        iSessionArray[aIndex]->SetRemoved( ETrue );

        // Initiate async cleanup

        InitiateCleanup();

        } 

    }

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

// CMccTranscoderImpl::SendTranscodeEventToClient

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

//   

void CMccTranscoderImpl::SendTranscodeEventToClient( 

    TMccEventType aEventType, TInt aError , TUint32 aSessionId, TUint32 aData )

    {

    __TRANSCODER( "CMccTranscoderImpl::SendTranscodeEventToClient" )

    if ( !iEventObserver )

        {

        __TRANSCODER( "CMccTranscoderImpl::SendTranscodeEventToClient, no observer" )

        return;

        }

    TMccEvent event;

    event.iErrorCode = aError;

    event.iEventCategory = KMccEventCategoryTranscode;

    event.iEventType = aEventType;

    event.iSessionId = aSessionId;

    event.iEventNumData = aData;

    iEventObserver->MccTranscoderEventReceived( event );

    __TRANSCODER( "CMccTranscoderImpl::SendTranscodeEventToClient, exit" )

    }

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

// CMccTranscoderImpl::NotifyVideoClipAdded

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

//    

void CMccTranscoderImpl::NotifyVideoClipAdded(

    CVedMovie& aMovie, TInt /*aIndex*/)

    {

    __TRANSCODER( "CMccTranscoderImpl::NotifyVideoClipAdded" )

    TInt session = FindSession( aMovie );

    // Session found

    if ( session >= 0 )

        {

        TUint32 sessionId = iSessionArray[session]->SessionId();

        iSessionArray[session]->ClipAdded();

        if ( iSessionArray[session]->QualityChangeNeeded() )

            {

            iSessionArray[session]->Movie().SetQuality( 

                iSessionArray[session]->Quality() );

            // Callback function ::NotifyMovieQualityChanged will be called

            }

        else

            {

            // No need to change quality, continue with transcoding initialization

            SetOutputParameters( aMovie );

            }

        }

    else

        {

        __TRANSCODER( "CMccTranscoderImpl::NotifyVideoClipAdded, \

session not found" )

        }  

    }

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

// CMccTranscoderImpl::NotifyMovieQualityChanged

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

//    

void CMccTranscoderImpl::NotifyMovieQualityChanged(CVedMovie& aMovie)

    {

    __TRANSCODER( "CMccTranscoderImpl::NotifyMovieQualityChanged" )

    SetOutputParameters( aMovie );

    __TRANSCODER( "CMccTranscoderImpl::NotifyMovieQualityChanged, exit" )

    }

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

// CMccTranscoderImpl::NotifyMovieProcessingStartedL

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

//  

void CMccTranscoderImpl::NotifyMovieProcessingStartedL(CVedMovie& aMovie)

    {

    __TRANSCODER( "CMccTranscoderImpl::NotifyMovieProcessingStartedL" )

    TInt session = FindSession( aMovie );

    if ( session >= 0 )

        {

        TUint32 sessionId = iSessionArray[session]->SessionId();

        // Send event to client

        SendTranscodeEventToClient( KMccTranscodeInProgress, KErrNone, sessionId );

        }

    else

        {

        __TRANSCODER( "CMccTranscoderImpl::NotifyMovieProcessingStartedL, \

session not found" )

        }

    }

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

// CMccTranscoderImpl::NotifyMovieOutputParametersChanged

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

//     

void CMccTranscoderImpl::NotifyMovieOutputParametersChanged(CVedMovie& aMovie)

    {

    __TRANSCODER( "CMccTranscoderImpl::NotifyMovieOutputParametersChanged" )

    TInt session = FindSession( aMovie );

    if ( session >= 0 )

        {

        TRAPD( err, iSessionArray[session]->Movie().ProcessL( 

            iSessionArray[session]->DesFile(), *this ) );

        // Next will call 

        // MVedMovieProcessingObserver::NotifyMovieProcessingStartedL    

        if ( err )

            {

            __TRANSCODER_INT1( "CMccTranscoderImpl::NotifyMovieOutput\

    ParametersChanged, call ProcessL, Error=", err )

            TUint32 sessionId = iSessionArray[session]->SessionId();

            // Error happened when process transcoding, remove the clip

            RemoveSession( session );

            SendTranscodeEventToClient( KMccTranscodeCompleted, err, sessionId );

            }

        }

    else

        {

        __TRANSCODER( "CMccTranscoderImpl::NotifyMovieOutputParametersChanged, \

session not found" )

        }

    }

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

// CMccTranscoderImpl::NotifyMovieProcessingCompleted

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

//   

void CMccTranscoderImpl::NotifyMovieProcessingCompleted(

    CVedMovie& aMovie, TInt aError)

    {

    __TRANSCODER( "CMccTranscoderImpl::NotifyMovieProcessingCompleted" )

    __TRANSCODER_INT1( "CMccTranscoderImpl::NotifyMovieProcessingCompleted, \

aError= ", aError)

    TInt session = FindSession( aMovie );

    if ( session >= 0 )

        {

        TUint32 sessionId = iSessionArray[session]->SessionId();

        // Clip not needed anymore

        RemoveSession( session );

        // Send event 

        SendTranscodeEventToClient( KMccTranscodeCompleted, 

                                    aError, 

                                    sessionId, 

                                    KMccTranscodingCompletedPercentage );

        }

    else

        {

        __TRANSCODER( "CMccTranscoderImpl::NotifyMovieProcessingCompleted, \

session not found" )

        }

    }

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

// CMccTranscoderImpl::NotifyVideoClipAddingFailed

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

//     

void CMccTranscoderImpl::NotifyVideoClipAddingFailed(

    CVedMovie& aMovie, TInt aError)

    {

    __TRANSCODER( "CMccTranscoderImpl::NotifyVideoClipAddingFailed" )

    TInt session = FindSession( aMovie );

    if ( session >= 0 )

        {

        TUint32 sessionId = iSessionArray[session]->SessionId();

        RemoveSession( session );

        // Send event to client   

        SendTranscodeEventToClient( KMccTranscodeCompleted, aError, sessionId );

        }

    else

        {

        __TRANSCODER_INT1( "CMccTranscoderImpl::NotifyVideoClipAddingFailed, \

aError is ignored:", aError )

        }

    }

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

// CMccTranscoderImpl::NotifyVideoClipRemoved

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

//     

void CMccTranscoderImpl::NotifyVideoClipRemoved(

    CVedMovie& aMovie, TInt /*aIndex*/ )

    {

    __TRANSCODER( "CMccTranscoderImpl::NotifyVideoClipRemoved" )

    TInt session = FindSession( aMovie );

    if ( session >= 0 )

        {

        __TRANSCODER( "CMccTranscoderImpl::NotifyVideoClipRemoved, \

removing session..." )

        RemoveSession( session );            

        }

    }

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

// CMccTranscoderImpl::NotifyMovieProcessingProgressed

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

//        

void CMccTranscoderImpl::NotifyMovieProcessingProgressed( 

    CVedMovie& aMovie, TInt aPercentage )

    {

    __TRANSCODER( "CMccTranscoderImpl::NotifyMovieProcessingProgressed" )

    TInt session = FindSession( aMovie );

    if ( session >= 0 )

        {

        __TRANSCODER_INT1( "CMccTranscoderImpl::NotifyMovieProcessingProgressed,\

aPercenctage=", aPercentage )

        TUint32 sessionId = iSessionArray[session]->SessionId();

        TInt modifiedPercentage = iSessionArray[session]->Progressed( aPercentage );

        if ( !(modifiedPercentage % KMccTranscoderProgressNotifFreq) )

            {

            SendTranscodeEventToClient( KMccTranscodeInProgress, 

                KErrNone, sessionId, modifiedPercentage );

            }

        }

    else

        {

        __TRANSCODER( "CMccTranscoderImpl::NotifyMovieProcessingProgressed, \