1 /* 2 * Copyright (C) 2013 Paul Davis <paul@linuxaudiosystems.com> 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 along 15 * with this program; if not, write to the Free Software Foundation, Inc., 16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 17 */ 18 19 #include <stdint.h> 20 21 #include <vector> 22 #include <map> 23 #include <string> 24 25 namespace ARDOUR { 26 27 // Names for the drivers on all possible systems 28 extern const char * const portaudio_driver_name; 29 extern const char * const coreaudio_driver_name; 30 extern const char * const alsa_driver_name; 31 extern const char * const oss_driver_name; 32 extern const char * const sun_driver_name; 33 extern const char * const freebob_driver_name; 34 extern const char * const ffado_driver_name; 35 extern const char * const netjack_driver_name; 36 extern const char * const dummy_driver_name; 37 38 /** 39 * Get a list of possible JACK audio driver names based on platform 40 */ 41 void get_jack_audio_driver_names (std::vector<std::string>& driver_names); 42 43 /** 44 * Get the default JACK audio driver based on platform 45 */ 46 void get_jack_default_audio_driver_name (std::string& driver_name); 47 48 /** 49 * Get a list of possible samplerates supported be JACK 50 */ 51 void get_jack_sample_rate_strings (std::vector<std::string>& sample_rates); 52 53 /** 54 * @return The default samplerate 55 */ 56 std::string get_jack_default_sample_rate (); 57 58 /** 59 * @return true if sample rate string was able to be converted 60 */ 61 bool get_jack_sample_rate_value_from_string (const std::string& srs, uint32_t& srv); 62 63 /** 64 * Get a list of possible period sizes supported be JACK 65 */ 66 void get_jack_period_size_strings (std::vector<std::string>& samplerates); 67 68 /** 69 * @return The default period size 70 */ 71 std::string get_jack_default_period_size (); 72 73 /** 74 * @return true if period size string was able to be converted 75 */ 76 bool get_jack_period_size_value_from_string (const std::string& pss, uint32_t& psv); 77 78 /** 79 * These are driver specific I think, so it may require a driver arg 80 * in future 81 */ 82 void get_jack_dither_mode_strings (const std::string& driver, std::vector<std::string>& dither_modes); 83 84 /** 85 * @return The default dither mode 86 */ 87 std::string get_jack_default_dither_mode (const std::string& driver); 88 89 /** 90 * @return Estimate of latency 91 * 92 * API matches current use in GUI 93 */ 94 std::string get_jack_latency_string (std::string samplerate, float periods, std::string period_size); 95 96 /** 97 * Key being a readable name to display in a GUI 98 * Value being name used in a jack commandline 99 */ 100 typedef std::map<std::string, std::string> device_map_t; 101 102 /** 103 * Use library specific code to find out what what devices exist for a given 104 * driver that might work in JACK. There is no easy way to find out what 105 * modules the JACK server supports so guess based on platform. For instance 106 * portaudio is cross-platform but we only return devices if built for 107 * windows etc 108 */ 109 void get_jack_alsa_device_names (device_map_t& devices); 110 void get_jack_portaudio_device_names (device_map_t& devices); 111 void get_jack_coreaudio_device_names (device_map_t& devices); 112 void get_jack_oss_device_names (device_map_t& devices); 113 void get_jack_sun_device_names (device_map_t& devices); 114 void get_jack_freebob_device_names (device_map_t& devices); 115 void get_jack_ffado_device_names (device_map_t& devices); 116 void get_jack_netjack_device_names (device_map_t& devices); 117 void get_jack_dummy_device_names (device_map_t& devices); 118 119 /* 120 * @return true if there were devices found for the driver 121 * 122 * @param driver The driver name returned by get_jack_audio_driver_names 123 * @param devices The map used to insert the drivers into, devices will be cleared before 124 * adding the available drivers 125 */ 126 bool get_jack_device_names_for_audio_driver (const std::string& driver, device_map_t& devices); 127 128 /* 129 * @return a list of readable device names for a specific driver. 130 */ 131 std::vector<std::string> get_jack_device_names_for_audio_driver (const std::string& driver); 132 133 /** 134 * @return true if the driver supports playback and recording 135 * on separate devices 136 */ 137 bool get_jack_audio_driver_supports_two_devices (const std::string& driver); 138 139 bool get_jack_audio_driver_supports_latency_adjustment (const std::string& driver); 140 141 bool get_jack_audio_driver_supports_setting_period_count (const std::string& driver); 142 143 /** 144 * The possible names to use to try and find servers, this includes 145 * any file extensions like .exe on Windows 146 * 147 * @return true if the JACK application names for this platform could be guessed 148 */ 149 bool get_jack_server_application_names (std::vector<std::string>& server_names); 150 151 /** 152 * Sets the PATH environment variable to contain directories likely to contain 153 * JACK servers so that if the JACK server is auto-started it can find the server 154 * executable. 155 * 156 * This is only modifies PATH on the mac at the moment. 157 */ 158 void set_path_env_for_jack_autostart (const std::vector<std::string>&); 159 160 /** 161 * Get absolute paths to directories that might contain JACK servers on the system 162 * 163 * @return true if !server_paths.empty() 164 */ 165 bool get_jack_server_dir_paths (std::vector<std::string>& server_dir_paths); 166 167 /** 168 * Get absolute paths to JACK servers on the system 169 * 170 * @return true if a server was found 171 */ 172 bool get_jack_server_paths (const std::vector<std::string>& server_dir_paths, 173 const std::vector<std::string>& server_names, 174 std::vector<std::string>& server_paths); 175 176 177 bool get_jack_server_paths (std::vector<std::string>& server_paths); 178 179 /** 180 * Get absolute path to default JACK server 181 */ 182 bool get_jack_default_server_path (std::string& server_path); 183 184 typedef std::vector<std::pair<std::string,std::string> > MidiOptions; 185 186 /** 187 * @return The name of the jack server config file 188 */ 189 std::string get_jack_server_config_file_name (); 190 191 std::string get_jack_server_user_config_dir_path (); 192 193 std::string get_jack_server_user_config_file_path (); 194 195 bool write_jack_config_file (const std::string& config_file_path, const std::string& command_line); 196 197 struct JackCommandLineOptions { 198 199 // see implementation for defaults 200 JackCommandLineOptions (); 201 202 //operator bool 203 //operator ostream 204 205 std::string server_path; 206 uint32_t timeout; 207 bool no_mlock; 208 uint32_t ports_max; 209 bool realtime; 210 uint32_t priority; 211 bool unlock_gui_libs; 212 bool verbose; 213 bool temporary; 214 bool playback_only; 215 bool capture_only; 216 std::string driver; 217 std::string input_device; 218 std::string output_device; 219 uint32_t num_periods; 220 uint32_t period_size; 221 uint32_t samplerate; 222 uint32_t input_channels; 223 uint32_t output_channels; 224 uint32_t input_latency; 225 uint32_t output_latency; 226 bool hardware_metering; 227 bool hardware_monitoring; 228 std::string dither_mode; 229 bool force16_bit; 230 bool soft_mode; 231 std::string midi_driver; 232 }; 233 234 std::vector<std::string> enumerate_midi_options (); 235 int set_midi_option (ARDOUR::JackCommandLineOptions&, const std::string& opt); 236 237 /** 238 * @return true if able to build a valid command line based on options 239 */ 240 bool get_jack_command_line_string (JackCommandLineOptions& options, std::string& command_line); 241 } 242