play-facade.hpp

Go to the documentation of this file.

/*
  PLAYER-FACADE.h  -  access point to the Lumiera player subsystem

  Copyright (C)         Lumiera.org
    2011,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#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*/