diff -r 000000000000 -r 1bce908db942 multimediacommscontroller/mmccshared/inc/mccinternalcodecs.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommscontroller/mmccshared/inc/mccinternalcodecs.h Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,639 @@ +/* +* 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: Definitions for Mcc internal codec information +* +*/ + + + + + +#ifndef MCCINTERNALCODECS_H +#define MCCINTERNALCODECS_H + +// INCLUDES +#include +#include +#include +#include +#include "mmcccodecinformation.h" +#include "mmccnetworksettings.h" + +// CONSTANTS + +// Internal value for Mcc codec information in order to catch undefined values +const TUint KMccCodecParamUndefined = 0; +// Internal value for undefined payload type as max payload type is 127 (7-bit value) +// and values 0-127 are used for different payload types. Naturally then value 128 is +// then a good value for payload type. +const TUint8 KMccPayloadTypeMax = 128; + +// Default ports for RTP & RTCP +//const TUint KMDefaultRtpPort = 5000; +//const TUint KDefaultRtcpPort = 5001; + +// Default jitter buffer size in milliseconds +const TUint KDefautJitterBufferSize = 200; + +// Number of AMR bitrates supported +const TUint KAmrBitratesSupported = 8; + +// Number of G.711 bitrates supported +const TUint KG711BitratesSupported = 1; + +// Number of iLBC bitrates supported +const TUint KIlbcBitratesSupported = 2; + +// Number of G.729 bitrates supported +const TUint KG729BitratesSupported = 1; + +// AMR BITRATES +const TUint KAmrBitrates[KAmrBitratesSupported] = + { + 4750, 5150, 5900, 6700, 7400, 7950, 10200, 12200 + }; + +// G.711 BITRATES +const TUint KG711Bitrates[KG711BitratesSupported] = + { + 64000 + }; + +// iLBC BITRATES (Can also tell the codec mode for iLBC (20ms, 30ms) +const TUint KIlbcBitrates[KIlbcBitratesSupported] = + { + 13330, 15200 + }; + +// G.729 BITRATES +const TUint KG729Bitrates[KG729BitratesSupported] = + { + 8000 + }; + +// Generic nothing mode +const TUint KMccCodecModeNone = 1; + +// G.711 Codec modes as it uses one FourCC +const TUint KG711ModeaLawEnc = 2; +const TUint KG711ModeuLawEnc = 3; + +// AMR Codec modes +const TUint KAmrCodecModeBandwidthEfficient = 4; +const TUint KAmrCodecModeOctetAlign = 5; + +// DTMF Modes +const TUint KDtmfModeEvent = 6; +const TUint KDtmfModeTone = 7; +const TUint KDtmfModeRedEvents = 8; + +// iLBC codec modes +const TUint KIlbcMode20msFrame = 9; +const TUint KIlbcMode30msFrame = 10; + +// NALU constants +const TInt KMccNaluStartCodeLen = 3; +const TInt KMccNaluEndCodeLen = 2; + +// MACROS + +// DATA TYPES + +// FUNCTION PROTOTYPES + +// FORWARD DECLARATIONS + +// CLASS DECLARATION + +/** +* Mcc Codec information for Mcc internal use +* +* @lib N/A +* @since Series 60 3.0 +*/ + +class TMccCodecInfo + { + public: // Constructors + + /** + * Default constructor + */ + inline TMccCodecInfo() : + iType(TUid()), + iFourCC( TFourCC() ), + iPayloadFormatEncoder( 0 ), + iPayloadFormatDecoder( 0 ), + iBitrate( KMccCodecParamUndefined ), + iSamplingFreq( 0 ), + iEnableDTX( EFalse ), + iCodecMode( KMccCodecParamUndefined ), + iAlgoUsed( ENoAlgoUsed ), + iPtime( KMccCodecParamUndefined ), + iMaxPtime( KMccCodecParamUndefined ), + iPayloadType( KMccPayloadTypeMax ), + iRedundantPayload( KMccPayloadTypeMax ), + iRedundancyCount( static_cast( KMccCodecParamUndefined ) ), + iHwFrameTime( 0 ), + iFrameSize( 0 ), + iCNFrameSize( 0 ), + iFmtpLength( 0 ), + iJitterSize( 0 ), + iNeighbor( EFalse ), + iModeChangePeriod( 1 ), + iJitterBufInactivityTimeOut( 0 ), + iJitterBufPlayToneTimeout( 0 ), + iJitterBufPlayToneFrequency( 0 ), + iJitterBufPlayToneDuration( 0 ), + iJitterBufThreshold( 0 ), + iJitterBufBufferLength( 0 ), + iComfortNoiseGenerationPt( KPayloadTypeUndefined ), + iBitrateMask( 0 ), + iAverageBitrate( 0 ), + iMaxBitrate( 0 ), + iFramerate( 0 ), + iVideoWidth( 0 ), + iVideoHeight( 0 ), + iMTUSize( 1400 ), + iSessionID( 0 ), + iLinkID( 0 ), + iStreamID( 0 ), + iKeepaliveInterval( 0 ), + iKeepalivePT( 0 ), + iKeepaliveData( KNullDesC8 ), + iIsUpdate(0), + iMaxRed( -1 ), + iSourceDefinedTimeStamps( EFalse ), + iConfigKey( KNullDesC8 ), + iEncodingDecodingDevice( KNullUid ) + { }; + + /** + * Copy constructor + */ + inline TMccCodecInfo( const TMccCodecInfo& aCodec ) : + iType( aCodec.iType ), + iSdpName( aCodec.iSdpName ), + iFourCC( aCodec.iFourCC ), + iPayloadFormatEncoder( aCodec.iPayloadFormatEncoder ), + iPayloadFormatDecoder( aCodec.iPayloadFormatDecoder ), + iBitrate( aCodec.iBitrate ), + iSamplingFreq( aCodec.iSamplingFreq ), + iEnableDTX( aCodec.iEnableDTX ), + iCodecMode( aCodec.iCodecMode ), + iAlgoUsed( aCodec.iAlgoUsed ), + iPtime( aCodec.iPtime ), + iMaxPtime( aCodec.iMaxPtime ), + iPayloadType( aCodec.iPayloadType ), + iRedundantPayload( aCodec.iRedundantPayload ), + iRedundancyCount( aCodec.iRedundancyCount ), + iHwFrameTime( aCodec.iHwFrameTime ), + iFrameSize( aCodec.iFrameSize ), + iCNFrameSize( aCodec.iCNFrameSize ), + iFmtpLength( aCodec.iFmtpLength ), + iJitterSize( aCodec.iJitterSize ), + iNeighbor( aCodec.iNeighbor ), + iModeChangePeriod( aCodec.iModeChangePeriod ), + iJitterBufInactivityTimeOut( aCodec.iJitterBufInactivityTimeOut ), + iJitterBufPlayToneTimeout( aCodec.iJitterBufPlayToneTimeout ), + iJitterBufPlayToneFrequency( aCodec.iJitterBufPlayToneFrequency ), + iJitterBufPlayToneDuration( aCodec.iJitterBufPlayToneDuration ), + iJitterBufThreshold( aCodec.iJitterBufThreshold ), + iJitterBufBufferLength( aCodec.iJitterBufBufferLength ), + iComfortNoiseGenerationPt( aCodec.iComfortNoiseGenerationPt ), + iBitrateMask( aCodec.iBitrateMask ), + iAverageBitrate( aCodec.iAverageBitrate ), + iMaxBitrate( aCodec.iMaxBitrate ), + iFramerate( aCodec.iFramerate ), + iVideoWidth( aCodec.iVideoWidth ), + iVideoHeight( aCodec.iVideoHeight ), + iMTUSize( aCodec.iMTUSize ), + iSessionID( aCodec.iSessionID ), + iLinkID( aCodec.iLinkID ), + iStreamID( aCodec.iStreamID ), + iPriority( aCodec.iPriority ), + iKeepaliveInterval( aCodec.iKeepaliveInterval ), + iKeepalivePT( aCodec.iKeepalivePT ), + iKeepaliveData( aCodec.iKeepaliveData ), + iIsUpdate( aCodec.iIsUpdate ), + iMaxRed( aCodec.iMaxRed ), + iSourceDefinedTimeStamps( aCodec.iSourceDefinedTimeStamps ), + iConfigKey( aCodec.iConfigKey ), + iEncodingDecodingDevice( aCodec.iEncodingDecodingDevice ) + + { }; + + public: // Functions + + /** + * Helper method for checking the codecinfo parameters + * @since Series 60 3.0 + * @param aCodec Codec which to check + * @return KErrNotReady or KErrNone + */ + static inline TInt CheckCodecInfo( const TMccCodecInfo& /*aCodec*/ ) + { + // And different codec bitrate/mode combinations should be checked also + /* + if( aCodec.iFourCC == KMMFFourCCCodeNULL) + { + return KErrNotReady; + } + else if( KMccCodecParamUndefined == aCodec.iBitrate ) + { + return KErrNotReady-1; + } + else if( KMccCodecParamUndefined == aCodec.iPtime ) + { + return KErrNotReady-2; + } + else if( KMccCodecParamUndefined == aCodec.iMaxPtime ) + { + return KErrNotReady-3; + } + else if( KMccPayloadTypeMax <= aCodec.iPayloadType ) + { + return KErrNotReady-4; + } + else + { + return KErrNone; + } + */ + // Need to reimplement this as this is not a good function + return KErrNone; + }; + + /** + * Function for comparing two codec info objects + * @since Series 60 3.0 + * @param aCodec1 Codecinfo 1 to compare + * @param aCodec2 Codecinfo 2 to compare + * @return TBool ETrue if aCodec1 and aCodec2 match + */ + static inline TBool Compare( const TMccCodecInfo& aCodec1, + const TMccCodecInfo& aCodec2 ) + { + if( aCodec1.iFourCC == aCodec2.iFourCC && + aCodec1.iBitrate == aCodec2.iBitrate && + aCodec1.iSamplingFreq == aCodec2.iSamplingFreq && + aCodec1.iVideoHeight == aCodec2.iVideoHeight && + aCodec1.iVideoWidth == aCodec2.iVideoWidth && + aCodec1.iFramerate == aCodec2.iFramerate && + aCodec1.iEnableDTX == aCodec2.iEnableDTX && + aCodec1.iCodecMode == aCodec2.iCodecMode && + aCodec1.iAlgoUsed == aCodec2.iAlgoUsed && + aCodec1.iPtime == aCodec2.iPtime && + aCodec1.iMaxPtime == aCodec2.iMaxPtime && + aCodec1.iPayloadType == aCodec2.iPayloadType && + aCodec1.iRedundantPayload == aCodec2.iRedundantPayload && + aCodec1.iRedundancyCount == aCodec2.iRedundancyCount && + aCodec1.iHwFrameTime == aCodec2.iHwFrameTime && + aCodec1.iFrameSize == aCodec2.iFrameSize && + aCodec1.iCNFrameSize == aCodec2.iCNFrameSize && + aCodec1.iJitterSize == aCodec2.iJitterSize && + aCodec1.iPriority.iPriority == aCodec2.iPriority.iPriority && + aCodec1.iPriority.iPref == aCodec2.iPriority.iPref && + aCodec1.iKeepaliveInterval == aCodec2.iKeepaliveInterval && + aCodec1.iKeepalivePT == aCodec2.iKeepalivePT && + aCodec1.iKeepaliveData == aCodec2.iKeepaliveData && + aCodec1.iSourceDefinedTimeStamps == aCodec2.iSourceDefinedTimeStamps && + aCodec1.iConfigKey == aCodec2.iConfigKey && + aCodec1.iEncodingDecodingDevice == aCodec2.iEncodingDecodingDevice ) + { + return ETrue; + } + else + { + return EFalse; + } + }; + + static TBool IsAvcPpsOrSpsData( const TDesC8& aBuffer, TBool aIgnoreStartCode = EFalse ) + { + TBool isPpsOrSps( EFalse ); + const TUint8 KMccAvcTypeMask = 0x1F; + const TUint8 KMccAvcTypePps = 0x7; + const TUint8 KMccAvcTypeSps = 0x8; + + TInt bufferIndex( 0 ); + TInt index( KErrNotFound ); + if ( aIgnoreStartCode ) + { + index = aBuffer.Length() > 0 ? 0 : KErrNotFound; + } + else + { + index = FindAvcNaluStart( bufferIndex, aBuffer ); + } + + if ( index != KErrNotFound ) + { + TUint8 typeInfo = aBuffer[ index ]; + isPpsOrSps = ( ( typeInfo & KMccAvcTypeMask ) == KMccAvcTypePps || + ( typeInfo & KMccAvcTypeMask ) == KMccAvcTypeSps ); + } + return isPpsOrSps; + }; + + /** + * This function finds a NALU's starting byte by detecting unique start code + * occurring in the buffer, as specified in sec B.2 of H264 specs. + * NOTE: 4-byte start code 0x00000001 is a special case of 3-byte code, + * automatically catered in the logic + * + * @param aBufferIndex, search start index, on return contains information + * of how for buffer was searched + * @param aBuffer + * @return KErrNotFound if nalu start code is not found, otherwise index + * to beginning of end code. + */ + static TInt FindAvcNaluStart( TInt& aBufferIndex, const TDesC8& aBuffer ) + { + TUint8 a1, a2, a3; + + if ( aBufferIndex < 0 ) + { + return KErrNotFound; + } + + const TUint8 *origDataPtr = aBuffer.Ptr(); + const TUint8 *dataPtr = origDataPtr; + TInt size( aBuffer.Size() ); + while ( aBufferIndex+KMccNaluStartCodeLen < size ) // at least one byte after start code + { + dataPtr = ( origDataPtr + aBufferIndex ); + a1 = *dataPtr; + dataPtr++; + a2 = *dataPtr; + dataPtr++; + a3 = *dataPtr; + + if ( a1 == 0x00 && a2 == 0x00 && a3 == 0x01 ) + { + aBufferIndex += KMccNaluStartCodeLen; + return aBufferIndex; + } + + aBufferIndex++; + } + + return KErrNotFound; + }; + + /** + * This function returns location of first byte at the end of NALU + * by detecting unique end pattern, as specified in sec B.2 of H264 specs. + * + * @param aBufferIndex, search start index, on return contains information + * of how for buffer was searched + * @param aBuffer + * @return index to end beginning of end code or last index of aBuffer if + * end code is not found + */ + static TInt FindAvcNaluEnd( TInt& aBufferIndex, const TDesC8& aBuffer ) + { + TUint8 a1, a2, a3; + + if ( ( aBufferIndex < 0 ) || ( aBufferIndex >= aBuffer.Size() ) ) + { + return KErrNotFound; + } + + const TUint8 *origDataPtr = aBuffer.Ptr(); + const TUint8 *dataPtr = origDataPtr; + TInt size( aBuffer.Size() ); + while ( aBufferIndex < size ) + { + if ( aBufferIndex+KMccNaluEndCodeLen < size ) + { + dataPtr = ( origDataPtr + aBufferIndex ); + a1 = *dataPtr; + dataPtr++; + a2 = *dataPtr; + dataPtr++; + a3 = *dataPtr; + + if( ( a1 == 0x00 && a2 == 0x00 && a3 == 0x01 ) || + ( a1 == 0x00 && a2 == 0x00 && a3 == 0x00 ) ) + { + return aBufferIndex; + } + } + aBufferIndex++; + } + + return aBufferIndex; + }; + + public: // Data + + TUid iType; + + /** + * Sdp name used in SDP messages + */ + TBuf8 iSdpName; + + // MMF FourCC code of the codec + TFourCC iFourCC; + + // MMF format encoder for the codec + TUint32 iPayloadFormatEncoder; + + // MMF format decoder for the codec + TUint32 iPayloadFormatDecoder; + + // Codec bitrate + TUint iBitrate; + + // sampling rate + TUint32 iSamplingFreq; + + // Should DTX/VAD/CNG be enabled + TBool iEnableDTX; + + // Codec mode + TUint iCodecMode; + + // Algorithm used + TUint iAlgoUsed; + + // Minimum packet time for codec + TUint iPtime; + + // Maximum packet time for codec + TUint iMaxPtime; + + // RTP Payload type for the codec + TUint8 iPayloadType; + + // RTP payload type for redundant audio + TUint8 iRedundantPayload; + + // Number of redundant frames if enabled + TUint8 iRedundancyCount; + + // Frametime + TUint8 iHwFrameTime; + + // Frame size + TUint iFrameSize; + + // CN Frame size + TUint8 iCNFrameSize; + + //Fmtp size + TInt iFmtpLength; + + // Jitter buffer size + TUint iJitterSize; + + // Mode change neighbor + TBool iNeighbor; + + // Mode change period + TUint iModeChangePeriod; + + //JitterBuffer InactivityTimeOut + TUint iJitterBufInactivityTimeOut; + + //JitterBuffer tone TimeOut + TUint iJitterBufPlayToneTimeout; + + //JitterBuffer tone frequecy + TUint iJitterBufPlayToneFrequency; + + //JitterBuffer tone duration + TUint iJitterBufPlayToneDuration; + + //JitterBuffer threshold + TUint iJitterBufThreshold; + + //JitterBuffer buffer length + TUint iJitterBufBufferLength; + + /** + * Comfort noise generation payload type . + * Disabled if KPayloadTypeUndefined. + */ + TUint8 iComfortNoiseGenerationPt; + + //Bitrates used in codec + TUint iBitrateMask; + + //Average bitrate used in codec + TUint iAverageBitrate; + + //Max bitrate used in codec + TUint iMaxBitrate; + + //Frame rate for video + TReal iFramerate; + + // Horizontal resolution of video + TUint iVideoWidth; + + // Vertical resolution of video + TUint iVideoHeight; + + // Network MTU size (in order to determine outgoing packet's maximum size, if needed) default: 1400 + TUint iMTUSize; + + // Session ID + TUint32 iSessionID; + + // Link ID + TUint32 iLinkID; + + // Stream ID + TUint32 iStreamID; + + // MMF Priority settings + TMMFPrioritySettings iPriority; + + // Rtp keepalive interval (secs) + TUint8 iKeepaliveInterval; + + // Rtp keepalive payload type + TUint8 iKeepalivePT; + + // Rtp keepalive data + TBuf8 iKeepaliveData; + + // Indicates if update param set + TBool iIsUpdate; + + /** + * Maximum redundancy in milliseconds + */ + TInt iMaxRed; + + // Trust timestamps provided by datasource + TBool iSourceDefinedTimeStamps; + + // Rtp keepalive data + TBuf8 iConfigKey; + + TUid iEncodingDecodingDevice; + }; + +typedef TPckgBuf TMccCodecInfoBuffer; + +/** +* Mcc Stream settings for Mcc internal use +* +* @lib N/A +* @since Series 60 3.0 +*/ +class TMccStreamSettings + { + public: // Constructors + + /** + * Default constructor + */ + inline TMccStreamSettings() : iRemoteAddress( KInetAddrAny ), + iLocalRtpPort( KDefaultRtpPort ), iLocalRtcpPort( KDefaultRtcpPort ), + iPriority( TMMFPrioritySettings() ), iIapId( 0 ), iRtcpEnabled( EFalse ), + iIpTos( 0 ) + { }; + + public: // Data + + // Remote address + TInetAddr iRemoteAddress; + + // Local RTP port + TUint iLocalRtpPort; + + // Local RTCP port + TUint iLocalRtcpPort; + + // MMF Priority settings + TMMFPrioritySettings iPriority; + + // IAP ID + TInt iIapId; + + // RTCP enabled + TBool iRtcpEnabled; + + // TOS setting + TInt iIpTos; + }; + +#endif // MCCINTERNALCODECS_H + +// End of File