// ------------------------------------------------------------------------ // eca-chainsetup.h: Class representing an ecasound chainsetup object. // Copyright (C) 1999-2004,2006 Kai Vehmanen // // Attributes: // eca-style-version: 3 // // 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // ------------------------------------------------------------------------ #ifndef INCLUDED_ECA_CHAINSETUP_H #define INCLUDED_ECA_CHAINSETUP_H #include #include #include #include #include "eca-chainsetup-position.h" #include "eca-chainsetup-parser.h" #include "eca-chainsetup-edit.h" #include "eca-error.h" class AUDIO_IO; class AUDIO_IO_MANAGER; class AUDIO_IO_DB_SERVER; class CHAIN; class CHAIN_OPERATOR; class CONTROLLER_SOURCE; class ECA_AUDIO_FORMAT; class ECA_CHAINSETUP_BUFPARAMS; class ECA_CHAINSETUP_impl; class ECA_ENGINE_DRIVER; class ECA_RESOURCES; class GENERIC_CONTROLLER; class LOOP_DEVICE; class MIDI_IO; class MIDI_SERVER; using std::map; using std::list; using std::string; using std::vector; /** * Class representing an ecasound chainsetup object. * * Chainsetup is the central data object. It contains * audio inputs, outputs, chains, operators and also * information about how they are connected. * * Notes: ECA_CHAINSETUP is closely coupled to the * ECA_CHAINSETUP_PARSER and ECA_ENGINE. * In addition, to ease implementation, * also ECA_CONTROL classes have direct access * to ECA_CHAINSETUP's implementation. * * @author Kai Vehmanen */ class ECA_CHAINSETUP : public ECA_CHAINSETUP_POSITION { public: friend class ECA_ENGINE; friend class ECA_CONTROL; friend class ECA_CONTROL_BASE; friend class ECA_CONTROL_OBJECTS; friend class ECA_CHAINSETUP_PARSER; // ------------------------------------------------------------------- /** @name Public type definitions and constants */ /*@{*/ enum Buffering_mode { cs_bmode_auto, cs_bmode_nonrt, cs_bmode_rt, cs_bmode_rtlowlatency, cs_bmode_none }; enum Mix_mode { cs_mmode_avg, cs_mmode_sum }; enum Audio_dir { cs_dir_input, cs_dir_output }; typedef enum Buffering_mode Buffering_mode_t; typedef enum Mix_mode Mix_mode_t; static const string default_audio_format_const; static const string default_bmode_nonrt_const; static const string default_bmode_rt_const; static const string default_bmode_rtlowlatency_const; /*@}*/ // ------------------------------------------------------------------- /** @name Functions for init and cleanup */ /*@{*/ ECA_CHAINSETUP(void); ECA_CHAINSETUP(const vector& options); ECA_CHAINSETUP(const string& setup_file); virtual ~ECA_CHAINSETUP(void); /*@}*/ // ------------------------------------------------------------------- /** @name Functions for handling audio objects */ /*@{*/ void add_input(AUDIO_IO* aiod); void add_output(AUDIO_IO* aiod, bool truncate); void add_default_output(void); void remove_audio_input(const string& label); void remove_audio_output(const string& label); void attach_input_to_selected_chains(const AUDIO_IO* obj); void attach_output_to_selected_chains(const AUDIO_IO* obj); bool ok_audio_object(const AUDIO_IO* aobj) const; bool is_realtime_target_output(int output_id) const; vector audio_input_names(void) const; vector audio_output_names(void) const; /*@}*/ // ------------------------------------------------------------------- /** @name Functions for handling chains */ /*@{*/ void add_default_chain(void); void add_new_chains(const vector& newchains); void remove_chains(void); void select_chains(const vector& chainsarg) { selected_chainids = chainsarg; } void select_all_chains(void); void clear_chains(void); void rename_chain(const string& name); void toggle_chain_muting(void); void toggle_chain_bypass(void); const vector& selected_chains(void) const { return selected_chainids; } unsigned int first_selected_chain(void) const; vector chain_names(void) const; vector get_attached_chains_to_iodev(const string& filename) const; const CHAIN* get_chain_with_name(const string& name) const; int get_chain_index(const string& name) const; /*@}*/ // ------------------------------------------------------------------- /** @name Functions for handling MIDI-objects */ /*@{*/ void add_midi_device(MIDI_IO* mididev); void remove_midi_device(const string& name); void add_default_midi_device(void); /*@}*/ // ------------------------------------------------------------------- /** @name Functions for chain operators */ /*@{*/ void add_chain_operator(CHAIN_OPERATOR* cotmp); void add_controller(GENERIC_CONTROLLER* csrc); void set_target_to_controller(void); /*@}*/ // ------------------------------------------------------------------- /** @name Functions for configuration (default values, settings) */ /*@{*/ void toggle_precise_sample_rates(bool value) { precise_sample_rates_rep = value; } void toggle_ignore_xruns(bool v) { ignore_xruns_rep = v; } void set_output_openmode(int value) { output_openmode_rep = value; } void set_default_audio_format(ECA_AUDIO_FORMAT& value); void set_default_midi_device(const string& name) { default_midi_device_rep = name; } void set_buffering_mode(Buffering_mode_t value); void set_audio_io_manager_option(const string& mgrname, const string& optionstr); void set_mix_mode(Mix_mode_t value) { mix_mode_rep = value; } bool precise_sample_rates(void) const { return precise_sample_rates_rep; } bool ignore_xruns(void) const { return ignore_xruns_rep; } const ECA_AUDIO_FORMAT& default_audio_format(void) const; const string& default_midi_device(void) const { return default_midi_device_rep; } int output_openmode(void) const { return output_openmode_rep; } Buffering_mode_t buffering_mode(void) const { return buffering_mode_rep; } bool is_valid_for_connection(bool verbose) const; bool multitrack_mode(void) const { return multitrack_mode_rep; } long int multitrack_mode_offset(void) const { return multitrack_mode_offset_rep; } Mix_mode_t mix_mode(void) const { return mix_mode_rep; } /*@}*/ // ------------------------------------------------------------------- /** @name Functions for overriding current buffering mode parameters */ /*@{*/ void set_buffersize(long int value); void toggle_raised_priority(bool value); void set_sched_priority(int value); void toggle_double_buffering(bool value); void set_double_buffer_size(long int v); void toggle_max_buffers(bool v); long int buffersize(void) const; bool raised_priority(void) const; int get_sched_priority(void) const; bool double_buffering(void) const; long int double_buffer_size(void) const; bool max_buffers(void) const; /*@}*/ // ------------------------------------------------------------------- /** @name Functions that modify current state */ /*@{*/ void set_name(const string& str) { setup_name_rep = str; } void set_filename(const string& str) { setup_filename_rep = str; } void enable(void) throw(ECA_ERROR&); void disable(void); const string& name(void) const { return setup_name_rep; } const string& filename(void) const { return setup_filename_rep; } bool execute_edit(const ECA::chainsetup_edit_t& edit); /*@}*/ // ------------------------------------------------------------------- /** @name Functions implemented from ECA_SAMPLERATE_AWARE */ /*@{*/ virtual void set_samples_per_second(SAMPLE_SPECS::sample_rate_t v); /*@}*/ // ------------------------------------------------------------------- /** @name Functions implemented from ECA_AUDIO_POSITION */ /*@{*/ virtual SAMPLE_SPECS::sample_pos_t seek_position(SAMPLE_SPECS::sample_pos_t pos); /*@}*/ // ------------------------------------------------------------------- /** @name Functions for observing current state */ /*@{*/ /** * Checks whether chainsetup is enabled (devices ready for use). */ bool is_enabled(void) const { return is_enabled_rep; } /** * Checks whether chainsetup is locked by ECA_ENGINE. * If locked, only a limited access to the chainsetup * data is allowed. */ bool is_locked(void) const { return is_locked_rep; } bool is_valid(void) const; bool has_realtime_objects(void) const; bool has_nonrealtime_objects(void) const; string options_to_string(void) const; /*@}*/ // ------------------------------------------------------------------- /** @name Functions for string->state conversions */ /*@{*/ /** * Returns the result of last call to interpret_option(), interpret_global_option() * or interpret_object_option(). * * @result true if options interpreted succesfully, otherwise false */ bool interpret_result(void) const { return cparser_rep.interpret_result(); } const string& interpret_result_verbose(void) const { return cparser_rep.interpret_result_verbose(); } void interpret_option(const string& arg); void interpret_global_option(const string& arg); void interpret_object_option(const string& arg); void interpret_options(const vector& opts); /*@}*/ // ------------------------------------------------------------------- /** @name Functions for string<->state conversions */ /*@{*/ void save(void) throw(ECA_ERROR&); void save_to_file(const string& filename) throw(ECA_ERROR&); /*@}*/ // ------------------------------------------------------------------- private: /** @name Configuration data (settings and values) */ /*@{*/ ECA_CHAINSETUP_impl* impl_repp; ECA_CHAINSETUP_PARSER cparser_rep; bool precise_sample_rates_rep; bool ignore_xruns_rep; bool rtcaps_rep; int output_openmode_rep; long int double_buffer_size_rep; string default_midi_device_rep; /*@}*/ // ------------------------------------------------------------------- /** @name Current setup data (internal state, objects) */ /*@{*/ bool is_locked_rep; bool is_enabled_rep; bool multitrack_mode_rep; bool multitrack_mode_override_rep; bool memory_locked_rep; bool midi_server_needed_rep; /* FIXME: only needed by ECA_ENGINE */ int selected_chain_index_rep; int selected_cop_index_rep; int selected_cop_param_index_rep; int selected_ctrl_index_rep; int selected_ctrl_param_index_rep; int db_clients_rep; long int multitrack_mode_offset_rep; string setup_name_rep; string setup_filename_rep; vector selected_chainids; map loop_map; vector input_start_pos; vector output_start_pos; Buffering_mode_t buffering_mode_rep; Buffering_mode_t active_buffering_mode_rep; Mix_mode_t mix_mode_rep; vector inputs; vector inputs_direct_rep; vector outputs; vector outputs_direct_rep; vector aio_managers_rep; map aio_manager_option_map_rep; vector chains; vector midi_devices; AUDIO_IO_DB_SERVER* pserver_repp; MIDI_SERVER* midi_server_repp; ECA_ENGINE_DRIVER* engine_driver_repp; /*@}*/ // ------------------------------------------------------------------- /** @name Functions for handling audio objects */ /*@{*/ AUDIO_IO_MANAGER* get_audio_object_manager(AUDIO_IO* aio) const; AUDIO_IO_MANAGER* get_audio_object_type_manager(AUDIO_IO* aio) const; void register_engine_driver(AUDIO_IO_MANAGER* amgr); void register_audio_object_to_manager(AUDIO_IO* aio); void unregister_audio_object_from_manager(AUDIO_IO* aio); void propagate_audio_io_manager_options(void); AUDIO_IO* add_audio_object_helper(AUDIO_IO* aio); void remove_audio_object_proxy(AUDIO_IO* aio); void remove_audio_object_loop(const string& label, AUDIO_IO* aio, int dir); void remove_audio_object_impl(const string& label, int dir, bool destroy); // ------------------------------------------------------------------- /** @name Functions for state<->string conversions */ /*@{*/ void load_from_file(const string& filename, vector& opts) const throw(ECA_ERROR&); /*@}*/ // ------------------------------------------------------------------- /** @name Functions for internal state changes */ /*@{*/ void select_active_buffering_mode(void); void enable_active_buffering_mode(void); void switch_to_direct_mode(void); void switch_to_direct_mode_helper(vector* objs, const vector& directobjs); void switch_to_db_mode(void); void switch_to_db_mode_helper(vector* objs, const vector& directobjs); void lock_all_memory(void); void unlock_all_memory(void); void set_defaults (void); int number_of_realtime_inputs(void) const; int number_of_realtime_outputs(void) const; int number_of_non_realtime_inputs(void) const; int number_of_non_realtime_outputs(void) const; int number_of_chain_operators(void) const; void toggle_locked_state(bool value) { is_locked_rep = value; } long int check_for_locked_buffersize(void) const; /*@}*/ // ------------------------------------------------------------------- /** @name Private helper functions */ /*@{*/ const ECA_CHAINSETUP_BUFPARAMS& active_buffering_parameters(void) const; const ECA_CHAINSETUP_BUFPARAMS& override_buffering_parameters(void) const; vector get_attached_chains_to_input(AUDIO_IO* aiod) const; vector get_attached_chains_to_output(AUDIO_IO* aiod) const; int number_of_attached_chains_to_input(AUDIO_IO* aiod) const; int number_of_attached_chains_to_output(AUDIO_IO* aiod) const; void add_chain_helper(const string& name); void enable_audio_object_helper(AUDIO_IO* aobj) const; void calculate_processing_length(void); /*@}*/ // ------------------------------------------------------------------- /** @name Static private helper functions */ /*@{*/ static bool ok_audio_object_helper(const AUDIO_IO* aobj, const vector& aobjs); static void check_object_samplerate(const AUDIO_IO* obj, SAMPLE_SPECS::sample_rate_t srate) throw(ECA_ERROR&); static string set_resource_helper(const ECA_RESOURCES& ecaresources, const string& tag, const string& alternative); static void audio_object_open_info(const AUDIO_IO* aio); /*@}*/ }; #endif