quantiser.cpp

Go to the documentation of this file.

/*
  Quantiser  -  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.

* *****************************************************************/


#include "lib/time/quantiser.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/time/timequant.hpp"
#include "lib/time.h"

#include <boost/rational.hpp>

using boost::rational_cast;
using std::string;


namespace error = lumiera::error;

namespace lib {
namespace time {
  
  
  PQuant
  getDefaultGridFallback()
  {
    static PQuant globalDefaultGrid (new FixedFrameQuantiser(1));
    return globalDefaultGrid;                                                    
  };
  
  
  
  
  
  Grid::~Grid() { } // hint to emit the VTable here...
  
  
  /* Note: the ctor QuTime(TimeValue, Symbol) and the static function
   *       PQuant Quantiser::retrieve (Symbol) are defined in common-services.cpp
   *       To use this special convenience shortcuts, you need to link against liblumieracore.so
   *       This allows to use the Advice-system to retrieve grid definitions directly from the session  
   */
  
  
  QuTime::QuTime (TimeValue raw, PQuant quantisation_to_use)
    : Time(raw)
    , quantiser_(quantisation_to_use)
    { }
  
  
  
  FixedFrameQuantiser::FixedFrameQuantiser (FrameRate const& frames_per_second, TimeValue referencePoint)
    : origin_(referencePoint)
    , raster_(__ensure_nonzero(frames_per_second.duration()))
    { }
  
  FixedFrameQuantiser::FixedFrameQuantiser (Duration const& frame_duration,     TimeValue referencePoint)
    : origin_(referencePoint)
    , raster_(__ensure_nonzero(frame_duration))
    { }
  
  
  
  
  TimeValue
  Quantiser::materialise  (TimeValue const& raw)  const
  {
    return timeOf (gridPoint (raw));
  }
  
  
  
  FrameCnt
  FixedFrameQuantiser::gridPoint (TimeValue const& rawTime)  const
  {
    return lumiera_quantise_frames (_raw(rawTime), _raw(origin_), _raw(raster_));
  }
  
  
  TimeValue
  FixedFrameQuantiser::gridLocal (TimeValue const& rawTime)  const
  {
    return TimeValue (lumiera_quantise_time (_raw(rawTime), _raw(origin_), _raw(raster_)));
  }
  
  
  TimeValue
  FixedFrameQuantiser::timeOf (FrameCnt gridPoint)  const
  {
    return TimeValue (lumiera_time_of_gridpoint (gridPoint, _raw(origin_), _raw(raster_)));
  }
  
  
  TimeValue
  FixedFrameQuantiser::timeOf (FSecs gridTime, int gridOffset)  const
  {
    Time gt(gridTime);
    TimeVar timePoint = gt + origin_;
    timePoint += gridOffset * Offset(raster_);
    return timePoint;
  }
  
  
  
  
  LUMIERA_ERROR_DEFINE (UNKNOWN_GRID, "referring to an undefined grid or scale in value quantisation");
  
  
  
}} // lib::time