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 "LuaBridge/LuaBridge.h"
89 #include "ardour/analyser.h"
90 #include "ardour/audio_library.h"
91 #include "ardour/audio_backend.h"
92 #include "ardour/audioengine.h"
93 #include "ardour/audioplaylist.h"
94 #include "ardour/audioregion.h"
95 #include "ardour/buffer_manager.h"
96 #include "ardour/control_protocol_manager.h"
97 #include "ardour/directory_names.h"
98 #include "ardour/event_type_map.h"
99 #include "ardour/filesystem_paths.h"
100 #include "ardour/midi_region.h"
101 #include "ardour/midi_ui.h"
102 #include "ardour/midiport_manager.h"
103 #include "ardour/mix.h"
104 #include "ardour/operations.h"
105 #include "ardour/panner_manager.h"
106 #include "ardour/plugin_manager.h"
107 #include "ardour/presentation_info.h"
108 #include "ardour/process_thread.h"
109 #include "ardour/profile.h"
110 #include "ardour/rc_configuration.h"
111 #include "ardour/region.h"
112 #include "ardour/route_group.h"
113 #include "ardour/runtime_functions.h"
114 #include "ardour/session_event.h"
115 #include "ardour/source_factory.h"
116 #include "ardour/transport_master_manager.h"
118 #include "ardour/uri_map.h"
120 #include "audiographer/routines.h"
122 #if defined (__APPLE__)
123 #include <CoreFoundation/CoreFoundation.h>
126 #include "pbd/i18n.h"
128 ARDOUR::RCConfiguration* ARDOUR::Config = 0;
129 ARDOUR::RuntimeProfile* ARDOUR::Profile = 0;
130 ARDOUR::AudioLibrary* ARDOUR::Library = 0;
132 using namespace ARDOUR;
136 bool libardour_initialized = false;
138 compute_peak_t ARDOUR::compute_peak = 0;
139 find_peaks_t ARDOUR::find_peaks = 0;
140 apply_gain_to_buffer_t ARDOUR::apply_gain_to_buffer = 0;
141 mix_buffers_with_gain_t ARDOUR::mix_buffers_with_gain = 0;
142 mix_buffers_no_gain_t ARDOUR::mix_buffers_no_gain = 0;
143 copy_vector_t ARDOUR::copy_vector = 0;
145 PBD::Signal1<void,std::string> ARDOUR::BootMessage;
146 PBD::Signal3<void,std::string,std::string,bool> ARDOUR::PluginScanMessage;
147 PBD::Signal1<void,int> ARDOUR::PluginScanTimeout;
148 PBD::Signal0<void> ARDOUR::GUIIdle;
149 PBD::Signal3<bool,std::string,std::string,int> ARDOUR::CopyConfigurationFiles;
151 std::map<std::string, bool> ARDOUR::reserved_io_names;
153 static bool have_old_configuration_files = false;
156 extern void setup_enum_writer ();
159 /* this is useful for quite a few things that want to check
160 if any bounds-related property has changed
162 PBD::PropertyChange ARDOUR::bounds_change;
165 setup_hardware_optimization (bool try_optimization)
167 bool generic_mix_functions = true;
169 if (try_optimization) {
171 FPU* fpu = FPU::instance();
173 #if defined (ARCH_X86) && defined (BUILD_SSE_OPTIMIZATIONS)
175 #ifdef PLATFORM_WINDOWS
176 /* We have AVX-optimized code for Windows */
178 if (fpu->has_avx()) {
180 /* AVX code doesn't compile on Linux yet */
184 info << "Using AVX optimized routines" << endmsg;
187 compute_peak = x86_sse_avx_compute_peak;
188 find_peaks = x86_sse_avx_find_peaks;
189 apply_gain_to_buffer = x86_sse_avx_apply_gain_to_buffer;
190 mix_buffers_with_gain = x86_sse_avx_mix_buffers_with_gain;
191 mix_buffers_no_gain = x86_sse_avx_mix_buffers_no_gain;
192 copy_vector = x86_sse_avx_copy_vector;
194 generic_mix_functions = false;
196 } else if (fpu->has_sse()) {
198 info << "Using SSE optimized routines" << endmsg;
201 compute_peak = x86_sse_compute_peak;
202 find_peaks = x86_sse_find_peaks;
203 apply_gain_to_buffer = x86_sse_apply_gain_to_buffer;
204 mix_buffers_with_gain = x86_sse_mix_buffers_with_gain;
205 mix_buffers_no_gain = x86_sse_mix_buffers_no_gain;
206 copy_vector = default_copy_vector;
208 generic_mix_functions = false;
212 #elif defined (__APPLE__) && defined (BUILD_VECLIB_OPTIMIZATIONS)
214 if (floor (kCFCoreFoundationVersionNumber) > kCFCoreFoundationVersionNumber10_4) { /* at least Tiger */
215 compute_peak = veclib_compute_peak;
216 find_peaks = veclib_find_peaks;
217 apply_gain_to_buffer = veclib_apply_gain_to_buffer;
218 mix_buffers_with_gain = veclib_mix_buffers_with_gain;
219 mix_buffers_no_gain = veclib_mix_buffers_no_gain;
220 copy_vector = default_copy_vector;
222 generic_mix_functions = false;
224 info << "Apple VecLib H/W specific optimizations in use" << endmsg;
228 /* consider FPU denormal handling to be "h/w optimization" */
233 if (generic_mix_functions) {
235 compute_peak = default_compute_peak;
236 find_peaks = default_find_peaks;
237 apply_gain_to_buffer = default_apply_gain_to_buffer;
238 mix_buffers_with_gain = default_mix_buffers_with_gain;
239 mix_buffers_no_gain = default_mix_buffers_no_gain;
240 copy_vector = default_copy_vector;
242 info << "No H/W specific optimizations in use" << endmsg;
245 AudioGrapher::Routines::override_compute_peak (compute_peak);
246 AudioGrapher::Routines::override_apply_gain_to_buffer (apply_gain_to_buffer);
250 lotsa_files_please ()
252 #ifndef PLATFORM_WINDOWS
255 if (getrlimit (RLIMIT_NOFILE, &rl) == 0) {
258 /* See the COMPATIBILITY note on the Apple setrlimit() man page */
259 rl.rlim_cur = min ((rlim_t) OPEN_MAX, rl.rlim_max);
261 rl.rlim_cur = rl.rlim_max;
264 if (setrlimit (RLIMIT_NOFILE, &rl) != 0) {
265 if (rl.rlim_cur == RLIM_INFINITY) {
266 error << _("Could not set system open files limit to \"unlimited\"") << endmsg;
268 error << string_compose (_("Could not set system open files limit to %1"), rl.rlim_cur) << endmsg;
271 if (rl.rlim_cur != RLIM_INFINITY) {
272 info << string_compose (_("Your system is configured to limit %1 to only %2 open files"), PROGRAM_NAME, rl.rlim_cur) << endmsg;
276 error << string_compose (_("Could not get system open files limit (%1)"), strerror (errno)) << endmsg;
279 /* this only affects stdio. 2048 is the maxium possible (512 the default).
281 * If we want more, we'll have to replaces the POSIX I/O interfaces with
282 * Win32 API calls (CreateFile, WriteFile, etc) which allows for 16K.
284 * see http://stackoverflow.com/questions/870173/is-there-a-limit-on-number-of-open-files-in-windows
285 * and http://bugs.mysql.com/bug.php?id=24509
287 int newmax = _setmaxstdio (2048);
289 info << string_compose (_("Your system is configured to limit %1 to only %2 open files"), PROGRAM_NAME, newmax) << endmsg;
291 error << string_compose (_("Could not set system open files limit. Current limit is %1 open files"), _getmaxstdio()) << endmsg;
297 copy_configuration_files (string const & old_dir, string const & new_dir, int old_version)
302 /* ensure target directory exists */
304 if (g_mkdir_with_parents (new_dir.c_str(), 0755)) {
308 if (old_version >= 3) {
310 old_name = Glib::build_filename (old_dir, X_("recent"));
311 new_name = Glib::build_filename (new_dir, X_("recent"));
313 copy_file (old_name, new_name);
315 old_name = Glib::build_filename (old_dir, X_("sfdb"));
316 new_name = Glib::build_filename (new_dir, X_("sfdb"));
318 copy_file (old_name, new_name);
320 /* can only copy ardour.rc/config - UI config is not compatible */
322 /* users who have been using git/nightlies since the last
323 * release of 3.5 will have $CONFIG/config rather than
324 * $CONFIG/ardour.rc. Pick up the newer "old" config file,
325 * to avoid confusion.
328 string old_name = Glib::build_filename (old_dir, X_("config"));
330 if (!Glib::file_test (old_name, Glib::FILE_TEST_EXISTS)) {
331 old_name = Glib::build_filename (old_dir, X_("ardour.rc"));
334 new_name = Glib::build_filename (new_dir, X_("config"));
336 copy_file (old_name, new_name);
338 /* copy templates and route templates */
340 old_name = Glib::build_filename (old_dir, X_("templates"));
341 new_name = Glib::build_filename (new_dir, X_("templates"));
343 copy_recurse (old_name, new_name);
345 old_name = Glib::build_filename (old_dir, X_("route_templates"));
346 new_name = Glib::build_filename (new_dir, X_("route_templates"));
348 copy_recurse (old_name, new_name);
352 old_name = Glib::build_filename (old_dir, X_("presets"));
353 new_name = Glib::build_filename (new_dir, X_("presets"));
355 copy_recurse (old_name, new_name);
358 g_mkdir_with_parents (Glib::build_filename (new_dir, plugin_metadata_dir_name).c_str(), 0755);
360 old_name = Glib::build_filename (old_dir, X_("plugin_statuses")); /* until 6.0 */
361 new_name = Glib::build_filename (new_dir, plugin_metadata_dir_name, X_("plugin_statuses"));
362 copy_file (old_name, new_name); /* can fail silently */
364 old_name = Glib::build_filename (old_dir, plugin_metadata_dir_name, X_("plugin_statuses"));
365 copy_file (old_name, new_name);
369 old_name = Glib::build_filename (old_dir, plugin_metadata_dir_name, X_("plugin_tags"));
370 new_name = Glib::build_filename (new_dir, plugin_metadata_dir_name, X_("plugin_tags"));
372 copy_file (old_name, new_name);
376 old_name = Glib::build_filename (old_dir, export_formats_dir_name);
377 new_name = Glib::build_filename (new_dir, export_formats_dir_name);
379 vector<string> export_formats;
380 g_mkdir_with_parents (Glib::build_filename (new_dir, export_formats_dir_name).c_str(), 0755);
381 find_files_matching_pattern (export_formats, old_name, X_("*.format"));
382 for (vector<string>::iterator i = export_formats.begin(); i != export_formats.end(); ++i) {
383 std::string from = *i;
384 std::string to = Glib::build_filename (new_name, Glib::path_get_basename (*i));
385 copy_file (from, to);
393 ARDOUR::check_for_old_configuration_files ()
395 int current_version = atoi (X_(PROGRAM_VERSION));
397 if (current_version <= 1) {
401 int old_version = current_version - 1;
403 string old_config_dir = user_config_directory (old_version);
404 /* pass in the current version explicitly to avoid creation */
405 string current_config_dir = user_config_directory (current_version);
407 if (!Glib::file_test (current_config_dir, Glib::FILE_TEST_IS_DIR)) {
408 if (Glib::file_test (old_config_dir, Glib::FILE_TEST_IS_DIR)) {
409 have_old_configuration_files = true;
415 ARDOUR::handle_old_configuration_files (boost::function<bool (std::string const&, std::string const&, int)> ui_handler)
417 if (have_old_configuration_files) {
418 int current_version = atoi (X_(PROGRAM_VERSION));
419 assert (current_version > 1); // established in check_for_old_configuration_files ()
420 int old_version = current_version - 1;
421 string old_config_dir = user_config_directory (old_version);
422 string current_config_dir = user_config_directory (current_version);
424 if (ui_handler (old_config_dir, current_config_dir, old_version)) {
425 copy_configuration_files (old_config_dir, current_config_dir, old_version);
433 ARDOUR::init (bool use_windows_vst, bool try_optimization, const char* localedir)
435 if (libardour_initialized) {
440 if (getenv("LUA_METATABLES")) {
441 luabridge::Security::setHideMetatables (false);
445 if (!PBD::init()) return false;
448 (void) bindtextdomain(PACKAGE, localedir);
449 (void) bind_textdomain_codeset (PACKAGE, "UTF-8");
452 SessionEvent::init_event_pool ();
454 Operations::make_operations_quarks ();
455 SessionObject::make_property_quarks ();
456 Region::make_property_quarks ();
457 MidiRegion::make_property_quarks ();
458 AudioRegion::make_property_quarks ();
459 RouteGroup::make_property_quarks ();
460 Playlist::make_property_quarks ();
461 AudioPlaylist::make_property_quarks ();
462 PresentationInfo::make_property_quarks ();
464 /* this is a useful ready to use PropertyChange that many
465 things need to check. This avoids having to compose
466 it every time we want to check for any of the relevant
470 bounds_change.add (ARDOUR::Properties::start);
471 bounds_change.add (ARDOUR::Properties::position);
472 bounds_change.add (ARDOUR::Properties::length);
474 /* provide a state version for the few cases that need it and are not
475 driven by reading state from disk (e.g. undo/redo)
478 Stateful::current_state_version = CURRENT_SESSION_FILE_VERSION;
480 ARDOUR::setup_enum_writer ();
482 // allow ardour the absolute maximum number of open files
483 lotsa_files_please ();
488 Library = new AudioLibrary;
490 BootMessage (_("Loading configuration"));
492 Config = new RCConfiguration;
494 if (Config->load_state ()) {
498 Config->set_use_windows_vst (use_windows_vst);
500 Config->set_use_lxvst(true);
503 Profile = new RuntimeProfile;
506 #ifdef WINDOWS_VST_SUPPORT
507 if (Config->get_use_windows_vst() && fst_init (0)) {
513 if (Config->get_use_lxvst() && vstfx_init (0)) {
518 #ifdef AUDIOUNIT_SUPPORT
519 AUPluginInfo::load_cached_info ();
522 setup_hardware_optimization (try_optimization);
524 SourceFactory::init ();
527 /* singletons - first object is "it" */
528 (void) PluginManager::instance();
530 (void) URIMap::instance();
532 (void) EventTypeMap::instance();
534 ControlProtocolManager::instance().discover_control_protocols ();
536 /* for each control protocol, check for a request buffer factory method
537 and if it exists, store it in the EventLoop list of such
538 methods. This allows the relevant threads to register themselves
539 with EventLoops so that signal emission can be RT-safe.
542 ControlProtocolManager::instance().register_request_buffer_factories ();
543 /* it would be nice if this could auto-register itself in the
544 constructor, since MidiControlUI is a singleton, but it can't be
545 created until after the engine is running. Therefore we have to
546 explicitly register it here.
548 EventLoop::register_request_buffer_factory (X_("midiUI"), MidiControlUI::request_factory);
550 ProcessThread::init ();
551 /* the + 4 is a bit of a handwave. i don't actually know
552 how many more per-thread buffer sets we need above
553 the h/w concurrency, but its definitely > 1 more.
555 BufferManager::init (hardware_concurrency() + 4);
557 PannerManager::instance().discover_panners();
559 ARDOUR::AudioEngine::create ();
561 /* it is unfortunate that we need to include reserved names here that
562 refer to control surfaces. But there's no way to ensure a complete
563 lack of collisions without doing this, since the control surface
564 support may not even be active. Without adding an API to control
565 surface support that would list their port names, we do have to
568 We also need to know if the given I/O is an actual route.
569 For routes (e.g. "master"), bus creation needs to be allowed the first time,
570 while for pure I/O (e.g. "Click") track/bus creation must always fail.
573 reserved_io_names[_("Monitor")] = true;
574 reserved_io_names[_("Master")] = true;
575 reserved_io_names["auditioner"] = true; // auditioner.cc Track (s, "auditioner",...)
578 reserved_io_names[X_("Click")] = false; // session.cc ClickIO (*this, X_("Click")
579 reserved_io_names[_("Control")] = false;
580 reserved_io_names[_("Mackie")] = false;
581 reserved_io_names[_("FaderPort Recv")] = false;
582 reserved_io_names[_("FaderPort Send")] = false;
583 reserved_io_names[_("FaderPort2 Recv")] = false;
584 reserved_io_names[_("FaderPort2 Send")] = false;
585 reserved_io_names[_("FaderPort8 Recv")] = false;
586 reserved_io_names[_("FaderPort8 Send")] = false;
587 reserved_io_names[_("FaderPort16 Recv")] = false;
588 reserved_io_names[_("FaderPort16 Send")] = false;
590 libardour_initialized = true;
596 ARDOUR::init_post_engine ()
600 if ((node = Config->control_protocol_state()) != 0) {
601 ControlProtocolManager::instance().set_state (*node, Stateful::loading_state_version);
604 if ((node = Config->transport_master_state()) != 0) {
605 if (TransportMasterManager::instance().set_state (*node, Stateful::loading_state_version)) {
606 error << _("Cannot restore transport master manager") << endmsg;
610 if (TransportMasterManager::instance().init ()) {
611 error << _("Cannot initialize transport master manager") << endmsg;
618 ARDOUR::PluginManager::instance().refresh (!Config->get_discover_vst_on_start());
624 if (!libardour_initialized) {
628 delete &ControlProtocolManager::instance();
629 ARDOUR::AudioEngine::destroy ();
635 #ifdef WINDOWS_VST_SUPPORT
642 delete &PluginManager::instance();
650 ARDOUR::no_auto_connect()
652 return getenv ("ARDOUR_NO_AUTOCONNECT") != 0;
658 FPU* fpu = FPU::instance ();
660 if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
661 // valgrind doesn't understand this assembler stuff
662 // September 10th, 2007
666 #if defined(ARCH_X86) && defined(USE_XMMINTRIN)
670 if (!fpu->has_flush_to_zero() && !fpu->has_denormals_are_zero()) {
674 MXCSR = _mm_getcsr();
676 #ifdef DEBUG_DENORMAL_EXCEPTION
677 /* This will raise a FP exception if a denormal is detected */
678 MXCSR &= ~_MM_MASK_DENORM;
681 switch (Config->get_denormal_model()) {
683 MXCSR &= ~(_MM_FLUSH_ZERO_ON | 0x40);
687 if (fpu->has_flush_to_zero()) {
688 MXCSR |= _MM_FLUSH_ZERO_ON;
693 MXCSR &= ~_MM_FLUSH_ZERO_ON;
694 if (fpu->has_denormals_are_zero()) {
700 if (fpu->has_flush_to_zero()) {
701 if (fpu->has_denormals_are_zero()) {
702 MXCSR |= _MM_FLUSH_ZERO_ON | 0x40;
704 MXCSR |= _MM_FLUSH_ZERO_ON;
715 /* this can be changed to modify the translation behaviour for
716 cases where the user has never expressed a preference.
718 static const bool translate_by_default = true;
721 ARDOUR::translation_enable_path ()
723 return Glib::build_filename (user_config_directory(), ".translate");
727 ARDOUR::translations_are_enabled ()
729 int fd = g_open (ARDOUR::translation_enable_path().c_str(), O_RDONLY, 0444);
732 return translate_by_default;
738 if (::read (fd, &c, 1) == 1 && c == '1') {
748 ARDOUR::set_translations_enabled (bool yn)
750 string i18n_enabler = ARDOUR::translation_enable_path();
751 int fd = g_open (i18n_enabler.c_str(), O_WRONLY|O_CREAT|O_TRUNC, 0644);
765 (void) ::write (fd, &c, 1);
768 Config->ParameterChanged ("enable-translation");
774 ARDOUR::get_available_sync_options ()
776 vector<SyncSource> ret;
778 boost::shared_ptr<AudioBackend> backend = AudioEngine::instance()->current_backend();
779 if (backend && backend->name() == "JACK") {
780 ret.push_back (Engine);
784 ret.push_back (MIDIClock);
790 /** Return a monotonic value for the number of microseconds that have elapsed
791 * since an arbitrary zero origin.
795 /* Thanks Apple for not implementing this basic SUSv2, POSIX.1-2001 function
797 #include <mach/mach_time.h>
798 #define CLOCK_REALTIME 0
799 #define CLOCK_MONOTONIC 0
801 clock_gettime (int /*clk_id*/, struct timespec *t)
803 static bool initialized = false;
804 static mach_timebase_info_data_t timebase;
806 mach_timebase_info(&timebase);
810 time = mach_absolute_time();
811 double nseconds = ((double)time * (double)timebase.numer)/((double)timebase.denom);
812 double seconds = ((double)time * (double)timebase.numer)/((double)timebase.denom * 1e9);
814 t->tv_nsec = nseconds;
820 ARDOUR::get_microseconds ()
822 #ifdef PLATFORM_WINDOWS
823 microseconds_t ret = 0;
824 LARGE_INTEGER freq, time;
826 if (QueryPerformanceFrequency(&freq))
827 if (QueryPerformanceCounter(&time))
828 ret = (microseconds_t)((time.QuadPart * 1000000) / freq.QuadPart);
833 if (clock_gettime (CLOCK_MONOTONIC, &ts) != 0) {
837 return (microseconds_t) ts.tv_sec * 1000000 + (ts.tv_nsec/1000);
841 /** Return the number of bits per sample for a given sample format.
843 * This is closely related to sndfile_data_width() but does NOT
844 * return a "magic" value to differentiate between 32 bit integer
845 * and 32 bit floating point values.
849 ARDOUR::format_data_width (ARDOUR::SampleFormat format)
855 case ARDOUR::FormatInt16:
857 case ARDOUR::FormatInt24: