play-service.cpp

Go to the documentation of this file.

/*
  PlayService  -  interface: render- and playback control
 
   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.
 
* *****************************************************************/
 
 
#include "lib/error.hpp"
#include "include/play-facade.hpp"
#include "steam/play/play-service.hpp"
#include "steam/play/play-process.hpp"
#include "steam/play/render-configurator.hpp"
#include "steam/play/output-manager.hpp"
#include "lib/util-foreach.hpp"
 
 
#include <string>
//#include <memory>
#include <memory>
 
 
 
namespace lumiera {
  
  
  Play::~Play() { } // emit VTables here...
  
  lib::Depend<Play> Play::facade;
  
  
  namespace error {
    LUMIERA_ERROR_DEFINE (CANT_PLAY, "unable to build playback or render process for this configuration");
  }
}//(End) namespace lumiera
 
 
namespace steam {
namespace play {
 
//using std::string;
//using lumiera::Subsys;
//using std::bind;
  using lib::Sync;
  using lib::RecursiveLock_NoWait;
  using std::weak_ptr;
  using std::bind;
//using std::function;
  using std::placeholders::_1;
  using util::remove_if;
  using util::and_all;
 
  
  namespace { // hidden local details of the service implementation....
  
    
    
    
    
    
    
  } // (End) hidden service impl details
  
  using lumiera::Play;
  
  typedef POutputManager Output;
  
  
  
  class ProcessTable
    : public Sync<RecursiveLock_NoWait>
    {
      typedef weak_ptr<PlayProcess> Entry;
      typedef std::vector<Entry> ProcTable;
      
      ProcTable processes_;
      
    public:
      
      Play::Controller
      establishProcess (PlayProcess* newProcess)
        {
          Play::Controller frontend;
          try {
              frontend.activate (newProcess, bind (&ProcessTable::endProcess, this, _1 ));
            }
          catch(...)
            {
              delete newProcess;
              throw;
            }
          
          Lock sync{this};
          processes_.push_back (frontend); // keeping a weak-reference
          return frontend;
        }
      
      
      bool
      isActive()  const
        {
          return not and_all (processes_, isDead);
        }
      
    private:
      void
      endProcess (PlayProcess* dyingProcess)
        {
          delete dyingProcess;
          
          Lock sync{this};
          remove_if (processes_, isDead);
        }
      
      static bool
      isDead (Entry const& e)
        {
          return e.expired();
        }
    };
  
  
    
  
  PlayService::~PlayService()
    {
      if (pTable_->isActive())
        {
          UNIMPLEMENTED ("block waiting for any ongoing play processes. Ensure the process table is empty -- OR -- hand it over to some kind of cleanup service");
        }
      ENSURE (!pTable_->isActive());
    }
  
  
  PlayService::PlayService()
    : pTable_(new ProcessTable)
    { }
  
  
  
  
  
  Play::Controller
  PlayService::connect (ModelPorts dataGenerators, POutputManager outputPossibilities)
  {
    Timings playbackTimings (lib::time::FrameRate::PAL);       
    
    return pTable_->establishProcess(
            PlayProcess::initiate(dataGenerators, 
                buildRenderConfiguration(outputPossibilities, playbackTimings)));
  }
  
  
  
}} // namespace steam::play
 
 
namespace lumiera {
  
  /* ==== convenience shortcuts for creating a PlayProcess ==== */
  
  Play::Controller
  Play::perform (ModelPorts ports, Output output)
  {
    return this->connect (ports, output);
  }
  
  
  Play::Controller
  Play::perform (Pipes, Output)
  {
    UNIMPLEMENTED ("build PlayProcess based on a set of pipes");
  }
  
  
  Play::Controller
  Play::perform (Timeline)
  {
    UNIMPLEMENTED ("build PlayProcess for a Timeline");
  }
  
  
  Play::Controller
  Play::perform (Viewer)
  {
    UNIMPLEMENTED ("build PlayProcess directly for a Viewer element");
  }
  
  
  Play::Controller
  Play::perform (Fork)
  {
    UNIMPLEMENTED ("build PlayProcess for a single Fork");
  }
  
  
  Play::Controller
  Play::perform (Clip)
  {
    UNIMPLEMENTED ("build virtual Timeline and PlayProcess to show a single Clip");
  }
  
  
}