445 lines
14 KiB
C++
445 lines
14 KiB
C++
// ------------------------------------------------------------------------
|
|
// eca-control.h: ECA_CONTROL class
|
|
// Copyright (C) 2009 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, see <http://www.gnu.org/licenses/>.
|
|
// ------------------------------------------------------------------------
|
|
|
|
#ifndef INCLUDED_ECA_CONTROL_H
|
|
#define INCLUDED_ECA_CONTROL_H
|
|
|
|
#include <list>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "kvu_locks.h"
|
|
|
|
#include "ctrl-source.h"
|
|
#include "eca-audio-format.h"
|
|
#include "eca-chainop.h"
|
|
#include "eca-chainsetup-edit.h"
|
|
#include "eca-control-dump.h"
|
|
#include "eca-control-main.h"
|
|
#include "eca-iamode-parser.h"
|
|
#include "sample-specs.h"
|
|
|
|
class AUDIO_IO;
|
|
class CHAIN_OPERATOR;
|
|
class GENERIC_CONTROLLER;
|
|
class ECA_CHAINSETUP;
|
|
class ECA_ENGINE;
|
|
class ECA_OBJECT_MAP;
|
|
class ECA_SESSION;
|
|
|
|
/**
|
|
* High-level interface to libecasound functionality
|
|
*
|
|
* @see ECA_CONTROL_MAIN, ECA_CONTROL_MT
|
|
*
|
|
* Related design patters: Facade (GoF185)
|
|
*
|
|
* @author Kai Vehmanen
|
|
*/
|
|
class ECA_CONTROL : public ECA_IAMODE_PARSER,
|
|
public ECA_CONTROL_MAIN {
|
|
|
|
|
|
public:
|
|
|
|
/** @name Constructors and dtors */
|
|
/*@{*/
|
|
|
|
ECA_CONTROL (ECA_SESSION* psession);
|
|
~ECA_CONTROL (void);
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name ECA_CONTROL_MAIN subset */
|
|
|
|
virtual bool is_running(void) const;
|
|
virtual bool is_connected(void) const;
|
|
virtual bool is_selected(void) const;
|
|
virtual bool is_finished(void) const;
|
|
virtual bool is_valid(void) const;
|
|
virtual bool is_engine_created(void) const;
|
|
virtual bool is_engine_running(void) const;
|
|
|
|
virtual void engine_start(void);
|
|
virtual int start(void);
|
|
virtual void stop(void);
|
|
virtual void stop_on_condition(void);
|
|
virtual int run(bool batchmode = true);
|
|
virtual void quit(void);
|
|
virtual void quit_async(void);
|
|
|
|
virtual void connect_chainsetup(struct eci_return_value *retval);
|
|
virtual void disconnect_chainsetup(void);
|
|
virtual const ECA_CHAINSETUP* get_connected_chainsetup(void) const;
|
|
|
|
virtual bool execute_edit_on_connected(const ECA::chainsetup_edit_t& edit);
|
|
virtual bool execute_edit_on_selected(const ECA::chainsetup_edit_t& edit, int index = -1);
|
|
|
|
virtual void print_last_value(struct eci_return_value *retval) const;
|
|
virtual void command(const std::string& cmd_and_args, struct eci_return_value *retval);
|
|
virtual void command_float_arg(const std::string& cmd, double arg, struct eci_return_value *retval);
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name Public functions for observing status
|
|
* (note: implemented in eca-control-base.cpp)
|
|
*/
|
|
/*@{*/
|
|
|
|
std::string engine_status(void) const;
|
|
|
|
SAMPLE_SPECS::sample_pos_t length_in_samples(void) const;
|
|
double length_in_seconds_exact(void) const;
|
|
SAMPLE_SPECS::sample_pos_t position_in_samples(void) const;
|
|
double position_in_seconds_exact(void) const;
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name Public functions for resource file access */
|
|
/*@{*/
|
|
|
|
/**
|
|
* Get resource values from ~/.ecasoundrc
|
|
*/
|
|
std::string resource_value(const std::string& key) const;
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name Public functions for chainsetup setup
|
|
* (note: implementated in eca-control-objects.cpp)
|
|
*/
|
|
/*@{*/
|
|
|
|
void add_chainsetup(const std::string& name);
|
|
void remove_chainsetup(void);
|
|
void load_chainsetup(const std::string& filename);
|
|
void save_chainsetup(const std::string& filename);
|
|
void select_chainsetup(const std::string& name);
|
|
void select_chainsetup_by_index(int index);
|
|
void edit_chainsetup(void);
|
|
|
|
std::string selected_chainsetup(void) const;
|
|
std::string connected_chainsetup(void) const;
|
|
|
|
void change_chainsetup_position(double seconds);
|
|
void change_chainsetup_position_samples(SAMPLE_SPECS::sample_pos_t samples);
|
|
void set_chainsetup_position(double seconds);
|
|
void set_chainsetup_position_samples(SAMPLE_SPECS::sample_pos_t samples);
|
|
|
|
double chainsetup_position(double seconds) const;
|
|
const ECA_CHAINSETUP* get_chainsetup(void) const;
|
|
const ECA_CHAINSETUP* get_chainsetup_filename(const std::string& filename) const;
|
|
std::vector<std::string> chainsetup_names(void) const;
|
|
const std::string& chainsetup_filename(void) const;
|
|
int chainsetup_buffersize(void) const;
|
|
|
|
void set_chainsetup_filename(const std::string& name);
|
|
void set_chainsetup_parameter(const std::string& name);
|
|
void set_chainsetup_sample_format(const std::string& name);
|
|
void set_chainsetup_processing_length_in_seconds(double value);
|
|
void set_chainsetup_processing_length_in_samples(SAMPLE_SPECS::sample_pos_t value);
|
|
void set_chainsetup_output_mode(int output_mode);
|
|
void toggle_chainsetup_looping(void);
|
|
void set_chainsetup_buffersize(int bsize);
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name Public functions for chain setup
|
|
* (note: implemented in eca-control-objects.cpp)
|
|
*/
|
|
/*@{*/
|
|
|
|
void add_chain(const std::string& names);
|
|
void add_chains(const std::string& names);
|
|
void add_chains(const std::vector<std::string>& names);
|
|
void remove_chains(void);
|
|
void select_chains_by_index(const std::vector<int>& index_numbers);
|
|
void select_chain(const std::string& chain);
|
|
void select_chains(const std::vector<std::string>& chains);
|
|
void deselect_chains(const std::vector<std::string>& chains);
|
|
void select_all_chains(void);
|
|
|
|
const std::vector<std::string>& selected_chains(void) const;
|
|
std::vector<std::string> chain_names(void) const;
|
|
const CHAIN* get_chain(void) const;
|
|
|
|
void clear_chains(void);
|
|
void rename_chain(const std::string& name);
|
|
void toggle_chain_muting(void);
|
|
void toggle_chain_bypass(void);
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name Managing chain operators and controllers
|
|
* (note: implemented in eca-control-objects.cpp)
|
|
*/
|
|
/*@{*/
|
|
|
|
void add_audio_input(const std::string& filename);
|
|
void remove_audio_input(void);
|
|
void attach_audio_input(void);
|
|
void select_audio_input(const std::string& name);
|
|
void select_audio_input_by_index(int index);
|
|
|
|
void add_audio_output(const std::string& filename);
|
|
void add_default_output(void);
|
|
void remove_audio_output(void);
|
|
void attach_audio_output(void);
|
|
void select_audio_output(const std::string& name);
|
|
void select_audio_output_by_index(int index);
|
|
void set_default_audio_format(const std::string& sfrm, int channels, long int srate, bool interleaving);
|
|
void set_default_audio_format(const ECA_AUDIO_FORMAT& format);
|
|
void set_default_audio_format_to_selected_input(void);
|
|
void set_default_audio_format_to_selected_output(void);
|
|
|
|
std::string attached_chains_input(AUDIO_IO* aiod) const;
|
|
std::string attached_chains_output(AUDIO_IO* aiod) const;
|
|
std::vector<std::string> attached_chains(const std::string& name) const;
|
|
|
|
const AUDIO_IO* get_audio_input(void);
|
|
std::vector<std::string> audio_input_names(void) const;
|
|
|
|
const AUDIO_IO* get_audio_output(void);
|
|
std::vector<std::string> audio_output_names(void) const;
|
|
|
|
const ECA_AUDIO_FORMAT& default_audio_format(void) const;
|
|
ECA_AUDIO_FORMAT get_audio_format(AUDIO_IO* aobj) const;
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name Managing chain operators and controllers
|
|
* (note: implemented in eca-control-objects.cpp)
|
|
*/
|
|
/*@{*/
|
|
|
|
void add_chain_operator(const std::string& chainop_params);
|
|
void add_chain_operator(CHAIN_OPERATOR* cotmp);
|
|
void remove_chain_operator(void);
|
|
void select_chain_operator(int chainop_id);
|
|
void select_chain_operator_parameter(int param);
|
|
void set_chain_operator_parameter(CHAIN_OPERATOR::parameter_t value);
|
|
void set_chain_operator_parameter(int chain, int op, int param, CHAIN_OPERATOR::parameter_t value);
|
|
|
|
int selected_chain_operator(void) const;
|
|
int selected_chain_operator_parameter(void) const;
|
|
|
|
const CHAIN_OPERATOR* get_chain_operator(void) const;
|
|
CHAIN_OPERATOR::parameter_t get_chain_operator_parameter(void) const;
|
|
std::vector<std::string> chain_operator_names(void) const;
|
|
std::vector<std::string> chain_operator_parameter_names(void) const;
|
|
|
|
void add_controller(const std::string& gcontrol_params);
|
|
void select_controller(int ctrl_id);
|
|
void select_controller_parameter(int param);
|
|
void set_controller_parameter(CHAIN_OPERATOR::parameter_t value);
|
|
void remove_controller(void);
|
|
|
|
int selected_controller(void) const;
|
|
int selected_controller_parameter(void) const;
|
|
int selected_controller_target(void) const;
|
|
|
|
const GENERIC_CONTROLLER* get_controller(void) const;
|
|
CONTROLLER_SOURCE::parameter_t get_controller_parameter(void) const;
|
|
std::vector<std::string> controller_names(void) const;
|
|
std::vector<std::string> controller_parameter_names(void) const;
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name Public functions for executing ECI commands */
|
|
/*@{*/
|
|
|
|
/**
|
|
* See ECA_IAMODE_PARSER for detailed decsription of 'action_id'.
|
|
*
|
|
* Result of the command can be queried with last_value_to_string().
|
|
*/
|
|
void action(int action_id, const std::vector<std::string>& args);
|
|
|
|
std::string last_error(void) const;
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name Implemenetations of ECI status commands */
|
|
/*@{*/
|
|
|
|
/**
|
|
* Return info about chainsetups
|
|
*/
|
|
std::string chainsetup_status(void) const;
|
|
|
|
/**
|
|
* Return info about current chain status
|
|
*
|
|
* require:
|
|
* is_selected() == true
|
|
* selected_chains().size() > 0
|
|
*/
|
|
std::string chain_status(void) const;
|
|
|
|
/**
|
|
* Return info about inputs and outputs
|
|
*/
|
|
std::string aio_status(void) const;
|
|
|
|
/**
|
|
* Return info about chain operators (selected chainsetup)
|
|
*
|
|
* require:
|
|
* is_selected() == true
|
|
*/
|
|
std::string chain_operator_status(void) const;
|
|
|
|
/**
|
|
* Return info about controllers (selected chainsetup)
|
|
*
|
|
* require:
|
|
* is_selected() == true
|
|
*/
|
|
std::string controller_status(void) const;
|
|
|
|
void aio_register(void);
|
|
void cop_register(void);
|
|
void preset_register(void);
|
|
void ladspa_register(void);
|
|
void ctrl_register(void);
|
|
|
|
void operator_descriptions_helper(const ECA_OBJECT_MAP& arg, std::string* result);
|
|
void cop_descriptions(void);
|
|
void preset_descriptions(void);
|
|
void ladspa_descriptions(bool use_id);
|
|
void ctrl_descriptions(void);
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
/** @name Helper functions */
|
|
/*@{*/
|
|
|
|
int float_to_string_precision(void) const { return(float_to_string_precision_rep); }
|
|
|
|
/*@}*/
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
protected:
|
|
|
|
void set_float_to_string_precision(int precision);
|
|
std::string float_to_string(double n) const;
|
|
|
|
private:
|
|
|
|
void set_last_string_list(const std::vector<std::string>& s);
|
|
void set_last_string(const std::list<std::string>& s);
|
|
void set_last_string(const std::string& s);
|
|
void set_last_float(double v);
|
|
void set_last_integer(int v);
|
|
void set_last_long_integer(long int v);
|
|
void set_last_error(const std::string& s);
|
|
void clear_last_values(void);
|
|
|
|
static void* start_normal_thread(void *ptr);
|
|
|
|
void start_engine_sub(bool batchmode);
|
|
void close_engine(void);
|
|
void run_engine(void);
|
|
|
|
std::string chainsetup_details_to_string(const ECA_CHAINSETUP* cs) const;
|
|
|
|
void audio_input_as_selected(void);
|
|
void audio_output_as_selected(void);
|
|
void rewind_audio_object(double seconds);
|
|
void forward_audio_object(double seconds);
|
|
void set_audio_object_position(double seconds);
|
|
void set_audio_object_position_samples(SAMPLE_SPECS::sample_pos_t samples);
|
|
void wave_edit_audio_object(void);
|
|
|
|
bool cond_stop_for_editing(void);
|
|
void cond_start_after_editing(bool was_running);
|
|
|
|
void send_chain_commands_to_engine(int command, double value);
|
|
|
|
void action(int action_id);
|
|
void check_action_preconditions(int action_id);
|
|
void chainsetup_option(const std::string& cmd);
|
|
void set_action_argument(const std::string& s);
|
|
void set_action_argument(const std::vector<std::string>& s);
|
|
void set_action_argument(double v);
|
|
void clear_action_arguments(void);
|
|
double first_action_argument_as_float(void) const;
|
|
std::string first_action_argument_as_string(void) const;
|
|
int first_action_argument_as_int(void) const;
|
|
long int first_action_argument_as_long_int(void) const;
|
|
SAMPLE_SPECS::sample_pos_t first_action_argument_as_samples(void) const;
|
|
const std::vector<std::string>& action_arguments_as_vector(void) const;
|
|
void fill_command_retval(struct eci_return_value *retval) const;
|
|
bool action_helper_check_cop_op_args(int copid, int coppid);
|
|
|
|
ECA_ENGINE* engine_repp;
|
|
ECA_SESSION* session_repp;
|
|
ECA_CHAINSETUP* selected_chainsetup_repp;
|
|
ECA_CONTROL_DUMP ctrl_dump_rep;
|
|
|
|
bool req_batchmode_rep;
|
|
pthread_t th_cqueue_rep;
|
|
ATOMIC_INTEGER engine_exited_rep;
|
|
int engine_pid_rep;
|
|
int last_exec_res_rep;
|
|
bool joining_rep;
|
|
|
|
int float_to_string_precision_rep;
|
|
|
|
AUDIO_IO* selected_audio_object_repp;
|
|
AUDIO_IO* selected_audio_input_repp;
|
|
AUDIO_IO* selected_audio_output_repp;
|
|
|
|
struct eci_return_value last_retval_rep;
|
|
|
|
bool wellformed_mode_rep;
|
|
|
|
std::vector<std::string> action_args_rep;
|
|
double action_arg_f_rep;
|
|
bool action_arg_f_set_rep;
|
|
bool action_ok;
|
|
bool action_reconnect;
|
|
bool action_restart;
|
|
};
|
|
|
|
#endif
|