--- a/dvrengine/CommonRecordingEngine/src/CCREngine.cpp Fri Jun 11 10:05:41 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1592 +0,0 @@
-/*
-* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
-* All rights reserved.
-* This component and the accompanying materials are made available
-* under the terms of the License "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: Engine part of the engine. In practice keeps count on*
-*/
-
-
-
-
-// INCLUDE FILES
-#include <pathinfo.h>
-#include "VideoServiceUtilsConf.hrh"
-#include "CCREngine.h"
-#include "CCRStreamingSession.h"
-#include "CCRSession.h"
-#include "CCRClientInformer.h"
-#include "CCRConnection.h"
-#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT
-#include <ipvideo/CRtpUtil.h>
-#include <ipvideo/CRtpClipHandler.h>
-#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT
-#include <e32msgqueue.h>
-#include <ipvideo/CRTypeDefs.h>
-#include <e32std.h>
-#include <es_sock.h>
-#include "videoserviceutilsLogger.h"
-
-// CONSTANTS
-const TUint KCRELoopbackPortStart( 1106 );
-
-// ============================ MEMBER FUNCTIONS ===============================
-
-// -----------------------------------------------------------------------------
-// CCREngine::NewL
-// Two-phased constructor.
-// -----------------------------------------------------------------------------
-//
-CCREngine* CCREngine::NewL( void )
- {
- CCREngine* self = new( ELeave ) CCREngine();
-
- // Use CleanupClosePushL to make sure the Close function defined in CObject
- // base class gets called. CObject will delete itself once its reference count
- // reaches zero. Using CleanupStack::PushL here results in E32USER-CBase panic 33
- // if there is a leave somewhere in construction
- CleanupClosePushL( *self );
-
- self->ConstructL();
- CleanupStack::Pop( self );
- return self;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::CCREngine
-// C++ default constructor can NOT contain any code, that might leave.
-// -----------------------------------------------------------------------------
-//
-CCREngine::CCREngine( void ) : iLoopbackPort( KCRELoopbackPortStart )
- {
- // None
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::ConstructL
-// Symbian 2nd phase constructor can leave.
-// -----------------------------------------------------------------------------
-//
-void CCREngine::ConstructL()
- {
- LOG( "CCREngine::ConstructL()" );
-
- // Note, quite high priority
- iCleanUp = new ( ELeave ) CAsyncCallBack( CActive::EPriorityStandard );
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::~CCREngine
-// Destructor.
-// -----------------------------------------------------------------------------
-//
-CCREngine::~CCREngine()
- {
- LOG( "CCREngine::~CCREngine()" );
-
- delete iCleanUp;
- iSessions.ResetAndDestroy();
- iSessionsToDelete.Reset();
- delete iConnection;
-#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT
- delete iClipHandler;
-#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- iSockServer.Close();
- delete iInformer;
- delete iQueueName;
- }
-
-// -----------------------------------------------------------------------------
-// Method for actual message handling.
-//
-// -----------------------------------------------------------------------------
-//
-void CCREngine::GeneralServiceL( const RMessage2& aMessage )
- {
-#if defined( LIVE_TV_RDEBUG_TRACE ) || defined( LIVE_TV_FILE_TRACE )
- if ( aMessage.Function() != ECRGetPosition )
- {
- LOG1( "CCREngine::GeneralService(), aMessage: %d", aMessage.Function() );
- }
-#endif // LIVE_TV_RDEBUG_TRACE || LIVE_TV_FILE_TRACE
-
- // Verify cababilities
- VerifyCapabilitiesL( aMessage );
-
- // Handle message
- TInt err( KErrNone );
- switch( aMessage.Function() )
- {
- case ECRSetIap:
- {
- TPckgBuf<SCRRtspIapParams> pckg;
- Read( aMessage, 0, pckg );
- err = SetConnectionId( pckg() );
- aMessage.Complete( err );
- }
- break;
-
- case ECRCancelSetIap:
- aMessage.Complete( CancelSetConnectionId() );
- break;
-
- case ECRPlayRtspUrl:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TPckgBuf<SCRRtspParams> pckg1;
- Read( aMessage, 1, pckg1 );
- TRAP( err, pckg0() = PlayRtspUrlL( pckg1() ) );
- if ( !err )
- {
- Write( aMessage, 0, pckg0 );
- }
- aMessage.Complete( err );
- }
- break;
-
- case ECRPlayDvbhLive:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TPckgBuf<SCRLiveParams> pckg1;
- Read( aMessage, 1, pckg1 );
- TRAP( err, pckg0() = PlayDvbhLiveL( pckg1() ) );
- if ( !err )
- {
- Write( aMessage, 0, pckg0 );
- }
- aMessage.Complete( err );
- }
- break;
-
- case ECRChangeService:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TPckgBuf<SCRLiveParams> pckg1;
- Read( aMessage, 0, pckg0 );
- Read( aMessage, 1, pckg1 );
- TRAP( err, pckg0() = ChangeDvbhServiceL( pckg0(), pckg1() ) );
- if ( !err )
- {
- Write( aMessage, 0, pckg0 );
- }
- aMessage.Complete( err );
- }
- break;
-
- case ECRPlayRtpFile:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TPckgBuf<SCRRtpPlayParams> pckg1;
- Read( aMessage, 1, pckg1 );
- TRAP( err, pckg0() = PlayRtpFileL( pckg1() ) );
- if ( !err )
- {
- Write( aMessage, 0, pckg0 );
- }
- aMessage.Complete( err );
- }
- break;
-
- case ECRPlayRtpHandle:
- {
- RFile fileHandle;
- err = fileHandle.AdoptFromClient( aMessage, 1, 2 );
- if ( !err )
- {
- TPckgBuf<TUint> pckg( 0 );
- TRAP( err, pckg() = PlayRtpFileL( fileHandle ) );
- if ( !err )
- {
- Write( aMessage, 0, pckg );
- }
- }
- fileHandle.Close();
- aMessage.Complete( err );
- }
- break;
-
- case ECRRecordCurrentStream:
- {
- TPckgBuf<TUint> pckg0( 0 );
- Read( aMessage, 0, pckg0 );
- TPckgBuf<SCRRecordParams> pckg1;
- Read( aMessage, 1, pckg1 );
- TRAP( err, RecordCurrentStreamL( pckg0(), pckg1() ) );
- aMessage.Complete( err );
- }
- break;
-
- case ECRRecordRtspStream:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TPckgBuf<SCRRtspParams> pckg1;
- Read( aMessage, 1, pckg1 );
- TPckgBuf<SCRRecordParams> pckg2;
- Read( aMessage, 2, pckg2 );
- TRAP( err, pckg0() = RecordRtspStreamL( pckg1(), pckg2() ) );
- aMessage.Complete( err );
- }
- break;
-
- case ECRRecordDvbhStream:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TPckgBuf<SCRLiveParams> pckg1;
- Read( aMessage, 1, pckg1 );
- TPckgBuf<SCRRecordParams> pckg2;
- Read( aMessage, 2, pckg2 );
- TRAP( err, pckg0() = RecordDvbhStreamL( pckg1(), pckg2() ) );
- aMessage.Complete( err );
- }
- break;
-
- case ECRPauseRecordStream:
- {
- TPckgBuf<TUint> pckg0( 0 );
- Read( aMessage, 0, pckg0 );
- TPckgBuf<TBool> pckg1( 0 );
- Read( aMessage, 1, pckg1 );
- aMessage.Complete( PauseRecordStream( pckg0(), pckg1() ) );
- }
- break;
-
- case ECRStopRecordStream:
- {
- TPckgBuf<TUint> pckg0( 0 );
- Read( aMessage, 0, pckg0 );
- aMessage.Complete( StopRecordStream( pckg0() ) );
- }
- break;
-
- case ECRStartTimeShift:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TPckgBuf<TUint> pckg1( 0 );
- Read( aMessage, 1, pckg1 );
- TRAP( err, pckg0() = StartTimeShiftL( pckg1() ) );
- if ( !err )
- {
- Write( aMessage, 0, pckg0 );
- }
- aMessage.Complete( err );
- }
- break;
-
- case ECRStopTimeShift:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TPckgBuf<TUint> pckg1( 0 );
- Read( aMessage, 0, pckg0 );
- Read( aMessage, 1, pckg1 );
- aMessage.Complete( StopTimeShift( pckg0(), pckg1() ) );
- }
- break;
-
- case ECRPlayCommand:
- {
- TPckgBuf<TUint> pckg0( 0 );
- Read( aMessage, 0, pckg0 );
- TPckgBuf<TInt64> pckg1( 0 );
- Read( aMessage, 1, pckg1 );
- TPckgBuf<TInt64> pckg2( 0 );
- Read( aMessage, 2, pckg2 );
- aMessage.Complete( PlayCommand( pckg0(), pckg1(), pckg2() ) );
- }
- break;
-
- case ECRPauseCommand:
- {
- TPckgBuf<TUint> pckg0( 0 );
- Read( aMessage, 0, pckg0 );
- aMessage.Complete( PauseCommand( pckg0() ) );
- }
- break;
-
- case ECRStopCommand:
- {
- TPckgBuf<TUint> pckg0( 0 );
- Read( aMessage, 0, pckg0 );
- aMessage.Complete( StopCommand( pckg0() ) );
- }
- break;
-
- case ECRSetPosition:
- {
- TPckgBuf<TUint> pckg0( 0 );
- Read( aMessage, 0, pckg0 );
- TPckgBuf<TInt64> pckg1( 0 );
- Read( aMessage, 1, pckg1 );
- err = SetPosition( pckg0(), pckg1() );
- aMessage.Complete( err );
- }
- break;
-
- case ECRGetPosition:
- {
- TPckgBuf<TUint> pckg0( 0 );
- Read( aMessage, 0, pckg0 );
- TPckgBuf<TInt64> pckg1( 0 );
- Read( aMessage, 1, pckg1 );
- TPckgBuf<TInt64> pckg2( 0 );
- err = GetPosition( pckg0(), pckg1(), pckg2() );
- Write( aMessage, 1, pckg1 );
- Write( aMessage, 2, pckg2 );
- aMessage.Complete( err );
- }
- break;
-
- case ECRCloseSession:
- {
- TPckgBuf<TUint> pckg0( 0 );
- Read( aMessage, 0, pckg0 );
- aMessage.Complete( CloseSession( pckg0() ) );
- }
- break;
-
- case ECRPlayNullSource:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TRAP( err, pckg0() = PlayNullSourceL() );
- Write( aMessage, 0, pckg0 );
- aMessage.Complete( err );
- }
- break;
-
- case ECRPlayRtspUrlToNullSink:
- {
- TPckgBuf<TUint> pckg0( 0 );
- TPckgBuf<SCRRtspParams> pckg1;
- Read( aMessage, 1, pckg1 );
- TRAP( err, pckg0() = PlayRtspUrlToNullSinkL( pckg1() ) );
- Write( aMessage, 0, pckg0 );
- aMessage.Complete( err );
- }
- break;
-
- default:
- aMessage.Complete( KErrNotSupported );
- break;
- }
- }
-
-//-----------------------------------------------------------------------------
-// CCREngine::SessionStop()
-// So, a session wants to quit. we can't just delete it here as return.
-// Statement would then take us to deleted instance: put up a cleanup
-// CAsyncCallBack and return.
-//-----------------------------------------------------------------------------
-//
-void CCREngine::SessionStop( CCRStreamingSession* aSession )
- {
- LOG1( "CCREngine::SessionStop(), Delete count: %d", iSessionsToDelete.Count() );
-
- // InsertInAddressOrder checks for duplicate, if there is already
- // entry for that session, the array will remain unchanged
- TRAPD( err, iSessionsToDelete.InsertInAddressOrderL( aSession ) );
- if ( err )
- {
- LOG1( "CCREngine::SessionStop(), InsertInAddressOrder leaved: %d", err );
- }
-
- // If not already active and sessions to delete?
- if ( !iCleanUp->IsActive() && iSessionsToDelete.Count() )
- {
- TCallBack cb( SessionStopCallBack, this );
- iCleanUp->Set( cb );
- iCleanUp->CallBack();
- }
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::ConnectionStatusChange
-//
-// -----------------------------------------------------------------------------
-//
-void CCREngine::ConnectionStatusChange(
- TInt aSessionId,
- TCRConnectionStatus aStatus,
- TInt aErr )
- {
- LOG3( "CCREngine::ConnectionStatusChange(), aSessionId: %d, aStatus: %d, Error: %d",
- aSessionId, aStatus, aErr );
-
- SCRQueueEntry entry = { ECRMsgQueueConnectionError, KErrNone };
- entry.iSessionId = aSessionId;
-
- switch ( aStatus )
- {
- case ECRConnectionError:
- {
- entry.iMsg = ECRMsgQueueConnectionError;
- entry.iErr = aErr;
- }
- break;
-
- case ECRAuthenticationNeeded:
- {
- entry.iMsg = ECRMsgQueueAuthenticationNeeded;
- entry.iErr = KErrNone;
- }
- break;
-
- case ECRNotEnoughBandwidth:
- {
- entry.iMsg = ECRMsgQueueNotEnoughBandwidth;
- entry.iErr = KErrNone;
- }
- break;
-
- case ECRNormalEndOfStream:
- {
- entry.iMsg = ECRMsgQueueNormalEndOfStream;
- entry.iErr = aErr;
- }
- break;
-
- case ECRAttachCompleted: // fall through
- case ECRSwitchingToTcp:
- {
- aStatus == ECRAttachCompleted ?
- ( entry.iMsg = ECRMsgQueueAttachCompleted ) :
- ( entry.iMsg = ECRMsgQueueSwitchingToTcp );
-
- if ( aErr == KErrNone )
- {
- // Releasing RSocket takes almost 40 seconds so we need
- // to always use different port number, otherwise an
- // "Already in use" error will be occurred.
- TTime now;
- now.UniversalTime();
- TInt port = KCRELoopbackPortStart + now.DateTime().Second();
- iLoopbackPort == port ? ( iLoopbackPort = port + 1 ) :
- ( iLoopbackPort = port );
-
- // Loopback port for VIA
- entry.iErr = iLoopbackPort;
- }
- else
- {
- entry.iErr = aErr;
- }
- }
- break;
-
- case ECRStreamIsLiveStream:
- {
- entry.iMsg = ECRMsgQueueStreamIsLiveStream;
- entry.iErr = aErr;
- }
- break;
-
- case ECRStreamIsRealMedia:
- {
- entry.iMsg = ECRMsgQueueStreamIsRealMedia;
- entry.iErr = aErr;
- }
- break;
-
- case ECRBearerChanged:
- {
- // Nobody is interested about this on the other side...
- return;
- }
-
- case ECRTestSinkData:
- {
- entry.iMsg = ECRMsgQueueTestSinkData;
- entry.iErr = aErr;
- }
- break;
-
- case ECRSdpAvailable:
- {
- entry.iMsg = ECRMsgQueueSdpAvailable;
- entry.iErr = aErr;
- }
- break;
-
- case ECRReadyToSeek:
- {
- entry.iMsg = ECRMsgQueueReadyToSeek;
- entry.iErr = aErr;
- }
- break;
-
- case ECRRecordingStarted:
- {
- entry.iMsg = ECRMsgQueueRecordingStarted;
- entry.iErr = aErr;
- }
- break;
-
- case ECRRecordingPaused:
- {
- entry.iMsg = ECRMsgQueueRecordingPaused;
- entry.iErr = aErr;
- }
- break;
-
- case ECRRecordingEnded:
- {
- entry.iMsg = ECRMsgQueueRecordingEnded;
- entry.iErr = aErr;
- }
- break;
-
- default:
- // None
- break;
- }
-
- if ( iQueueName && iInformer )
- {
- iInformer->SendMessage( iQueueName->Des(), entry );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::VerifyCapabilitiesL
-// Checks capabilities of user of DVR API.
-// -----------------------------------------------------------------------------
-//
-void CCREngine::VerifyCapabilitiesL( const RMessage2& aMessage )
- {
- if ( !aMessage.HasCapability( ECapabilityNetworkServices,
- __PLATSEC_DIAGNOSTIC_STRING( "NetworkServices" ) ) )
- {
- LOG( "CCREngine::VerifyRbfCapabilitiesL(), Missing: NetworkServices !" );
- User::Leave( KErrPermissionDenied );
- }
-
- if ( !aMessage.HasCapability( ECapabilityReadUserData,
- __PLATSEC_DIAGNOSTIC_STRING( "ReadUserData" ) ) )
- {
- LOG( "CCREngine::VerifyRbfCapabilitiesL(), Missing: ReadUserData !" );
- User::Leave( KErrPermissionDenied );
- }
-
- if ( !aMessage.HasCapability( ECapabilityWriteUserData,
- __PLATSEC_DIAGNOSTIC_STRING( "WriteUserData" ) ) )
- {
- LOG( "CCREngine::VerifyRbfCapabilitiesL(), Missing: WriteUserData !" );
- User::Leave( KErrPermissionDenied );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::SetConnectionId
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::SetConnectionId( const SCRRtspIapParams& aIap )
- {
- LOG( "CCREngine::SetConnectionId() in" );
-
- TRAPD ( err, CreateConnectionL() ) ;
- if ( err == KErrNone )
- {
- delete iQueueName; iQueueName = NULL;
- TRAP( err, iQueueName = aIap.iQueueName.AllocL() );
- if ( err == KErrNone )
- {
- iConnection->Attach( aIap.iConnectionId );
- }
-
- }
- LOG1( "CCREngine::SetConnectionId() out, err: %d", err );
- return err;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::CancelSetConnectionId
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::CancelSetConnectionId()
- {
- LOG( "CCREngine::CancelSetConnectionId() in" );
-
- TInt err( KErrNone );
- if ( iConnection )
- {
- iSessions.ResetAndDestroy();
- delete iConnection; iConnection = NULL;
- iSockServer.Close();
- err = iSockServer.Connect( KESockDefaultMessageSlots * 3 );
- if ( err == KErrNone )
- {
- TRAP( err, iConnection = CCRConnection::NewL( iSockServer ) );
- if ( err == KErrNone && iConnection )
- {
- err = iConnection->RegisterObserver( this );
- }
- }
- }
-
- LOG1( "CCREngine::CancelSetConnectionId() out, err: %d", err );
- return err;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PlayRtspUrlL
-// Go through stream sessions and try to find if given url is already playing.
-// If not, create new RTSP session and add sink to it.
-// -----------------------------------------------------------------------------
-//
-TUint CCREngine::PlayRtspUrlL( const SCRRtspParams& aRtspParams )
- {
- LOG( "CCREngine::PlayRtspUrlL() in" );
-
- const TInt sessionIndex( VerifyRtspSessionL( aRtspParams ) );
- iSessions[sessionIndex]->CreateRtspSinkL( iLoopbackPort );
- TUint sessionChk( iSessions[sessionIndex]->SourceChecksum() );
- LOG1( "CCREngine::PlayRtspUrlL() out, sessionChk: %d", sessionChk );
- return sessionChk;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PlayDvbhLiveL
-// Go through stream sessions and try to find if current service is already
-// If not, create new DVB-H session and add sink to it.
-// -----------------------------------------------------------------------------
-//
-TUint CCREngine::PlayDvbhLiveL( const SCRLiveParams& aLiveParams )
- {
- LOG( "CCREngine::PlayDvbhLiveL() in" );
-
- const TInt sessionIndex( VerifyDvbhSessionL( aLiveParams ) );
- iSessions[sessionIndex]->CreateXpsSinkL();
- iSessions[sessionIndex]->PostActionL();
- TUint sessionChk( iSessions[sessionIndex]->SourceChecksum() );
- LOG1( "CCREngine::PlayDvbhLiveL() out, sessionChk: %d", sessionChk );
- return sessionChk;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::ChangeDvbhServiceL
-// Go through stream sessions and try to find if current service is already
-// If not, create new DVB-H session and add sink to it.
-// -----------------------------------------------------------------------------
-//
-TUint CCREngine::ChangeDvbhServiceL(
- const TUint aSessionChk,
- const SCRLiveParams& aLiveParams )
- {
- LOG( "CCREngine::ChangeDvbhServiceL() in" );
-
- // Verify exist session
- const TInt currentSession( VerifySession( aSessionChk ) );
- User::LeaveIfError( currentSession );
-
- // Can't perform if recording or timeshift ongoing
- if ( iSessions[currentSession]->ClipHandlerUsed() )
- {
- User::Leave( KErrInUse );
- }
-
- // New session for new service
- const TInt sessionIndex( VerifyDvbhSessionL( aLiveParams ) );
- if ( sessionIndex == currentSession )
- {
- // Same service, no actions
- return aSessionChk;
- }
-
- // Stop sockets of DVB-H source (filters released)
- User::LeaveIfError( iSessions[currentSession]->StopCommand() );
-
- // Transfer ownership of existing XPS sink to a new session
- User::LeaveIfError( iSessions[currentSession]->TransferSink(
- CCRStreamingSession::ECRXpsSinkId, *iSessions[sessionIndex] ) );
- iSessions[sessionIndex]->PostActionL();
- TUint sessionChk( iSessions[sessionIndex]->SourceChecksum() );
-
- // Delete existing unused session
- SessionStop( iSessions[currentSession] );
- LOG1( "CCREngine::ChangeDvbhServiceL() out, sessionChk: %d", sessionChk );
- return sessionChk;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PlayRtpFileL
-//
-// -----------------------------------------------------------------------------
-//
-TUint CCREngine::PlayRtpFileL( const SCRRtpPlayParams& aRtpParams )
- {
- LOG( "CCREngine::PlayRtpFileL() in" );
-
- const TInt sessionIndex( VerifyRtpFileSessionL( aRtpParams ) );
- iSessions[sessionIndex]->CreateXpsSinkL();
- iSessions[sessionIndex]->PostActionL();
- TUint sessionChk( iSessions[sessionIndex]->SourceChecksum() );
- LOG1( "CCREngine::PlayRtpFileL() out, sessionChk: %d", sessionChk );
- return sessionChk;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PlayRtpFileL
-//
-// -----------------------------------------------------------------------------
-//
-TUint CCREngine::PlayRtpFileL( const RFile& aFileHandle )
- {
- LOG( "CCREngine::PlayRtpFileL() in, with hadle" );
-
- TInt sessionIndex( VerifyRtpFileSessionL( aFileHandle ) );
- iSessions[sessionIndex]->CreateXpsSinkL();
- iSessions[sessionIndex]->PostActionL();
- TUint sessionChk( iSessions[sessionIndex]->SourceChecksum() );
- LOG1( "CCREngine::PlayRtpFileL() out, sessionChk: %d", sessionChk );
- return sessionChk;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::RecordCurrentStreamL
-//
-// -----------------------------------------------------------------------------
-//
-void CCREngine::RecordCurrentStreamL(
- const TUint aSessionChk,
- const SCRRecordParams& aRecordParams )
- {
- LOG1( "CCREngine::StartRecordStreamL() in, aSessionChk: %d", aSessionChk );
-
- // Verify session
- const TInt sessionIndex( VerifySession( aSessionChk ) );
-
- // Session exist?
- if ( sessionIndex > KErrNotFound )
- {
- CreateRecordingSinkL( sessionIndex, aRecordParams );
- iSessions[sessionIndex]->PostActionL();
- }
-
- LOG1( "CCREngine::StartRecordStreamL() out, sessionIndex: %d", sessionIndex );
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::RecordRtspStreamL
-//
-// -----------------------------------------------------------------------------
-//
-TUint CCREngine::RecordRtspStreamL(
- const SCRRtspParams& aRtspParams,
- const SCRRecordParams& aRecordParams )
- {
- LOG( "CCREngine::RecordRtspStreamL() in" );
-
- // Verify session
- const TInt sessionIndex( VerifyRtspSessionL( aRtspParams ) );
-
- // Recording sink
- CreateRecordingSinkL( sessionIndex, aRecordParams );
- TUint sessionChk( iSessions[sessionIndex]->SourceChecksum() );
- LOG1( "CCREngine::RecordRtspStreamL() out, sessionChk: %d", sessionChk );
- return sessionChk;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::RecordDvbhStreamL
-//
-// -----------------------------------------------------------------------------
-//
-TUint CCREngine::RecordDvbhStreamL(
- const SCRLiveParams& aLiveParams,
- const SCRRecordParams& aRecordParams )
- {
- LOG( "CCREngine::RecordDvbhStreamL() in" );
-
- // Verify session
- const TInt sessionIndex( VerifyDvbhSessionL( aLiveParams ) );
-
- // Recording sink
- CreateRecordingSinkL( sessionIndex, aRecordParams );
- iSessions[sessionIndex]->PostActionL();
- TUint sessionChk( iSessions[sessionIndex]->SourceChecksum() );
- LOG1( "CCREngine::RecordDvbhStreamL() out, sessionChk: %d", sessionChk );
- return sessionChk;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PauseRecordStream
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::PauseRecordStream( const TUint aSessionChk, const TBool& aStart )
- {
- LOG2( "CCREngine::PauseRecordStream() in, aSessionChk: %d, aStart: %d",
- aSessionChk, aStart );
- // Verify session
- const TInt sessionIndex( VerifySession( aSessionChk ) );
-
- // Session exist?
- if ( sessionIndex > KErrNotFound )
- {
- TInt err( KErrNone );
- if ( aStart )
- {
- // Clip format not known, so all types must try to pause
- err = iSessions[sessionIndex]->PauseCommand(
- CCRStreamingSession::ECRRtpRecSinkId );
- if ( err == KErrCompletion )
- {
- err = iSessions[sessionIndex]->PauseCommand(
- CCRStreamingSession::ECR3gpRecSinkId );
- }
-
- ConnectionStatusChange( aSessionChk, ECRRecordingPaused, err );
- }
- else
- {
- // Clip format not known, so all types must try to pause
- err = iSessions[sessionIndex]->RestoreCommand(
- CCRStreamingSession::ECRRtpRecSinkId );
- if ( err == KErrCompletion )
- {
- err = iSessions[sessionIndex]->RestoreCommand(
- CCRStreamingSession::ECR3gpRecSinkId );
- }
-
- ConnectionStatusChange( aSessionChk, ECRRecordingStarted, err );
- }
-
- LOG1( "CCREngine::PauseRecordStream() out, err: %d", err );
- return err;
- }
-
- LOG1( "CCREngine::PauseRecordStream() out, sessionIndex: %d", sessionIndex );
- return sessionIndex;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::StopRecordStream
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::StopRecordStream( const TUint aSessionChk )
- {
- LOG1( "CCREngine::StopRecordStream() in, aSessionChk: %d", aSessionChk );
-
- // Verify session
- const TInt sessionIndex( VerifySession( aSessionChk ) );
-
- // Session exist?
- if ( sessionIndex > KErrNotFound )
- {
- // Clip format not known, so all types must try to stop
- iSessions[sessionIndex]->StopCommand(
- CCRStreamingSession::ECRRtpRecSinkId );
- iSessions[sessionIndex]->StopCommand(
- CCRStreamingSession::ECR3gpRecSinkId );
- // Possible error(s) ignored
- }
-
- LOG1( "CCREngine::StopRecordStream() out, sessionIndex: %d", sessionIndex );
- return sessionIndex;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::StartTimeShift
-// Existing stream play will be splitted to two sessions. Existing source will
-// be directed to recording and existing sink will get new source from playback.
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::StartTimeShiftL( const TUint aSessionChk )
- {
- LOG1( "CCREngine::StartTimeShiftL() in, aSessionChk: %d", aSessionChk );
-
-#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT
-
- // Verify session
- const TInt currentSession( VerifySession( aSessionChk ) );
- User::LeaveIfError( currentSession );
-
- // Initial time shift clip name
- TPath initialName( KDvrTimeShiftFile );
- initialName.AppendNum( 0 );
-
- // RTP clip handler
- CreateClipHandlerL();
-
- // Start recording of stream
- SCRRecordParams recordParams;
- recordParams.iFileName.Set( initialName );
- recordParams.iFormat = ECRRecordTimeShift;
- iSessions[currentSession]->CreateRtpRecordSinkL( recordParams, iClipHandler );
- iSessions[currentSession]->PostActionL();
-
- // Create new session for time shift clip playback
- SCRRtpPlayParams params;
- params.iFileName = initialName;
- const TInt timeShiftSession( VerifyRtpFileSessionL( params ) );
- iSessions[timeShiftSession]->PostActionL();
-
- // Transfer ownership of existing XPS sink to a new session
- User::LeaveIfError( iSessions[currentSession]->TransferSink(
- CCRStreamingSession::ECRXpsSinkId, *iSessions[timeShiftSession] ) );
-
- // Session checksum
- TUint sessionChk( iSessions[timeShiftSession]->SourceChecksum() );
- LOG1( "CCREngine::StartTimeShiftL() out, sessionChk: %d", sessionChk );
- return sessionChk;
-
-#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- ( void )aSessionChk;
- return KErrNotSupported;
-#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::StopTimeShift
-// Streaming is set back to one session. Streaming orginal source stays and sink
-// from temporary playback will be moved back to orginal session.
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::StopTimeShift(
- const TUint aTimeShiftChk,
- const TUint aCurrentChk )
- {
- LOG2( "CCREngine::StopTimeShift() in, aTimeShiftChk: %d, aCurrentChk: %d",
- aTimeShiftChk, aCurrentChk );
-#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT
-
- // Verify session
- int ret( KErrNotFound );
- const TInt currentSession( VerifySession( aCurrentChk ) );
- const TInt timeShiftSession( VerifySession( aTimeShiftChk ) );
-
- // Session exist?
- if ( currentSession > KErrNotFound && timeShiftSession > KErrNotFound )
- {
- // Stop time shift clip recording
- iSessions[currentSession]->StopCommand(
- CCRStreamingSession::ECR3gpRecSinkId );
-
- // Stop time shift clip playback
- iSessions[timeShiftSession]->StopCommand();
-
- // Transfer ownership of existing XPS sink back to the old session
- ret = iSessions[timeShiftSession]->TransferSink(
- CCRStreamingSession::ECRXpsSinkId, *iSessions[currentSession] );
-
- // Delete second session
- SessionStop( iSessions[timeShiftSession] );
- }
-
- // Clip handler not needed any longer
- DeleteClipHandler( currentSession );
-
- LOG1( "CCREngine::StopTimeShift() out, ret: %d", ret );
- return ret;
-
-#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- ( void )aTimeShiftChk;
- ( void )aCurrentChk;
- return KErrNotSupported;
-#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PlayCommand
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::PlayCommand(
- const TUint aSessionChk,
- const TReal aStartPos,
- const TReal aEndPos )
- {
- LOG1( "CCREngine::PlayCommand(), aSessionChk: %d", aSessionChk );
-
- // Verify session
- const TInt sessionIndex( VerifySession( aSessionChk ) );
-
- // New session needed?
- if ( sessionIndex > KErrNotFound )
- {
- return iSessions[sessionIndex]->PlayCommand( aStartPos, aEndPos );
- }
-
- return KErrNotReady;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PauseCommand
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::PauseCommand( const TUint aSessionChk )
- {
- LOG1( "CCREngine::PauseCommand(), aSessionChk: %d", aSessionChk );
-
- // Verify session
- const TInt sessionIndex( VerifySession( aSessionChk ) );
-
- // New session needed?
- if ( sessionIndex > KErrNotFound )
- {
- return iSessions[sessionIndex]->PauseCommand();
- }
-
- return KErrNotReady;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::StopCommand
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::StopCommand( const TUint aSessionChk )
- {
- LOG1( "CCREngine::StopCommand(), aSessionChk: %d", aSessionChk );
-
- // Verify session
- const TInt sessionIndex( VerifySession( aSessionChk ) );
-
- // New session needed?
- if ( sessionIndex > KErrNotFound )
- {
- return iSessions[sessionIndex]->StopCommand();
- }
-
- return KErrNotReady;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::SetPosition
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::SetPosition(
- const TUint aSessionChk,
- const TInt64 aPosition )
- {
- LOG1( "CCREngine::SetPosition(), aSessionChk: %d", aSessionChk );
-
- const TInt sessionIndex( VerifySession( aSessionChk ) );
- if ( sessionIndex > KErrNotFound )
- {
- return iSessions[sessionIndex]->SetPosition( aPosition );
- }
-
- return KErrNotReady;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::GetPosition
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::GetPosition(
- const TUint aSessionChk,
- TInt64& aPosition,
- TInt64& aDuration )
- {
- const TInt sessionIndex( VerifySession( aSessionChk ) );
- if ( sessionIndex > KErrNotFound )
- {
- return iSessions[sessionIndex]->GetPosition( aPosition, aDuration );
- }
-
- return KErrNotReady;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::CloseSession
-//
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::CloseSession( const TUint aSessionChk )
- {
- LOG1( "CCREngine::CloseSession(), aSessionChk: %d", aSessionChk );
-
- // Verify session
- const TInt sessionIndex( VerifySession( aSessionChk ) );
- if ( sessionIndex > KErrNotFound )
- {
- SessionStop( iSessions[sessionIndex] );
- }
-
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PlayNullSourceL
-//
-// -----------------------------------------------------------------------------
-//
-TUint CCREngine::PlayNullSourceL()
- {
- LOG( "CCREngine::PlayNullSourceL() in" );
-
- _LIT( KNullSourceClip, "NullSource.rtp" );
- TFileName nullSourcePath;
-#if ( defined( __WINS__ ) || defined( __WINSCW__ ) )
- nullSourcePath = PathInfo::PhoneMemoryRootPath();
-#else // __WINS__ || __WINSCW__
- nullSourcePath = PathInfo::MemoryCardRootPath();
-#endif // __WINS__ || __WINSCW__
- nullSourcePath.Append( KNullSourceClip );
-
- TInt sessionIndex( VerifySession( nullSourcePath ) );
- if ( sessionIndex == KErrNotFound )
- {
- CCRStreamingSession* session = CCRStreamingSession::NewL(
- iSockServer, iConnection, *this );
- CleanupStack::PushL( session );
- User::LeaveIfError( iSessions.Append( session ) );
- CleanupStack::Pop( session );
-
- // Only one source per session
- sessionIndex = iSessions.Count() - 1;
- iSessions[sessionIndex]->OpenSourceL( nullSourcePath );
- }
-
- iSessions[sessionIndex]->CreateXpsSinkL();
- //iSessions[sessionIndex]->CreateNullSinkL();
- iSessions[sessionIndex]->PostActionL();
- TUint sessionChk( iSessions[sessionIndex]->SourceChecksum() );
- LOG1( "CCREngine::PlayNullSourceL() out, sessionChk: %d", sessionChk );
- return sessionChk;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PlayRtspUrlToNullSinkL
-//
-// -----------------------------------------------------------------------------
-//
-TUint CCREngine::PlayRtspUrlToNullSinkL( const SCRRtspParams& aRtspParams )
- {
- LOG( "CCREngine::PlayRtspUrlToNullSinkL() in" );
-
- const TInt sessionIndex( VerifyRtspSessionL( aRtspParams ) );
- iSessions[sessionIndex]->CreateNullSinkL();
- TUint sessionChk( iSessions[sessionIndex]->SourceChecksum() );
- LOG1( "CCREngine::PlayRtspUrlToNullSinkL() out, sessionChk: %d", sessionChk );
- return sessionChk;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::CreateConnectionL
-//
-// -----------------------------------------------------------------------------
-//
-void CCREngine::CreateConnectionL( void )
- {
- LOG( "CCREngine::CreateConnectionL() in" );
-
- if ( iConnection == NULL )
- {
- User::LeaveIfError( iSockServer.Connect( KESockDefaultMessageSlots * 3 ) );
- iConnection = CCRConnection::NewL( iSockServer );
- User::LeaveIfError( iConnection->RegisterObserver( this ) );
-
- // Informer
- if ( iInformer == NULL )
- {
- iInformer = CCRClientInformer::NewL();
- }
- }
-
- LOG( "CCREngine::CreateConnectionL() out" );
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::CreateClipHandlerL
-//
-// -----------------------------------------------------------------------------
-//
-void CCREngine::CreateClipHandlerL( void )
- {
- LOG1( "CCREngine::CreateClipHandlerL(), iClipHandler: %d", iClipHandler );
-
-#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT
-
- if ( !iClipHandler )
- {
- iClipHandler = CRtpClipHandler::NewL();
- }
-#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::VerifyRtspSessionL
-// Go through stream sessions and try to find if RTSP stream is already playing.
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::VerifyRtspSessionL( const SCRRtspParams& aRtspParams )
- {
- TInt sessionIndex( VerifySession( aRtspParams.iUrl ) );
-
- // New session needed?
- if ( sessionIndex == KErrNotFound )
- {
- CCRStreamingSession* session = CCRStreamingSession::NewL(
- iSockServer, iConnection, *this );
- CleanupStack::PushL( session );
- User::LeaveIfError( iSessions.Append( session ) );
- CleanupStack::Pop( session );
-
- // Only one source per session
- sessionIndex = iSessions.Count() - 1;
- iSessions[sessionIndex]->OpenSourceL( aRtspParams, aRtspParams.iUrl );
- }
-
- User::LeaveIfError( sessionIndex );
- return sessionIndex;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::VerifyDvbhSessionL
-// Go through stream sessions and try to find if DVB-H live is already playing.
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::VerifyDvbhSessionL( const SCRLiveParams& aLiveParams )
- {
- // Verify session
- HBufC* definition = HBufC::NewLC( aLiveParams.iSdpData.Length() );
- definition->Des().Copy( aLiveParams.iSdpData );
- TInt sessionIndex( VerifySession( *definition ) );
-
- // New session needed?
- if ( sessionIndex == KErrNotFound )
- {
- CCRStreamingSession* session = CCRStreamingSession::NewL(
- iSockServer, iConnection, *this );
- CleanupStack::PushL( session );
- User::LeaveIfError( iSessions.Append( session ) );
- CleanupStack::Pop( session );
-
- // Only one source per session
- sessionIndex = iSessions.Count() - 1;
- iSessions[sessionIndex]->OpenSourceL( aLiveParams, *definition );
- }
-
- CleanupStack::PopAndDestroy( definition );
- User::LeaveIfError( sessionIndex );
- return sessionIndex;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::VerifyRtpFileSessionL
-// Go through stream sessions and try to find if RTP clip is already playing.
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::VerifyRtpFileSessionL( const SCRRtpPlayParams& aRtpParams )
- {
-#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT
-
- // Verify session
- TInt sessionIndex( VerifySession( aRtpParams.iFileName ) );
-
- // New session needed?
- if ( sessionIndex == KErrNotFound )
- {
-
- CCRStreamingSession* session = CCRStreamingSession::NewL(
- iSockServer, iConnection, *this );
- CleanupStack::PushL( session );
- User::LeaveIfError( iSessions.Append( session ) );
- CleanupStack::Pop( session );
-
- // RTP clip handler
- CreateClipHandlerL();
-
- // Only one source per session
- sessionIndex = iSessions.Count() - 1;
- iSessions[sessionIndex]->OpenSourceL( aRtpParams, iClipHandler,
- aRtpParams.iFileName );
- }
-
- User::LeaveIfError( sessionIndex );
- return sessionIndex;
-
-#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- ( void )aRtpParams;
- return KErrNotSupported;
-#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::VerifyRtpFileSessionL
-// Go through stream sessions and try to find if RTP clip is already playing.
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::VerifyRtpFileSessionL( const RFile& aFileHandle )
- {
-#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT
-
- TFileName fileName( KNullDesC );
- aFileHandle.FullName( fileName );
- TInt sessionIndex( VerifySession( fileName ) );
-
- // New session needed?
- if ( sessionIndex == KErrNotFound )
- {
- CCRStreamingSession* session = CCRStreamingSession::NewL(
- iSockServer, iConnection, *this );
- CleanupStack::PushL( session );
- User::LeaveIfError( iSessions.Append( session ) );
- CleanupStack::Pop( session );
-
- // RTP clip handler
- CreateClipHandlerL();
-
- // Only one source per session
- sessionIndex = iSessions.Count() - 1;
- iSessions[sessionIndex]->OpenSourceL( aFileHandle, iClipHandler, fileName );
- }
-
- User::LeaveIfError( sessionIndex );
- return sessionIndex;
-
-#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- ( void )aFileHandle;
- return KErrNotSupported;
-#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::VerifySession
-// Go through stream sessions and try to find stream is already playing.
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::VerifySession( const TDesC& aName )
- {
- if ( iSessions.Count() > 0 )
- {
- for ( TInt i( iSessions.Count() - 1 ); i >= 0; i-- )
- {
- const TUint chksm( iSessions[i]->SourceDefinition( aName ) );
- if ( chksm == iSessions[i]->SourceChecksum() )
- {
- return i;
- }
- }
- }
-
- return KErrNotFound;
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::VerifySession
-// Go through stream sessions and try to find session index from active sessions.
-// -----------------------------------------------------------------------------
-//
-TInt CCREngine::VerifySession( const TUint aSessionChk )
- {
- if ( iSessions.Count() > 0 )
- {
- for ( TInt i( iSessions.Count() - 1 ); i >= 0; i-- )
- {
- if ( aSessionChk == iSessions[i]->SourceChecksum() )
- {
- return i;
- }
- }
- }
-
- return KErrNotFound;
- }
-
-//-----------------------------------------------------------------------------
-// CCREngine::CreateRecordingSinkL
-//
-//-----------------------------------------------------------------------------
-//
-void CCREngine::CreateRecordingSinkL(
- const TInt aSessionIndex,
- const SCRRecordParams& aRecordParams )
- {
- LOG1( "CCREngine::CreateRecordingSinkL(), aSessionIndex: %d", aSessionIndex );
-
- User::LeaveIfError( aSessionIndex );
- switch ( aRecordParams.iFormat )
- {
-#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT
- case ECRRecordFormatRtp:
- // RTP clip handler
- CreateClipHandlerL();
- iSessions[aSessionIndex]->CreateRtpRecordSinkL(
- aRecordParams, iClipHandler );
- break;
-#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT
-
- case ECRRecordFormat3gp:
- iSessions[aSessionIndex]->Create3gpRecordSinkL( aRecordParams );
- break;
-
- default:
- LOG( "CCREngine::CreateRecordingSinkL(), Clip format invalid !");
- User::Leave( KErrNotSupported );
- break;
- }
- }
-
-//-----------------------------------------------------------------------------
-// CCREngine::SessionStopCallBack
-//
-//-----------------------------------------------------------------------------
-//
-TInt CCREngine::SessionStopCallBack ( TAny* aThis )
- {
- LOG( "CCREngine::SessionStopCallBack()" );
-
- CCREngine* self = static_cast<CCREngine*>( aThis );
- self->DoSessionStop();
- return self->iSessionsToDelete.Count();
- }
-
-//-----------------------------------------------------------------------------
-// CCREngine::DoSessionStop
-//
-//-----------------------------------------------------------------------------
-//
-void CCREngine::DoSessionStop( void )
- {
- LOG1( "CCREngine::DoSessionStop() in, iSessionsToDelete.Count = %d", iSessionsToDelete.Count() );
-
- for ( TInt i( iSessionsToDelete.Count() - 1 ); i >= 0; i-- )
- {
- for ( TInt j( iSessions.Count() - 1 ); j >= 0; j-- )
- {
- if ( iSessions[j] == iSessionsToDelete[i] )
- {
- delete iSessions[j];
- iSessions.Remove( j );
- }
- }
- }
-
- // Supposed to be empty by now
- DeleteClipHandler( KErrNotFound );
- iSessionsToDelete.Reset();
- LOG( "CCREngine::DoSessionStop() out" );
- }
-
-//-----------------------------------------------------------------------------
-// CCREngine::DeleteClipHandler
-//
-//-----------------------------------------------------------------------------
-//
-void CCREngine::DeleteClipHandler( const TInt aCurrentSessionIndex )
- {
- LOG1( "CCREngine::DeleteClipHandler(), aCurrentSessionIndex: %d",
- aCurrentSessionIndex );
-#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT
-
- if ( iClipHandler )
- {
- // Find out clip handler usage
- TBool notUsed( ETrue );
- for ( TInt i( iSessions.Count() - 1 ); i >= 0; i-- )
- {
- if ( i != aCurrentSessionIndex && iSessions[i]->ClipHandlerUsed() )
- {
- notUsed = EFalse;
- }
- }
-
- // Clip handler not needed any longer?
- if ( notUsed )
- {
- delete iClipHandler; iClipHandler = NULL;
- LOG( "CCREngine::DeleteClipHandler(), RTP ClipHandler deleted !" );
- }
- }
-
-#else // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- ( void )aCurrentSessionIndex;
-#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::Read
-// Read from the client thread, if unsuccessful, panic the client.
-// -----------------------------------------------------------------------------
-//
-void CCREngine::Read(
- const RMessage2& aMessage,
- const TInt& aParam,
- TDes8& aDes )
- {
- TRAPD( err, aMessage.ReadL( aParam, aDes ) );
- if ( err )
- {
- PanicClient( ECRPanicBadDescriptor, aMessage );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::Read
-// Read from the client thread, if unsuccessful, panic the client.
-// -----------------------------------------------------------------------------
-//
-void CCREngine::Read(
- const RMessage2& aMessage,
- const TInt& aParam,
- TDes16& aDes )
- {
- TRAPD( err, aMessage.ReadL( aParam, aDes ) );
- if ( err )
- {
- PanicClient( ECRPanicBadDescriptor, aMessage );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::Write
-// Write to the client thread, if unsuccessful, panic the client.
-// -----------------------------------------------------------------------------
-//
-void CCREngine::Write(
- const RMessage2& aMessage,
- const TInt& aParam,
- const TDesC8& aDes )
- {
- TRAPD( err, aMessage.WriteL( aParam, aDes ) );
- if ( err )
- {
- PanicClient( ECRPanicBadDescriptor, aMessage );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::Write
-// Write to the client thread, if unsuccessful, panic the client.
-// -----------------------------------------------------------------------------
-//
-void CCREngine::Write(
- const RMessage2& aMessage,
- const TInt& aParam,
- const TDesC16& aDes )
- {
- TRAPD( err, aMessage.WriteL( aParam, aDes ) );
- if ( err )
- {
- PanicClient( ECRPanicBadDescriptor, aMessage );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CCREngine::PanicClient
-//
-// -----------------------------------------------------------------------------
-//
-void CCREngine::PanicClient( TInt aPanic, const RMessage2& aMessage )
- {
- // Panic the client on server side
- _LIT( KRbfClientFault, "Common recording engine" );
- aMessage.Panic( KRbfClientFault, aPanic );
- }
-
-// End of File