diff --git a/src/backend/real-clock.cpp b/src/backend/real-clock.cpp new file mode 100644 index 000000000..b651520f0 --- /dev/null +++ b/src/backend/real-clock.cpp @@ -0,0 +1,72 @@ +/* + Timings - timing specifications for a frame quantised data stream + + Copyright (C) Lumiera.org + 2012, Hermann Vosseler + + 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. + +* *****************************************************/ + + +#include "backend/real-clock.hpp" +#include "lib/time/timequant.hpp" + + + +namespace backend { + + +// using lib::time::PQuant; +// using lib::time::Time; + + namespace { // hidden local details of the service implementation.... + + + } // (End) hidden service impl details + + + /** storage for the singleton accessor, holding + * an instance of the RealClock service */ + lib::Singleton RealClock::_clock; + + + /** Initialise a service to retrieve system time with sufficient precision + */ + RealClock::RealClock () + { + UNIMPLEMENTED ("system clock service"); + } + + RealClock::~RealClock () + { + UNIMPLEMENTED ("disconnect the system clock service"); + } + + + + TimeValue + RealClock::readSystemTime() + { + UNIMPLEMENTED ("access the system clock"); + gavl_time_t ticksSince1970 = 1261440000000000L; + + ENSURE (ticksSince1970 == Time::limited (ticksSince1970)); + return TimeValue::buildRaw_(ticksSince1970); // bypassing the limit check + } + + + +} // namespace backend diff --git a/src/backend/real-clock.hpp b/src/backend/real-clock.hpp new file mode 100644 index 000000000..3ce89342d --- /dev/null +++ b/src/backend/real-clock.hpp @@ -0,0 +1,103 @@ +/* + REAL-CLOCK.hpp - convenience front-end to access the system clock + + Copyright (C) Lumiera.org + 2012, Hermann Vosseler + + 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. + +*/ + +/** @file real-clock.hpp + ** Front-end for simplified access to the current wall clock time. + ** The implementation relies on Lumiera backend functions to access the + ** system clock with a sufficient level of precision. The result is + ** delivered in lumiera's internal \link lib::time::Time time format \endlink + ** + ** @todo WIP-WIP-WIP 3/2012 + ** @todo this might be a good candidate also to provide some kind of + ** translation service, i.e. a grid to anchor a logical time value + ** with actual running wall clock time + ** + ** @see lib/time/timevalue.hpp + */ + + +#ifndef BACKEND_REAL_CLOCK_H +#define BACKEND_REAL_CLOCK_H + + +#include "lib/error.hpp" +//#include "lib/handle.hpp" +#include "lib/time/timevalue.hpp" +#include "lib/singleton.hpp" +//#include "proc/engine/buffer-provider.hpp" +//#include "lib/iter-source.hpp" +//#include "lib/sync.hpp" + +//#include +//#include +//#include +//#include +//#include + +//namespace lib { +//namespace time{ +// class Quantiser; +// typedef std::tr1::shared_ptr PQuant; +//}} + +namespace backend { + + using lib::time::Time; + using lib::time::TimeValue; +//using std::string; + +//using std::vector; +//using std::tr1::shared_ptr; +//using boost::scoped_ptr; + + + /** + * Convenience frontend to access the current wall clock time + */ + class RealClock + { + + ~RealClock (); + RealClock (); + + friend class lib::singleton::StaticCreate; + + + static lib::Singleton _clock; + + public: + + static Time + now() + { + return Time(_clock().readSystemTime()); + } + + + private: + TimeValue readSystemTime(); + }; + + + +} // namespace backend +#endif diff --git a/src/proc/engine/time-anchor.hpp b/src/proc/engine/time-anchor.hpp index 8905ad7a9..d5812adf2 100644 --- a/src/proc/engine/time-anchor.hpp +++ b/src/proc/engine/time-anchor.hpp @@ -26,6 +26,7 @@ #include "proc/common.hpp" //#include "proc/state.hpp" +#include "backend/real-clock.hpp" #include "lib/time/timevalue.hpp" #include "proc/play/timings.hpp" @@ -36,11 +37,12 @@ namespace proc { namespace engine { + using backend::RealClock; // using lib::time::TimeSpan; using lib::time::Offset; // using lib::time::FSecs; + using lib::time::TimeVar; using lib::time::Time; -// // class ExitNode; /** @@ -62,7 +64,7 @@ namespace engine { class TimeAnchor { play::Timings timings_; - uint64_t anchorPoint_; + int64_t anchorPoint_; Time relatedRealTime_; Time @@ -80,13 +82,13 @@ namespace engine { deadline = timings.getTimeDue() - engineLatency; break; } - return deadline - timings.getOutputLatency(); + return deadline - timings.outputLatency; } - TimeAnchor (play::Timings timings, Offset engineLatency, uint64_t startFrame) + TimeAnchor (play::Timings timings, Offset engineLatency, int64_t startFrame) : timings_(timings) - , anchorPoint(startFrame) + , anchorPoint_(startFrame) , relatedRealTime_(expectedTimeofArival(timings, engineLatency)) { } @@ -104,7 +106,7 @@ namespace engine { * start delay from internals of the engine in this case. */ static TimeAnchor - build (play::Timings timings, uint64_t startFrame) + build (play::Timings timings, int64_t startFrame) { const boost::rational DEFAULT_LATENCY_FACTOR (1,3); Offset startDelay = timings.getFrameDurationAt(startFrame) * DEFAULT_LATENCY_FACTOR; diff --git a/src/proc/play/timings.cpp b/src/proc/play/timings.cpp index 956b5f72a..564f65d45 100644 --- a/src/proc/play/timings.cpp +++ b/src/proc/play/timings.cpp @@ -83,8 +83,16 @@ namespace play { Timings::getFrameDurationAt (TimeValue refPoint) const { int64_t frameNr = grid_->gridPoint (refPoint); + return getFrameDurationAt(frameNr); + } + + + Duration + Timings::getFrameDurationAt (int64_t refFrameNr) const + { return Offset (grid_->timeOf(frameNr), grid_->timeOf(frameNr+1)); } + /** @remarks the purpose of this function is to support scheduling @@ -98,9 +106,26 @@ namespace play { { return Duration (Time::ANYTIME); } - - - - + + Time + Timings::getTimeDue() const + { + if (TIMEBOUND == playbackUrgency) + { + UNIMPLEMENTED ("scheduled delivery spec"); + } + else + return Time::NEVER; + } + + + Timings + Timings::constrainedBy (Timings additionalConditions) + { + UNIMPLEMENTED ("how to combine timing constraints"); + } + + + }} // namespace proc::play diff --git a/src/proc/play/timings.hpp b/src/proc/play/timings.hpp index 085fc267e..634ece475 100644 --- a/src/proc/play/timings.hpp +++ b/src/proc/play/timings.hpp @@ -69,6 +69,7 @@ namespace play { using lib::time::TimeValue; using lib::time::Duration; using lib::time::Offset; + using lib::time::Time; //using std::string; //using std::vector; @@ -98,6 +99,7 @@ namespace play { public: PlaybackUrgency playbackUrgency; + Duration outputLatency; Timings (FrameRate fps); @@ -107,6 +109,7 @@ namespace play { Offset getFrameOffsetAt (TimeValue refPoint) const; Duration getFrameDurationAt (TimeValue refPoint) const; + Duration getFrameDurationAt (int64_t refFrameNr) const; /** the frame spacing and duration remains constant for some time... * @param startPoint looking from that time point into future @@ -114,14 +117,18 @@ namespace play { * to assume unaltered frame dimensions */ Duration constantFrameTimingsInterval (TimeValue startPoint) const; + /** for scheduled time of delivery, which is signalled + * by \code playbackUrgency == TIMEBOUND \endcode + * @return wall clock time to expect delivery of data corresponding + * to \link #getOrigin time axis origin \endlink + * @note for other playback urgencies \c Time::NEVER + */ + Time getTimeDue() const; //////////////TODO further accessor functions here - Timings - constrainedBy (Timings additionalConditions) - { - UNIMPLEMENTED ("how to combine timing constraints"); - } + Timings constrainedBy (Timings additionalConditions); + };