play-facade.hpp

Go to the documentation of this file.

/*
  PLAYER-FACADE.h  -  access point to the Lumiera player subsystem
 
   Copyright (C)
     2011,            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 STEAM_INTERFACE_PLAY_H
#define STEAM_INTERFACE_PLAY_H
 
 
 
#include "lib/depend.hpp"
#include "lib/handle.hpp"
#include "lib/iter-source.hpp"                 
#include "lib/time/control.hpp"
#include "lib/time/timevalue.hpp"
#include "steam/mobject/model-port.hpp"
#include "steam/mobject/output-designation.hpp"
#include "steam/mobject/session/clip.hpp"
#include "steam/mobject/session/fork.hpp"
#include "steam/play/output-manager.hpp"
#include "steam/asset/timeline.hpp"
#include "steam/asset/viewer.hpp"
 
 
 
namespace steam {
namespace play {
  
  class PlayProcess;
}}
 
 
namespace lumiera {
  
  namespace time = lib::time;
  
  using std::weak_ptr;
    
    
    /**************************************************************/
    class Play
      {
      protected:
        virtual ~Play();
        friend class lib::DependencyFactory<Play>;
      public:
        
        static lib::Depend<Play> facade;
        
        
        class Controller
          : public lib::Handle<steam::play::PlayProcess>
          {
          public:
            void play(bool);          
            void scrub(bool);         
            void adjustSpeed(double); 
            void go(time::Time);      
            
            void controlPlayhead (time::Control<time::Time>     & ctrl);
            void controlDuration (time::Control<time::Duration> & ctrl);
            void controlLooping  (time::Control<time::TimeSpan> & ctrl);
            
            void useProxyMedia (bool);
            void setQuality (uint);
            
            bool is_playing()   const;
            bool is_scrubbing() const;
            double getSpeed()   const;
            uint getQuality()   const;
            bool usesProxy()    const;
            
            operator weak_ptr<steam::play::PlayProcess>()  const;
          };
        
        
        using ModelPorts = lib::IterSource<steam::mobject::ModelPort>::iterator;
        using Pipes      = lib::IterSource<steam::mobject::OutputDesignation>::iterator;
        using Output     = steam::play::POutputManager;
        using Clip       = steam::mobject::session::PClip;
        using Fork       = steam::mobject::PFork;
        using Timeline   = steam::asset::PTimeline;
        using Viewer     = steam::asset::PViewer;
        
        
        /* ==== convenience shortcuts for common use cases ==== */
        Controller perform(ModelPorts, Output);
        Controller perform(Pipes, Output);
        Controller perform(Timeline);
        Controller perform(Viewer);
        Controller perform(Fork);
        Controller perform(Clip);
        
      protected:
        virtual Controller connect(ModelPorts, Output)      =0;
      };
    
    
} // namespace lumiera
#endif /*STEAM_INTERFACE_PLAY_H*/