FCL/sf/mw/mmmw: comparison mmserv/voipaudioservices/JitterBufferUtility/src/JitterBufferImpl.cpp

equal deleted inserted replaced

-:a493a607b5bf
+:eabc8c503852
 /*
 * Copyright (c) 2008 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:  Implementation of Mcc Jitterbuffer
 *
 */
 // INCLUDE FILES
 #include <e32base.h>
 #include <mmcccodecinformation.h> //codec FourCC declarations
 #include "debugtracemacros.h"
 #include "CngGenerator.h"
 #include "InternalDef.h"
 #include "JitterBufferObserver.h"
 #include "JitterBufferImpl.h"
 // -----------------------------------------------------------------------------
 // TJitterBufferElement::CompareSeqNum
 // Compare SequenceNumber
 // -----------------------------------------------------------------------------
 //
 TInt TJitterBufferElement::CompareSeqNum(const TJitterBufferElement& aElem1,
 const TJitterBufferElement& aElem2)
 {
 if (aElem1.iSequenceNumber > aElem2.iSequenceNumber)
 {
 return (-1);
 }
 // TJitterBufferElement::CompareStamp
 // Compare Stamp
 // -----------------------------------------------------------------------------
 //
 TInt TJitterBufferElement::CompareStamp(const TJitterBufferElement& aElem1,
 const TJitterBufferElement& aElem2)
 {
 if (aElem1.iTimeStamp > aElem2.iTimeStamp)
 {
 return (-1);
 }
 // CVoIPJitterBufferImpl::CVoIPJitterBufferImpl
 // C++ default constructor can NOT contain any code, that might leave.
 // -----------------------------------------------------------------------------
 //
 CVoIPJitterBufferImpl::CVoIPJitterBufferImpl(MJitterBufferObserver* aObserver) :
-iBufStampSorter(TLinearOrder<TJitterBufferElement>(
+iBufStampSorter(TLinearOrder<TJitterBufferElement> (
 TJitterBufferElement::CompareStamp)),
-iBufSequenceSorter(TLinearOrder<TJitterBufferElement>(
+iBufSequenceSorter(TLinearOrder<TJitterBufferElement> (
 TJitterBufferElement::CompareSeqNum))
 {
 iObserver = aObserver;
 iTonePlayTime.UniversalTime();
 iSampleRate = KDefaultSampleRateInkHz;
 iPlay = EFalse;
 // CVoIPJitterBufferImpl::NewL
 // Static constructor.
 // -----------------------------------------------------------------------------
 //
 CVoIPJitterBufferImpl* CVoIPJitterBufferImpl::NewL(
 MJitterBufferObserver* aObserver)
 {
-CVoIPJitterBufferImpl* self = new(ELeave) CVoIPJitterBufferImpl(aObserver);
+CVoIPJitterBufferImpl* self = new (ELeave) CVoIPJitterBufferImpl(aObserver);
 CleanupStack::PushL(self);
 self->ConstructL();
 CleanupStack::Pop(self);
 return self;
 }
 // CVoIPJitterBufferImpl::SetupL
 // Setup Jitter buffer
 // -----------------------------------------------------------------------------
 //
 void CVoIPJitterBufferImpl::SetupL(const TFourCC aCodec,
 const TVoIPJBConfig& aJBConfig)
 {
 TRACE_PRN_FN_ENT;
 __ASSERT_ALWAYS(aJBConfig.iJitterLatency, User::Leave(KErrArgument));
 __ASSERT_ALWAYS(aJBConfig.iJBBufferLength, User::Leave(KErrArgument));
 iJBConfig = aJBConfig;
 if (iJBConfig.iJBInactivityTimeOut)
 {
 if ((iJBConfig.iJBPlayToneFrequency > 0) &&
 (iJBConfig.iJBPlayToneDuration > 0))
 {
 iPlayToneInterval = iJBConfig.iJBPlayToneTimeout;
 iPlay = ETrue;
 }
 }
 else if (aCodec == KMccFourCCIdG711)
 {
 // G.711 is configured dynamically. Take voip headerlength also into
 // account. G.711 hwframetime is in milliseconds, so need to multiply.
 iFrameSize = (iJBConfig.iSampleInterval * KDefaultSampleRateInkHz) +
 KVoIPHeaderLength;
 iSampleInterval = 0;
 // In case of G.711 codec dynamic configuration, we may need to double
 // the jitter buffer length if HW frame time is changed from 20ms to
 // 10ms.
 iBuffer.Reset();
 // Calculate needed elements
 iBufferLength = iJBConfig.iJBBufferLength * bufLenMultiplier;
 if (iJBConfig.iJBThreshold >= iBufferLength)
-	{
+{
-	// adjust threshold size (no need to leave here)
+// adjust threshold size (no need to leave here)
-	iJBConfig.iJBThreshold = iBufferLength / 2;
+iJBConfig.iJBThreshold = iBufferLength / 2;
-	}
+}
 // If the difference between buffer length and threshold is less than 10
 // increase buffer length, so the differences is 10. This helps handle
 // buffer overflow more easily.
 CheckThresholdBufferLength(iBufferLength, iJBConfig.iJBThreshold);
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::ResetBufferL
 // Reset Jitter Buffer
 // -----------------------------------------------------------------------------
 //
 void CVoIPJitterBufferImpl::ResetBuffer(TBool aPlayTone)
 {
 TRACE_PRN_FN_ENT;
 for (TInt i = 0; i < iBufferLength; i++)
 newElement.iDataFrame = buf;
 newElement.iSequenceNumber = -1;
 newElement.iTimeStamp = -1;
 iBuffer.AppendL(newElement);
 CleanupStack::Pop(buf);
 iBufferLength++;
 // Insert one NO_DATA frame into the audio stream, so the jitterbuffer has
 // the possibility to grow at least one frame from the current size. If
 // the current playout threshold is zero, then there is ongoing playback or
 }
 TRACE_PRN_FN_EXT;
 }
+#ifdef __FEATURE_NOT_SUPPORTED__
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::CalculateDelay
 // Calculates the current jitter buffer playback
 // -----------------------------------------------------------------------------
 //
 TTimeIntervalMicroSeconds32 CVoIPJitterBufferImpl::CalculateDelay() const
 {
-TTimeIntervalMicroSeconds32 delay =
+TTimeIntervalMicroSeconds32 delay = iJBConfig.iJitterLatency *
-iJBConfig.iJitterLatency * iPacketsInBuffer;
+iPacketsInBuffer;
-//    TRACE_PRN_N1(_L("JB-CalculateDelay-> Delay [%d]"), delay);
+//TRACE_PRN_N1(_L("JB-CalculateDelay-> Delay [%d]"), delay);
 return delay;
 }
+#endif //__FEATURE_NOT_SUPPORTED__
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::AddDataFrame
 // Adds audio frame into the jitter buffer
 // -----------------------------------------------------------------------------
 //  3.1 DTX start packet may be lost
 //  3.2 DTX UPDATE packet may be lost (if used)
 //
 TUint index = FindLargestSeqNum();
 if (iLastPlayedSeqNum < KMaxSeqNumber - iSeqNumIncrement)
 {
 iIsWrappedAround = IsSeqNumWrappedAround(iLargestSeqNum,
 iCurrentSeqNum);
 }
 else
 {
 // If the last played frame was larger than the current largest
 // in JB we are most likely running in the wrap-around mode.
 iIsWrappedAround = IsSeqNumWrappedAround(iLastPlayedSeqNum,
 iLargestSeqNum);
 }
 if (iIsWrappedAround)
 {
 iLastPlayedSeqNum = -1;
 TRACE_PRN_N1(_L("JB-> [ADD] LARGEST IN  [%d]"), TInt32(iLargestSeqNum));
 TRACE_PRN_N1(_L("JB-> [ADD] THIS FRAME  [%d]"), TInt32(iCurrentSeqNum));
 TRACE_PRN_N1(_L("JB-> [ADD] LAST PLAYED [%d]"), TInt32(iLastPlayedSeqNum));
 TRACE_PRN_N1(_L("JB-> [ADD] PACKETS [%d]"), iPacketsInBuffer);
-iDataBuffer = static_cast<CMMFDataBuffer*>(aDataBuffer);
+iDataBuffer = static_cast<CMMFDataBuffer*> (aDataBuffer);
 if (iCurrentSeqNum > iLastPlayedSeqNum)
 {
 if (IsFull())
 {
 {
 TRACE_PRN_N(_L("JB-> [ADD] BUFFER EMPTY - Tone NOT played"));
 TRACE_PRN_N1(_L("JB-> [ADD] Interval Tm [%d]"), interval.Int());
 }
 // No point to run at 0 threshold; restore the original
 // settings and rebuffer.
 iCurrentPlayThreshold = iOriginalPlayThreshold;
 const TInt64 nextGetSeqNum(iLastPlayedSeqNum + iSeqNumIncrement);
 const TInt64 frameSeq(iDataBuffer->FrameNumber());
 {
 iNumOfLateFrames++;
 aDataBuffer->SetStatus(EAvailable);
 TRACE_PRN_N(_L("JB-> [ADD] TOO LATE"));
 }
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::GetDataFrame
 if (aBuffer == NULL)
 {
 return KErrNotReady;
 }
-iDataBuffer = static_cast<CMMFDataBuffer*>(aBuffer);
+iDataBuffer = static_cast<CMMFDataBuffer*> (aBuffer);
 TDes8& playBuffer(iDataBuffer->Data());
 iFramesPlayed++;
 if (IsEmpty())
 {
 // Buffer is empty, so we need to generate CN frames. During DTX period
 // this is where we'll end up. If we are empty because of DTX period,
 // the CN generator will do the error concealment.
 TRACE_PRN_N(_L("JB-> [GET] BUFFER EMPTY"));
-iCNGenerator->GenerateSidPacket(playBuffer, iDataBuffer->RequestSize());
+iCNGenerator->GenerateSidPacket(playBuffer,
+iDataBuffer->RequestSize());
 // Used for talkburst; when talk-burst is over, reset buffer
 // and sequence number
 if (iJBConfig.iJBInactivityTimeOut > 0 && iInactivityTime >= 0)
 {
 // Currently it is only used for AMR codec.
 iInactivityTime += iSampleInterval;
 if (iInactivityTime >= iJBConfig.iJBInactivityTimeOut)
 {
 TRACE_PRN_N1(_L("JB-> [GET] Inactivity Time Detected [%d]"),
 iInactivityTime);
 iInactivityTime = -1;
 ResetBuffer();
 }
 }
 }
 if (iPacketsInBuffer < iCurrentPlayThreshold)
 {
 // Give comfort noise when we are buffering before playback starts
 TRACE_PRN_N(_L("JB-> [GET] THRESHOLD NOT REACHED"));
 iCNGenerator->GenerateSidPacket(playBuffer,
 iDataBuffer->RequestSize());
 }
 else
 {
 // Reset threshold, so we can  play current talk-spurt till the
 // end without affecting speech quality. This means that we will
 // play the buffer until it is empty. After that, it is either
 // DTX period or packet loss.
 iCurrentPlayThreshold = 0;
 // The actual sequence number which is in the buffer
-//            const TInt64 frameToPlay(
+//const TInt64 frameToPlay(
-//                         iBuffer[iPacketsInBuffer - 1].iSequenceNumber);
+//iBuffer[iPacketsInBuffer - 1].iSequenceNumber);
 TRACE_PRN_N1(_L("JB-> [GET] FRAME TO PLAY [%d]"),
 TInt32(iBuffer[iPacketsInBuffer - 1].iSequenceNumber));
 TRACE_PRN_N1(_L("JB-> [GET] LAST PLAYED   [%d]"),
 TInt32(iLastPlayedSeqNum));
 TRACE_PRN_N1(_L("JB-> [GET] PACKETS [%d]"), iPacketsInBuffer);
 // Get next in order frame to play
 TJitterBufferElement& jbElement = iBuffer[iPacketsInBuffer - 1];
-if (playBuffer.MaxLength() >= jbElement.iDataFrame->Data().Length())
+if (playBuffer.MaxLength() >=
+jbElement.iDataFrame->Data().Length())
 {
 playBuffer.Copy(jbElement.iDataFrame->Data());
 }
 else
 {
 TRACE_PRN_N1(_L("JB-> [GET] ERROR: BUFFER TOO SMALL [%d]"),
 playBuffer.MaxLength());
 iCNGenerator->GenerateSidPacket(playBuffer,
 iDataBuffer->RequestSize());
 }
 iLastPlayedSeqNum = jbElement.iSequenceNumber;
 jbElement.iSequenceNumber = -1;
 jbElement.iTimeStamp = -1;
 iPacketsInBuffer--;
 // Reset inactivity timeout timer
 iInactivityTime = 0;
+#ifdef __FEATURE_NOT_SUPPORTED__
 // Try to lead new buffer to DTX period
 iCNGenerator->DoDtxDecision(playBuffer);
-}
+#endif //__FEATURE_NOT_SUPPORTED__
 }
+}
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::FindLargestSeqNum
 // CVoIPJitterBufferImpl::InsertBufferElement
 // Insert Buffer Element
 // -----------------------------------------------------------------------------
 //
 void CVoIPJitterBufferImpl::InsertBufferElement(const TDesC8& aBuffer,
 TInt64 aLargestSeqNum)
 {
-//    TRACE_PRN_FN_ENT;
+/* if (aBuffer.Length() == 0 || aBuffer.Length() > iFrameSize)
-/*    if (aBuffer.Length() == 0 || aBuffer.Length() > iFrameSize)
 {
 TRACE_PRN_N(_L("JB->INVALID DATA, IGNORING"));
 return;
 }*/
 const TInt len(BufferLength());
 if (iIsWrappedAround)
 {
-iBuffer[len-1].iDataFrame->Data().Copy(aBuffer);
+iBuffer[len - 1].iDataFrame->Data().Copy(aBuffer);
-iBuffer[len-1].iSequenceNumber = iCurrentSeqNum;
+iBuffer[len - 1].iSequenceNumber = iCurrentSeqNum;
 for (TInt i = 0; i < len; i++)
 {
 if (iBuffer[i].iTimeStamp > aLargestSeqNum)
 {
 aLargestSeqNum = iBuffer[i].iTimeStamp;
 }
 }
-iBuffer[len-1].iTimeStamp = aLargestSeqNum + 1;
+iBuffer[len - 1].iTimeStamp = aLargestSeqNum + 1;
 iBuffer.Sort(iBufStampSorter);
 iLastPlayedSeqNum = -1;
 }
 else
 {
-iBuffer[len-1].iDataFrame->Data().Copy(aBuffer);
+iBuffer[len - 1].iDataFrame->Data().Copy(aBuffer);
-iBuffer[len-1].iSequenceNumber = iCurrentSeqNum;
+iBuffer[len - 1].iSequenceNumber = iCurrentSeqNum;
-iBuffer[len-1].iTimeStamp = iCurrentSeqNum - BufferLength();
+iBuffer[len - 1].iTimeStamp = iCurrentSeqNum - BufferLength();
 iBuffer.Sort(iBufSequenceSorter);
 }
 iPacketsInBuffer++;
-//    TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::BufferLength()
 // Return buffer length.
 TInt CVoIPJitterBufferImpl::BufferLength() const
 {
 return iBufferLength;
 }
+#ifdef __FEATURE_NOT_SUPPORTED__
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::PacketCount()
 // Return number of packets that are currently in the buffer.
 // -----------------------------------------------------------------------------
 //
 TInt CVoIPJitterBufferImpl::PacketCount() const
 {
 return iPacketsInBuffer;
 }
+#endif //__FEATURE_NOT_SUPPORTED__
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::IsFull()
 // Return:    True if full
 //            False if not full
 // This is because of network packet loss, where there might be gaps between
 // frame sequence numbers.
 // -----------------------------------------------------------------------------
 //
 TBool CVoIPJitterBufferImpl::IsSeqNumWrappedAround(TInt64 aSeqNum1,
 TInt64 aSeqNum2) const
 {
 TBool status = EFalse;
 if (aSeqNum1 >= (KMaxSeqNumber - iSeqNumIncrement) &&
 aSeqNum2 <= (iBufferLength * iSeqNumIncrement))
 {
 TRACE_PRN_N(_L("JB-> SEQUENCE WRAPPED-AROUND"));
 status = ETrue;
 }
 return status;
 }
+#ifdef __FEATURE_NOT_SUPPORTED__
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::GenerateStatistics
 // Generates the statistics from the jitterbuffer
 // -----------------------------------------------------------------------------
 //
 void CVoIPJitterBufferImpl::GenerateStatistics(/*TJBStats& aStats*/) const
-{/*
+{
 aStats.iFramesReceived = iFramesReceived;
 aStats.iBufferLength = iBufferLength;
 aStats.iFramesInBuffer = iPacketsInBuffer;
 aStats.iFrameLoss = iFramesLost;
 aStats.iLateFrames = iNumOfLateFrames;
 aStats.iFramesRemoved = iFramesRemoved;
-aStats.iFramesPlayed = iFramesPlayed;*/
+aStats.iFramesPlayed = iFramesPlayed;
 }
+#endif //__FEATURE_NOT_SUPPORTED__
 // -----------------------------------------------------------------------------
 // CVoIPJitterBufferImpl::CheckThresholdBufferLength
 // -----------------------------------------------------------------------------
 //
 void CVoIPJitterBufferImpl::CheckThresholdBufferLength(TInt& aBufferLength,
 TInt aTreshhold) const
 {
 const TInt numTen = 10;
 if ((aBufferLength - aTreshhold) < numTen)
 {
 aBufferLength = aTreshhold + numTen;
 }
 }
 //  End of File

changeset 53	eabc8c503852
parent 0	71ca22bcf22a