quantiser.hpp

Go to the documentation of this file.

/*
  QUANTISER.hpp  -  aligning time values to a time grid
 
   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_QUANTISER_H
#define LIB_TIME_QUANTISER_H
 
#include "lib/error.hpp"
#include "lib/time/grid.hpp"
#include "lib/time/formats.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/iter-adapter.hpp"
 
#include <vector>
#include <string>
#include <cmath>
 
 
namespace lib {
namespace time {
  
  LUMIERA_ERROR_DECLARE (UNKNOWN_GRID); 
  
  
  namespace { // stashed here for later
    
    template<typename NUM>
    struct ValTrait;
    
    template<>
    struct ValTrait<int>
      {
        static int    asInt    (int val) { return val; }
        static double asDouble (int val) { return val; }
      };
    
    template<>
    struct ValTrait<double>
      {
        static int    asInt    (double val) { return std::floor(0.5+val); }  
        static double asDouble (double val) { return val; }
      };
    
  }
  
  
  
  PQuant getDefaultGridFallback();                                        
  
  
  
  
  
  class Quantiser
    : public virtual Grid
    {
    protected:
      format::Supported supportedFormats_;
      
      Quantiser()
        : supportedFormats_(format::SupportStandardTimecode())
        { }
      
    public:
      template<class FMT>
      bool
      supports()  const
        {
          return supportedFormats_.check<FMT>();
        }
      
      static PQuant retrieve (Symbol gridID);                         
      TimeValue materialise  (TimeValue const& raw)       const;
      
      
      //------Grid-API----------------------------------------------
      virtual FrameCnt  gridPoint (TimeValue const& raw)  const   =0;
      virtual Offset    gridLocal (TimeValue const& raw)  const   =0;
      virtual TimeValue timeOf    (FrameCnt gridPoint)    const   =0;
      virtual TimeValue timeOf    (FSecs, int =0)         const   =0;
    };
  
  
  
  
  
  class FixedFrameQuantiser
    : public Quantiser
    {
      Time     origin_;
      Duration raster_;
      
    public:
      FixedFrameQuantiser (FrameRate const& frames_per_second, TimeValue referencePoint  =TimeValue(0));
      FixedFrameQuantiser (Duration const& frame_duration,     TimeValue referencePoint  =TimeValue(0));
      
      FrameCnt  gridPoint (TimeValue const&)   const override;
      Offset    gridLocal (TimeValue const&)   const override;
      TimeValue timeOf    (FrameCnt gridPoint) const override;
      TimeValue timeOf    (FSecs, int =0)      const override;
      
    private:
      static int64_t grid_aligned (TimeValue const&, TimeValue const&);
    };
  
  
  
}} // lib::time
#endif