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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

ESSynchronizer.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: ESSynchonizer.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 "ESSynchronizer.hpp"
//#include <SDL.h>



ESSynchronizer::ESSynchronizer(ESInfo* esi, GlobalTimer * globalTimer) {
        gettimeofday(&tv,NULL);
        
        this->globalTimer = globalTimer;
        cond_pause_mutex.initialize("ESSync-Cond_Pause_Mutex");
        cond_pause.initialize();
        paused = false;
        es=esi;
        strcpy(name,"ESSynchronizer");
        outputRate = 1.0;
        frmCount = 0;
        dropCount = 0;
}


ESSynchronizer::~ESSynchronizer() {
  cond_pause.destroy();
  cond_pause_mutex.destroy();
}


void ESSynchronizer::initialize() {
}


bool ESSynchronizer::setOutputRateFactor(double factor) {
  if (factor <= 0.0 || !globalTimer)
    return false;
  globalTimer->setPaused(true);
  globalTimer->adjust(globalTimer->getActualSec() * outputRate / factor);
  outputRate = factor;
  globalTimer->setPaused(false);
  return true;
}


bool ESSynchronizer::adjust(double sec) {
  if (!globalTimer || sec < 0.0)
    return false;
  globalTimer->adjust(sec / outputRate);
  return true;
}


void ESSynchronizer::setPaused(bool pause) {
  cond_pause_mutex.lock();
  paused = pause;
  if (!paused)
          cond_pause.signal();
  cond_pause_mutex.release();
}


/***************************************************************/
list < Frame * > ESSynchronizer::adapt(Frame * frm) {
        bool forwardFrame = false;
        list < Frame * >tmp;
        int act_wait;
        double t, tframe;

        /* block until not paused */
        cond_pause_mutex.lock();
        while (paused) {
          dprintf_full("ESSynchronizer::adapt() PAUSED @ %4.2f sec, frame %i\n",
                       globalTimer->getActualSec(), frm->getAU()->cts);
          cond_pause.condWait(cond_pause_mutex.getMutexObject());
        }
        cond_pause_mutex.release();

        tmp.push_front(frm);
        
        //TURN OFF SYNC IF BENCHMARKING NETWORK!
#ifdef NETBENCH
#define FORCE_DISPLAY
#endif

#ifdef FORCE_DISPLAY
        forwardFrame = true;
#endif
        
        Frame::FrameType myType = frm->getType();


#ifndef LOCALBENCH
        if ((myType == Frame::I_VOP) || (myType == Frame::P_VOP) || (myType == Frame::HEADER_VOP))
                forwardFrame = true;
#endif

        if(myType == Frame::NN_VOP || myType == Frame::MP3_AUDIO)
                forwardFrame = true;
        

        if (frmCount == 0) //always show first frame!
                forwardFrame = true;

        frmCount++;

        // a bypassing YUV_VOP or RGB_VOP is fully subjected to dropping, if time is out!

        if(frm->getMediaTimeScale() == 0)
                frm->setMediaTimeScale(es->getMediaTimeScale());

        assert(frm->getMediaTimeScale() != 0);
        t = (double) frm->getMediaTimeScale();
        if (outputRate != 1.0)
          t *= outputRate;
        tframe = (double)frm->getAU()->cts / t; // play-out time in seconds
        act_wait = (int) ((tframe - globalTimer->getActualSec()) * 1000.0 );

        //dprintf_full("ESSynchronizer::adapt() frame type=%d   forwarding=%d  cts=%d  timescale(t)=%f  tframe=%f\n", 
        //                      myType, forwardFrame, frm->getAU()->cts, t, tframe);

        /* Detect discontinuity in stream and re-synchronize GlobalTimer.
         * Re-synchronization is done only if the current frame is *ahead*
         * of play-out time to avoid competing with 
         * SDLaudioIO:sdl_audio_callback().
         */
        if (act_wait > ESSYNC_DISCONT_MSECS) {
          dprintf_small("ESSynchronizer::adapt() detected stream discontinuity (%d > %d, "
                        "re-synchronizing globalTimer to %4.2f sec\n", act_wait, ESSYNC_DISCONT_MSECS, tframe);
          globalTimer->adjust(tframe);
          act_wait = 0;
        }

        //dprintf_full("ESSynchronizer::adapt @ %4.2f sec, outputRate %5.3f, frameCTS %i (size %i) -> act_wait: %i\n", 
        //           globalTimer->getActualSec(), outputRate, frm->getAU()->cts, frm->getAU()->size,act_wait);

        if (act_wait > (-1) * ESSYNC_GRACE_MSECS) {
                forwardFrame = true;
        }

        if (forwardFrame) {
                if(act_wait >= 10 /*&& frm->getType() != Frame::MP3_AUDIO*/)
                        msleep(act_wait);
        } else { //not forward frame
                dprintf_err("ESSynchronizer::adapt  -> act_wait: %i DROPPING frame (dropCount=%d) ... missed CTS %i!!!\n",
                                                                act_wait, ++dropCount, frm->getAU()->cts);
                //deletion is done in DataChannel!
                frm->markForDelete();
                return tmp;
        }
        
        return tmp;
}

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