/*
* 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:  
*
*/



#include "mcefilesource.h"
#include "mcevideostream.h"
#include "mceaudiostream.h"
#include "mcemanager.h"
#include "mcesession.h"
#include "utf.h"


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


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C CMceFileSource* CMceFileSource::NewL(
            CMceManager& aManager,
            const TFileName& aFileName )
    {
    CMceFileSource* self = CMceFileSource::NewLC( aManager, aFileName );
    CleanupStack::Pop( self );
    return self;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C CMceFileSource* CMceFileSource::NewLC(
            CMceManager& aManager,
            const TFileName& aFileName )
    {
    CMceFileSource* self = new (ELeave) CMceFileSource();
    CleanupStack::PushL( self );
    self->ConstructL( &aManager, aFileName );
    return self;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C CMceFileSource::~CMceFileSource()
    {
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceFileSource::EnableL()
    {
    CMceMediaSource::DoEnableL();
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceFileSource::DisableL()
    { 
    CMceMediaSource::DoDisableL();
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceFileSource::UpdateL ( const TFileName& aFileName )
    {
    iFileName = aFileName;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//    
EXPORT_C TInt CMceFileSource::MediaElementCountL( TMceMediaType aType ) const
    {
    if ( aType == KMceAudio )
        {
        return iAudioElementCount;
        }
    else if ( aType == KMceVideo )
        {
        return iVideoElementCount;
        }
    return 0;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//    
EXPORT_C void CMceFileSource::SetCurrentMediaElementL( 
            TMceMediaType aType, 
            TInt aIndex )
    {
    __ASSERT_ALWAYS( aIndex >= 0 &&
                     aIndex < MediaElementCountL( aType ), 
                     User::Leave( KErrArgument ) );
                     
    if ( aType == KMceAudio )
        {
        iCurrentAudioElement = aIndex;
        }
    else if ( aType == KMceVideo )
        {
        iCurrentVideoElement = aIndex;
        }
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//      
EXPORT_C TInt CMceFileSource::CurrentMediaElement( TMceMediaType aType )
    {
    if ( aType == KMceAudio )
        {
        return iCurrentAudioElement;
        }
    else if ( aType == KMceVideo )
        {
        return iCurrentVideoElement;
        }
    
    return 0;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//      
EXPORT_C void CMceFileSource::SetPositionL( 
            const TTimeIntervalMicroSeconds& aPosition )
    {
    __ASSERT_ALWAYS( aPosition <= DurationL() &&
                     aPosition >= TTimeIntervalMicroSeconds( 0 ), 
                     User::Leave( KErrArgument ) );
    
    iPosition = aPosition;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//          
EXPORT_C TTimeIntervalMicroSeconds CMceFileSource::PositionL() const
    {        
    return iPosition;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//          
EXPORT_C TTimeIntervalMicroSeconds CMceFileSource::DurationL() const
    {
    return iDuration;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//  
EXPORT_C void CMceFileSource::SetFastForwardL( TBool aUseFFWD )
    {
    __ASSERT_ALWAYS( this->MediaElementCountL( KMceVideo ) > 0, 
                     User::Leave( KErrNotSupported ) );


    iFastForward = aUseFFWD;
        
    
    if ( iFastForward )
        {
        iFastRewind = EFalse;
        }
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//  
EXPORT_C void CMceFileSource::SetFastRewindL( TBool aUseFRWD )
    {
    __ASSERT_ALWAYS( this->MediaElementCountL( KMceVideo ) > 0, 
                     User::Leave( KErrNotSupported ) );

    iFastRewind = aUseFRWD;
        
    if ( iFastRewind )
        {
        iFastForward = EFalse;
        }
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//  
EXPORT_C void CMceFileSource::TranscodeL( const TFileName& aFileName )
    {
    __ASSERT_ALWAYS( aFileName != KNullDesC, User::Leave( KErrArgument ) );

    TBool transcodingNeeded = EFalse;
    for ( TInt i = 0; i < iStreams.Count(); ++i )
        {
        if ( iStreams[i]->State() == CMceMediaStream::ETranscodingRequired )
            {
            transcodingNeeded = ETrue;
            if ( iStreams[i]->Type() == KMceAudio )
                {
                CMceAudioStream* audio = 
                                    static_cast<CMceAudioStream*>(iStreams[i]);
                __ASSERT_ALWAYS( audio->Codecs().Count() > 0, 
                                 User::Leave( KErrNotReady ) );
                }
            else
                {
                CMceVideoStream* video = 
                                    static_cast<CMceVideoStream*>(iStreams[i]);
                __ASSERT_ALWAYS( video->Codecs().Count() > 0, 
                                 User::Leave( KErrNotReady ) );
                }
               
            iStreams[i]->iState = CMceMediaStream::ETranscoding;
            }
        }
    
    __ASSERT_ALWAYS( transcodingNeeded, User::Leave( KErrNotReady ) );
        
    }

   
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//  
EXPORT_C void CMceFileSource::CancelTranscodeL()
    {
    TBool transcodingOngoing = EFalse;
    
    for ( TInt i = 0; i < iStreams.Count(); ++i )
        {
        if ( iStreams[i]->State() == CMceMediaStream::ETranscoding )
            {
            transcodingOngoing = ETrue;
            iStreams[i]->iState = CMceMediaStream::ETranscodingRequired;
            }
        }
    
    __ASSERT_ALWAYS( transcodingOngoing, User::Leave( KErrNotReady ) );
    
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//  
EXPORT_C TInt CMceFileSource::TranscodingProgressL() const
    {
    TBool transcodingOngoing = EFalse;
    
    if ( iFailWithCode != KErrNone )
        {
        TInt failCode = iFailWithCode;
        iFailWithCode = KErrNone;
        User::Leave( failCode );
        }
    
    for ( TInt i = 0; i < iStreams.Count(); ++i )
        {
        if ( iStreams[i]->State() == CMceMediaStream::ETranscoding )
            {
            transcodingOngoing = ETrue;
            }
        }
    
    __ASSERT_ALWAYS( transcodingOngoing, User::Leave( KErrNotReady ) );

    return iTranscodingPercentage; 
    }
        

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMceFileSource::InitializeL( CMceManager* aManager )
    {
    __ASSERT_ALWAYS( aManager, User::Leave( KErrArgument ) );

    iDuration = TTimeIntervalMicroSeconds( 100000000 );
    
    iAudioElementCount = 1;
    iVideoElementCount = 1;
        
    }
    
// -----------------------------------------------------------------------------
// Factory method for inner usage
// -----------------------------------------------------------------------------
//
CMceFileSource* CMceFileSource::NewL()
    {
    CMceFileSource* self = CMceFileSource::NewLC();
    CleanupStack::Pop( self );
    return self;
    }


// -----------------------------------------------------------------------------
// Factory method for inner usage
// -----------------------------------------------------------------------------
//
CMceFileSource* CMceFileSource::NewLC()
    {
    CMceFileSource* self = new (ELeave) CMceFileSource();
    CleanupStack::PushL( self );
    self->ConstructL( NULL, KNullDesC() );
    return self;
    }    
    
    
// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//  
CMceFileSource::CMceFileSource()
    {
    iType = KMceFileSource;    
    }


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//  
void CMceFileSource::ConstructL( CMceManager* aManager, 
                                 const TFileName& aFileName )
    {
    
    iFileName = aFileName;
    
    if ( aManager )
        {        
        InitializeL( aManager );
        }
   
    }