/*
* 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 );
}
}