--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommsengine/mmcecli/src/mcevideostream.cpp Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,492 @@
+/*
+* 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 "mcevideostream.h"
+#include "mcevideocodec.h"
+#include "mcesession.h"
+#include "mcemanager.h"
+#include "mcemediasource.h"
+#include "mcemediasink.h"
+#include "mcecamerasource.h"
+#include "mcertpsource.h"
+#include "mcertpsink.h"
+#include "mcedisplaysink.h"
+#include "mceserial.h"
+#include "mceevents.h"
+#include "mceh263codec.h"
+#include "mcefilesource.h"
+#include "mcecomfilesource.h"
+#include "mceclilogs.h"
+#include "cleanupresetanddestroy.h"
+
+
+#define _FLAT_DATA static_cast<CMceComVideoStream*>( iFlatData )
+
+
+
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// Factory method
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMceVideoStream* CMceVideoStream::NewL()
+ {
+ CMceVideoStream* self = CMceVideoStream::NewLC();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// Factory method
+// Leaves instance on CleanupStack.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMceVideoStream* CMceVideoStream::NewLC()
+ {
+ CMceVideoStream* self = new (ELeave) CMceVideoStream();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Destructor.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMceVideoStream::~CMceVideoStream()
+ {
+ iCodecs.ResetAndDestroy();
+ iSupportedVideoCodecs.ResetAndDestroy();
+ }
+
+
+// -----------------------------------------------------------------------------
+// Returns codec.
+// Returns the codecs available to the session.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const RPointerArray<CMceVideoCodec>& CMceVideoStream::Codecs()
+ {
+ return iCodecs;
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CMceVideoStream::AddCodecL( CMceVideoCodec* aCodec )
+ {
+ __ASSERT_ALWAYS(aCodec, User::Leave(KErrArgument));
+ iCodecs.AppendL(aCodec);
+ aCodec->Attach( *this );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CMceVideoStream::RemoveCodecL( CMceVideoCodec& aCodec )
+ {
+ RemoveCodecL( aCodec, Binder() );
+ }
+
+
+// -----------------------------------------------------------------------------
+// NOT IMPLEMENTED YET
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CMceVideoStream::ReplaceCodecsL( RPointerArray<CMceVideoCodec>* /*aCodecs*/ )
+ {
+ User::Leave( KErrNotSupported );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const RPointerArray<const CMceVideoCodec>&
+ CMceVideoStream::SupportedVideoCodecs() const
+ {
+ return iSupportedVideoCodecs;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::InternalizeL
+// -----------------------------------------------------------------------------
+//
+void CMceVideoStream::InternalizeL( MMceComSerializationContext& aSerCtx )
+ {
+ CMceMediaStream::InternalizeL( aSerCtx );
+
+ TMceVideoStreamSerializer<CMceVideoStream> serial( *this );
+ serial.InternalizeL( aSerCtx );
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::ExternalizeL
+// -----------------------------------------------------------------------------
+//
+void CMceVideoStream::ExternalizeL( MMceComSerializationContext& aSerCtx )
+ {
+ CMceMediaStream::ExternalizeL( aSerCtx );
+
+ TMceVideoStreamSerializer<CMceVideoStream> serial( *this );
+ serial.ExternalizeL( aSerCtx );
+
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::InitializeL
+// -----------------------------------------------------------------------------
+//
+void CMceVideoStream::InitializeL(
+ CMceSession& aParent,
+ TBool aDiscardUnusedCodecs )
+ {
+ CMceMediaStream::InitializeL( aParent, aDiscardUnusedCodecs );
+
+ for( TInt i = 0; i < iCodecs.Count(); i++ )
+ {
+ iCodecs[i]->InitializeL( *this );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::InitializeL
+// -----------------------------------------------------------------------------
+//
+void CMceVideoStream::InitializeL( CMceManager* aManager, CMceSession& aSession )
+ {
+ MCECLI_DEBUG("CMceVideoStream::InitializeL, Entry");
+
+ __ASSERT_ALWAYS( aManager, User::Leave( KErrArgument ) );
+
+ CMceMediaStream::InitializeL( aManager, aSession );
+
+ if ( iCodecs.Count() == 0 )
+ {
+ const RPointerArray<const CMceVideoCodec>& supportedCodes =
+ aManager->SupportedVideoCodecs();
+ for( TInt i = 0; i < supportedCodes.Count(); i++ )
+ {
+ CMceVideoCodec* codec = supportedCodes[i]->CloneL();
+ CleanupStack::PushL( codec );
+ AddCodecL( codec );
+ CleanupStack::Pop( codec );
+ MCECLI_DEBUG_SVALUE("CMceVideoStream::InitializeL, \
+Added supported codec", codec->SdpName() );
+
+ }
+ }
+ MCECLI_DEBUG("CMceVideoStream::InitializeL, Exit");
+
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::SynchronizeWithFileL
+// -----------------------------------------------------------------------------
+//
+void CMceVideoStream::SynchronizeWithFileL( CMceFileSource& aFile )
+ {
+ MCECLI_DEBUG("CMceVideoStream::SynchronizeWithFileL, Entry");
+
+ const TDesC8& videoCodec = aFile.SupportedVideo();
+
+ TBool transcodingRequired( EFalse );
+
+ CMceManager* manager = aFile.Manager();
+
+ if ( iCodecs.Count() == 0 && manager )
+ {
+ const RPointerArray<const CMceVideoCodec>& supportedCodecs =
+ manager->SupportedVideoCodecs();
+
+ CMceVideoCodec* codec = NULL;
+ for( TInt j = 0; j < supportedCodecs.Count() && !codec; j++ )
+ {
+ if ( videoCodec.CompareF( supportedCodecs[ j ]->SdpName() ) == 0 )
+ {
+ codec = supportedCodecs[ j ]->CloneL();
+ CleanupStack::PushL( codec );
+ AddCodecL( codec );
+ CleanupStack::Pop( codec );
+ MCECLI_DEBUG_SVALUE("CMceVideoStream::SynchronizeWithFileL, \
+Added supported codec", codec->SdpName() );
+
+ }
+ }
+ }
+
+ for( TInt i = 0; i < iCodecs.Count(); i++ )
+ {
+ CMceVideoCodec* codec = iCodecs[i];
+ if ( videoCodec.CompareF( codec->SdpName() ) == 0 )
+ {
+ const TMceFileInfo& info = aFile.FileInfo();
+
+ TUint allowedMaxBitrate = 0;
+ TUint allowedBitrates = 0;
+
+ TInt resolveError =
+ static_cast<CMceComCodec*>( codec->FlatData() )->
+ ResolveAllowedBitrates( info.iVideoBitRate, allowedBitrates );
+
+ if ( resolveError )
+ {
+ allowedBitrates = 0xFF;
+ }
+
+ codec->SetAllowedBitrates( allowedBitrates );
+ codec->SetBitrate( info.iVideoBitRate );
+ codec->SetFrameRateL( info.iVideoFrameRate );
+ codec->SetResolutionL( info.iVideoFrameSize );
+
+ allowedMaxBitrate = codec->MaxBitRate();
+
+ if ( resolveError || info.iVideoBitRate > allowedMaxBitrate )
+ {
+ transcodingRequired = ETrue;
+ }
+ }
+ else
+ {
+ delete iCodecs[ i ];
+ iCodecs.Remove( i );
+ i--;
+ }
+ }
+
+ if ( iCodecs.Count() == 0 || transcodingRequired )
+ {
+ SetState( CMceMediaStream::ETranscodingRequired );
+ }
+ else
+ {
+ SetState( CMceMediaStream::EInitialized );
+ }
+ TState state = State();
+ MCECLI_DEBUG_MEDIASTATE("CMceVideoStream::SynchronizeWithFileL, exit state", state );
+ }
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::FindCodec
+// -----------------------------------------------------------------------------
+//
+CMceCodec* CMceVideoStream::FindCodec( CMceCodec& aCodec )
+ {
+ const RPointerArray<CMceCodec>& codecs =
+ reinterpret_cast<const RPointerArray<CMceCodec>&>( Codecs() );
+ return CMceMediaStream::FindCodec( codecs, aCodec );
+ }
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::ReorderCodecsByPreferenceL
+// -----------------------------------------------------------------------------
+//
+void CMceVideoStream::ReorderCodecsByPreferenceL( TBool aDiscardUnusedCodecs )
+ {
+ // First remove all disabled codecs
+ if ( aDiscardUnusedCodecs )
+ {
+ TInt lastIndex( iCodecs.Count() - 1 );
+ for( TInt i = lastIndex; i >= 0; i-- )
+ {
+ if ( iCodecs[i]->State() == CMceCodec::EDisabled )
+ {
+ RemoveCodecL( *iCodecs[ i ] );
+ }
+ }
+ }
+
+ TBool inPreferenceOrder = ETrue;
+
+ for( TInt i = 0; i < iCodecs.Count() - 1 && inPreferenceOrder; i++ )
+ {
+ if ( iCodecs[i]->Preference() > iCodecs[i+1]->Preference() )
+ {
+ inPreferenceOrder = EFalse;
+ }
+ }
+
+ if ( !inPreferenceOrder )
+ {
+ RPointerArray<CMceVideoCodec> updated;
+
+ MceCleanupResetAndDestroyPushL( updated );
+
+ TLinearOrder<CMceVideoCodec> order( CMceVideoCodec::ComparePreferences );
+
+ for( TInt i = iCodecs.Count() -1; i >= 0; i-- )
+ {
+ CMceVideoCodec* codec = iCodecs[i];
+ iCodecs.Remove( i );
+ User::LeaveIfError( updated.InsertInOrderAllowRepeats( codec, order ) );
+ }
+
+ iCodecs.ResetAndDestroy();
+
+ for( TInt i = updated.Count() -1; i >= 0; i-- )
+ {
+ CMceVideoCodec* newcodec = updated[i];
+ updated.Remove( i );
+ User::LeaveIfError( iCodecs.InsertInOrderAllowRepeats( newcodec, order ) );
+ }
+
+ CleanupStack::PopAndDestroy();//updated;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::BaseCodecs
+// -----------------------------------------------------------------------------
+//
+const RPointerArray<CMceCodec>& CMceVideoStream::BaseCodecs()
+ {
+ const RPointerArray<CMceCodec>& codecs =
+ reinterpret_cast<const RPointerArray<CMceCodec>&>( Codecs() );
+ return codecs;
+ }
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::RemoveCodecL
+// -----------------------------------------------------------------------------
+//
+void CMceVideoStream::RemoveCodecL( CMceVideoCodec& aCodec, TBool aBinderOriginated )
+ {
+ MCECLI_DEBUG_SVALUE( "CMceVideoStream::RemoveCodecL, sdp name:", aCodec.SdpName() )
+
+ TBool removed( EFalse );
+ for(int i = 0; i < iCodecs.Count() && !removed; i++ )
+ {
+ if( iCodecs[i] == &aCodec ||
+ iCodecs[i]->SdpName().CompareF( aCodec.SdpName() ) == 0 )
+ {
+ MCECLI_DEBUG( "CMceVideoStream::RemoveCodecL, removing" )
+
+ TBool commandBound = aBinderOriginated ? ( Binder() ) : ( !Binder() );
+ if ( BoundStream() && commandBound )
+ {
+ static_cast<CMceVideoStream*>(
+ iLinkedStream )->RemoveCodecL( aCodec, aBinderOriginated );
+ }
+
+ delete iCodecs[i];
+ iCodecs.Remove( i );
+ removed = ETrue;
+ }
+ }
+
+ MCECLI_DEBUG( "CMceVideoStream::RemoveCodecL, Exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::EventReceivedL
+// -----------------------------------------------------------------------------
+//
+TInt CMceVideoStream::EventReceivedL( TMceEvent& aEvent )
+ {
+
+ TInt status = CMceMediaStream::EventReceivedL( aEvent );
+ if ( status != KMceEventNotConsumed )
+ {
+ return status;
+ }
+
+ //try codecs
+ if ( aEvent.Id().IsCodecId() )
+ {
+ TInt codecStatus = status;
+ TInt j = 0;
+ while ( codecStatus != KMceEventConsumed && j < iCodecs.Count() )
+ {
+ CMceVideoCodec* codec = iCodecs[j];
+ codecStatus = codec->EventReceivedL( aEvent );
+ if ( codecStatus == KMceEventUpdate )
+ {
+ MCECLI_DEBUG("CMceVideoStream::EventReceivedL, \
+update codec by replacing old version with new one");
+
+ CMceVideoCodec* updateCodec = static_cast<CMceVideoCodec*>( aEvent.Message() );
+ iCodecs.Remove( j );
+ delete codec;
+ updateCodec->InitializeL( *this );
+ iCodecs.AppendL( updateCodec );
+ updateCodec->Updated();
+ codecStatus = KMceEventConsumed;
+ }
+ j++;
+ }
+ status = codecStatus == KMceEventNotOwner ? KMceEventNotConsumed : codecStatus;
+ }
+
+ return status;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceVideoStream::IsAllowedCombination
+// -----------------------------------------------------------------------------
+//
+TBool CMceVideoStream::IsAllowedCombination()
+ {
+ return ETrue;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Default C++ constructor.
+// -----------------------------------------------------------------------------
+//
+CMceVideoStream::CMceVideoStream()
+ :CMceMediaStream()
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+// Symbian 2nd phase constructor.
+// -----------------------------------------------------------------------------
+//
+void CMceVideoStream::ConstructL()
+ {
+ CMceComVideoStream* stream = CMceComVideoStream::NewLC();
+ CMceMediaStream::ConstructL( stream );
+ CleanupStack::Pop( stream );
+ }
+
+
+
+ // End of File
+
+
+
+
+