/* Copyright (C) 2011 Tim Mayberry 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. */ #include #include #include #include namespace ARDOUR { // Names for the drivers on all possible systems extern const char * const portaudio_driver_name; extern const char * const coreaudio_driver_name; extern const char * const alsa_driver_name; extern const char * const oss_driver_name; extern const char * const freebob_driver_name; extern const char * const ffado_driver_name; extern const char * const netjack_driver_name; extern const char * const dummy_driver_name; /** * Get a list of possible JACK audio driver names based on platform */ void get_jack_audio_driver_names (std::vector& driver_names); /** * Get the default JACK audio driver based on platform */ void get_jack_default_audio_driver_name (std::string& driver_name); /** * Get a list of possible JACK midi driver names based on platform */ void get_jack_midi_system_names (const std::string& driver, std::vector& driver_names); /** * Get the default JACK midi driver based on platform */ void get_jack_default_midi_system_name (const std::string& driver_name, std::string& midi_system); /** * Get a list of possible samplerates supported be JACK */ void get_jack_sample_rate_strings (std::vector& sample_rates); /** * @return The default samplerate */ std::string get_jack_default_sample_rate (); /** * @return true if sample rate string was able to be converted */ bool get_jack_sample_rate_value_from_string (const std::string& srs, uint32_t& srv); /** * Get a list of possible period sizes supported be JACK */ void get_jack_period_size_strings (std::vector& samplerates); /** * @return The default period size */ std::string get_jack_default_period_size (); /** * @return true if period size string was able to be converted */ bool get_jack_period_size_value_from_string (const std::string& pss, uint32_t& psv); /** * These are driver specific I think, so it may require a driver arg * in future */ void get_jack_dither_mode_strings (const std::string& driver, std::vector& dither_modes); /** * @return The default dither mode */ std::string get_jack_default_dither_mode (const std::string& driver); /** * @return Estimate of latency * * API matches current use in GUI */ std::string get_jack_latency_string (std::string samplerate, float periods, std::string period_size); /** * @return true if a JACK server is running */ bool jack_server_running (); /** * Key being a readable name to display in a GUI * Value being name used in a jack commandline */ typedef std::map device_map_t; /** * Use library specific code to find out what what devices exist for a given * driver that might work in JACK. There is no easy way to find out what * modules the JACK server supports so guess based on platform. For instance * portaudio is cross-platform but we only return devices if built for * windows etc */ void get_jack_alsa_device_names (device_map_t& devices); void get_jack_portaudio_device_names (device_map_t& devices); void get_jack_coreaudio_device_names (device_map_t& devices); void get_jack_oss_device_names (device_map_t& devices); void get_jack_freebob_device_names (device_map_t& devices); void get_jack_ffado_device_names (device_map_t& devices); void get_jack_netjack_device_names (device_map_t& devices); void get_jack_dummy_device_names (device_map_t& devices); /* * @return true if there were devices found for the driver * * @param driver The driver name returned by get_jack_audio_driver_names * @param devices The map used to insert the drivers into, devices will be cleared before * adding the available drivers */ bool get_jack_device_names_for_audio_driver (const std::string& driver, device_map_t& devices); /* * @return a list of readable device names for a specific driver. */ std::vector get_jack_device_names_for_audio_driver (const std::string& driver); /** * @return true if the driver supports playback and recording * on separate devices */ bool get_jack_audio_driver_supports_two_devices (const std::string& driver); bool get_jack_audio_driver_supports_latency_adjustment (const std::string& driver); bool get_jack_audio_driver_supports_setting_period_count (const std::string& driver); /** * The possible names to use to try and find servers, this includes * any file extensions like .exe on Windows * * @return true if the JACK application names for this platform could be guessed */ bool get_jack_server_application_names (std::vector& server_names); /** * Sets the PATH environment variable to contain directories likely to contain * JACK servers so that if the JACK server is auto-started it can find the server * executable. * * This is only modifies PATH on the mac at the moment. */ void set_path_env_for_jack_autostart (const std::vector&); /** * Get absolute paths to directories that might contain JACK servers on the system * * @return true if !server_paths.empty() */ bool get_jack_server_dir_paths (std::vector& server_dir_paths); /** * Get absolute paths to JACK servers on the system * * @return true if a server was found */ bool get_jack_server_paths (const std::vector& server_dir_paths, const std::vector& server_names, std::vector& server_paths); bool get_jack_server_paths (std::vector& server_paths); /** * Get absolute path to default JACK server */ bool get_jack_default_server_path (std::string& server_path); /** * @return The name of the jack server config file */ std::string get_jack_server_config_file_name (); std::string get_jack_server_user_config_dir_path (); std::string get_jack_server_user_config_file_path (); bool write_jack_config_file (const std::string& config_file_path, const std::string& command_line); struct JackCommandLineOptions { // see implementation for defaults JackCommandLineOptions (); //operator bool //operator ostream std::string server_path; uint32_t timeout; bool no_mlock; uint32_t ports_max; bool realtime; uint32_t priority; bool unlock_gui_libs; bool verbose; bool temporary; bool playback_only; bool capture_only; std::string driver; std::string input_device; std::string output_device; uint32_t num_periods; uint32_t period_size; uint32_t samplerate; uint32_t input_latency; uint32_t output_latency; bool hardware_metering; bool hardware_monitoring; std::string dither_mode; bool force16_bit; bool soft_mode; std::string midi_driver; }; /** * @return true if able to build a valid command line based on options */ bool get_jack_command_line_string (const JackCommandLineOptions& options, std::string& command_line); /** * We don't need this at the moment because the gui stores all its settings */ //std::string get_jack_command_line_from_config_file (const std::string& config_file_path); }