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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

GlobalTimer.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       GlobalTimer.cpp                                               *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * 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:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#include "GlobalTimer.hpp"

/* condition represented by cond_block */
#define COND_NOT_BLOCKED     (pauseRefCnt.getUsage() == 0 && prefetchRefCnt.getUsage() == 0)


GlobalTimer::GlobalTimer() {            
        dprintf_full("GlobalTimer::  Construct\n");
        cond_block.initialize();
        cond_block_mutex.initialize("GlobalTimer-cond_block_mutex");
        time_mutex.initialize("GlobalTimer-time_mutex");
        strcpy(name,"GlobalTimer");
        reset();
}


GlobalTimer::~GlobalTimer() {
        dprintf_full("GlobalTimer::~GlobalTimer\n");
        cond_block.destroy();
        cond_block_mutex.destroy();
        time_mutex.destroy();
}


void GlobalTimer::reset() {
        dprintf_full("GlobalTimer::reset\n");

        cond_block_mutex.lock();
        es=NULL;
        firstFrame = true;
        wasBlocked = false;
        dropUntil = 0;
        pauseRefCnt.reset();
        prefetchRefCnt.reset();

        time_mutex.lock();
        now_dtime = 0.0;
        start_dtime = 0.0;
        actualSec = 0.0;
        time_mutex.release();

        cond_block.broadcast();
        cond_block_mutex.release();
}


void GlobalTimer::initialize() {
  reset();
}


void GlobalTimer::setPaused(bool setPause) {  
  cond_block_mutex.lock();
  if (setPause) {
    pauseRefCnt.increase();
  } else {
    wasBlocked = !COND_NOT_BLOCKED;
    pauseRefCnt.decrease();
    if (COND_NOT_BLOCKED)
                cond_block.broadcast();
  }
  dprintf_full("GlobalTimer::setPaused(%s) Number of Pausers now: %i\n",
               setPause ? "true" : "false", pauseRefCnt.getUsage());
  cond_block_mutex.release();
}


void GlobalTimer::setPrefetching(bool setPrefetching) {
  cond_block_mutex.lock();
  if (setPrefetching) {
    prefetchRefCnt.increase();
  } else {
    wasBlocked = !COND_NOT_BLOCKED;
    prefetchRefCnt.decrease();
    if (COND_NOT_BLOCKED)
                cond_block.broadcast();
  }
  dprintf_full("GlobalTimer::setPrefetching(%s) Number of Prefetchers now: %i\n",
               setPrefetching ? "true" : "false", prefetchRefCnt.getUsage());
  cond_block_mutex.release();
}


double GlobalTimer::getActualSec() {
  if (start_dtime == 0.0)
    return 0.0;
  if (!isPaused()) {
    time_mutex.lock();
    gettimeofday(&tv,NULL);
    now_dtime =  tv.tv_sec + tv.tv_usec/1000000.0;
    actualSec = now_dtime - start_dtime;
    time_mutex.release();
  }
  return actualSec;
}


void GlobalTimer::dropFramesUntil(u32 cts) {
  dprintf_full("GlobalTimer::dropFramesUntil(cts = %u)\n", cts);
  dropUntil = cts;
}


/***************************************************************/
//called by AudioIO
void GlobalTimer::adjustToTS(int ts, int mediaTimeScale) {
        double diff;

        assert(mediaTimeScale != 0);
        time_mutex.lock();
        gettimeofday(&tv,NULL);
        now_dtime =  tv.tv_sec + tv.tv_usec/1000000.0;
        diff = (start_dtime + (double)ts / (double)mediaTimeScale) - now_dtime;
        start_dtime -= diff;
        dprintf_full("GlobalTimer::adjustToTS %i (scale %i) adjusts by %i msecs\n",ts,mediaTimeScale,(int)(diff*1000.0));
        time_mutex.release();
}


void GlobalTimer::adjust(double sec) {
  time_mutex.lock();
  gettimeofday(&tv, NULL);
  now_dtime =  tv.tv_sec + tv.tv_usec/1000000.0;
  start_dtime = now_dtime - sec;
  time_mutex.release();
}


/***************************************************************/
list < Frame * > GlobalTimer::adapt(Frame * frm) {
  list < Frame * >tmp;
  assert(frm);
  if (dropUntil && frm->getAU()->cts < dropUntil) {
    dprintf_full("GlobalTimer::adapt() dropUntil = %u, DROPPING frame CTS %u\n",
                 dropUntil, frm->getAU()->cts);
    return tmp;
  }
  cond_block_mutex.lock();
  while (!COND_NOT_BLOCKED) {
    dprintf_full("GlobalTimer(%p)::adapt blocking on CTS %u (Pausers %d, Prefetchers %d)\n",
                 this, ( (frm&&frm->getAU()) ? frm->getAU()->cts : (unsigned)-1 ),
                 pauseRefCnt.getUsage(), prefetchRefCnt.getUsage());
        cond_block.condWait(cond_block_mutex.getMutexObject());
  }

  if(frm) {
    tmp.push_front(frm);
        
    time_mutex.lock();
    gettimeofday(&tv,NULL);
    if(wasBlocked) { //adjust base time
      wasBlocked = false;
      double pause_dtime = now_dtime; //store old dtime
      now_dtime =  tv.tv_sec + tv.tv_usec/1000000.0;
      start_dtime += (now_dtime - pause_dtime);
      actualSec = now_dtime - start_dtime;
    }
                
    now_dtime =  tv.tv_sec + tv.tv_usec/1000000.0;
    if (firstFrame) {
      firstFrame = false;
      start_dtime = now_dtime;
    }
    actualSec = now_dtime - start_dtime;
    dprintf_full("GlobalTimer::adapt forwarding frame CTS %u at time %2.3f\n",
                 ( (frm&&frm->getAU()) ? frm->getAU()->cts : (unsigned)-1 ),
                 actualSec);
    time_mutex.release();
  }
  cond_block_mutex.release();
  return tmp;
}

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