ipappsrv_plat/media_control_api/inc/mmcccodecinformation.h
changeset 0 1bce908db942
child 32 f2ed1fc4c163
equal deleted inserted replaced
-1:000000000000 0:1bce908db942
       
     1 /*
       
     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:    Class is used for configuring media codecs.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 
       
    21 #ifndef MMCCCODECINFORMATION_H
       
    22 #define MMCCCODECINFORMATION_H
       
    23 
       
    24 // INCLUDES
       
    25 #include <e32base.h>
       
    26 #include <e32des8.h>
       
    27 #include <e32svr.h>
       
    28 #include <mmf/common/mmfcontroller.h>
       
    29 
       
    30 // FORWARD DECLARATIONS
       
    31 
       
    32 class TMccCodecInfo;
       
    33 
       
    34 // CONSTANTS
       
    35 
       
    36 // Codec names used in SDP messages
       
    37 _LIT8( KPCMUSdpName, "PCMU" );
       
    38 _LIT8( KPCMASdpName, "PCMA" );
       
    39 _LIT8( KAMRSdpName, "AMR" );
       
    40 _LIT8( KAMRWbSdpName, "AMR-WB" );
       
    41 _LIT8( KILBCSdpName, "iLBC" );
       
    42 _LIT8( KG729SdpName, "G729" );
       
    43 _LIT8( KTelephoneEvent, "telephone-event" );
       
    44 _LIT8( KRedSdpName, "red" );
       
    45 _LIT8( KCnSdpName, "CN" );
       
    46 _LIT8( KH263SdpName, "H263" );
       
    47 _LIT8( KH2631998SdpName, "H263-1998" );
       
    48 _LIT8( KH2632000SdpName, "H263-2000" );
       
    49 _LIT8( KAVCSdpName, "H264" );
       
    50 _LIT8( KAACSdpName, "AAC" );
       
    51 _LIT8( KIlbcFmtp, "mode=" );
       
    52 _LIT8( KSemicolonSpace, "; " );
       
    53 _LIT8( KCommaSign, "," );
       
    54 const TInt KPTimeFactor = 1000;
       
    55 
       
    56 // Maximum buffer length for SDP names
       
    57 const TInt KMaxSdpNameLength = 20;
       
    58 const TUint8 KMaxPacketrate = 10;
       
    59 const TInt KMaxFmtpLen( 120 ); // Change if this gets too small
       
    60 const TInt KMaxKeepAliveDataLen( 161 );
       
    61 
       
    62 // Dynamic payload type limits, see RFC 3551
       
    63 const TUint8 KMaxPayloadType = 127;
       
    64 const TUint8 KMinDynamicPT = 96;
       
    65 const TUint8 KPayloadTypeUndefined = 128;
       
    66 
       
    67 // Default payload types for codecs that use dynamic payload types
       
    68 const TUint8 KDefaultAmrNbPT = 96;
       
    69 const TUint8 KDefaultIlbcPT = 97;
       
    70 const TUint8 KDefaultDtmfPT = 98;
       
    71 const TUint8 KDefaultRedPT = 99;
       
    72 const TUint8 KDefaultAmrWbPT = 100;
       
    73 
       
    74 // Static payload types, see RFC 3551
       
    75 const TUint8 KPcmuPayloadType = 0;
       
    76 const TUint8 KPcmaPayloadType = 8;
       
    77 const TUint8 KG729PayloadType = 18;
       
    78 const TUint8 KCnPayloadType = 13;
       
    79 const TUint8 KCnPayloadTypeReserved = 19;
       
    80 
       
    81 // Packet length constants, in milliseconds
       
    82 const TUint KMinPtime = 10;
       
    83 const TUint KDefaultPtime = 20;
       
    84 const TUint KMaxPtime = 200;
       
    85 
       
    86 // Max gen red count
       
    87 const TUint KMaxGenRedCount = 1;
       
    88 
       
    89 // Max config key length
       
    90 const TInt KMaxConfigKeyLen = 100;
       
    91 
       
    92 // FourCC values for different codecs supported by MCC
       
    93 
       
    94 // (' ', 'A', 'M', 'R')
       
    95 const TUint32 KMccFourCCIdAMRNB = 0x524d4120;
       
    96 
       
    97 // (' ', 'A', 'W', 'B')
       
    98 const TUint32 KMccFourCCIdAMRWB = 0x42574120;
       
    99 
       
   100 // ('G', '7', '1', '1')
       
   101 const TUint32 KMccFourCCIdG711 = 0x31313747;
       
   102 
       
   103 // ('G', '7', '2', '9')
       
   104 const TUint32 KMccFourCCIdG729 = 0x39323747;
       
   105 
       
   106 // ('i', 'L', 'B', 'C')
       
   107 const TUint32 KMccFourCCIdILBC = 0x43424c49;
       
   108 
       
   109 // ( 'D', 'T', 'M', 'F' )
       
   110 const TUint32 KMccFourCCIdDTMF = 0x464d5444;
       
   111 
       
   112 // ( 'H', '2', '6', '3' )
       
   113 const TUint32 KMccFourCCIdH263 = 0x461A1B1C;
       
   114 
       
   115 // ( 'H', '2', '6', '4' )
       
   116 const TUint32 KMccFourCCIdAVC = 0x461A1BDD;
       
   117 
       
   118 // Red - not official
       
   119 const TUint32 KMccFourCCIdRed = 0x4DDDDDDD;
       
   120 
       
   121 // Comfort noise - not official
       
   122 const TUint32 KMccFourCCIdCN = 0x4DDDDDDE;
       
   123 
       
   124 
       
   125 // DATA TYPES
       
   126 /**
       
   127 * Codec mode
       
   128 */
       
   129 typedef TUint TCodecMode;
       
   130 
       
   131 const TUint ENothing = 1;
       
   132 const TUint EPCMU = 2;
       
   133 const TUint EPCMA = 3;
       
   134 const TUint EBandwidthEfficient = 4;
       
   135 const TUint EOctetAligned = 5;
       
   136 const TUint EDTMFModeEvent = 6;
       
   137 const TUint EDTMFModeInband = 7;
       
   138 const TUint EDTMFModeTone = 8;
       
   139 const TUint EDTMFModeRedEvents = 9;
       
   140 
       
   141 /**
       
   142 * Algorithm used
       
   143 */      
       
   144 typedef TUint TAlgoUsed;
       
   145 
       
   146 const TUint ENoAlgoUsed = 1;  
       
   147 const TUint EGenRedUsed = 2;
       
   148 const TUint EAmrFecUsed = 3; 
       
   149 
       
   150 // FUNCTION PROTOTYPES
       
   151 
       
   152 // CLASS DECLARATION
       
   153 /**
       
   154 *  Container class for the codec information.
       
   155 *
       
   156 *  @lib mmccinterface.dll
       
   157 */
       
   158 class CMccCodecInformation : public CBase
       
   159 {
       
   160 public:  // Constructors and destructor
       
   161 
       
   162     /**
       
   163     * Destructor.
       
   164     */
       
   165     virtual ~CMccCodecInformation();
       
   166 
       
   167 protected:  // New functions
       
   168     
       
   169     /**
       
   170     * C++ default constructor.
       
   171     */
       
   172     CMccCodecInformation();
       
   173     
       
   174 public: // New functions
       
   175 
       
   176     /**
       
   177     * Constructs a clone from this codec object. Note that the clone falls
       
   178     * back to given codec's default settings.
       
   179     * @return CMccCodecInformation Pointer to the newly created codec clone
       
   180     */
       
   181     virtual CMccCodecInformation* CloneDefaultsL() = 0;
       
   182     
       
   183     /**
       
   184     * Constructs a clone from this codec object and copies the original 
       
   185     * object's current settings to the newly created clone.
       
   186     * @return CMccCodecInformation Pointer to the newly created codec clone
       
   187     */
       
   188     virtual CMccCodecInformation* CloneDetailedL() = 0;
       
   189             
       
   190     /**
       
   191     * Checks the codec values if signalling is needed.
       
   192     * @param aCandidate new codec to be checked
       
   193     * @return ETrue if signalling is needed
       
   194     */
       
   195     virtual TBool RequireSignalling( const CMccCodecInformation& aCandidate ) const;      
       
   196        
       
   197 public: // sets
       
   198     
       
   199     virtual void SetValues( TMccCodecInfo codecInfo );
       
   200         
       
   201     virtual void GetValues( TMccCodecInfo& codecInfo ) const;
       
   202 
       
   203     /**
       
   204     * Type of the codec, like KUidMediaTypeAudio or KUidMediaTypeVideo.
       
   205     * @return type of the codec.
       
   206     */
       
   207     virtual TUid Type() const;
       
   208     
       
   209     /**
       
   210     * Enable / Disable Voice Activity Detection.
       
   211     * @param aEnableVAD Boolean indicating whether to enable
       
   212     *     Voice Activity Detection
       
   213     * @return KErrNotSupported if codec doesn't support VAD; otherwise KErrNone.
       
   214     */
       
   215     virtual TInt EnableVAD( TBool aEnableVAD ) = 0;
       
   216  
       
   217     /**
       
   218     * Sets bitrate used with codec.
       
   219     * @param aBitrate New bitrate value
       
   220     * @return KErrNotSupported if codec doesn't support bitrate value
       
   221     *     issued; otherwise KErrNone.
       
   222     */
       
   223     virtual TInt SetBitrate( TUint aBitrate ) = 0;
       
   224     
       
   225     /**
       
   226     * Sets the sampling frequency.
       
   227     * @param aSamplingFreq Sampling frequency to be used
       
   228     * @return KErrNotSupported if codec doesn't support sampling frequency
       
   229     *     issued; otherwise KErrNone.
       
   230     */
       
   231     virtual TInt SetSamplingFreq( TUint32 aSamplingFreq ) = 0;
       
   232     
       
   233     /**
       
   234     * Sets the sdp name of the codec.
       
   235     * @param aSdpName sdp name of the codec.
       
   236     * @return KErrNotSupported if not allowed; otherwise KErrNone.
       
   237     */
       
   238     virtual TInt SetSdpName( const TDesC8& aSdpName ) = 0;
       
   239     
       
   240     /**
       
   241     * Sets the payload type.
       
   242     * @param aPayloadType type identifier to be used for payload.
       
   243     * @return KErrNotSupported if not allowed; otherwise KErrNone.
       
   244     */
       
   245     virtual TInt SetPayloadType( TUint8 aPayloadType ) = 0;
       
   246 
       
   247     /**
       
   248     * Sets the codec mode.
       
   249     * @param aMode Codec mode, eg. ULAW/ALAW, bandwidth eff / octet aligned
       
   250     * @return KErrNotSupported if codec doesnt' support codec mode
       
   251     *     value issued; otherwise KErrNone.
       
   252     */
       
   253     virtual TInt SetCodecMode( TCodecMode aCodecMode ) = 0;
       
   254     
       
   255     /**
       
   256     * Sets the allowed bitrates for the codec.
       
   257     * @param aBitrateMask bitrate mask.
       
   258     * @return KErrNotSupported if codec doesnt' support the bitrate mask
       
   259     *     value issued; otherwise KErrNone.
       
   260     */
       
   261     virtual TInt SetAllowedBitrates( TUint aBitrateMask );
       
   262     
       
   263     /**
       
   264     * Sets the packet time
       
   265     * @param aPTime PacketTime.
       
   266     * @return One of the standard system-wide error codes.
       
   267     */
       
   268     virtual TInt SetPTime( TUint aPTime ) = 0;        
       
   269     
       
   270     /**
       
   271     * Sets max packet time
       
   272     * @param aMaxPTime Maximum PacketTime
       
   273     * @return One of the standard system-wide error codes.
       
   274     */
       
   275     virtual TInt SetMaxPTime( TUint aMaxPTime ) = 0; 
       
   276                      
       
   277     /**
       
   278     * Set JitterBuffer Buffer length
       
   279     * @param aJitterBufBufferLength length for buffer
       
   280     * @return One of the standard system-wide error codes.
       
   281     */
       
   282     virtual TInt SetJitterBufBufferLength( TUint aJitterBufBufferLength );      
       
   283 
       
   284     /**
       
   285     * Set JitterBuffer threshold
       
   286     * @param aJitterBufThreshold threshold value for buffer before playout starts
       
   287     * @return One of the standard system-wide error codes.
       
   288     */
       
   289     virtual TInt SetJitterBufThreshold( TUint aJitterBufThreshold );      
       
   290    
       
   291     /**
       
   292     * Set JitterBuffer inactivity timeout in millisecounds
       
   293     * @param aJitterBufInactivityTimeOut timeout value for RTP inactivity
       
   294     * @return One of the standard system-wide error codes.
       
   295     */
       
   296     virtual TInt SetJitterBufInactivityTimeOut( TUint aJitterBufInactivityTimeOut );     
       
   297 
       
   298     /**
       
   299     * Sets max bitrate
       
   300     * @param aMaxBitrate Maximum bitrate
       
   301     * @return One of the standard system-wide error codes.
       
   302     */
       
   303     virtual TInt SetMaxBitrate( TUint aMaxBitrate ); 
       
   304 
       
   305     /**
       
   306     * Sets average bitrate
       
   307     * @param aAverageBitrate average bitrate
       
   308     * @return One of the standard system-wide error codes.
       
   309     */
       
   310     virtual TInt SetAverageBitrate( TUint aAverageBitrate ); 
       
   311 
       
   312     /**
       
   313     * Sets framerate
       
   314     * @param aFramerate frame rate
       
   315     * @return One of the standard system-wide error codes.
       
   316     */
       
   317     virtual TInt SetFramerate( TReal aFramerate ); 
       
   318 
       
   319     /**
       
   320     * Sets height of the frame
       
   321     * @param aFrameHeight height of the frame
       
   322     * @return One of the standard system-wide error codes.
       
   323     */
       
   324     virtual TInt SetFrameHeight( TUint aFrameHeight ); 
       
   325 
       
   326     /**
       
   327     * Sets width of the frame
       
   328     * @param aFrameWidth width of the frame
       
   329     * @return One of the standard system-wide error codes.
       
   330     */
       
   331     virtual TInt SetFrameWidth( TUint aFrameWidth ); 
       
   332     
       
   333     /**
       
   334     * Set algorithm.
       
   335     * @param aAlgo codec specific algorithm to be used
       
   336     * @return One of the standard system-wide error codes.
       
   337     */
       
   338     virtual TInt SetAlgo( TAlgoUsed aAlgo );
       
   339     
       
   340     /**
       
   341     * Set redundancy count.
       
   342     * @param aRedCount count for redundancy
       
   343     * @return One of the standard system-wide error codes.
       
   344     */
       
   345     virtual TInt SetRedCount( TUint aRedCount );
       
   346     
       
   347     /**
       
   348     * Set redundancy payload type.
       
   349     * @param aRedPT payload type for redundancy
       
   350     * @return One of the standard system-wide error codes.
       
   351     */
       
   352     virtual TInt SetRedundancyPT( TUint8 aRedPT );
       
   353          
       
   354     /**
       
   355     * Set priority for media resource.
       
   356     * @param aPriority priority for media resource
       
   357     * @return One of the standard system-wide error codes.
       
   358     */
       
   359     virtual void SetPriority( TInt aPriority );
       
   360     
       
   361     /**
       
   362     * Set priority preference for media resource.
       
   363     * @param aPreference priority preference for media resource
       
   364     * @return One of the standard system-wide error codes.
       
   365     */
       
   366     virtual void SetPriorityPreference(TInt aPreference );
       
   367 
       
   368     /**
       
   369     * Set keep alive packets send timer value.
       
   370     * @param aTimerValue timer value in seconds for keep alive packets
       
   371     * @return One of the standard system-wide error codes.
       
   372     */
       
   373     virtual TInt SetKeepAliveTimer( TUint8 aTimerValue );
       
   374 
       
   375     /**
       
   376     * Set keep alive packets payload type.
       
   377     * @param aKeepAlivePT payload type for keep alive packets
       
   378     * @return One of the standard system-wide error codes.
       
   379     */
       
   380     virtual TInt SetKeepAlivePT( TUint8 aKeepAlivePT );
       
   381 
       
   382     /**
       
   383     * Set keep alive packets payload data.
       
   384     * @param aData payload data for keep alive packets
       
   385     * @return One of the standard system-wide error codes.
       
   386     */
       
   387     virtual TInt SetKeepAliveData( const TDesC8& aData );
       
   388     
       
   389     /**
       
   390     * Enable / Disable Comfort noise generation.
       
   391     * @param aComfortNoisePT Payloadtype value indicating what
       
   392     *        payload type should be used for comfort noise.
       
   393     *        KPayloadTypeUndefined can be used to turn comfor noise
       
   394     *        generation off.
       
   395     * @return One of the standard system-wide error codes.
       
   396     */
       
   397     virtual TInt SetComfortNoiseGeneration( TUint8 aComfortNoisePT );
       
   398 
       
   399     
       
   400     /**
       
   401     * Set number of channels. Range between 1 to 8. Refer to RFC3551 4.1
       
   402     * for interpretation of channels value. Default value is 1.
       
   403     * @return   One of the standard system-wide error codes.
       
   404     */
       
   405     virtual TInt SetChannels( TInt aNumOfChannels );
       
   406         
       
   407     /**
       
   408     * Sets the upper limit on the usage of redundancy in milliseconds.
       
   409     * @param    aMaxRed   maximum redundancy
       
   410     * @return   One of the standard system-wide error codes.
       
   411     */
       
   412     virtual TInt SetMaxRed( TInt aMaxRed );
       
   413 
       
   414     /**
       
   415     * Set encoder/decoder configuration key
       
   416     * @param aConfigKey, config key as Base64 encoded
       
   417     */    
       
   418     virtual void SetConfigKeyL( const TDesC8& aConfigKey );
       
   419     
       
   420     /**
       
   421     * Sets preferred encoding device for uplink stream and preferred decoding
       
   422     * device for downlink stream.
       
   423     * @param aEncodingDecodingDevice
       
   424     */
       
   425     virtual void SetPreferredEncodingDecodingDevice( 
       
   426                                     TUid aEncodingDecodingDevice );
       
   427               
       
   428 public: // get
       
   429 
       
   430     /**
       
   431     * Get VAD status.
       
   432     * @return Boolean indicating is VAD activated
       
   433     */
       
   434     virtual TBool VAD( ) const;
       
   435 
       
   436     /**
       
   437     * Gets bitrate value used currently.
       
   438     * @return Bitrate value
       
   439     */
       
   440     virtual TUint Bitrate( ) const;
       
   441     
       
   442     /**
       
   443     * Gets the bitrate mask 
       
   444     * @return Bitrate mask
       
   445     */
       
   446     virtual TUint AllowedBitrates() const;
       
   447 
       
   448     /**
       
   449     * Gets sampling frequency used currently.
       
   450     * @return Sampling frequency
       
   451     */
       
   452     virtual TUint32 SamplingFreq( ) const;
       
   453 
       
   454     /**
       
   455     * Gets the sdp name.
       
   456     * @return Sdp name used
       
   457     */
       
   458     virtual const TDesC8& SdpName() const;
       
   459     
       
   460     /**
       
   461     * Gets the payload type.
       
   462     * @return Payload type used
       
   463     */
       
   464     virtual TUint8 PayloadType( ) const;
       
   465 
       
   466     /**
       
   467     * Gets the codec mode
       
   468     * @return Codec mode used
       
   469     */
       
   470     virtual TCodecMode CodecMode( ) const;
       
   471     
       
   472     /**
       
   473     * Gets the packet time.
       
   474     * @return Packet Time.
       
   475     */
       
   476     virtual TInt PTime( ) const;        
       
   477     
       
   478     /**
       
   479     * Gets max packet time.
       
   480     * @return Max PacketTime.
       
   481     */
       
   482     virtual TInt MaxPTime( ) const;        
       
   483     
       
   484     /**
       
   485     * Gets the codec specific fmtp value for SDP.
       
   486     * @return Fmtp.
       
   487     */
       
   488     virtual TDesC8& GetFmtpL( );        
       
   489        
       
   490     /**
       
   491     * Codec FourCC.
       
   492     * @return FourCC.
       
   493     */        
       
   494     virtual TUint32 FourCC( ) const;
       
   495             
       
   496     /**
       
   497     * Get HW FrameTime.
       
   498     * @return FrameTime in milliseconds
       
   499     */
       
   500     virtual TInt FrameTime( ) const;
       
   501     
       
   502     /**
       
   503     * Get FrameSize.
       
   504     * @return FrameSize in bytes
       
   505     */
       
   506     virtual TInt FrameSize( ) const;
       
   507             
       
   508     /**
       
   509     * Get Algorithm used.
       
   510     * @return FrameSize in bytes
       
   511     */
       
   512     virtual TAlgoUsed Algo( ) const;       
       
   513            
       
   514     /**
       
   515     * Get Redundancy Count.
       
   516     * @return Redundancy Count
       
   517     */
       
   518     virtual TUint RedCount( ) const;    
       
   519             
       
   520     /**
       
   521     * Get Redundancy PayloadType.
       
   522     * @return Redundancy PayloadType
       
   523     */
       
   524     virtual TUint8 RedundancyPT( ) const; 
       
   525     
       
   526     /**
       
   527     * Get JitterBuffer inactivity timeout
       
   528     * @return timeout time.
       
   529     */
       
   530     virtual TUint JitterBufInactivityTimeOut() const;  
       
   531     
       
   532     /**
       
   533     * Get JitterBuffer threshold
       
   534     * @return threshold.
       
   535     */
       
   536     virtual TUint JitterBufThreshold() const;      
       
   537            
       
   538     /**
       
   539     * Get JitterBuffer Buffer length
       
   540     * @return Buffer length.
       
   541     */
       
   542     virtual TUint JitterBufBufferLength() const;      
       
   543            
       
   544     /**
       
   545     * Gets max bitrate
       
   546     * @return Maximum bitrate.
       
   547     */
       
   548     virtual TUint MaxBitrate() const; 
       
   549 
       
   550     /**
       
   551     * Gets average bitrate
       
   552     * @return average bitrate.
       
   553     */
       
   554     virtual TUint AverageBitrate() const; 
       
   555 
       
   556     /**
       
   557     * Gets framerate
       
   558     * @return frame rate.
       
   559     */
       
   560     virtual TReal Framerate() const; 
       
   561 
       
   562     /**
       
   563     * Gets height of the frame
       
   564     * @return height of the frame.
       
   565     */
       
   566     virtual TUint FrameHeight() const; 
       
   567 
       
   568     /**
       
   569     * Gets width of the frame
       
   570     * @return width of the frame.
       
   571     */
       
   572     virtual TUint FrameWidth() const; 
       
   573                                          
       
   574     /**
       
   575     * Gets media priority
       
   576     * @return media priority.
       
   577     */
       
   578     virtual TInt Priority( ) const;
       
   579 
       
   580     /**
       
   581     * Gets media priority preference
       
   582     * @return media priority preference.
       
   583     */
       
   584     virtual TInt PriorityPreference( ) const;
       
   585 
       
   586     /**
       
   587     * Get keep alive packets send timer value.
       
   588     * @return keep alive packets send timer value.
       
   589     */
       
   590     virtual TUint8 KeepAliveTimer() const;
       
   591 
       
   592     /**
       
   593     * Get keep alive packets payload type.
       
   594     * @return keep alive packets payload type.
       
   595     */
       
   596     virtual TUint8 KeepAlivePT() const;
       
   597 
       
   598     /**
       
   599     * Get keep alive packets payload data.
       
   600     * @return keep alive packets payload data.
       
   601     */
       
   602     virtual const TDesC8& KeepAliveData() const;
       
   603     
       
   604     /**
       
   605     * Get Comfort noise payload type value.
       
   606     * @return Payload type value indicating which 
       
   607     *         payload type is used for comfort noise generation.
       
   608     *         If KPayloadTypeUndefined is returned, comfort
       
   609     *         noise generation is disabled.
       
   610     */
       
   611     virtual TUint8 ComfortNoiseGeneration() const;
       
   612     
       
   613     /**
       
   614     * Get number of channels.
       
   615     * @return   One of the standard system-wide error codes.
       
   616     */
       
   617     virtual TInt GetChannels( TInt& aNumOfChannels ) const;
       
   618         
       
   619     /**
       
   620     * Returns the maximum redundancy
       
   621     * @return   maximum redundancy in milliseconds
       
   622     */
       
   623     virtual TInt MaxRed() const;
       
   624           
       
   625     /**
       
   626     * Fills array with red payload types.
       
   627     * @param        aRedPayloads   
       
   628     */
       
   629     virtual void RedPayloadsL( RArray<TUint>& aRedPayloads ) const;
       
   630     
       
   631     /**
       
   632     * Get encoder/decoder configuration key
       
   633     * @return key or NULL, ownership is transferred
       
   634     */    
       
   635     virtual HBufC8* ConfigKeyL() const;
       
   636     
       
   637     /**
       
   638     * Get preferred encoding device for uplink stream and preferred decoding
       
   639     * device for downlink stream.
       
   640     */
       
   641     virtual TUid PreferredEncodingDecodingDevice() const;
       
   642 
       
   643 public: //Fmtp, set, parse and create fmtp string from internal attributes
       
   644 
       
   645     /**
       
   646     * Sets the fmtp attribute, i.e. iFmtpAttr == aFmtp  
       
   647     * @param aFmtp Fmtp attribute
       
   648     * @return void
       
   649     */
       
   650     virtual void SetFmtpAttrL( const TDesC8& aFmtp, TBool parseFmtp = ETrue );
       
   651     
       
   652     /**
       
   653     * Parses the fmtp attributes, and updates the internal values
       
   654     * except the iFmtpAttr attribute
       
   655     * @param aFmtp Fmtp attribute
       
   656     * @return True if any param was updated
       
   657     */
       
   658     virtual TBool ParseFmtpAttrL( const TDesC8& aFmtp );      
       
   659    
       
   660     /**
       
   661     * Creates the fmtp string from internal values
       
   662     * @return void
       
   663     */
       
   664     virtual void CreateFmtpAttrListL();
       
   665   
       
   666     /**
       
   667     * Creates the fmtp string from internal values and the given bitrates
       
   668     * @return void
       
   669     */
       
   670     virtual void CreateFmtpAttrListL( const RArray<TUint>& aBitrates );
       
   671 
       
   672 private:
       
   673 
       
   674     /**
       
   675     * Specifies the number of frame blocks,
       
   676     * that is the interval at which codec mode changes are allowed
       
   677     * @return   One of the standard system-wide error codes.
       
   678     */
       
   679     virtual TInt SetModeChangePeriod( const TInt aPeriod );
       
   680     
       
   681     /**
       
   682     * Get specified number of frame blocks
       
   683     * @return   One of the standard system-wide error codes.
       
   684     */
       
   685     virtual TInt ModeChangePeriod( ) const;
       
   686     
       
   687     /**
       
   688     * Set boolean variable, which indicates change between two modes.
       
   689     * With default value 1 changes are only allowed to the 
       
   690     * neighboring mode.
       
   691     * @return   One of the standard system-wide error codes.
       
   692     */
       
   693     virtual TInt SetModeChangeNeighbor( const TBool aNeighbor );
       
   694     
       
   695     /**
       
   696     * Get boolean variable, which indicates change between two modes.
       
   697     * @return   iNeighbor
       
   698     */
       
   699     virtual TBool ModeChangeNeighbor( ) const;
       
   700     
       
   701     /**
       
   702     * Set boolean type frame CRC value. With value 1 CRC shall be
       
   703     * included in the payload, otherwise not. 1 also implies that
       
   704     * octet-alignet operation shall be used for the session.
       
   705     * @return   One of the standard system-wide error codes.
       
   706     */
       
   707     virtual TInt SetCrc( const TBool aCrc );
       
   708     
       
   709     /**
       
   710     * Get boolean type CRC value.
       
   711     * @return   iCrc
       
   712     */
       
   713     virtual TBool GetCrc( ) const;
       
   714     
       
   715     /**
       
   716     * Set robust sorting on/off with boolean value. With value 1
       
   717     * the payload SHALL employ robust sorting. Implies automatically
       
   718     * that octet-aligned operation SHALL be used for the session.
       
   719     * @return   One of the standard system-wide error codes.
       
   720     */     
       
   721     virtual TInt SetRobustSorting( const TBool aRobust );
       
   722     
       
   723     /**
       
   724     * Get boolean type robust sorting value
       
   725     * @return   iRobust
       
   726     */
       
   727     virtual TBool GetRobustSorting( ) const;
       
   728     
       
   729     /**
       
   730     * Set interleaving as unsigned integer. Number range is 0-63.
       
   731     * Indicates that frame-block level interleaving SHALL be
       
   732     * used for the session and it's value defines the max number of
       
   733     * frame-blocks allowed in interleaving group. Implies automatically
       
   734     * that octet-aligned operation SHALL be used.
       
   735     * @return   One of the standard system-wide error codes.
       
   736     */
       
   737     virtual TInt SetInterleaving( const TInt aFrameBlockCount );
       
   738     
       
   739     /**
       
   740     * Get Interleaving value
       
   741     * @return   iFrameBlockCount
       
   742     */
       
   743     virtual TInt GetInterleaving() const;
       
   744           
       
   745     
       
   746 protected:  // Data
       
   747 
       
   748     /**
       
   749     * Type of codec, like KUidMediaTypeAudio or KUidMediaTypeVideo
       
   750     */
       
   751     TUid iType;
       
   752     
       
   753     /**
       
   754     * Enables or disables VAD (Voice Activity Detection)
       
   755     */
       
   756     TBool iEnableVAD;
       
   757 
       
   758     /**
       
   759     * Sampling frequency used with codec
       
   760     */
       
   761     TUint32 iSamplingFreq;
       
   762 
       
   763     /**
       
   764     * Sdp name used in SDP messages
       
   765     */
       
   766     TBuf8<KMaxSdpNameLength> iSdpName;        
       
   767 
       
   768     /**
       
   769     * Stream's packet time
       
   770     */
       
   771     TUint iPTime;
       
   772     
       
   773     /**
       
   774     * Stream's max packet time
       
   775     */
       
   776     TUint iMaxPTime;
       
   777     
       
   778     /**
       
   779     * Fmtp attribute
       
   780     */
       
   781     HBufC8* iFmtpAttr;
       
   782     
       
   783     /**
       
   784     * Parsed fmtp attr
       
   785     */
       
   786     TUint iParsedFmtp;
       
   787     
       
   788     /**
       
   789     * Stream's bit rate
       
   790     */
       
   791     TUint iBitrate;
       
   792 
       
   793     /**
       
   794     * Bitrate mask, allowed modes
       
   795     */
       
   796     TUint iBitrateMask;
       
   797     
       
   798     /**
       
   799     * Payload type
       
   800     */
       
   801     TUint8 iPayloadType;
       
   802 
       
   803     /**
       
   804     * Codec mode ( e.g. PCMU, PCMA, Bandwidth efficient, octet aligned )
       
   805     */
       
   806     TCodecMode iCodecMode;        
       
   807 
       
   808     /**
       
   809     * Local port
       
   810     */
       
   811     TUint iStartMediaPort;
       
   812         
       
   813     /**
       
   814     * Codec FourCC
       
   815     */
       
   816     TUint32 iFourCC;
       
   817     
       
   818     /**
       
   819     * FrameTime
       
   820     */
       
   821     TInt iHwFrameTime;
       
   822     
       
   823     /**
       
   824     * FrameSize
       
   825     */
       
   826     TInt iFrameSize;
       
   827     
       
   828     /**
       
   829     * Algorithm used
       
   830     */
       
   831     TAlgoUsed iAlgoUsed;
       
   832     
       
   833     /**
       
   834     * Redundancy count
       
   835     */
       
   836     TUint iRedCount;
       
   837     
       
   838     /**
       
   839     * Redundancy PayloadType
       
   840     */
       
   841     TUint8 iRedundancyPT;
       
   842     
       
   843     /**
       
   844     * JitterBuffer InactivityTimeOut
       
   845     *
       
   846     * Used for talkburst
       
   847     * In millisecound when the sequence number should be zerod 
       
   848     * after a talkburst 
       
   849     * ( iJitterBufInactivityTimeOut / iHwFrameTime ) == InactivityEvent
       
   850     */
       
   851     TUint iJitterBufInactivityTimeOut;
       
   852     
       
   853     /**
       
   854     * JitterBuffer threshold
       
   855     *
       
   856     * How many packets should be in the buffer
       
   857     * before they are played
       
   858     */
       
   859     TUint iJitterBufThreshold;
       
   860     
       
   861     /**
       
   862     * JitterBuffer threshold
       
   863     *
       
   864     * How many packets the jitter buffer can hold
       
   865     */
       
   866     TUint iJitterBufBufferLength;
       
   867            
       
   868     /**
       
   869     * Mode change period
       
   870     */
       
   871     TInt iModeChangePeriod;
       
   872     
       
   873     /**
       
   874     * Mode change neighbor
       
   875     */
       
   876     TBool iNeighbor;
       
   877     
       
   878     /**
       
   879     * Crc value
       
   880     */
       
   881     TBool iCrc;
       
   882     
       
   883     /**
       
   884     * Robust sorting indicator
       
   885     */
       
   886     TBool iRobust;
       
   887     
       
   888     /**
       
   889     * Interleaving value
       
   890     */
       
   891     TInt iFrameBlockCount;
       
   892     
       
   893     /**
       
   894      * Number of channels
       
   895      */
       
   896     TInt iNumOfChannels;
       
   897         
       
   898     /**
       
   899      * Payload type for comfort noise generation
       
   900      */
       
   901     TUint8 iComfortNoiseGenerationPt;
       
   902            
       
   903     /**
       
   904     * MMF priority settings
       
   905     */
       
   906     TInt iPriority;
       
   907             
       
   908     /**
       
   909     * MMF priority settings
       
   910     */
       
   911     TInt iPriorityPreference;
       
   912     
       
   913     /**
       
   914     * Average bitrate used in codec
       
   915     */
       
   916     TUint iAverageBitrate;
       
   917             
       
   918     /**
       
   919     * Max bitrate used in codec
       
   920     */
       
   921     TUint iMaxBitrate;
       
   922     
       
   923     /**
       
   924     * Frame rate for video
       
   925     */
       
   926     TReal iFramerate;
       
   927 
       
   928     /**
       
   929     * Horizontal resolution of video
       
   930     */
       
   931     TUint iVideoWidth;
       
   932 
       
   933     /**
       
   934     * Vertical resolution of video
       
   935     */
       
   936     TUint iVideoHeight;
       
   937     
       
   938     /**
       
   939     * Timer value for keep alive data
       
   940     */
       
   941     TUint8 iKeepAliveTimer;
       
   942     
       
   943     /**
       
   944     * Payload type value for keep alive data
       
   945     */
       
   946     TUint8 iKeepAlivePT;
       
   947     
       
   948     /**
       
   949     * Data for keep alive
       
   950     */
       
   951     TBuf8<KMaxKeepAliveDataLen> iKeepAliveData;
       
   952             
       
   953     // MMF format encoder for the codec
       
   954     TUint32 iPayloadFormatEncoder;
       
   955 
       
   956     // MMF format decoder for the codec
       
   957     TUint32 iPayloadFormatDecoder;
       
   958     
       
   959     /**
       
   960     * Maximum redundancy in milliseconds
       
   961     */
       
   962     TInt iMaxRed;
       
   963     
       
   964     /**
       
   965     * Encoder/decoder configuration key
       
   966     */
       
   967     HBufC8* iConfigKey;
       
   968     
       
   969     /**
       
   970     * Encoder/decoder uid
       
   971     */
       
   972     TUid iEncodingDecodingDevice;
       
   973         
       
   974 private:
       
   975 
       
   976     #ifdef TEST_EUNIT
       
   977         friend class UT_CMccCodecInformation;
       
   978     #endif
       
   979 };
       
   980 
       
   981 #endif      // MMCCCODECINFORMATION_H
       
   982 
       
   983 // End of File