timecode.cpp

Go to the documentation of this file.

/*
  Timecode  -  implementation of fixed grid aligned 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.
 
* *****************************************************************/
 
 
#include "lib/time/timecode.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/time/timequant.hpp"
#include "lib/time/formats.hpp"
#include "lib/util.hpp"
#include "lib/util-quant.hpp"
 
#include <regex>
#include <functional>
#include <boost/lexical_cast.hpp>
 
using util::unConst;
using util::isSameObject;
using util::floorwrap;
using std::string;
using std::regex;
using std::smatch;
using std::regex_search;
using boost::lexical_cast;
 
namespace lumiera {
namespace error {
  LUMIERA_ERROR_DEFINE (INVALID_TIMECODE, "timecode format error, illegal value encountered");
}}
 
namespace lib {
namespace time {
  namespace error = lumiera::error;
  
  namespace format {  /* ================= Timecode implementation details ======== */
    
    
    
    TimeValue
    Frames::parse (string const& frameNumber, QuantR frameGrid)
    {
      static regex frameNr_parser{"(?:^|[^\\d\\.\\-])(\\-?\\d+)#"};   // no leading [.-\d],  digit+'#'
      smatch match;                                                   // note: ECMA regexp does not support lookbehind
      if (regex_search (frameNumber, match, frameNr_parser))
        return frameGrid.timeOf (lexical_cast<FrameCnt> (match[1]));
      else
        throw error::Invalid ("unable to parse framecount \""+frameNumber+"\""
                             , LERR_(INVALID_TIMECODE));
    }
    
    
    TimeValue
    Smpte::parse (string const&, QuantR)
    {
      UNIMPLEMENTED("parsing SMPTE timecode");
    }
    
    
    TimeValue
    Hms::parse (string const&, QuantR)
    {
      UNIMPLEMENTED("parse a hours:mins:secs time specification");
    }
    
    
    TimeValue
    Seconds::parse (string const& seconds, QuantR grid)
    {
      static regex fracSecs_parser ("(?:^|[^\\./\\d\\-])(\\-?\\d+)(?:([\\-\\+]\\d+)?/(\\d+))?sec");
                                  //__no leading[./-\d]   number      [+-]  number '/' number 'sec'
      
      #define SUB_EXPR(N) lexical_cast<int> (match[N])
      smatch match;
      if (regex_search (seconds, match, fracSecs_parser))
        if (match[2].matched)
          {
            // complete spec with all parts
            FSecs fractionalPart (SUB_EXPR(2), SUB_EXPR(3));
            int fullSeconds (SUB_EXPR(1));
            return grid.timeOf (fullSeconds + fractionalPart);
          }
        else
        if (match[3].matched)
          {
            // only a fractional part was given
            return grid.timeOf (FSecs (SUB_EXPR(1), SUB_EXPR(3)));
          }
        else
          {
            // just simple non-fractional seconds
            return grid.timeOf (FSecs (SUB_EXPR(1)));
          }
      else
        throw error::Invalid ("unable to parse \""+seconds+"\" as (fractional)seconds"
                             , LERR_(INVALID_TIMECODE));
    }
    
    
    
    
    void
    Frames::rebuild (FrameNr& frameNr, QuantR quantiser, TimeValue const& rawTime)
    {
      frameNr.setValueRaw (quantiser.gridPoint (rawTime));
    }
    
    TimeValue
    Frames::evaluate (FrameNr const& frameNr, QuantR quantiser)
    {
      return quantiser.timeOf (frameNr);
    }
 
    
    void
    Smpte::rebuild (SmpteTC& tc, QuantR quantiser, TimeValue const& rawTime)
    {
      tc.clear();
      tc.frames = quantiser.gridPoint (rawTime);
      // will automatically wrap over to the seconds, minutes and hour fields
    }
    
    TimeValue
    Smpte::evaluate (SmpteTC const& tc, QuantR quantiser)
    {
      uint frameRate = tc.getFps();
      int64_t gridPoint(tc.frames);
      gridPoint += int64_t(tc.secs)  * frameRate;
      gridPoint += int64_t(tc.mins)  * frameRate * 60;
      gridPoint += int64_t(tc.hours) * frameRate * 60 * 60;
      return quantiser.timeOf (tc.sgn * gridPoint);
    }
    
    uint
    Smpte::getFramerate (QuantR quantiser_, TimeValue const& rawTime)
    {
      FrameCnt refCnt = quantiser_.gridPoint(rawTime);
      FrameCnt newCnt = quantiser_.gridPoint(Time(0,1) + rawTime);
      FrameCnt effectiveFrames = newCnt - refCnt;
      ENSURE (1000 > effectiveFrames);
      ENSURE (0 < effectiveFrames);
      return uint(effectiveFrames);
    }
    
    
    void
    Smpte::applyRangeLimitStrategy (SmpteTC& tc)
    {
      if (tc.hours < 0)
        tc.invertOrientation();
    }
  }
  
  
  namespace { // Timecode implementation details
    
    typedef util::IDiv<int> Div;
    
    void
    wrapFrames  (SmpteTC* thisTC, int rawFrames)
    {
      Div scaleRelation = floorwrap<int> (rawFrames, thisTC->getFps());
      thisTC->frames.setValueRaw (scaleRelation.rem);
      thisTC->secs += scaleRelation.quot;
    }
    
    void
    wrapSeconds (SmpteTC* thisTC, int rawSecs)
    {
      Div scaleRelation = floorwrap (rawSecs, 60);
      thisTC->secs.setValueRaw (scaleRelation.rem);
      thisTC->mins += scaleRelation.quot;
    }
    
    void
    wrapMinutes (SmpteTC* thisTC, int rawMins)
    {
      Div scaleRelation = floorwrap (rawMins, 60);
      thisTC->mins.setValueRaw (scaleRelation.rem);
      thisTC->hours += scaleRelation.quot;
    }
    
    void
    wrapHours   (SmpteTC* thisTC, int rawHours)
    {
      thisTC->hours.setValueRaw (rawHours);
      format::Smpte::applyRangeLimitStrategy (*thisTC);
    }
    
    
    using std::bind;
    using std::placeholders::_1;
    
    inline void
    setupComponentNormalisation (SmpteTC& thisTC)
    {
      thisTC.hours.installMutator (wrapHours,   thisTC);
      thisTC.mins.installMutator  (wrapMinutes, thisTC);
      thisTC.secs.installMutator  (wrapSeconds, thisTC);
      thisTC.frames.installMutator(wrapFrames,  thisTC);
    }
    
  }//(End)implementation details
  
  
  FrameNr::FrameNr (QuTime const& quantisedTime)
    : TCode(quantisedTime)
    , CountVal()
    {
      quantisedTime.castInto (*this);
    }
  
 
  SmpteTC::SmpteTC (QuTime const& quantisedTime)
    : TCode(quantisedTime)
    , effectiveFramerate_(Format::getFramerate (*quantiser_, quantisedTime))
    {
      setupComponentNormalisation (*this);
      quantisedTime.castInto (*this);
    }
  
  
  SmpteTC::SmpteTC (SmpteTC const& o)
    : TCode(o)
    , effectiveFramerate_(o.effectiveFramerate_)
    {
      setupComponentNormalisation (*this);
      sgn    = o.sgn;
      hours  = o.hours;
      mins   = o.mins;
      secs   = o.secs;
      frames = o.frames;
    }
  
  
  SmpteTC&
  SmpteTC::operator= (SmpteTC const& o)
    {
      if (not isSameObject (*this, o))
        {
          TCode::operator= (o);
          effectiveFramerate_ = o.effectiveFramerate_;
          sgn    = o.sgn;
          hours  = o.hours;
          mins   = o.mins;
          secs   = o.secs;
          frames = o.frames;
        }
      return *this;
    }
  
  
  HmsTC::HmsTC (QuTime const& quantisedTime)
    : TCode(quantisedTime)
//  : tpoint_(quantisedTime)           //////////////////////////////////////////////////////////////////////TICKET #736 implement HMS format
    { }
  
  
  Secs::Secs (QuTime const& quantisedTime)
    : TCode(quantisedTime)
//  : sec_(TimeVar(quantisedTime) / TimeValue::SCALE)   /////////////////////////////////////////////////////TICKET #736 implement Seconds format
    { }
  
  
  
  void
  SmpteTC::clear()
  {
    frames.setValueRaw(0);
    secs.setValueRaw  (0);
    mins.setValueRaw  (0);
    hours.setValueRaw (0);
    sgn.setValueRaw  (+1);
  }
  
  
  void
  SmpteTC::rebuild()
  {
    TimeValue point = Format::evaluate (*this, *quantiser_);
    Format::rebuild (*this, *quantiser_, point);
  }
  
  
  void
  SmpteTC::invertOrientation()
  {
    int fr (getFps());
    int f (fr - frames); // revert orientation
    int s (60 - secs);  //  of the components
    int m (60 - mins); //
    int h = -hours;   //  assumed to be negative
    sgn *= -1;       //   flip sign field
    
    if (f < fr) --s; else f -= fr;
    if (s < 60) --m; else s -= 60;
    if (m < 60) --h; else m -= 60;
    
    hours.setValueRaw(h);
    mins   = m;  // invoking setters
    secs   = s; //  ensures normalisation
    frames = f;
  }
  
  
  uint
  SmpteTC::getFps()  const
  {
    return effectiveFramerate_;    
  }
  
  
  string
  SmpteTC::show()  const
  {
    string tc;
           tc.reserve(15);
           tc += sgn.show();
           tc += hours.show();
           tc += ':';
           tc += mins.show();
           tc += ':';
           tc += secs.show();
           tc += ':';
           tc += frames.show();
    return tc;
  }
  
  SmpteTC&
  SmpteTC::operator++ ()
  {
    frames += sgn;
    return *this;
  }
  
  SmpteTC&
  SmpteTC::operator-- ()
  {
    frames -= sgn;
    return *this;
  }
  
  namespace {
    const auto TIME_SCALE_sec{lib::time::TimeValue::SCALE        };
    const auto TIME_SCALE_ms {lib::time::TimeValue::SCALE / 1'000};
  }
  
  int
  HmsTC::getSecs() const
  {         
    return (_raw (tpoint_) / TIME_SCALE_sec) % 60;
  }
  
  int
  HmsTC::getMins() const
  {
    return (_raw (tpoint_) / TIME_SCALE_sec / 60) % 60;
  }
  
  int
  HmsTC::getHours() const
  {
    return _raw (tpoint_) / TIME_SCALE_sec / 60 / 60;
  }
  
  double
  HmsTC::getMillis() const
  {
    return (_raw (tpoint_) / TIME_SCALE_ms) % 1000;
  }
  
}} // lib::time