libs/ardour/ardour/engine_state_controller.h

   1 /*
   2  Copyright (C) 2014 Waves Audio Ltd.
   3
   4  This program is free software; you can redistribute it and/or modify
   5  it under the terms of the GNU General Public License as published by
   6  the Free Software Foundation; either version 2 of the License, or
   7  (at your option) any later version.
   8
   9  This program is distributed in the hope that it will be useful,
  10  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  GNU General Public License for more details.
  13
  14  You should have received a copy of the GNU General Public License
  15  along with this program; if not, write to the Free Software
  16  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18  */
  19
  20 #ifndef __gtk2_ardour__engine_state_controller__
  21 #define __gtk2_ardour__engine_state_controller__
  22
  23 #include <vector>
  24 #include <list>
  25
  26 #include "ardour/types.h"
  27 #include "ardour/audio_backend.h"
  28
  29 namespace ARDOUR {
  30
  31 class AudioBackendInfo;
  32
  33 /**
  34  * @class EngineStateController
  35  * @brief EngineStateController class.
  36  *
  37  * Implements usecases for Audio devices and Audio/Midi ports.
  38  * Persistantly saves to the config device configuration settings and audio/midi port states
  39  */
  40 class EngineStateController
  41 {
  42 public:
  43
  44     // public data types:
  45
  46     /**
  47      * @struct PortState
  48      * Structure which represents AudioPort state
  49      */
  50     struct PortState {
  51         std::string name; ///< Audio Port name
  52         bool active;      ///< Audio Port state
  53
  54         PortState ()
  55         : name(""),
  56         active(false)
  57         {
  58         }
  59
  60         PortState (const std::string& name)
  61         : name(name),
  62         active(false)
  63         {
  64         }
  65
  66         bool operator==(const PortState& rhs) {return rhs.name == name; }
  67
  68     };
  69
  70     /// @typedef Type for the list of all available audio ports
  71     typedef std::list<PortState> PortStateList;
  72
  73     /**
  74      * @struct MidiPortState
  75      * Structure which represents MidiPort state.
  76      */
  77     struct MidiPortState
  78     {
  79         std::string name;     ///< Midi Port name
  80         bool active;          ///< Midi Port state
  81         bool available;       ///< Midi Port availability - if it is physicaly available or not
  82         bool scene_connected; ///< Is midi port used for scene MIDI marker in/out
  83         bool mtc_in;          ///< Is midi port used as MTC in
  84
  85         MidiPortState(const std::string& name):
  86         name(name),
  87         active(false),
  88         available(false),
  89         scene_connected(false),
  90         mtc_in(false)
  91         {}
  92
  93         bool operator==(const MidiPortState& rhs)
  94         {
  95             return name == rhs.name;
  96         }
  97     };
  98
  99     /// @typedef Type for the list of MidiPorts ever registered in the system
 100     typedef std::list<MidiPortState> MidiPortStateList;
 101
 102
 103     //Interfaces
 104
 105     /** Get an instance of EngineStateController singleton.
 106      * @return EngineStateController instance pointer
 107      */
 108     static EngineStateController* instance ();
 109
 110     /** Associate session with EngineStateController instance.
 111      */
 112         void set_session (Session* session);
 113
 114     /** Remove link to the associated session.
 115      */
 116         void remove_session ();
 117
 118     //////////////////////////////////////////////////////////////////////////////////////////////////////////
 119     // General backend/device information methods
 120
 121     /** Provides names of all available backends.
 122      *
 123      * @param[out] available_backends - vector of available backends
 124      */
 125     void available_backends (std::vector<const AudioBackendInfo*>& available_backends);
 126
 127     /** Provides the name of currently used backend.
 128      *
 129      * @return the name of currently used backend
 130      */
 131     const std::string& get_current_backend_name() const;
 132
 133     /** Provides the name of currently used device.
 134      *
 135      * @return the name of currently used device
 136      */
 137     const std::string& get_current_device_name () const;
 138
 139     /** Provides names for all available devices.
 140      *
 141      * @param[out] device_vector - vector of available devices
 142      */
 143     void enumerate_devices (std::vector<ARDOUR::AudioBackend::DeviceStatus>& device_vector) const;
 144
 145     /** Get sample rate used by current device.
 146      *
 147      * @return current sample rate
 148      */
 149     ARDOUR::framecnt_t get_current_sample_rate () const;
 150
 151     /** Get default sample rate for current backend.
 152      *
 153      * @return default sample rate for current backend
 154      */
 155     ARDOUR::framecnt_t get_default_sample_rate () const;
 156
 157     /** Get sample rates which are supported by current device and current backend.
 158      *
 159      * @param[out] sample_rates - vector of supported sample rates
 160      */
 161     void available_sample_rates_for_current_device (std::vector<float>& sample_rates) const;
 162
 163     /** Get buffer size used by current device.
 164      *
 165      * @return current buffer size
 166      */
 167     ARDOUR::pframes_t get_current_buffer_size () const;
 168
 169     /** Get default buffer size for current backend.
 170      *
 171      * @return default buffer size for current backend
 172      */
 173     ARDOUR::pframes_t get_default_buffer_size () const;
 174
 175     /** Get buffer sizes which are supported by current device and current backend.
 176      *
 177      * @param[out] buffer_sizes - vector of supported buffer_sizes
 178      */
 179     void available_buffer_sizes_for_current_device (std::vector<ARDOUR::pframes_t>& buffer_sizes) const;
 180
 181     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 182     // device state control methods
 183
 184     /** Get the number of all enabled Audio inputs.
 185      *
 186      * @return number of all enabled Audio inputs
 187      */
 188     uint32_t            get_available_inputs_count() const;
 189     /** Get the number of all enabled Audio outputs.
 190      *
 191      * @return number of all enabled Audio outputs
 192      */
 193     uint32_t            get_available_outputs_count () const;
 194
 195     /** Get vector of all enabled physical Audio input port names.
 196      *
 197      * @param[out] port_names - vector of all enabled Audio input names
 198      */
 199     void                get_physical_audio_inputs (std::vector<std::string>& port_names);
 200     /** Get vector of all enabled physical Audio input port names.
 201      *
 202      * @param[out] port_names - vector of all enabled Audio input names
 203      */
 204     void                get_physical_audio_outputs (std::vector<std::string>& port_names);
 205
 206     /** Get vector of all enabled physical MIDI input port names.
 207      *
 208      * @param[out] port_names - vector of all enabled MIDI input names
 209      */
 210     void                get_physical_midi_inputs (std::vector<std::string>& port_names);
 211     /** Get vector of all enabled physical MIDI output port names.
 212      *
 213      * @param[out] port_names - vector of all enabled MIDI output names
 214      */
 215     void                get_physical_midi_outputs (std::vector<std::string>& port_names);
 216
 217     /** Sets new state to all Audio inputs.
 218      *
 219      * @param[in] state - new state
 220      */
 221     void                set_state_to_all_inputs(bool state);
 222     /** Sets new state to all Audio outputs.
 223      * @note Does nothing in Stereo Out mode
 224      * @param[in] state - new state
 225      */
 226     void                set_state_to_all_outputs(bool state);
 227
 228     /** Get vector of states for all physical Audio input ports.
 229      *
 230      * @param[out] channel_states - vector of input port states
 231      */
 232     void                get_physical_audio_input_states(std::vector<PortState>& channel_states);
 233     /** Get vector of states for all physical Audio output ports.
 234      *
 235      * @param[out] channel_states - vector of output port states
 236      */
 237     void                get_physical_audio_output_states(std::vector<PortState>& channel_states);
 238
 239     /** Set state of the specified Audio input port.
 240      *
 241      * @param[in] port_name - input name
 242      * @param[in] state - new state
 243      */
 244     void                set_physical_audio_input_state(const std::string& port_name, bool state);
 245     /** Set state of the specified Audio output port.
 246      *
 247      * @param[in] port_name - output name
 248      * @param[in] state - new state
 249      */
 250     void                set_physical_audio_output_state(const std::string& port_name, bool state);
 251
 252     /** Get state of the specified Audio input port.
 253      *
 254      * @param[in] port_name - input name
 255      * @return input state
 256      */
 257     bool                get_physical_audio_input_state(const std::string& port_name);
 258     /** Get state of the specified Audi output port.
 259      *
 260      * @param[in] port_name - output name
 261      * @return output state
 262      */
 263     bool                get_physical_audio_output_state(const std::string& port_name);
 264
 265
 266     /** Get vector of all enabled MIDI input port names.
 267      *
 268      * @param[out] channel_states - vector of enabled inputs
 269      */
 270     void                get_physical_midi_input_states (std::vector<MidiPortState>& channel_states);
 271     /** Get vector of all enabled MIDI output port names.
 272      *
 273      * @param[out] channel_states - vector of enabled outputs
 274      */
 275     void                get_physical_midi_output_states (std::vector<MidiPortState>& channel_states);
 276
 277     /** Get name of mtc source port
 278      *
 279      * return name of mtc source port
 280      */
 281     std::string          get_mtc_source_port ();
 282
 283     /** Set ltc source port
 284      *
 285      * @param[in] port - name of ltc source port
 286      */
 287     void                set_ltc_source_port (const std::string& port);
 288     /** Get name of ltc source port
 289      *
 290      * return name of ltc source port
 291      */
 292     std::string          get_ltc_source_port ();
 293
 294     /** Set ltc output port
 295      *
 296      * @param[in] port - name of ltc output port
 297      */
 298     void                set_ltc_output_port (const std::string&);
 299     /** Get name of ltc output port
 300      *
 301      * return name of ltc output port
 302      */
 303     std::string         get_ltc_output_port ();
 304
 305     /** Set state of the specified MIDI input port.
 306      *
 307      * @param[in] port_name - input name
 308      * @param[in] state - new state
 309      */
 310     void                set_physical_midi_input_state(const std::string& port_name, bool state);
 311     /** Set state of the specified MIDI output port.
 312      *
 313      * @param[in] port_name - output name
 314      * @param[in] state - new state
 315      */
 316     void                set_physical_midi_output_state(const std::string& port_name, bool state);
 317     /** Get state of the specified MIDI input port.
 318      *
 319      * @param[in] port_name - input name
 320      * @param[out] scene_connected - is port used as Scene In or not
 321      * @return input state
 322      */
 323     bool                get_physical_midi_input_state(const std::string& port_name, bool& scene_connected);
 324     /** Get state of the specified MIDI output port.
 325      *
 326      * @param[in] port_name - output name
 327      * @param[out] scene_connected - is port used as Scene Out or not
 328      * @return output state
 329      */
 330     bool                get_physical_midi_output_state(const std::string& port_name, bool& scene_connected);
 331
 332     /** Set state of Scene In connection for the specified MIDI input port.
 333      *
 334      * @param[in] port_name - input name
 335      * @param[in] state - new state
 336      */
 337     void                set_physical_midi_scene_in_connection_state(const std::string& port_name, bool state);
 338     /** Set state of Scene Out connection for the specified MIDI output port.
 339      *
 340      * @param[in] port_name - input name
 341      * @param[in] state - new state
 342      */
 343     void                set_physical_midi_scenen_out_connection_state(const std::string&, bool);
 344
 345     /** Disocnnect all MIDI input ports from Scene In.
 346      */
 347     void                set_all_midi_scene_inputs_disconnected();
 348     /** Disocnnect all MIDI output ports from Scene Out.
 349      */
 350     void                set_all_midi_scene_outputs_disconnected();
 351
 352     /** Set MIDI TimeCode input port
 353      * @note There is a sense to choose MIDI TimeCode input only because
 354      * our MIDI TimeCode is propagated to all midi output ports.
 355      */
 356     void                set_mtc_source_port (const std::string&);
 357
 358     /** Check if AudioEngine setup is required
 359      * @return true if setup is required, otherwise - false
 360      */
 361     bool                is_setup_required() const {return ARDOUR::AudioEngine::instance()->setup_required (); }
 362
 363     ////////////////////////////////////////////////////////////////////////////////////////////////////
 364     // Methods set parameters inside the controller
 365     // the state of engine won't change untill we make a "push" of this state to the backend
 366     // NOTE: Use push_state_to_backend() method to update backend with the most recent controller state
 367
 368     /** Set new sample rate for current device in EngineStateController database
 369      * @note Use push_state_to_backend() method to update backend/device state with the most recent controller state
 370      * @param sample_rate - new sample rate
 371      */
 372     bool        set_new_sample_rate_in_controller(framecnt_t sample_rate);
 373     /** Set new buffer size for current device in EngineStateController database
 374      * @note Use push_state_to_backend() method to update backend/device state with the most recent controller state
 375      * @param buffer_size - new buffer size
 376      */
 377     bool        set_new_buffer_size_in_controller(pframes_t buffer_size);
 378
 379     /** @brief push current controller state to backend.
 380      * Propagate and set all current EngineStateController parameters to the backend
 381      * @note Engine will be restarted if it's running when this method is called.
 382      * @note If an attempt ot set parameters is unsuccessful current device will be switched to "None".
 383      * @param start - start the Engine if it was not running when this function was called.
 384      * @return true on success, otherwise - false
 385      */
 386     bool        push_current_state_to_backend(bool start);
 387     /** Switch to new backend
 388      * @note The change will be propagated emmidiatelly as if push_current_state_to_backend () was called.
 389      * @param backend_name - new backend name.
 390      * @return true on success, otherwise - false
 391      */
 392     bool        set_new_backend_as_current(const std::string& backend_name);
 393     /** Switch to new device
 394      * @note The change will be propagated emmidiatelly as if push_current_state_to_backend () was called.
 395      * @param device_name - new device name.
 396      * @return true on success, otherwise - false
 397      */
 398     bool        set_new_device_as_current(const std::string& device_name);
 399
 400
 401     ////////////////////////////////////////////////////////////////////////////////////////////////////
 402     // Methods to save/serialize setting states
 403
 404     /** Serialize Audio/Midi settings (entire EngineStateController database) to XML
 405      * @return XML note with serialized states
 406      */
 407     XMLNode&    serialize_audio_midi_settings();
 408     /** Save Audio/Midi settings (entire EngineStateController database) to config persistently
 409      */
 410     void        save_audio_midi_settings();
 411
 412     ////////////////////////////////////////////////////////////////////////////////////////////////////
 413     //UPDATE SIGNALS
 414     /** This signal is emitted if the sample rate changes */
 415     PBD::Signal0<void> SampleRateChanged;
 416     /** This signal is emitted if the buffer size changes */
 417     PBD::Signal0<void> BufferSizeChanged;
 418     /** This signal is emitted if the device list changes */
 419     PBD::Signal1<void, bool> DeviceListChanged;
 420         /** This signal is emitted if the device cannot operate properly */
 421     PBD::Signal0<void> DeviceError;
 422
 423     ////////////////////////////////////////////////////////////////////////////////////////////////////
 424     //ENGINE STATE SIGNALS
 425     /** This signal is emitted when the engine is started */
 426     PBD::Signal0<void> EngineRunning;
 427     /** This signal is emitted when the engine is stopped */
 428     PBD::Signal0<void> EngineStopped;
 429     /** This signal is emitted if Engine processing is terminated */
 430     PBD::Signal0<void> EngineHalted;
 431
 432     /** This signal is emitted if the AUDIO input channel configuration changes */
 433     PBD::Signal0<void> InputConfigChanged;
 434     /** This signal is emitted if the AUDIO output channel configuration changes */
 435     PBD::Signal0<void> OutputConfigChanged;
 436     /** This signal is emitted if the AUDIO output connection mode changes
 437      * @note By output connection mode "Stereo Out" or "Multi Out" is meant
 438      */
 439     PBD::Signal0<void> OutputConnectionModeChanged;
 440
 441     /** This signals is emitted if the MIDI input channel configuration changes */
 442     PBD::Signal0<void> MIDIInputConfigChanged;
 443     /** This signals is emitted if the MIDI output channel configuration changes */
 444     PBD::Signal0<void> MIDIOutputConfigChanged;
 445     /** This signals is emitted if the MIDI Scene In connection changes */
 446     PBD::Signal2<void, const std::vector<std::string>&, bool> MIDISceneInputConnectionChanged;
 447     /** This signals is emitted if the MIDI Scene Out connection changes */
 448     PBD::Signal2<void, const std::vector<std::string>&, bool> MIDISceneOutputConnectionChanged;
 449
 450     /** This signal is emitted if the MTC Input channel is changed */
 451     PBD::Signal1<void, const std::string&> MTCInputChanged;
 452
 453     /** This signal is emitted if new Audio/MIDI ports are registered or unregistered */
 454     PBD::Signal0<void> PortRegistrationChanged;
 455
 456 private:
 457
 458     EngineStateController(); /// singleton
 459     ~EngineStateController(); /// singleton
 460     EngineStateController(const EngineStateController& ); /// prohibited
 461     EngineStateController& operator=(const EngineStateController&); /// prohibited
 462
 463     ////////////////////////////////////////////////////////////////////////////////////////////
 464     // private data structures
 465
 466     /** @struct Engine state
 467      * @brief State structure.
 468      * Contains information about single device/backend state
 469      */
 470     struct State {
 471                 std::string backend_name; ///< state backend name
 472                 std::string device_name; ///< state device name
 473                 ARDOUR::framecnt_t sample_rate; ///< sample rate used by the device in this state
 474                 ARDOUR::pframes_t buffer_size; ///< buffer size used by the device in this state
 475
 476         PortStateList input_channel_states; ///< states of device Audio inputs
 477                 PortStateList multi_out_channel_states; ///< states of device Audio inputs in Multi Out mode
 478         PortStateList stereo_out_channel_states; ///< states of device Audio inputs in Stereo Out mode
 479                 bool active; ///< was this state the most recent active one
 480
 481                 State()
 482         : sample_rate(0)
 483         , buffer_size(0)
 484         , input_channel_states (0)
 485         , multi_out_channel_states (0)
 486         , stereo_out_channel_states (0)
 487         , active (false)
 488         {
 489         }
 490
 491         bool operator==(const State& rhs)
 492         {
 493             return (backend_name == rhs.backend_name) && (device_name == rhs.device_name);
 494         }
 495
 496         /** Forms string name for the state
 497          * @return name string
 498          */
 499         std::string form_state_name() {
 500             return std::string("State:" + backend_name + ":" + device_name);
 501         }
 502
 503         /** @struct StatepPredicate
 504          * This predicate is used to identify a state during search in the list of states
 505          */
 506         struct StatePredicate
 507         {
 508             StatePredicate(const std::string& backend_name, const std::string& device_name)
 509             : _backend_name (backend_name)
 510             , _device_name (device_name)
 511             {}
 512
 513             bool operator()(boost::shared_ptr<ARDOUR::EngineStateController::State> rhs)
 514             {
 515                 return (_backend_name == rhs->backend_name) && (_device_name == rhs->device_name);
 516             }
 517
 518         private:
 519             std::string _backend_name;
 520             std::string _device_name;
 521         };
 522     };
 523
 524     /// @typedef Type for the state pointer
 525     typedef boost::shared_ptr<State> StatePtr;
 526     /// @typedef Type for the list of states
 527     typedef std::list<StatePtr> StateList;
 528
 529     ////////////////////////////////////////////////////////////////////////////////////////////////////
 530     // methods to manage setting states
 531
 532     /** Deserializes and loads Engine and Audio port states from the config to EngineStateController
 533      */
 534     void _deserialize_and_load_engine_states();
 535     /** Deserializes and loads MIDI port states from the config to EngineStateController
 536      */
 537     void _deserialize_and_load_midi_port_states();
 538     /** Serializes Engine and Audio port states from EngineStateController to XML node
 539      * @param[in,out] audio_midi_settings_node - node to serialize the satets to
 540      */
 541     void _serialize_engine_states(XMLNode* audio_midi_settings_node);
 542     /** Serializes MIDI port states from EngineStateController to XML node
 543      * @param[in,out] audio_midi_settings_node - node to serialize the satets to
 544      */
 545     void _serialize_midi_port_states(XMLNode* audio_midi_settings_node);
 546
 547     /** Provides initial state configuration.
 548      * It loades the last active state if there is one and it is aplicable.
 549      * Otherwise default state (None device with default sample rate and buffer size) is loaded.
 550      */
 551     void _do_initial_engine_setup();
 552
 553     /** Loades provided state.
 554      * @note It's possible that provided state can't be loaded
 555      * (device disconnected or reqested parameters are not supported anymore).
 556      * @param state - state to apply
 557      * @return true on success, otherwise - false
 558      */
 559     bool _apply_state(const StatePtr& state);
 560
 561     /** Gets available device channels from engine and updates internal controller state
 562      */
 563     void _update_device_channels_state();
 564
 565     /** Check "Stereo Out" mode channels state configuration and make it correspond Stereo Out mode requirements
 566      */
 567     void _refresh_stereo_out_channel_states();
 568
 569     ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 570     // internal helper functions
 571     /** make sure that current device parameters are supported and fit session requirements
 572      * @return true if current state is valid and all parameters are supported, otherwise - false
 573      */
 574         bool _validate_current_device_state();
 575
 576     /** change ltc source port in case of the input ports list change
 577      */
 578     void _update_ltc_source_port ();
 579     /** change ltc source port in case of the output ports list change
 580      */
 581     void _update_ltc_output_port ();
 582
 583     /** check that port is still existed in the list of input ports
 584      @param[in] port - port name
 585      @return true if current port is existed, otherwise - false
 586      */
 587     bool _audio_input_port_exists (const std::string& port);
 588     /** check that port is still existed in the list of output ports
 589      @param[in] port - port name
 590      @return true if current port is existed, otherwise - false
 591      */
 592     bool _audio_output_port_exists (const std::string& port);
 593
 594
 595
 596     ////////////////////////////////////////
 597     // callbacks
 598     /** Invoked when Engine starts running
 599      */
 600     void _on_engine_running();
 601     /** Invoked when Engine is halted
 602      */
 603     void _on_engine_halted();
 604     /** Invoked when Engine processing is terminated
 605      */
 606     void _on_engine_stopped();
 607     /** Invoked when Device error accured, it failed to start or didn't accept the change which should
 608      */
 609         void _on_device_error();
 610     /** Invoked when current device changes sample rate
 611      */
 612     void _on_sample_rate_change(ARDOUR::framecnt_t);
 613     /** Invoked when current device changes buffer size
 614      */
 615     void _on_buffer_size_change(ARDOUR::pframes_t);
 616     /** Invoked when the list of available devices is changed
 617      */
 618     void _on_device_list_change();
 619     /** Invoked when the config parameter is changed
 620      */
 621     void _on_parameter_changed (const std::string&);
 622     /** Invoked when Audio/MIDI ports are registered or unregistered
 623      */
 624     void _on_ports_registration_update ();
 625     /** Invoked when session loading process is complete
 626      */
 627         void _on_session_loaded();
 628     ////////////////////////////////////////
 629
 630     ////////////////////////////////////////
 631     // attributes
 632     StatePtr _current_state; ///< current state pointer
 633     // list of system states
 634     StateList _states; ///< list of all available states
 635
 636     MidiPortStateList _midi_inputs; ///< midi input states
 637     MidiPortStateList _midi_outputs; ///< midi output states
 638
 639     std::string _last_used_real_device; ///< last active non-default (real) device
 640
 641         Session* _session; ///< current session
 642
 643     // Engine connections stuff
 644         PBD::ScopedConnectionList update_connections; ///< connection container for update signals
 645         PBD::ScopedConnectionList session_connections; ///< connection container for session signals
 646     PBD::ScopedConnection running_connection; ///< connection container for EngineRunning signal
 647     PBD::ScopedConnection halt_connection; ///< connection container for EngineHalted signal
 648     PBD::ScopedConnection stopped_connection; ///< connection container for EngineStopped signal
 649 };
 650
 651 } // namespace ARDOUR
 652
 653 #endif /* defined(__gtk2_ardour__engine_state_controller__) */