multimediacommscontroller/mmccshared/inc/mccinternalcodecs.h
changeset 0 1bce908db942
child 18 817c922b90eb
--- /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 <mmf/common/mmfutilities.h>
+#include <mmf/common/mmffourcc.h>
+#include <mmf/common/mmfbase.h>
+#include <in_sock.h>
+#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<TUint8>( 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<KMaxSdpNameLength> 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<KMaxKeepAliveDataLen> 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<KMaxConfigKeyLen> iConfigKey;
+        
+        TUid iEncodingDecodingDevice;
+    };
+
+typedef TPckgBuf<TMccCodecInfo> 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