void* RTPSessionInterface::CurrentBitRate(QTSSDictionary* inSession, UInt32* outLen)
{
RTPSessionInterface* theSession = (RTPSessionInterface*)inSession;
theSession->UpdateBitRateInternal(OS::Milliseconds());
// Return the result
*outLen = sizeof(theSession->fMovieCurrentBitRate);
return &theSession->fMovieCurrentBitRate;
}
void* RTPSessionInterface::TimeConnected(QTSSDictionary* inSession, UInt32* outLen)
{
RTPSessionInterface* theSession = (RTPSessionInterface*)inSession;
theSession->fTimeConnected = (OS::Milliseconds() - theSession->GetSessionCreateTime());
// Return the result
*outLen = sizeof(theSession->fTimeConnected);
return &theSession->fTimeConnected;
}
void QTSServerInterface::KillAllRTPSessions()
{
OSMutexLocker locker(fRTPMap->GetMutex());
for (OSRefHashTableIter theIter(fRTPMap->GetHashTable()); !theIter.IsDone(); theIter.Next())
{
OSRef* theRef = theIter.GetCurrent();
RTPSessionInterface* theSession = (RTPSessionInterface*)theRef->GetObject();
theSession->Signal(Task::kKillEvent);
}
}
void* RTPSessionInterface::PacketLossPercent(QTSSDictionary* inSession, UInt32* outLen)
{
RTPSessionInterface* theSession = (RTPSessionInterface*)inSession;
RTPStream* theStream = NULL;
UInt32 theLen = sizeof(theStream);
SInt64 packetsLost = 0;
SInt64 packetsSent = 0;
for (int x = 0; theSession->GetValue(qtssCliSesStreamObjects, x, (void*)&theStream, &theLen) == QTSS_NoErr; x++)
{
if (theStream != NULL)
{
UInt32 streamCurPacketsLost = 0;
theLen = sizeof(UInt32);
(void)theStream->GetValue(qtssRTPStrCurPacketsLostInRTCPInterval, 0, &streamCurPacketsLost, &theLen);
//qtss_printf("stream = %d streamCurPacketsLost = %" _U32BITARG_ " \n",x, streamCurPacketsLost);
UInt32 streamCurPackets = 0;
theLen = sizeof(UInt32);
(void)theStream->GetValue(qtssRTPStrPacketCountInRTCPInterval, 0, &streamCurPackets, &theLen);
//qtss_printf("stream = %d streamCurPackets = %" _U32BITARG_ " \n",x, streamCurPackets);
packetsSent += (SInt64)streamCurPackets;
packetsLost += (SInt64)streamCurPacketsLost;
//qtss_printf("stream calculated loss = %f \n",x, (Float32) streamCurPacketsLost / (Float32) streamCurPackets);
}
theStream = NULL;
theLen = sizeof(UInt32);
}
//Assert(packetsLost <= packetsSent);
if (packetsSent > 0)
{
if (packetsLost <= packetsSent)
theSession->fPacketLossPercent = (Float32)((((Float32)packetsLost / (Float32)packetsSent) * 100.0));
else
theSession->fPacketLossPercent = 100.0;
}
else
theSession->fPacketLossPercent = 0.0;
//qtss_printf("Session loss percent packetsLost = %qd packetsSent= %qd theSession->fPacketLossPercent=%f\n",packetsLost,packetsSent,theSession->fPacketLossPercent);
// Return the result
*outLen = sizeof(theSession->fPacketLossPercent);
return &theSession->fPacketLossPercent;
}
RTPSessionInterface* RTPStatsUpdaterTask::GetNewestSession(OSRefTable* inRTPSessionMap)
{
//Caller must lock down the RTP session map
SInt64 theNewestPlayTime = 0;
RTPSessionInterface* theNewestSession = NULL;
//use the session map to iterate through all the sessions, finding the most
//recently connected client
for (OSRefHashTableIter theIter(inRTPSessionMap->GetHashTable()); !theIter.IsDone(); theIter.Next())
{
OSRef* theRef = theIter.GetCurrent();
RTPSessionInterface* theSession = (RTPSessionInterface*)theRef->GetObject();
Assert(theSession->GetSessionCreateTime() > 0);
if (theSession->GetSessionCreateTime() > theNewestPlayTime)
{
theNewestPlayTime = theSession->GetSessionCreateTime();
theNewestSession = theSession;
}
}
return theNewestSession;
}
SInt64 RTPStatsUpdaterTask::Run()
{
QTSServerInterface* theServer = QTSServerInterface::sServer;
// All of this must happen atomically wrt dictionary values we are manipulating
OSMutexLocker locker(&theServer->fMutex);
//First update total bytes. This must be done because total bytes is a 64 bit number,
//so no atomic functions can apply.
//
// NOTE: The line below is not thread safe on non-PowerPC platforms. This is
// because the fPeriodicRTPBytes variable is being manipulated from within an
// atomic_add. On PowerPC, assignments are atomic, so the assignment below is ok.
// On a non-PowerPC platform, the following would be thread safe:
//unsigned int periodicBytes = atomic_add(&theServer->fPeriodicRTPBytes, 0);
unsigned int periodicBytes = theServer->fPeriodicRTPBytes;
(void)atomic_sub(&theServer->fPeriodicRTPBytes, periodicBytes);
theServer->fTotalRTPBytes += periodicBytes;
// Same deal for packet totals
unsigned int periodicPackets = theServer->fPeriodicRTPPackets;
(void)atomic_sub(&theServer->fPeriodicRTPPackets, periodicPackets);
theServer->fTotalRTPPackets += periodicPackets;
// ..and for lost packet totals
unsigned int periodicPacketsLost = theServer->fPeriodicRTPPacketsLost;
(void)atomic_sub(&theServer->fPeriodicRTPPacketsLost, periodicPacketsLost);
theServer->fTotalRTPPacketsLost += periodicPacketsLost;
SInt64 curTime = OS::Milliseconds();
//for cpu percent
Float32 cpuTimeInSec = GetCPUTimeInSeconds();
//also update current bandwidth statistic
if (fLastBandwidthTime != 0)
{
Assert(curTime > fLastBandwidthTime);
UInt32 delta = (UInt32)(curTime - fLastBandwidthTime);
if (delta < 1000)
WarnV(delta >= 1000, "Timer is off");
//do the bandwidth computation using floating point divides
//for accuracy and speed.
Float32 bits = (Float32)(periodicBytes * 8);
Float32 theTime = (Float32)delta;
theTime /= 1000;
bits /= theTime;
Assert(bits >= 0);
theServer->fCurrentRTPBandwidthInBits = (UInt32)bits;
// okay let's do it for MP3 bytes now
bits = (Float32)(((SInt64)theServer->fTotalMP3Bytes - fLastTotalMP3Bytes) * 8);
bits /= theTime;
theServer->fCurrentMP3BandwidthInBits = (UInt32)bits;
//do the same computation for packets per second
Float32 packetsPerSecond = (Float32)periodicPackets;
packetsPerSecond /= theTime;
Assert(packetsPerSecond >= 0);
theServer->fRTPPacketsPerSecond = (UInt32)packetsPerSecond;
//do the computation for cpu percent
Float32 diffTime = cpuTimeInSec - theServer->fCPUTimeUsedInSec;
theServer->fCPUPercent = (diffTime/theTime) * 100;
UInt32 numProcessors = OS::GetNumProcessors();
if (numProcessors > 1)
theServer->fCPUPercent /= numProcessors;
}
fLastTotalMP3Bytes = (SInt64)theServer->fTotalMP3Bytes;
fLastBandwidthTime = curTime;
// We use a running average for avg. bandwidth calculations
theServer->fAvgMP3BandwidthInBits = (theServer->fAvgMP3BandwidthInBits
+ theServer->fCurrentMP3BandwidthInBits)/2;
//for cpu percent
theServer->fCPUTimeUsedInSec = cpuTimeInSec;
//also compute average bandwidth, a much more smooth value. This is done with
//the fLastBandwidthAvg, a timestamp of the last time we did an average, and
//fLastBytesSent, the number of bytes sent when we last did an average.
if ((fLastBandwidthAvg != 0) && (curTime > (fLastBandwidthAvg +
(theServer->GetPrefs()->GetAvgBandwidthUpdateTimeInSecs() * 1000))))
{
UInt32 delta = (UInt32)(curTime - fLastBandwidthAvg);
SInt64 bytesSent = theServer->fTotalRTPBytes - fLastBytesSent;
Assert(bytesSent >= 0);
//do the bandwidth computation using floating point divides
//for accuracy and speed.
Float32 bits = (Float32)(bytesSent * 8);
Float32 theAvgTime = (Float32)delta;
theAvgTime /= 1000;
bits /= theAvgTime;
Assert(bits >= 0);
theServer->fAvgRTPBandwidthInBits = (UInt32)bits;
fLastBandwidthAvg = curTime;
fLastBytesSent = theServer->fTotalRTPBytes;
//if the bandwidth is above the bandwidth setting, disconnect 1 user by sending them
//a BYE RTCP packet.
SInt32 maxKBits = theServer->GetPrefs()->GetMaxKBitsBandwidth();
if ((maxKBits > -1) && (theServer->fAvgRTPBandwidthInBits > ((UInt32)maxKBits * 1024)))
{
//we need to make sure that all of this happens atomically wrt the session map
OSMutexLocker locker(theServer->GetRTPSessionMap()->GetMutex());
RTPSessionInterface* theSession = this->GetNewestSession(theServer->fRTPMap);
if (theSession != NULL)
if ((curTime - theSession->GetSessionCreateTime()) <
theServer->GetPrefs()->GetSafePlayDurationInSecs() * 1000)
theSession->Signal(Task::kKillEvent);
}
}
else if (fLastBandwidthAvg == 0)
{
fLastBandwidthAvg = curTime;
fLastBytesSent = theServer->fTotalRTPBytes;
}
(void)this->GetEvents();//we must clear the event mask!
return theServer->GetPrefs()->GetTotalBytesUpdateTimeInSecs() * 1000;
}
