/*
* Copyright (c) 2009 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 "vedmovie.h"

_LIT( KMccTranscodedFile, "C:\\data\\videos\\timeraudio.3gp" );
_LIT( KMccTranscodedAvcFile, "C:\\data\\videos\\H264_QCIF_AMR_output.3gp" );


// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
CVedMovie* CVedMovie::NewL(RFs* aFs)
    {
    CVedMovie* movie = CVedMovie::NewLC( aFs );
    CleanupStack::Pop( movie );
    return movie;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
CVedMovie* CVedMovie::NewLC(RFs* /*aFs*/)
    {
    CVedMovie* movie = new ( ELeave ) CVedMovie;
    CleanupStack::PushL( movie );
    movie->ConstructL();
    return movie;
    }    

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
CVedMovie::~CVedMovie()
    {
    CancelProcessing();
   
    delete iDeltaTimer;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
CVedMovie::CVedMovie() :
    iDeltaTimerCallBack(AsyncTimerExpired, this)
    {
    iDeltaTimerEntry.Set(iDeltaTimerCallBack);
    iAudioType = EVedAudioTypeAMR;
    }
    
// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
void CVedMovie::ConstructL()
    {
    iDeltaTimer = CDeltaTimer::NewL(CActive::EPriorityStandard);
    }
    
// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//    
void CVedMovie::SetQuality(TVedMovieQuality aQuality)
    {
    iQuality = aQuality;
    IssueCallback( ENotifyMovieQualityChanged );
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
TVedVideoType CVedMovie::VideoType() const
    {
    return EVedVideoTypeH263Profile0Level45;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
TSize CVedMovie::Resolution() const
    {
    return TSize( 176, 144 );
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
TVedAudioType CVedMovie::AudioType() const
    {
    return iAudioType;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
TInt CVedMovie::AudioSamplingRate() const
    {
    return 8000;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
TVedAudioChannelMode CVedMovie::AudioChannelMode() const
    {
    return EVedAudioChannelModeSingleChannel;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
void CVedMovie::InsertVideoClipL(const TDesC& /*aFileName*/, TInt /*aIndex*/)
    {
	IssueCallback( ENotifyVideoClipAdded );
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
void CVedMovie::ProcessL(const TDesC& aFileName,
                           MVedMovieProcessingObserver& aObserver)
    {
    TFileName sourcePath;
    
    if ( iOutputParams.iVideoType == EVedVideoTypeAVCBaselineProfile )
        {
        // AVC output
        sourcePath.Copy( KMccTranscodedAvcFile );
        }
    else
        {
        // H263 output
        sourcePath.Copy( KMccTranscodedFile );
        }
   	
    RFs fs;
	User::LeaveIfError( fs.Connect() );
	CleanupClosePushL( fs );
	
	CFileMan* fileMan = CFileMan::NewL(fs);
	CleanupStack::PushL(fileMan); 
	
	// Make sure path exists, ignore errors since path might exist already
	fs.MkDirAll( aFileName );	
	
	// Make the destination file writeable, ignore errors since most probably
	// file doesn't exist yet
    fileMan->Attribs( aFileName, 0, KEntryAttReadOnly, TTime( 0 ), 0 );
    
	User::LeaveIfError( fileMan->Copy( sourcePath, aFileName ) );
    
	CleanupStack::PopAndDestroy( 2 ); // fileMan, fs
	
    iProcessObserver = &aObserver;
    iProgress = 0;
    
    IssueCallback( ENotifyMovieProcessingStartedL );
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
void CVedMovie::CancelProcessing()
    {
     if ( iDeltaTimer )
        {
        iDeltaTimer->Remove( iDeltaTimerEntry );
        }
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
void CVedMovie::RegisterMovieObserverL(MVedMovieObserver* aObserver)
    {
    iObserver = aObserver;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
void CVedMovie::UnregisterMovieObserver(MVedMovieObserver* /*aObserver*/)
    {
    iObserver = NULL;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
TInt CVedMovie::AudioBitrate() const
    {
    return 12200;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
TReal CVedMovie::VideoFrameRate() const
    {
    return 15.0;
    }

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
void CVedMovie::SetOutputParametersL(TVedOutputParameters& aOutputParams)
    {
    iOutputParams = aOutputParams;
    IssueCallback( ENotifyMovieOutputParametersChanged );
    }
    
// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
void CVedMovie::IssueCallback( TVedMovieCurrentCallbackType aCallback )
	{
	iDeltaTimer->Remove(iDeltaTimerEntry);
	iCurrentCallback = aCallback;
	TTimeIntervalMicroSeconds32 interval(200000);
	iDeltaTimer->Queue(interval, iDeltaTimerEntry);	
	}	
 
// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//
TInt CVedMovie::AsyncTimerExpired(TAny* aPtr)
	{
	CVedMovie* self = reinterpret_cast<CVedMovie*>(aPtr);
	
	TRAP_IGNORE( self->DoCurrentCallbackL() )

  	return ETrue;
	} 

// -----------------------------------------------------------------------------
// CVedMovie
// -----------------------------------------------------------------------------
//	
void CVedMovie::DoCurrentCallbackL()
    {
    __ASSERT_ALWAYS( iObserver, User::Leave( KErrNotReady ) );
    
    switch ( iCurrentCallback )
        {
        case ENotifyVideoClipAdded:
            {
            iObserver->NotifyVideoClipAdded( *this, 0 );
            break;
            }
        case ENotifyMovieQualityChanged:
            {
            iObserver->NotifyMovieQualityChanged( *this );
            break;
            }
        case ENotifyMovieOutputParametersChanged:
            {
            iObserver->NotifyMovieOutputParametersChanged( *this );
            break;
            }
        case ENotifyMovieProcessingStartedL:
            {
            __ASSERT_ALWAYS( iProcessObserver, User::Leave( KErrNotReady ) );
            
            iProcessObserver->NotifyMovieProcessingStartedL( *this );
            IssueCallback( ENotifyMovieProcessingProgressed );
            break;
            }
        case ENotifyMovieProcessingProgressed:
            {
            __ASSERT_ALWAYS( iProcessObserver, User::Leave( KErrNotReady ) );
            
            iProgress += 20;
            if ( iProgress < 100 )
                {
                iProcessObserver->NotifyMovieProcessingProgressed( *this, iProgress );
                IssueCallback( ENotifyMovieProcessingProgressed );
                }
            else
                {
                IssueCallback( ENotifyMovieProcessingCompleted );
                }
            break;
            }
        case ENotifyMovieProcessingCompleted:
            {
            __ASSERT_ALWAYS( iProcessObserver, User::Leave( KErrNotReady ) );
            
            iProgress = 100;
            iProcessObserver->NotifyMovieProcessingCompleted( *this, KErrNone );
            break;
            }
        default:
            {
            break;
            }
        }
    }