Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

SimpleStatistics.cpp

#ifndef WINCE

#include "SimpleStatistics.hpp"
#include <assert.h>
#include "ESInfo.hpp"
#include "sord/directory.h"
#include "sord/entry.h"

SimpleStatistics::SimpleStatistics(const char* saveToFileName,const ESInfo* esi, bool s,
                                                                                                                                         bool overwriteFileIfExists): serverMode(s)
{
        assert(saveToFileName);
        assert(VITOOKI_SIMPLESTATISTICS_MAXSECONDS%2==0);
        
        memset(fileName,0,MAX_STR_LEN);
        strncpy(fileName,saveToFileName,MAX_STR_LEN-1);
        es=esi;
        if(overwriteFileIfExists) {
                FILE* fp=fopen(fileName,"wb"); // deletes the file
                if(fp)
                        fclose(fp);
        }
        currentPos=-1;lastNotSavedPos=0;
        lastSecSaved=0;
        playCalled=false;teardownCalled=false;
        startUpDelayInMS=lastCTS=lastGetCTS=0;
        highestCTSSeen=0;
};

SimpleStatistics::~SimpleStatistics() {
        if(!teardownCalled)
                teardown();
};
        
void SimpleStatistics::insertFrame(u32 cts, u32 bytes,u32 seqNrStart,u32 seqNrEnd)
{
        assert(seqNrStart<=seqNrEnd);
        if(currentPos==-1) {
                // initial insert, measure startup delay
                struct timeval t;
                gettimeofday(&t,NULL);
                s32 tmp=SimpleStatistics::calcDiffInMS(startTime,t);
                if(tmp<0) {
                        dprintf_err("SimpleStatistics::insertFrame: Negative startupDelay!\n");
                        tmp=0;
                }
                startUpDelayInMS=(u32)tmp;
        }
        // detect when we have a new second
        detectNewSecond();
        // now add the frame
        // in clientmode the "In" values are increased
        if(!serverMode) {
                stats[currentPos].numBytesIn+=bytes;
                stats[currentPos].numFramesIn++;
                stats[currentPos].numPacketsIn+=(seqNrEnd-seqNrStart+1);
        }
        else { // in server mode the "out" values
                stats[currentPos].numBytesOut+=bytes;
                stats[currentPos].numFramesOut++;
                stats[currentPos].numPacketsOut+=(seqNrEnd-seqNrStart+1);
        }
        // check TS
        if(stats[currentPos].firstTS>seqNrStart)
                stats[currentPos].firstTS=seqNrStart;
        if(stats[currentPos].lastTS<seqNrEnd)
                stats[currentPos].lastTS=seqNrEnd;
        // check CTS
        if(stats[currentPos].firstCTS>cts)
                stats[currentPos].firstCTS=cts;
        if(stats[currentPos].lastCTS<cts)
                stats[currentPos].lastCTS=cts;  
                
        // adding a frame increases buffer in clientMode
        if(!serverMode) {
                stats[currentPos].bytesBuffered+=bytes;
                stats[currentPos].packetsBuffered+=(seqNrEnd-seqNrStart);
                // calc ms depending on the cts range
                // catch out of order inserts
                if(cts>highestCTSSeen)
                        highestCTSSeen=cts;
                u32 msDiff=(u32)(1000*(highestCTSSeen-lastGetCTS))/(es->getMediaTimeScale());
                if(msDiff>stats[currentPos].msBuffered)
                        stats[currentPos].msBuffered=msDiff;
                dprintf_full("SimpleStatistics::insertFrame lastCTSIn %u lastCTSOut %u msDiff %u\n",cts,lastGetCTS,msDiff);
        }
}
void SimpleStatistics::insertPacket(u32 cts, u32 bytes, u32 seqNr, bool firstPacketOfFrame)
{
        if(currentPos==-1) {
                // initial insert, measure startup delay
                struct timeval t;
                gettimeofday(&t,NULL);
                s32 tmp=SimpleStatistics::calcDiffInMS(startTime,t);
                if(tmp<0) {
                        dprintf_err("SimpleStatistics::insertFrame: Negative startupDelay!\n");
                        tmp=0;
                }
                startUpDelayInMS=(u32)tmp;
                stats[0].firstCTS=0;
        }
        // detect when we have a new second
        detectNewSecond();
        if(cts>highestCTSSeen)
                        highestCTSSeen=cts;
        // now add the packet
        // in clientmode the "In" values are increased
        if(!serverMode) {
                stats[currentPos].numBytesIn+=bytes;
                if(firstPacketOfFrame)
                        stats[currentPos].numFramesIn++;
                stats[currentPos].numPacketsIn++;
        }
        else { // in server mode the "out" values
                stats[currentPos].numBytesOut+=bytes;
                if(firstPacketOfFrame)
                        stats[currentPos].numFramesOut++;
                stats[currentPos].numPacketsOut++;
        }
        // check TS
        if(stats[currentPos].firstTS>seqNr)
                stats[currentPos].firstTS=seqNr;
        if(stats[currentPos].lastTS<seqNr)
                stats[currentPos].lastTS=seqNr;
        // check CTS, do not include headers!
        if(cts!=0) {
                if(stats[currentPos].firstCTS>cts)
                        stats[currentPos].firstCTS=cts;
                if(stats[currentPos].lastCTS<cts)
                        stats[currentPos].lastCTS=cts;          
        }
        // adding a packet increases buffer in clientMode
        if(!serverMode) {
                stats[currentPos].bytesBuffered+=bytes;
                stats[currentPos].packetsBuffered++;
                // calc ms depending on the cts range
                // catch out of order inserts
                u32 msDiff=(u32)(1000*(highestCTSSeen-lastGetCTS))/(es->getMediaTimeScale());
                // catch packets sent out-of-order
                if(msDiff>stats[currentPos].msBuffered)
                        stats[currentPos].msBuffered=msDiff;
                dprintf_full("SimpleStatistics::insertPacket lastCTSIn %u lastCTSOut %u msDiff %u buf %u\n",
                        cts,lastGetCTS,msDiff,stats[currentPos].msBuffered);
        }
};

void SimpleStatistics::detectNewSecond()
{
        if(currentPos==-1 || (currentPos>=0 && stats[currentPos].second!=SimpleStatistics::getCurrentSecond())) {
                u32 curBufferMS=0;u32 curBufferPak=0;u32 curBytesBuf=0;
                if(currentPos>=0) {
                        // copy buffer from last, but only in clientMode!
                        if(!serverMode) {
                                curBufferMS=stats[currentPos].msBuffered;
                                curBufferPak=stats[currentPos].packetsBuffered;
                                curBytesBuf=stats[currentPos].bytesBuffered;
                        }
                }
                else { // currentPos is -1
                        lastNotSavedPos=0;
                        stats[0].firstCTS=0;
                }
                currentPos++; // switch to next free position
                if(currentPos==VITOOKI_SIMPLESTATISTICS_MAXSECONDS/2) {
                        // if we enter the second half, save the second half!
                        if(lastNotSavedPos==VITOOKI_SIMPLESTATISTICS_MAXSECONDS/2)
                                saveToFile(lastNotSavedPos,VITOOKI_SIMPLESTATISTICS_MAXSECONDS-1);
                }
                else if(currentPos>=VITOOKI_SIMPLESTATISTICS_MAXSECONDS) { // handle overflow
                        saveToFile(0,VITOOKI_SIMPLESTATISTICS_MAXSECONDS/2-1); // save the lower half to disk
                        currentPos=0; // start from the beginning
                }
                stats[currentPos].reset(SimpleStatistics::getCurrentSecond()); // reset the entry
                // correct buffer entries
                stats[currentPos].msBuffered=curBufferMS;
                stats[currentPos].packetsBuffered=curBufferPak;
                stats[currentPos].bytesBuffered=curBytesBuf;
        }
}

void SimpleStatistics::getFrame(u32 cts,u32 bytes,u32 seqNrStart,u32 seqNrEnd)
{
        // serverMode doesn't support getFrame
        if(!serverMode) {
                // detect when we have a new second
                detectNewSecond();

                // the out values are used as bytes-consumed entries
                stats[currentPos].numBytesOut+=bytes;
                stats[currentPos].numFramesOut++;
                stats[currentPos].numPacketsOut+=(seqNrEnd-seqNrStart+1);
                if(lastGetCTS<cts)
                        lastGetCTS=cts;
                
                                
                // if we get a frame we reduce buffer
                u32 msDiff=(u32)(1000*(highestCTSSeen-lastGetCTS)/(es->getMediaTimeScale()));
                stats[currentPos].msBuffered=msDiff;
                dprintf_full("SimpleStatistics::getFrame lastCTSIn %u lastCTSOut %u msDiff %u\n",highestCTSSeen,lastGetCTS,msDiff);
                stats[currentPos].bytesBuffered-=bytes;
                stats[currentPos].packetsBuffered-=(seqNrEnd-seqNrStart+1);
        }
        
}
void SimpleStatistics::dropInsertedPacket(u32 bytes, u32 seqNr, u32 cts,bool noOtherPacketsWereDroppedForThisFrame)
{
                
        // only available in clientMode
        if(!serverMode) {
                detectNewSecond();
                // now search: to which second does the dropped packet belong
                int index=currentPos;
                bool stop=false;
                while(index>=lastNotSavedPos && !stop) {
                        if(stats[index].firstTS<=seqNr && seqNr<=stats[index].lastTS) {
                                stop=true;
                        }
                        else
                                index--;
                }
                // note if we didn't find a position, we will assume the packet
                // arrived at pos lastNotSavedPos!
                if(index<lastNotSavedPos)
                        index=lastNotSavedPos;
                stats[index].packetsDropped++;
                // now correct buffer values for all entries

                // a dropped packet only reduces buffer
                if(lastGetCTS<cts)
                        lastGetCTS=cts;
                for(int i=index;i<=currentPos;i++) {
                        stats[i].bytesBuffered-=bytes;
                        stats[i].packetsBuffered--;
                        if(noOtherPacketsWereDroppedForThisFrame) {
                                // reduce buffer time by one frame
                                u32 decr=((es->getVOPTimeIncrement()*1000)/es->getMediaTimeScale());
                                if(stats[i].msBuffered>decr)
                                        stats[i].msBuffered-=decr;
                                else
                                        stats[i].msBuffered=0;
                        }
                }
                // Fix possible rounding errors
                u32 msDiff=(u32)(highestCTSSeen-lastGetCTS)/(es->getMediaTimeScale());
                stats[currentPos].msBuffered=msDiff;
                dprintf_full("SimpleStatistics::dropInsertedPacket lastCTSIn %u lastCTSOut %u msDiff %u\n",cts,lastGetCTS,msDiff);
        }
}

void SimpleStatistics::notifyLostPacket(u32 seqNr)
{
        // only available in clientMode
        if(!serverMode) {
                detectNewSecond();
                // now search: to which second does the dropped packet belong
                int index=currentPos;
                bool stop=false;
                while(index>=lastNotSavedPos && !stop) {
                        if(stats[index].firstTS<=seqNr && seqNr<=stats[index].lastTS) {
                                stop=true;
                        }
                        else
                                index--;
                }
                // note if we didn't find a position, we will assume the packet
                // arrived at pos lastNotSavedPos!
                if(index<lastNotSavedPos)
                        index=lastNotSavedPos;
                stats[index].packetsLost++;
        }
};

void SimpleStatistics::play(u32 cts,bool clearBuffers)
{
        detectNewSecond();
        if(!playCalled) {
                gettimeofday(&startTime,NULL);
                playCalled=true;
        }
        else {
                if(clearBuffers) {
                        stats[currentPos].reset(stats[currentPos].second);
                }
        }
};
void SimpleStatistics::pause()
{

};

void SimpleStatistics::teardown()
{
        // save not saved entries
        saveToFile(lastNotSavedPos,currentPos);
        teardownCalled=true;
}


void SimpleStatistics::saveToFile(int startPos,int endPos)
{
        dprintf_full("SimpleStatistics::saveToFile start %i end %i\n",startPos,endPos);
        if(startPos<0 || endPos<0)
                return;
        if(endPos<startPos)
                endPos+=VITOOKI_SIMPLESTATISTICS_MAXSECONDS;
        FILE* fp=fopen(this->fileName,"ab");
        if(!fp) {
                dprintf_err("SimpleStatistics::saveToFile: Failed to save statistic\n");
                return;
        }
        StatEntry tmp(0);
        if(lastSecSaved==0) // the very first time when we save
                lastSecSaved=stats[startPos%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].second;
        
        fprintf(fp,"# sec\t\tpakIn\tbytIn\tfrmIn\tpakOut\tbytOut\tfrmOut\tpakBuf\tbytBuf\tmsBuf\tpakDro\tbegTS\tendTS\tpakLost\tfirstCTS\tlastCTS\n");
        fprintf(fp,"# startupdelayinMS=%u\n",startUpDelayInMS);
        for(int i=startPos;i<=endPos;i++) {
                // empty second? no data received?
                if(stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].firstCTS==0xffffffffu)
                        stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].firstCTS=0;
                if(stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].firstTS==0xffffffffu)
                        stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].firstTS=0;

                while(lastSecSaved<stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].second-1) {
                        // save 0 entries which are not included in the array
                        lastSecSaved++;
                        tmp.reset(lastSecSaved);
                        tmp.firstCTS=tmp.firstTS=0; // no packets seen
                        // buffer did not change!
                        tmp.bytesBuffered=stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].bytesBuffered;
                        tmp.packetsBuffered=stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].packetsBuffered;
                        tmp.msBuffered=stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].msBuffered;
                        saveOneStatEntry(fp,tmp);
                }
                saveOneStatEntry(fp,stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS]);
                lastSecSaved=stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].second;
                stats[i%VITOOKI_SIMPLESTATISTICS_MAXSECONDS].reset(0);
        }
        fclose(fp);
        lastNotSavedPos=(endPos+1)%VITOOKI_SIMPLESTATISTICS_MAXSECONDS;

};

u32 SimpleStatistics::getNumBytesOutLastNSeconds(int n)
{
        detectNewSecond();
        dprintf_full("SimpleStatistics::getNumBytesOutLastNSeconds(int %i)\n",n);
        if(n>30)
                n=30;
        if(n<=0)
                n=1;    
        // start at currentPos, go back in time
        // at most n entries are included in the value  
        u32 lastIncludedSecond=stats[currentPos].second-n+1;
        u32 sumBytesOut=0;
        for(int i=currentPos;i>currentPos-n && stats[i].second>=lastIncludedSecond;i--) {
                dprintf_full("%i:add %u\n",stats[i].second,stats[i].numBytesOut);
                sumBytesOut+=stats[i].numBytesOut;
        }
        return sumBytesOut;
}
SimpleStatistics::StatEntry SimpleStatistics::getSumOfLastNSeconds(int n)
{
        detectNewSecond();
        dprintf_full("SimpleStatistics::getSumOfLastNSeconds(int %i)\n",n);
        if(n>30)
                n=30;
        if(n<=0)
                n=1;    
        // start at currentPos, go back in time
        // at most n entries are included in the value  
        u32 lastIncludedSecond=stats[currentPos].second-n+1;
        StatEntry sumBytesOut(0xffffffff);
        for(int i=currentPos;i>currentPos-n && stats[i].second>=lastIncludedSecond;i--) {
                int j=i;
                if(j<0)
                        j+=VITOOKI_SIMPLESTATISTICS_MAXSECONDS;
                sumBytesOut+=stats[i];
        }
        return sumBytesOut;     
};
void SimpleStatistics::saveOneStatEntry(FILE* fp, const StatEntry& s)
{
        assert(fp);
        char buffer[4096];
        if(s.convertToString(buffer,4096)) {
        fprintf(fp,"%s\n",buffer);
        }
        else {
                dprintf_err("SimpleStatistics::saveOneStatEntry: text truncated and not saved\n");
        }
}

u32 SimpleStatistics::getCurrentSecond()
{
        static struct timeval t;
        gettimeofday(&t,NULL);
        return (u32)t.tv_sec;
}
u32 SimpleStatistics::getCurrentMilliSecond()
{
        static struct timeval t;
        gettimeofday(&t,NULL);
        return (u32)(t.tv_usec/1000);   
}
s32 SimpleStatistics::calcDiffInMS(const struct timeval &oldTime, const struct timeval &newTime) 
{
        return 1000*(newTime.tv_sec-oldTime.tv_sec)+(newTime.tv_usec-oldTime.tv_usec)/1000;
}

bool SimpleStatistics::createGlobalLog(const char* outFile, const char* srcDir, const char* key1, 
        const char* key2, const char* key3)
{
        assert(outFile && srcDir && key1);
        if(!outFile || !srcDir || !key1)
                return false;
        FILE* outFP=fopen(outFile,"wb");
        if(!outFP)
                return false;

        // 1. scan directory
        // 2. extract min+max time values from directory
        // 3. create array of StatEntries
        // 4. sum up StatEntries
        // 5. save result
        sord::directory src(srcDir);
        if(!src) {
                dprintf_err("SimpleStatistics::createGlobalLog: failed to open %s as dir\n",srcDir);
                fclose(outFP);
                return false;
        }
        sord::directory::const_iterator &i = src.begin();
        sord::directory::const_iterator &end = src.end();
        std::list<char*> logFiles;
        char cleanDirName[MAX_STR_LEN];
        char tmpBuffer[MAX_STR_LEN];
        strcpy(cleanDirName,srcDir);
        StatEntry tmpStat;
        if( cleanDirName[strlen(cleanDirName)-1]!='/' &&
                cleanDirName[strlen(cleanDirName)-1]!='\\') {
                strcat(cleanDirName,"/");
        }
        u32 firstTime=0xffffffff;
        u32 lastTime=0;
        u32 invalidFilesFound=0;
        for (; i != end; ++i) {
                // isa file?
                if(i->get_type() == sord::entry::type_regular) {
                        // does it match the key(s)?

                        if(strstr(i->get_name(),key1) &&
                                (key2==NULL || (key2!=NULL && strstr(i->get_name(),key2))) &&
                                (key3==NULL || (key3!=NULL && strstr(i->get_name(),key3)))) {
                                        // found an entry, push it back to list
                                        char* tmpFullFileName=new char[strlen(cleanDirName)+strlen(i->get_name())+1];
                                        sprintf(tmpFullFileName,"%s%s",cleanDirName,i->get_name());
                                        // now verify the entry
                                        FILE* fp=fopen(tmpFullFileName,"rb");
                                        if(fp) {
                                                // try reading the first and last entry
                                                u32 tmpStart=0xffffffff;
                                                u32 tmpEnd=0;
                                                while(!feof(fp)) {
                                                        if(fgets(tmpBuffer,MAX_STR_LEN,fp)) {
                                                                if(StatEntry::createFromString(tmpBuffer,tmpStat)) {
                                                                        // extract the second
                                                                        u32 tmpSec=tmpStat.second;
                                                                        if(tmpSec<tmpStart)
                                                                                tmpStart=tmpSec;
                                                                        if(tmpSec>tmpEnd)
                                                                                tmpEnd=tmpSec;
                                                                }
                                                        }
                                                }
                                                if(tmpEnd!=0 && tmpStart!=0xffffffff) {
                                                        // at least one valid entry is in the file!
                                                        // everything okay, now set the new global range
                                                        if(lastTime<tmpEnd)
                                                                lastTime=tmpEnd;
                                                        if(tmpStart<firstTime)
                                                                firstTime=tmpStart;
                                                        // insert the log file
                                                        logFiles.push_back(tmpFullFileName);
                                                }
                                                else {
                                                        invalidFilesFound++;
                                                        delete[] tmpFullFileName;
                                                }
                                                fclose(fp);
                                        }
                                        else {
                                                invalidFilesFound++;
                                                delete[] tmpFullFileName;
                                        }               
                          }
                }
        }
        if(logFiles.empty()) {
                fclose(outFP);
                return false;
        }
        // now create the array of statEntries
        int arraySize=lastTime-firstTime+1;
        StatEntry* array=new StatEntry[arraySize];
        int j=0;
        // reset the entries
        for(j=0;j<arraySize;j++) {
                array[j].reset(firstTime+j);
        }
        // now parse all entries in the list and sum up
        std::list<char*>::iterator li;
        FILE* logFP=NULL;
        u32 validFilesFound=0;
        while(!logFiles.empty()) {
                li=logFiles.begin();
                logFP=fopen( (*li), "rb");
                if(logFP) {
                        // read all entries
                        while(!feof(logFP)) {
                                if(fgets(tmpBuffer,MAX_STR_LEN,logFP)) {
                                        if(StatEntry::createFromString(tmpBuffer,tmpStat)) {
                                                int idx=tmpStat.second-firstTime;
                                                array[idx]+=tmpStat;
                                        }
                                }
                        }
                        fclose(logFP);
                        validFilesFound++;
                }
                else {
                        invalidFilesFound++;
                }
                delete[] (*li);
                logFiles.pop_front();
        }
        // dump stat to file
        // outFP is already open
        // write header
        fprintf(outFP,"# Found %u valid files, %u invalid files were ignored\n",
                validFilesFound,invalidFilesFound);
        for(j=0;j<arraySize;j++) {
                SimpleStatistics::saveOneStatEntry(outFP,array[j]);
        }
        fclose(outFP);
        return true;
}


#endif //wince

© ViTooKi 2003 :: [Lite version] Created with Doxygen