timecode.hpp

Go to the documentation of this file.

/*
  TIMECODE.hpp  -  grid aligned and fixed format time specifications
 
   Copyright (C)
     2010,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_TIME_TIMECODE_H
#define LIB_TIME_TIMECODE_H
 
#include "lib/time/timevalue.hpp"
#include "lib/time/formats.hpp"
#include "lib/time/digxel.hpp"
#include "lib/symbol.hpp"
 
#include <boost/operators.hpp>
#include <boost/lexical_cast.hpp> 
#include <string>
 
 
namespace lib {
namespace time {
  
  using std::string;
  using lib::Literal;
  using boost::lexical_cast; 
  
  
  class TCode
    {
      
    public:
      virtual ~TCode() { }
      
      operator string()  const { return show(); }
      string describe()  const { return string(tcID()); }
      Time   getTime()   const { return Time(value()); }
      
    protected:
      TCode (PQuant const& quant)
        : quantiser_(quant)
        { }
      
      virtual string show()     const   =0;
      virtual Literal tcID()    const   =0;
      virtual TimeValue value() const   =0;
      
    protected:
      PQuant quantiser_;
    };
  
  
  class QuTime;
  
  class FrameNr
    : public TCode
    , public CountVal
    {
      
      string show()     const { return string(CountVal::show())+"#"; }
      Literal tcID()    const { return "Framecount"; }
      TimeValue value() const { return Format::evaluate (*this, *quantiser_); }
      
    public:
      using Format = format::Frames;
      
      FrameNr (QuTime const& quantisedTime);
      
      static FrameCnt quant (Time const&, Symbol gridID);// defined in common-services.cpp
      
      using TCode::operator string;
     // CountVal implicitly convertible to long      ///////////TICKET #882 : outch! should be a 64bit type!
    };
  
  
  
  class SmpteTC
    : public TCode
    , boost::unit_steppable<SmpteTC>
    {
      uint effectiveFramerate_;
      
      virtual string show()     const ;
      virtual Literal tcID()    const { return "SMPTE"; }
      virtual TimeValue value() const { return Format::evaluate (*this, *quantiser_); }
      
      
    public:
      using Format = format::Smpte;
      
      SmpteTC (QuTime const& quantisedTime);
      SmpteTC (SmpteTC const&);
      SmpteTC& operator= (SmpteTC const&);
      
      uint getFps()   const;
      
      void clear();
      void rebuild();
      void invertOrientation();
 
      
      HourDigit hours;
      SexaDigit mins;
      SexaDigit secs;
      SexaDigit frames;
      Signum    sgn;
      
      SmpteTC& operator++();
      SmpteTC& operator--();
    };
  
  
  
  class HmsTC
    : public TCode
    {
      TimeVar tpoint_;          
      
      virtual string show()     const { return string(tpoint_); }
      virtual Literal tcID()    const { return "Timecode"; }
      virtual TimeValue value() const { return tpoint_; }
      
    public:
      using Format = format::Hms;
      
      HmsTC (QuTime const& quantisedTime);
      
      double getMillis () const;
      int getSecs      () const;
      int getMins      () const;
      int getHours     () const;
    };
  
  
  
  class Secs
    : public TCode
    {
      FSecs sec_;
      
      virtual string show()     const { return string(Time(sec_)); }
      virtual Literal tcID()    const { return "Seconds"; }
      virtual TimeValue value() const { return Time(sec_); }
      
    public:
      using Format = format::Seconds;
      
      Secs (QuTime const& quantisedTime);
      
      operator FSecs()  const;
    };
  
  
}} // lib::time
#endif