tick-service.hpp

Go to the documentation of this file.

/*
  TICK-SERVICE.hpp  -  issuing timed callbacks

  Copyright (C)         Lumiera.org
    2009,               Joel Holdsworth <joel@airwebreathe.org.uk>,
                        Hermann Vosseler <Ichthyostega@web.de>

  This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef STEAM_PLAY_TICKSERVICE_H
#define STEAM_PLAY_TICKSERVICE_H


#include "lib/error.hpp"
#include "lib/thread.hpp"

#include <unistd.h>   // for usleep()

#include <functional>
#include <limits>


namespace steam {
namespace node {

  using std::function;
  using std::bind;
  
  
  
  /********************************************************/
  class TickService
    : lib::ThreadJoinable<>
    {
      typedef function<void(void)> Tick;
      volatile uint timespan_;
      
      static const uint POLL_TIMEOUT = 1000;
      
    public:
      TickService (Tick callback)
        : ThreadJoinable("Tick generator (dummy)"
                        , bind (&TickService::timerLoop, this, callback)
                        )
        { 
          INFO (steam, "TickService started.");
        }
      
     ~TickService ()
        {
          timespan_ = 0;
          this->join();
          usleep (200000);    // additional delay allowing GTK to dispatch the last output
          
          INFO (steam, "TickService shutdown.");
        }
      
      
      void activate (uint fps)
        {
          REQUIRE (  0==fps 
                  ||(   1000000/fps < std::numeric_limits<uint>::max() 
                     && 1000000/fps > POLL_TIMEOUT));
          if (fps)
            timespan_ = 1000000/fps; // microseconds per tick
          else
            timespan_ = POLL_TIMEOUT;
        }
      
      
    private:
      void timerLoop(Tick periodicFun)
        {
          timespan_ = POLL_TIMEOUT;
          while (0 < timespan_)
            {
              if (timespan_ > POLL_TIMEOUT)
                periodicFun();
              
              usleep (timespan_);
            }
          TRACE (proc_dbg, "Tick Thread timer loop exiting..."); 
        }

    };
  
  
  
  
}} // namespace steam::node
#endif