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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

TimeMeasurement.cpp

/***********************************************************************
*                                                                      *
* ViTooKi                                                              *
*                                                                      *
* title: TimeMeasurement.cpp (S H A R E D)                             *
*                                                                      *
*                                                                      *
*                                                                      *
* ITEC institute of the University of Klagenfurt (Austria)             *
* http://www.itec.uni-klu.ac.at                                        *
*                                                                      *
*                                                                      *
* For more information visit the ViTooKi homepage:                     *
* http://ViTooKi.sourceforge.net                                       *
* vitooki-user@lists.sourceforge.net                                   *
* vitooki-devel@lists.sourceforge.net                                  *
*                                                                      *
* This file is part of ViTooKi, a free video toolkit.                  *
* ViTooKi is free software; you can redistribute it and/or             *
* modify it under the terms of the GNU General Public License          *
* as published by the Free Software Foundation; either version 2       *
* of the License, or (at your option) any later version.               *
*                                                                      *
* This program is distributed in the hope that it will be useful,      *
* but WITHOUT ANY WARRANTY; without even the implied warranty of       *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
* GNU General Public License for more details.                         *
*                                                                      *
* You should have received a copy of the GNU General Public License    *
* along with this program; if not, write to the Free Software          *
* Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
* MA  02111-1307, USA.                                                 *
*                                                                      *
***********************************************************************/

/***********************************************************************
*                                                                      *
*  REVISION HISTORY:                                                   *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************/

/***********************************************************************
* Video Session Migration System, 2004                                 *
* Author: Klaus Schoeffmann                                            *
************************************************************************/


#include "TimeMeasurement.hpp"


/***********************************************************************/
TimeMeasurement::TimeMeasurement()
{
  previousSessionDuration = 0;
  duration = 0;
  sections = new vector<TimeSection*>;
}

/***********************************************************************/
TimeMeasurement::~TimeMeasurement()
{
  Globals::sdebug << "\nimeMeasurement::~TimeMeasurement() cleanup...";
  vector<TimeSection*>::iterator iter = sections->begin();
  while (iter != sections->end())
  {
    TimeSection *sect = *iter;
    delete sect;
    iter++;
  }
  sections->clear();
  Globals::sdebug << "\nimeMeasurement::~TimeMeasurement() done!";
}

/***********************************************************************/
void TimeMeasurement::addNewSection(ulong prebuffertime)
{
  Globals::sdebug << "\nTimeMeasurement::addNewSection";
  assert(sections != NULL);
  assert(sections->size() >= 0);
  Globals::sdebug << "\nbefore new ts";
  int sectionNumber = sections->size();
  Globals::sdebug << "\nsections.size = " << sectionNumber;
  Globals::sdebug << "\nprebuffertime = " << prebuffertime;
  //TODO: sometimes the proxy crashes exactly on the next line. However, I do not know why???
  TimeSection *ts = new TimeSection(sectionNumber+1, prebuffertime);
  Globals::sdebug << "\nafter new ts";
  assert(ts != NULL);
  sections->push_back(ts);
  Globals::sdebug << "\nTimeMeasurement:: session added";
}

/***********************************************************************/
void TimeMeasurement::setPreviousSessionDuration(ulong previousSessionDuration)
{
  this->previousSessionDuration = previousSessionDuration;
}

/***********************************************************************/
void TimeMeasurement::setDuration(ulong duration)
{
  this->duration = duration;
}

/***********************************************************************/
ulong TimeMeasurement::getPreviousSessionDuration()
{
  return previousSessionDuration;
}

/***********************************************************************/
ulong TimeMeasurement::getDuration()
{
  return duration;
}

/***********************************************************************/
void TimeMeasurement::startTS()
{
  assert(sections->back() != NULL);

  TimeSection *ts = sections->back();
  ts->start();
}

/***********************************************************************/
void TimeMeasurement::stopTS()
{
  assert(sections->back() != NULL);

  TimeSection *ts = sections->back();
  ts->stop();
}

/***********************************************************************/
void TimeMeasurement::setTSrequestedFrom(ulong reqfrom)
{
  assert(sections->back() != NULL);

  //set range-from value for current time-section
  vector<TimeSection*>::const_iterator iter = sections->end();
  iter--;
  TimeSection *ts = *iter;
  ts->setRequestedFrom(reqfrom);

  //look if there exists a previous time-section
  if (iter != sections->begin())
  {
    //set corrected time-TO on previous time-section
    iter--;
    TimeSection *prevts = *iter;
    prevts->setClientReceived(reqfrom - prevts->getRequestedFrom());
  }

  Globals::sdebug << "\nTimeMeasurement::setTSrequestedFrom(): " << reqfrom;
}


/***********************************************************************/
void TimeMeasurement::setTSserverPlayout(ulong playout)
{
  assert(sections->back() != NULL);

  TimeSection *ts = sections->back();
  ts->setServerPlayout(playout);
}


/***********************************************************************/
void TimeMeasurement::setTSclientPlayout(ulong playout)
{
  assert(sections->back() != NULL);

  TimeSection *ts = sections->back();
  ts->setClientPlayout(playout);
}

/***********************************************************************/
uint TimeMeasurement::getTimeSectionCount()
{
  return sections->size();
}

/***********************************************************************/
ulong TimeMeasurement::getElapsedTime(uint sectionNr, ulong currserverPlayout, ulong currclientPlayout)
{
  assert(sections->back() != NULL);

  Globals::sdebug << "\n********************************\n";
  Globals::sdebug << "\nTimeMeasurement::getElapsedTime() sectionNr=" << sectionNr << ", currserverPlayout=" << currserverPlayout << ", currclientPlayout=" << currclientPlayout;

  //elapsed time, considering all time-sections
  long tmElapsed = 0;

  //cumulative client-received
  //this value contains the duration of all time-sections, which
  //were confirmed by the client
  ulong cumClientReceived = 0;

  //if there was a section-number specified, iterate
  //through the sections only until specified section-number
  uint untilSection = sections->size();
  if (sectionNr != 0)
  {
    untilSection = sectionNr;
  }
  Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): untilSection=" << untilSection;

  //iterate through sections
  vector<TimeSection*>::const_iterator iter = sections->begin();
  for (uint i =1; iter != sections->end() && i <= untilSection; iter++, i++)
  {
    TimeSection *ts = *iter;
    long tsElapsed; //elapsed time of time-section

    if (ts->getMeasuredStarttime() == 0)
    {
      cerr << "\nWARNING: getmeasuredstarttime of timesection " << i << " == 0 !!!" << endl;
    }
    else
    {

      Globals::sdebug << "\nTimeMeasurement::getElapsedTime()" << i << ": ";

      //calculate elapsed time of this time-section
      //if we do not have an endtime yet, use current time as end-time
      Globals::sdebug << "\n\t measuredendtime=" << ts->getMeasuredEndtime() << " ";
      if (ts->getMeasuredEndtime() != 0)
      {
        tsElapsed = ts->getMeasuredEndtime() - ts->getMeasuredStarttime() - ts->getPrebufferTime();
      }
      else
      {
        tsElapsed = ts->getCurrentMsecs() - ts->getMeasuredStarttime() - ts->getPrebufferTime();
      }

      //if session has not been started already, correct value to null
      if (tsElapsed < 0) tsElapsed = 0;

      //if we have a value confirmed by the player for this section, use this instead of
      if (currclientPlayout != 0 && ((iter+1) == sections->end()))
      {
        tmElapsed = currclientPlayout;
        Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): current CLIENT playout chosen";
      }
      else if (ts->getClientReceived() != 0)
      {
        tmElapsed += ts->getClientReceived();
        cumClientReceived += ts->getClientReceived();
        Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): CLIENTRECEIVE(pause) chosen";
        Globals::sdebug << "\t(clientreceived=" << ts->getClientReceived() << " cumclientreceived=" << cumClientReceived << ") ";
      }
      else if (currserverPlayout != 0 && ((iter+1) == sections->end()))
      {
        Globals::sdebug << "\n\t currserverPlayout=" << currserverPlayout;
        //if we have a value confirmed by the player for the last section, use this instead of
        if (i > 1 && cumClientReceived != 0)
        {
          tmElapsed = cumClientReceived + (currserverPlayout - (*(iter-1))->getServerPlayout());
          cumClientReceived = 0; //do not use this value for later sections
          Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): CORRECTED SERVERPLAYOUT chosen";
          Globals::sdebug << "\t corrected clientplayout=" << tmElapsed;
        }
        else
        {
          tmElapsed = currserverPlayout;
          Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): current SERVER playout chosen";
        }
      }
      else
      {

        //if we have a value from the client or the mediaserver, use this instead of
        //(attention!: this value is cumulative)
        //otherwise use calculation above
        if (ts->getClientPlayout() != 0)
        {
          Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): CLIENT playout chosen";
          Globals::sdebug << "(\t clientplayout=" << ts->getClientPlayout() << ") ";
          tmElapsed += ts->getClientPlayout();
        }
        else if (ts->getServerPlayout() != 0)
        {
          Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): SERVER playout chosen";
          Globals::sdebug << "(\t serverplayout=" << ts->getServerPlayout() << ") ";
          //on more than one timesections: if we have a previous section, which
          //were confirmed by the client, add difference to that confirmed value
          if (i > 1 && cumClientReceived != 0)
          {
            tmElapsed = cumClientReceived + (ts->getServerPlayout() - (*(iter-1))->getServerPlayout());
            cumClientReceived = 0; //do not use this value for later sections
            Globals::sdebug << "\n\t corrected clientplayout=" << tmElapsed << " ";
          }
          else
          {
            tmElapsed = ts->getServerPlayout();
          }
        }
        else
        {
          tmElapsed += tsElapsed;
          Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): OWN ESTIMANTION chosen (tmElapsed=" << tmElapsed << ")";
        }

      }
    }
  }

  Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): tmElapsed=" << tmElapsed << " prevSD=" << previousSessionDuration;
  Globals::sdebug << "\nTimeMeasurement::getElapsedTime(): RESULT=" << (tmElapsed + previousSessionDuration);
  Globals::sdebug << "\n********************************\n";

  return tmElapsed + previousSessionDuration;
}

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