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; }