2 Copyright (C) 2000 Paul Davis
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.
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.
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.
20 #include "libardour-config.h"
27 #include <cstdio> // Needed so that libraptor (included in lrdf) won't complain
30 #include <sys/types.h>
32 #ifndef PLATFORM_WINDOWS
33 #include <sys/resource.h>
41 #include "pbd/gstdio_compat.h"
43 #ifdef PLATFORM_WINDOWS
44 #include <stdio.h> // for _setmaxstdio
45 #include <windows.h> // for LARGE_INTEGER
48 #ifdef WINDOWS_VST_SUPPORT
53 #include "ardour/linux_vst_support.h"
56 #ifdef AUDIOUNIT_SUPPORT
57 #include "ardour/audio_unit.h"
60 #if defined(__SSE__) || defined(USE_XMMINTRIN)
61 #include <xmmintrin.h>
65 #undef check /* stupid Apple and their un-namespaced, generic Carbon macros */
68 #include <glibmm/fileutils.h>
69 #include <glibmm/miscutils.h>
76 #include "pbd/error.h"
79 #include "pbd/strsplit.h"
81 #include "pbd/file_utils.h"
82 #include "pbd/enumwriter.h"
84 #include "midi++/port.h"
85 #include "midi++/mmc.h"
87 #include "ardour/analyser.h"
88 #include "ardour/audio_library.h"
89 #include "ardour/audio_backend.h"
90 #include "ardour/audioengine.h"
91 #include "ardour/audioplaylist.h"
92 #include "ardour/audioregion.h"
93 #include "ardour/buffer_manager.h"
94 #include "ardour/control_protocol_manager.h"
95 #include "ardour/directory_names.h"
96 #include "ardour/event_type_map.h"
97 #include "ardour/filesystem_paths.h"
98 #include "ardour/midi_region.h"
99 #include "ardour/midi_ui.h"
100 #include "ardour/midiport_manager.h"
101 #include "ardour/mix.h"
102 #include "ardour/operations.h"
103 #include "ardour/panner_manager.h"
104 #include "ardour/plugin_manager.h"
105 #include "ardour/process_thread.h"
106 #include "ardour/profile.h"
107 #include "ardour/rc_configuration.h"
108 #include "ardour/region.h"
109 #include "ardour/route_group.h"
110 #include "ardour/runtime_functions.h"
111 #include "ardour/session_event.h"
112 #include "ardour/source_factory.h"
113 #include "ardour/uri_map.h"
115 #include "audiographer/routines.h"
117 #if defined (__APPLE__)
118 #include <Carbon/Carbon.h> // For Gestalt
123 ARDOUR::RCConfiguration* ARDOUR::Config = 0;
124 ARDOUR::RuntimeProfile* ARDOUR::Profile = 0;
125 ARDOUR::AudioLibrary* ARDOUR::Library = 0;
127 using namespace ARDOUR;
131 bool libardour_initialized = false;
133 compute_peak_t ARDOUR::compute_peak = 0;
134 find_peaks_t ARDOUR::find_peaks = 0;
135 apply_gain_to_buffer_t ARDOUR::apply_gain_to_buffer = 0;
136 mix_buffers_with_gain_t ARDOUR::mix_buffers_with_gain = 0;
137 mix_buffers_no_gain_t ARDOUR::mix_buffers_no_gain = 0;
138 copy_vector_t ARDOUR::copy_vector = 0;
140 PBD::Signal1<void,std::string> ARDOUR::BootMessage;
141 PBD::Signal3<void,std::string,std::string,bool> ARDOUR::PluginScanMessage;
142 PBD::Signal1<void,int> ARDOUR::PluginScanTimeout;
143 PBD::Signal0<void> ARDOUR::GUIIdle;
144 PBD::Signal3<bool,std::string,std::string,int> ARDOUR::CopyConfigurationFiles;
146 std::vector<std::string> ARDOUR::reserved_io_names;
148 static bool have_old_configuration_files = false;
151 extern void setup_enum_writer ();
154 /* this is useful for quite a few things that want to check
155 if any bounds-related property has changed
157 PBD::PropertyChange ARDOUR::bounds_change;
160 setup_hardware_optimization (bool try_optimization)
162 bool generic_mix_functions = true;
164 if (try_optimization) {
166 FPU* fpu = FPU::instance();
168 #if defined (ARCH_X86) && defined (BUILD_SSE_OPTIMIZATIONS)
170 #ifdef PLATFORM_WINDOWS
171 /* We have AVX-optimized code for Windows */
173 if (fpu->has_avx()) {
175 /* AVX code doesn't compile on Linux yet */
179 info << "Using AVX optimized routines" << endmsg;
182 compute_peak = x86_sse_avx_compute_peak;
183 find_peaks = x86_sse_avx_find_peaks;
184 apply_gain_to_buffer = x86_sse_avx_apply_gain_to_buffer;
185 mix_buffers_with_gain = x86_sse_avx_mix_buffers_with_gain;
186 mix_buffers_no_gain = x86_sse_avx_mix_buffers_no_gain;
187 copy_vector = x86_sse_avx_copy_vector;
189 generic_mix_functions = false;
191 } else if (fpu->has_sse()) {
193 info << "Using SSE optimized routines" << endmsg;
196 compute_peak = x86_sse_compute_peak;
197 find_peaks = x86_sse_find_peaks;
198 apply_gain_to_buffer = x86_sse_apply_gain_to_buffer;
199 mix_buffers_with_gain = x86_sse_mix_buffers_with_gain;
200 mix_buffers_no_gain = x86_sse_mix_buffers_no_gain;
201 copy_vector = default_copy_vector;
203 generic_mix_functions = false;
207 #elif defined (__APPLE__) && defined (BUILD_VECLIB_OPTIMIZATIONS)
208 SInt32 sysVersion = 0;
210 if (noErr != Gestalt(gestaltSystemVersion, &sysVersion))
213 if (sysVersion >= 0x00001040) { // Tiger at least
214 compute_peak = veclib_compute_peak;
215 find_peaks = veclib_find_peaks;
216 apply_gain_to_buffer = veclib_apply_gain_to_buffer;
217 mix_buffers_with_gain = veclib_mix_buffers_with_gain;
218 mix_buffers_no_gain = veclib_mix_buffers_no_gain;
219 copy_vector = default_copy_vector;
221 generic_mix_functions = false;
223 info << "Apple VecLib H/W specific optimizations in use" << endmsg;
227 /* consider FPU denormal handling to be "h/w optimization" */
232 if (generic_mix_functions) {
234 compute_peak = default_compute_peak;
235 find_peaks = default_find_peaks;
236 apply_gain_to_buffer = default_apply_gain_to_buffer;
237 mix_buffers_with_gain = default_mix_buffers_with_gain;
238 mix_buffers_no_gain = default_mix_buffers_no_gain;
239 copy_vector = default_copy_vector;
241 info << "No H/W specific optimizations in use" << endmsg;
244 AudioGrapher::Routines::override_compute_peak (compute_peak);
245 AudioGrapher::Routines::override_apply_gain_to_buffer (apply_gain_to_buffer);
249 lotsa_files_please ()
251 #ifndef PLATFORM_WINDOWS
254 if (getrlimit (RLIMIT_NOFILE, &rl) == 0) {
257 /* See the COMPATIBILITY note on the Apple setrlimit() man page */
258 rl.rlim_cur = min ((rlim_t) OPEN_MAX, rl.rlim_max);
260 rl.rlim_cur = rl.rlim_max;
263 if (setrlimit (RLIMIT_NOFILE, &rl) != 0) {
264 if (rl.rlim_cur == RLIM_INFINITY) {
265 error << _("Could not set system open files limit to \"unlimited\"") << endmsg;
267 error << string_compose (_("Could not set system open files limit to %1"), rl.rlim_cur) << endmsg;
270 if (rl.rlim_cur != RLIM_INFINITY) {
271 info << string_compose (_("Your system is configured to limit %1 to only %2 open files"), PROGRAM_NAME, rl.rlim_cur) << endmsg;
275 error << string_compose (_("Could not get system open files limit (%1)"), strerror (errno)) << endmsg;
278 /* this only affects stdio. 2048 is the maxium possible (512 the default).
280 * If we want more, we'll have to replaces the POSIX I/O interfaces with
281 * Win32 API calls (CreateFile, WriteFile, etc) which allows for 16K.
283 * see http://stackoverflow.com/questions/870173/is-there-a-limit-on-number-of-open-files-in-windows
284 * and http://bugs.mysql.com/bug.php?id=24509
286 int newmax = _setmaxstdio (2048);
288 info << string_compose (_("Your system is configured to limit %1 to only %2 open files"), PROGRAM_NAME, newmax) << endmsg;
290 error << string_compose (_("Could not set system open files limit. Current limit is %1 open files"), _getmaxstdio) << endmsg;
296 copy_configuration_files (string const & old_dir, string const & new_dir, int old_version)
301 /* ensure target directory exists */
303 if (g_mkdir_with_parents (new_dir.c_str(), 0755)) {
307 if (old_version == 3) {
309 old_name = Glib::build_filename (old_dir, X_("recent"));
310 new_name = Glib::build_filename (new_dir, X_("recent"));
312 copy_file (old_name, new_name);
314 old_name = Glib::build_filename (old_dir, X_("sfdb"));
315 new_name = Glib::build_filename (new_dir, X_("sfdb"));
317 copy_file (old_name, new_name);
319 /* can only copy ardour.rc/config - UI config is not compatible */
321 /* users who have been using git/nightlies since the last
322 * release of 3.5 will have $CONFIG/config rather than
323 * $CONFIG/ardour.rc. Pick up the newer "old" config file,
324 * to avoid confusion.
327 string old_name = Glib::build_filename (old_dir, X_("config"));
329 if (!Glib::file_test (old_name, Glib::FILE_TEST_EXISTS)) {
330 old_name = Glib::build_filename (old_dir, X_("ardour.rc"));
333 new_name = Glib::build_filename (new_dir, X_("config"));
335 copy_file (old_name, new_name);
337 /* copy templates and route templates */
339 old_name = Glib::build_filename (old_dir, X_("templates"));
340 new_name = Glib::build_filename (new_dir, X_("templates"));
342 copy_recurse (old_name, new_name);
344 old_name = Glib::build_filename (old_dir, X_("route_templates"));
345 new_name = Glib::build_filename (new_dir, X_("route_templates"));
347 copy_recurse (old_name, new_name);
351 old_name = Glib::build_filename (old_dir, X_("presets"));
352 new_name = Glib::build_filename (new_dir, X_("presets"));
354 copy_recurse (old_name, new_name);
358 old_name = Glib::build_filename (old_dir, X_("plugin_statuses"));
359 new_name = Glib::build_filename (new_dir, X_("plugin_statuses"));
361 copy_file (old_name, new_name);
365 old_name = Glib::build_filename (old_dir, export_formats_dir_name);
366 new_name = Glib::build_filename (new_dir, export_formats_dir_name);
368 vector<string> export_formats;
369 g_mkdir_with_parents (Glib::build_filename (new_dir, export_formats_dir_name).c_str(), 0755);
370 find_files_matching_pattern (export_formats, old_name, X_("*.format"));
371 for (vector<string>::iterator i = export_formats.begin(); i != export_formats.end(); ++i) {
372 std::string from = *i;
373 std::string to = Glib::build_filename (new_name, Glib::path_get_basename (*i));
374 copy_file (from, to);
382 ARDOUR::check_for_old_configuration_files ()
384 int current_version = atoi (X_(PROGRAM_VERSION));
386 if (current_version <= 1) {
390 int old_version = current_version - 1;
392 string old_config_dir = user_config_directory (old_version);
393 /* pass in the current version explicitly to avoid creation */
394 string current_config_dir = user_config_directory (current_version);
396 if (!Glib::file_test (current_config_dir, Glib::FILE_TEST_IS_DIR)) {
397 if (Glib::file_test (old_config_dir, Glib::FILE_TEST_IS_DIR)) {
398 have_old_configuration_files = true;
404 ARDOUR::handle_old_configuration_files (boost::function<bool (std::string const&, std::string const&, int)> ui_handler)
406 if (have_old_configuration_files) {
407 int current_version = atoi (X_(PROGRAM_VERSION));
408 assert (current_version > 1); // established in check_for_old_configuration_files ()
409 int old_version = current_version - 1;
410 string old_config_dir = user_config_directory (old_version);
411 string current_config_dir = user_config_directory (current_version);
413 if (ui_handler (old_config_dir, current_config_dir, old_version)) {
414 copy_configuration_files (old_config_dir, current_config_dir, old_version);
422 ARDOUR::init (bool use_windows_vst, bool try_optimization, const char* localedir)
424 if (libardour_initialized) {
428 if (!PBD::init()) return false;
431 (void) bindtextdomain(PACKAGE, localedir);
432 (void) bind_textdomain_codeset (PACKAGE, "UTF-8");
435 SessionEvent::init_event_pool ();
437 Operations::make_operations_quarks ();
438 SessionObject::make_property_quarks ();
439 Region::make_property_quarks ();
440 MidiRegion::make_property_quarks ();
441 AudioRegion::make_property_quarks ();
442 RouteGroup::make_property_quarks ();
443 Playlist::make_property_quarks ();
444 AudioPlaylist::make_property_quarks ();
446 /* this is a useful ready to use PropertyChange that many
447 things need to check. This avoids having to compose
448 it every time we want to check for any of the relevant
452 bounds_change.add (ARDOUR::Properties::start);
453 bounds_change.add (ARDOUR::Properties::position);
454 bounds_change.add (ARDOUR::Properties::length);
456 /* provide a state version for the few cases that need it and are not
457 driven by reading state from disk (e.g. undo/redo)
460 Stateful::current_state_version = CURRENT_SESSION_FILE_VERSION;
462 ARDOUR::setup_enum_writer ();
464 // allow ardour the absolute maximum number of open files
465 lotsa_files_please ();
470 Library = new AudioLibrary;
472 BootMessage (_("Loading configuration"));
474 Config = new RCConfiguration;
476 if (Config->load_state ()) {
480 Config->set_use_windows_vst (use_windows_vst);
482 Config->set_use_lxvst(true);
485 Profile = new RuntimeProfile;
488 #ifdef WINDOWS_VST_SUPPORT
489 if (Config->get_use_windows_vst() && fst_init (0)) {
495 if (Config->get_use_lxvst() && vstfx_init (0)) {
500 #ifdef AUDIOUNIT_SUPPORT
501 AUPluginInfo::load_cached_info ();
504 setup_hardware_optimization (try_optimization);
506 SourceFactory::init ();
509 /* singletons - first object is "it" */
510 (void) PluginManager::instance();
512 (void) URIMap::instance();
514 (void) EventTypeMap::instance();
516 ControlProtocolManager::instance().discover_control_protocols ();
518 /* for each control protocol, check for a request buffer factory method
519 and if it exists, store it in the EventLoop list of such
520 methods. This allows the relevant threads to register themselves
521 with EventLoops so that signal emission can be RT-safe.
524 ControlProtocolManager::instance().register_request_buffer_factories ();
525 /* it would be nice if this could auto-register itself in the
526 constructor, since MidiControlUI is a singleton, but it can't be
527 created until after the engine is running. Therefore we have to
528 explicitly register it here.
530 EventLoop::register_request_buffer_factory (X_("midiUI"), MidiControlUI::request_factory);
532 ProcessThread::init ();
533 /* the + 4 is a bit of a handwave. i don't actually know
534 how many more per-thread buffer sets we need above
535 the h/w concurrency, but its definitely > 1 more.
537 BufferManager::init (hardware_concurrency() + 4);
539 PannerManager::instance().discover_panners();
541 ARDOUR::AudioEngine::create ();
543 /* it is unfortunate that we need to include reserved names here that
544 refer to control surfaces. But there's no way to ensure a complete
545 lack of collisions without doing this, since the control surface
546 support may not even be active. Without adding an API to control
547 surface support that would list their port names, we do have to
551 char const * const reserved[] = {
560 for (int n = 0; reserved[n]; ++n) {
561 reserved_io_names.push_back (reserved[n]);
564 libardour_initialized = true;
570 ARDOUR::init_post_engine ()
573 if ((node = Config->control_protocol_state()) != 0) {
574 ControlProtocolManager::instance().set_state (*node, Stateful::loading_state_version);
579 ARDOUR::PluginManager::instance().refresh (!Config->get_discover_vst_on_start());
585 if (!libardour_initialized) {
589 ARDOUR::AudioEngine::destroy ();
595 delete &ControlProtocolManager::instance();
596 #ifdef WINDOWS_VST_SUPPORT
603 delete &PluginManager::instance();
611 ARDOUR::no_auto_connect()
613 return getenv ("ARDOUR_NO_AUTOCONNECT") != 0;
619 FPU* fpu = FPU::instance ();
621 if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
622 // valgrind doesn't understand this assembler stuff
623 // September 10th, 2007
627 #if defined(ARCH_X86) && defined(USE_XMMINTRIN)
631 if (!fpu->has_flush_to_zero() && !fpu->has_denormals_are_zero()) {
635 MXCSR = _mm_getcsr();
637 #ifdef DEBUG_DENORMAL_EXCEPTION
638 /* This will raise a FP exception if a denormal is detected */
639 MXCSR &= ~_MM_MASK_DENORM;
642 switch (Config->get_denormal_model()) {
644 MXCSR &= ~(_MM_FLUSH_ZERO_ON | 0x40);
648 if (fpu->has_flush_to_zero()) {
649 MXCSR |= _MM_FLUSH_ZERO_ON;
654 MXCSR &= ~_MM_FLUSH_ZERO_ON;
655 if (fpu->has_denormals_are_zero()) {
661 if (fpu->has_flush_to_zero()) {
662 if (fpu->has_denormals_are_zero()) {
663 MXCSR |= _MM_FLUSH_ZERO_ON | 0x40;
665 MXCSR |= _MM_FLUSH_ZERO_ON;
676 /* this can be changed to modify the translation behaviour for
677 cases where the user has never expressed a preference.
679 static const bool translate_by_default = true;
682 ARDOUR::translation_enable_path ()
684 return Glib::build_filename (user_config_directory(), ".translate");
688 ARDOUR::translations_are_enabled ()
690 int fd = g_open (ARDOUR::translation_enable_path().c_str(), O_RDONLY, 0444);
693 return translate_by_default;
699 if (::read (fd, &c, 1) == 1 && c == '1') {
709 ARDOUR::set_translations_enabled (bool yn)
711 string i18n_enabler = ARDOUR::translation_enable_path();
712 int fd = g_open (i18n_enabler.c_str(), O_WRONLY|O_CREAT|O_TRUNC, 0644);
726 (void) ::write (fd, &c, 1);
734 ARDOUR::get_available_sync_options ()
736 vector<SyncSource> ret;
738 boost::shared_ptr<AudioBackend> backend = AudioEngine::instance()->current_backend();
739 if (backend && backend->name() == "JACK") {
740 ret.push_back (Engine);
744 ret.push_back (MIDIClock);
750 /** Return a monotonic value for the number of microseconds that have elapsed
751 * since an arbitrary zero origin.
755 /* Thanks Apple for not implementing this basic SUSv2, POSIX.1-2001 function
757 #include <mach/mach_time.h>
758 #define CLOCK_REALTIME 0
759 #define CLOCK_MONOTONIC 0
761 clock_gettime (int /*clk_id*/, struct timespec *t)
763 static bool initialized = false;
764 static mach_timebase_info_data_t timebase;
766 mach_timebase_info(&timebase);
770 time = mach_absolute_time();
771 double nseconds = ((double)time * (double)timebase.numer)/((double)timebase.denom);
772 double seconds = ((double)time * (double)timebase.numer)/((double)timebase.denom * 1e9);
774 t->tv_nsec = nseconds;
780 ARDOUR::get_microseconds ()
782 #ifdef PLATFORM_WINDOWS
783 microseconds_t ret = 0;
784 LARGE_INTEGER freq, time;
786 if (QueryPerformanceFrequency(&freq))
787 if (QueryPerformanceCounter(&time))
788 ret = (microseconds_t)((time.QuadPart * 1000000) / freq.QuadPart);
793 if (clock_gettime (CLOCK_MONOTONIC, &ts) != 0) {
797 return (microseconds_t) ts.tv_sec * 1000000 + (ts.tv_nsec/1000);
801 /** Return the number of bits per sample for a given sample format.
803 * This is closely related to sndfile_data_width() but does NOT
804 * return a "magic" value to differentiate between 32 bit integer
805 * and 32 bit floating point values.
809 ARDOUR::format_data_width (ARDOUR::SampleFormat format)
815 case ARDOUR::FormatInt16:
817 case ARDOUR::FormatInt24: