multimediacommscontroller/tsrc/amrpayloadformatstub/src/AmrPayloadFormatRead_STUB.cpp
/*
* Copyright (c) 2002-2004 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: PayloadFormat plugin capable to read RTP payload containing
* AMR audio.
*
*/
// INCLUDE FILES
#include <E32base.h>
#include <mmf/common/mmffourcc.h>
#include "AmrPayloadFormatRead.h"
#include "AmrPayloadEncoder.h"
#include "AmrPayloadDecoder.h"
#include "AmrPayloadFormatUtil.h"
#include "AmrCommonUtil.h"
#include "MccRtpDataSource.h"
#include "MccRedPayloadRead.h"
#include "MccRedPayloadFormatDefs.h"
#include "mccuids.hrh"
#include "MmccCodecInformation.h"
#include "Mccdef.h"
#ifdef VOIP_TRACE_ENABLED
#include <voip_trace.h>
#endif
// EXTERNAL DATA STRUCTURES
// EXTERNAL FUNCTION PROTOTYPES
// CONSTANTS
const TUid KRedReadImplementFormat = { KImplUidRedPayloadFormatDecode };
// MACROS
// LOCAL CONSTANTS AND MACROS
// MODULE DATA STRUCTURES
// LOCAL FUNCTION PROTOTYPES
// FORWARD DECLARATIONS
// ============================= LOCAL FUNCTIONS ===============================
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::CAmrPayloadFormatRead
//
// CAmrPayloadFormatRead default constructor, can NOT contain any code,
// that might leave
// Phase #1 of 2-phase constructor
// -----------------------------------------------------------------------------
//
CAmrPayloadFormatRead::CAmrPayloadFormatRead ( ) :
iSamplingRate( 8000 ),
iChannels( 1 ),
iMode( 7 ),
iPayloadDecoder( NULL ),
iStreamEncoder( TStreamEncoder() )
{
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::ConstructL
//
// Symbian 2nd phase constructor can leave.
// Phase #2 of 2-phase constructor
// Create an instance of the AMR-NB decoder format class
// Payload decoder ( either bandwidth efficient or octet aligned mode ) instance
// is created in InitializeL-method.
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::ConstructL ( MDataSource* /*aSource*/ )
{
iFourCC.Set( TFourCC( ' ','A','M','R' ) );
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::NewL
//
// Two-phased constructor.
// Static function for creating and constructing an instance of the AMR-NB format.
//
// Returns: CAmrPayloadFormatRead* : pointer to created instance
// -----------------------------------------------------------------------------
//
CAmrPayloadFormatRead* CAmrPayloadFormatRead::NewL ( MDataSource* aSource )
{
CAmrPayloadFormatRead* self = new ( ELeave ) CAmrPayloadFormatRead;
CleanupStack::PushL ( self );
self->ConstructL ( aSource );
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::~CAmrPayloadFormatRead
//
// Destructor.
// -----------------------------------------------------------------------------
//
CAmrPayloadFormatRead::~CAmrPayloadFormatRead ( )
{
// commented out CreateSourceBufferL now sets aReference to ETrue.
// datapath doesn't clean this buffer any longer.
if ( iFrameBufferOne )
{
delete iFrameBufferOne;
}
if ( iFrameBufferTwo )
{
delete iFrameBufferTwo;
}
if ( iSourceBuffer )
{
delete iSourceBuffer;
}
if ( iStateMachine )
{
iStateMachine->Cancel( );
delete iStateMachine;
}
delete iPayloadDecoder;
iRtpDataSource = NULL;
iClip = NULL;
iDataPath = NULL;
iBufferToRead = NULL;
#ifdef FTD_ENABLED
iJBufStatsQueue.Close();
#endif
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::Streams
//
// Return number of audio streams for the given media
// -----------------------------------------------------------------------------
//
TUint CAmrPayloadFormatRead::Streams( TUid aMediaType ) const
{
if ( KUidMediaTypeAudio == aMediaType )
{
return 1;
}
else
{
return 0;
}
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::FrameTimeInterval
//
// Return the frame time interval for the given media
// -----------------------------------------------------------------------------
//
TTimeIntervalMicroSeconds CAmrPayloadFormatRead::FrameTimeInterval(
TMediaId aMediaId ) const
{
if ( KUidMediaTypeAudio == aMediaId.iMediaType )
{
TInt hwFrametime = static_cast<TInt>( iCInfo.iHwFrameTime );
return TTimeIntervalMicroSeconds( TInt64( hwFrametime ) );
}
else
{
return TTimeIntervalMicroSeconds( TInt64( 0 ) );
}
}
// The following functions are virtual function implementation from MDataSource
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::FillBufferL
// Fill Buffer
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::FillBufferL( CMMFBuffer* /*aBuffer*/,
MDataSink* aConsumer,
TMediaId /*aMediaId*/ )
{
iDataPath = aConsumer;
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::DoRead
// Reads data starting from the given position into the source buffer
// -----------------------------------------------------------------------------
//
TBool CAmrPayloadFormatRead::DoRead( CMMFBuffer* /*aBuffer*/ )
{
return ETrue;
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::FillSinkBuffer
//
// Read RTP payload and convert it into AMR frames.
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::FillSinkBufferL( )
{
#ifdef TRACE_AMR_PAYLOAD_FORMAT_READ
AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillSinkBuffer( )" );
#endif
#ifdef VOIP_MCC_DL_TRACE_ENABLED
VoipTrace( "%x %x", MCC_TRACE, MCC_AMR_PLF_READ_FILLSINKBUFFER );
#endif
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::FillSourceBufferL
//
// Send fill buffer request to RTP Data Soure
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::FillSourceBufferL( )
{
#ifdef TRACE_AMR_PAYLOAD_FORMAT_READ
AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::FillSourceBufferL( )" );
#endif
#ifdef VOIP_TRACE_ENABLED
VoipTrace( "%x %x", MCC_TRACE, MCC_AMR_PLF_READ_FILLSOURCEBUFFERL );
#endif
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SendDataToSinkL
//
// Send full frame buffer to Data Path
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::SendDataToSinkL( )
{
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::CreateSourceBufferL
//
// Create a source buffer for the given media and indicate in aReference if buffer
// is created.
// -----------------------------------------------------------------------------
//
CMMFBuffer* CAmrPayloadFormatRead::CreateSourceBufferL( TMediaId /*aMediaId*/,
TBool &aReference )
{
// the source buffers belong to AmrPayloadFormatRead not to datapath
// aference should be set to ETrue and destried by AmrPayloadFormatRead itself.
aReference = ETrue;
if ( !iFrameBufferOne )
{
iFrameBufferOne = CMMFDataBuffer::NewL( 100 );
}
return iFrameBufferOne;
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::CreateSourceBufferL
//
// Create a source buffer for the given media, setting frame size to match
// the given sink buffer
// -----------------------------------------------------------------------------
//
CMMFBuffer* CAmrPayloadFormatRead::CreateSourceBufferL( TMediaId aMediaId,
CMMFBuffer& /*aSinkBuffer*/,
TBool &aReference )
{
return CreateSourceBufferL( aMediaId, aReference );
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SourceDataTypeCode
//
// Return the source data type ( four CC code ) for the given media
// -----------------------------------------------------------------------------
//
TFourCC CAmrPayloadFormatRead::SourceDataTypeCode( TMediaId aMediaId )
{
if ( KUidMediaTypeAudio == aMediaId.iMediaType )
{
return iFourCC;
}
else
{
return TFourCC( ); //defaults to 'NULL' fourCC
}
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SetSourceDataTypeCode
//
// Set the source data type to the given four CC code for the given media
// -----------------------------------------------------------------------------
//
TInt CAmrPayloadFormatRead::SetSourceDataTypeCode( TFourCC /*aSourceFourCC*/,
TMediaId /*aMediaId*/ )
{
/*#ifdef TRACE_AMR_PAYLOAD_FORMAT_READ
RDebug::Print ( _L("CAmrPayloadFormatRead::SetSourceDataTypeCode") );
#endif
#ifdef VOIP_TRACE_ENABLED
VoipTrace( "%x %x %d", Mcc_TRACE, Mcc_AMR_PLF_READ_SETSOURCEDATATYPECODE,
aSourceFourCC.FourCC() );
#endif
if ( KUidMediaTypeAudio != aMediaId.iMediaType )
{
return KErrNotSupported;
}
iFourCC = aSourceFourCC;
iMediaId = aMediaId;
iClip->SetSourceDataTypeCode( iFourCC, iMediaId );*/
return KErrNone;
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SourceThreadLogon
//
// Log in to the source thread
// -----------------------------------------------------------------------------
//
TInt CAmrPayloadFormatRead::SourceThreadLogon(
MAsyncEventHandler& /*aEventHandler*/ )
{
return KErrNone;
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::NegotiateSourceL( MDataSink& aDataSink )
//
// Negotiate source settings to match data sink object.
// Re-size frame buffers if needed
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::NegotiateSourceL( MDataSink& /*aDataSink*/ )
{
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SourceThreadLogoff
//
// Log out of the source thread.
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::SourceThreadLogoff( )
{
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::DataBufferFilledL
//
// Called after the data buffer is filled. Update the number of bytes read
// and the current read position for the next read operation.
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::DataBufferFilledL( CMMFBuffer* /*aBuffer*/,
const TRtpRecvHeader& /*aRtpHeader*/ )
{
AMR_PAYLOAD_FORMAT_READ( "CAmrPayloadFormatRead::BufferFilledL" );
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::NumChannels
// Gets the number of channels
// -----------------------------------------------------------------------------
//
TUint CAmrPayloadFormatRead::NumChannels( )
{
return iChannels;
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SampleRate
//
// Get the packetization rate.
// -----------------------------------------------------------------------------
//
TUint CAmrPayloadFormatRead::SampleRate( )
{
return iSamplingRate;
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SetSampleRate
// Only supported sample rate for AMR-NB is 8000Hz
// -----------------------------------------------------------------------------
//
TInt CAmrPayloadFormatRead::SetSampleRate ( TUint aSampleRate )
{
#ifdef VOIP_TRACE_ENABLED
VoipTrace( "%x %x %d", MCC_TRACE, MCC_AMR_PLF_READ_SETSAMPLERATE,
aSampleRate );
#endif
if( KAmrNbSampleRate != aSampleRate )
{
return KErrNotSupported;
}
else
{
iSamplingRate = aSampleRate;
return KErrNone;
}
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::Duration
//
// Return the clip duration for the given media.
// -----------------------------------------------------------------------------
//
TTimeIntervalMicroSeconds CAmrPayloadFormatRead::Duration( TMediaId /*aMediaType*/ ) const
{
return TTimeIntervalMicroSeconds( TInt64( 0 ) );
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::CancelDlRequest( )
//
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::CancelDlRequest()
{
#ifdef TRACE_AMR_PAYLOAD_FORMAT_READ
AMR_PAYLOAD_FORMAT_READ( "CAmrPayloadFormatRead::CancelDlRequest" );
#endif
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SourcePrimeL()
//
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::SourcePrimeL()
{
#ifdef TRACE_AMR_PAYLOAD_FORMAT_READ
AMR_PAYLOAD_FORMAT_READ( "CAmrPayloadFormatRead::SourcePrimeL" );
#endif
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SourcePlayL()
//
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::SourcePlayL()
{
#ifdef TRACE_AMR_PAYLOAD_FORMAT_READ
AMR_PAYLOAD_FORMAT_READ( "CAmrPayloadFormatRead::SourcePlayL" );
#endif
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SourcePauseL()
//
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::SourcePauseL()
{
#ifdef TRACE_AMR_PAYLOAD_FORMAT_READ
AMR_PAYLOAD_FORMAT_READ( "CAmrPayloadFormatRead::SourcePauseL" );
#endif
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SourceStopL( )
//
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::SourceStopL()
{
#ifdef TRACE_AMR_PAYLOAD_FORMAT_READ
AMR_PAYLOAD_FORMAT_READ( "CAmrPayloadFormatRead::SourceStopL" );
#endif
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SinkDataTypeCode()
// Returns the datatype code for this Format Decoder
// -----------------------------------------------------------------------------
//
TFourCC CAmrPayloadFormatRead::SinkDataTypeCode( TMediaId aMediaId )
{
if( KUidMediaTypeAudio == aMediaId.iMediaType )
{
return iFourCC;
}
else
{
return TFourCC();
}
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::ConfigurePayloadFormatL
// Configure payload decoding parameters.
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::ConfigurePayloadFormatL( const TDesC8& /*aConfigParams*/ )
{
AMR_PAYLOAD_FORMAT_READ( "CAmrPayloadFormatRead::ConfigurePayloadFormatL" );
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::UpdateConfigurationL
// Update payload decoder parameters
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::UpdateConfigurationL( const TMccCodecInfo& /*aConfigParams*/ )
{
AMR_PAYLOAD_FORMAT_READ( "CAmrPayloadFormatRead::UpdateConfigurationL" );
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::SendAmrEventToClient
// -----------------------------------------------------------------------------
//
void CAmrPayloadFormatRead::SendAmrEventToClient(
TMccInternalEventType /*aEventType*/ )
{
}
// -----------------------------------------------------------------------------
// CAmrPayloadFormatRead::CreateClipBufferL
// Creates buffer needed in data transfer with format readers clip.
// -----------------------------------------------------------------------------
//
CMMFDataBuffer* CAmrPayloadFormatRead::CreateClipBufferL(
TUint /*aSize*/, TBool& /*aIsOwnBuffer*/ )
{
AMR_PAYLOAD_FORMAT_READ ( "CAmrPayloadFormatRead::CreateClipBufferL" )
return NULL;
}
// ========================== OTHER EXPORTED FUNCTIONS =========================
// End of File