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;
164 static PBD::ScopedConnection engine_startup_connection;
167 setup_hardware_optimization (bool try_optimization)
169 bool generic_mix_functions = true;
171 if (try_optimization) {
173 FPU* fpu = FPU::instance();
175 #if defined (ARCH_X86) && defined (BUILD_SSE_OPTIMIZATIONS)
177 #ifdef PLATFORM_WINDOWS
178 /* We have AVX-optimized code for Windows */
180 if (fpu->has_avx()) {
182 /* AVX code doesn't compile on Linux yet */
186 info << "Using AVX optimized routines" << endmsg;
189 compute_peak = x86_sse_avx_compute_peak;
190 find_peaks = x86_sse_avx_find_peaks;
191 apply_gain_to_buffer = x86_sse_avx_apply_gain_to_buffer;
192 mix_buffers_with_gain = x86_sse_avx_mix_buffers_with_gain;
193 mix_buffers_no_gain = x86_sse_avx_mix_buffers_no_gain;
194 copy_vector = x86_sse_avx_copy_vector;
196 generic_mix_functions = false;
198 } else if (fpu->has_sse()) {
200 info << "Using SSE optimized routines" << endmsg;
203 compute_peak = x86_sse_compute_peak;
204 find_peaks = x86_sse_find_peaks;
205 apply_gain_to_buffer = x86_sse_apply_gain_to_buffer;
206 mix_buffers_with_gain = x86_sse_mix_buffers_with_gain;
207 mix_buffers_no_gain = x86_sse_mix_buffers_no_gain;
208 copy_vector = default_copy_vector;
210 generic_mix_functions = false;
214 #elif defined (__APPLE__) && defined (BUILD_VECLIB_OPTIMIZATIONS)
216 if (floor (kCFCoreFoundationVersionNumber) > kCFCoreFoundationVersionNumber10_4) { /* at least Tiger */
217 compute_peak = veclib_compute_peak;
218 find_peaks = veclib_find_peaks;
219 apply_gain_to_buffer = veclib_apply_gain_to_buffer;
220 mix_buffers_with_gain = veclib_mix_buffers_with_gain;
221 mix_buffers_no_gain = veclib_mix_buffers_no_gain;
222 copy_vector = default_copy_vector;
224 generic_mix_functions = false;
226 info << "Apple VecLib H/W specific optimizations in use" << endmsg;
230 /* consider FPU denormal handling to be "h/w optimization" */
235 if (generic_mix_functions) {
237 compute_peak = default_compute_peak;
238 find_peaks = default_find_peaks;
239 apply_gain_to_buffer = default_apply_gain_to_buffer;
240 mix_buffers_with_gain = default_mix_buffers_with_gain;
241 mix_buffers_no_gain = default_mix_buffers_no_gain;
242 copy_vector = default_copy_vector;
244 info << "No H/W specific optimizations in use" << endmsg;
247 AudioGrapher::Routines::override_compute_peak (compute_peak);
248 AudioGrapher::Routines::override_apply_gain_to_buffer (apply_gain_to_buffer);
252 lotsa_files_please ()
254 #ifndef PLATFORM_WINDOWS
257 if (getrlimit (RLIMIT_NOFILE, &rl) == 0) {
260 /* See the COMPATIBILITY note on the Apple setrlimit() man page */
261 rl.rlim_cur = min ((rlim_t) OPEN_MAX, rl.rlim_max);
263 rl.rlim_cur = rl.rlim_max;
266 if (setrlimit (RLIMIT_NOFILE, &rl) != 0) {
267 if (rl.rlim_cur == RLIM_INFINITY) {
268 error << _("Could not set system open files limit to \"unlimited\"") << endmsg;
270 error << string_compose (_("Could not set system open files limit to %1"), rl.rlim_cur) << endmsg;
273 if (rl.rlim_cur != RLIM_INFINITY) {
274 info << string_compose (_("Your system is configured to limit %1 to %2 open files"), PROGRAM_NAME, rl.rlim_cur) << endmsg;
278 error << string_compose (_("Could not get system open files limit (%1)"), strerror (errno)) << endmsg;
281 /* this only affects stdio. 2048 is the maxium possible (512 the default).
283 * If we want more, we'll have to replaces the POSIX I/O interfaces with
284 * Win32 API calls (CreateFile, WriteFile, etc) which allows for 16K.
286 * see http://stackoverflow.com/questions/870173/is-there-a-limit-on-number-of-open-files-in-windows
287 * and http://bugs.mysql.com/bug.php?id=24509
289 int newmax = _setmaxstdio (2048);
291 info << string_compose (_("Your system is configured to limit %1 to %2 open files"), PROGRAM_NAME, newmax) << endmsg;
293 error << string_compose (_("Could not set system open files limit. Current limit is %1 open files"), _getmaxstdio()) << endmsg;
299 copy_configuration_files (string const & old_dir, string const & new_dir, int old_version)
304 /* ensure target directory exists */
306 if (g_mkdir_with_parents (new_dir.c_str(), 0755)) {
310 if (old_version >= 3) {
312 old_name = Glib::build_filename (old_dir, X_("recent"));
313 new_name = Glib::build_filename (new_dir, X_("recent"));
315 copy_file (old_name, new_name);
317 old_name = Glib::build_filename (old_dir, X_("sfdb"));
318 new_name = Glib::build_filename (new_dir, X_("sfdb"));
320 copy_file (old_name, new_name);
322 /* can only copy ardour.rc/config - UI config is not compatible */
324 /* users who have been using git/nightlies since the last
325 * release of 3.5 will have $CONFIG/config rather than
326 * $CONFIG/ardour.rc. Pick up the newer "old" config file,
327 * to avoid confusion.
330 string old_name = Glib::build_filename (old_dir, X_("config"));
332 if (!Glib::file_test (old_name, Glib::FILE_TEST_EXISTS)) {
333 old_name = Glib::build_filename (old_dir, X_("ardour.rc"));
336 new_name = Glib::build_filename (new_dir, X_("config"));
338 copy_file (old_name, new_name);
340 /* copy templates and route templates */
342 old_name = Glib::build_filename (old_dir, X_("templates"));
343 new_name = Glib::build_filename (new_dir, X_("templates"));
345 copy_recurse (old_name, new_name);
347 old_name = Glib::build_filename (old_dir, X_("route_templates"));
348 new_name = Glib::build_filename (new_dir, X_("route_templates"));
350 copy_recurse (old_name, new_name);
354 old_name = Glib::build_filename (old_dir, X_("presets"));
355 new_name = Glib::build_filename (new_dir, X_("presets"));
357 copy_recurse (old_name, new_name);
360 g_mkdir_with_parents (Glib::build_filename (new_dir, plugin_metadata_dir_name).c_str(), 0755);
362 old_name = Glib::build_filename (old_dir, X_("plugin_statuses")); /* until 6.0 */
363 new_name = Glib::build_filename (new_dir, plugin_metadata_dir_name, X_("plugin_statuses"));
364 copy_file (old_name, new_name); /* can fail silently */
366 old_name = Glib::build_filename (old_dir, plugin_metadata_dir_name, X_("plugin_statuses"));
367 copy_file (old_name, new_name);
371 old_name = Glib::build_filename (old_dir, plugin_metadata_dir_name, X_("plugin_tags"));
372 new_name = Glib::build_filename (new_dir, plugin_metadata_dir_name, X_("plugin_tags"));
374 copy_file (old_name, new_name);
378 old_name = Glib::build_filename (old_dir, export_formats_dir_name);
379 new_name = Glib::build_filename (new_dir, export_formats_dir_name);
381 vector<string> export_formats;
382 g_mkdir_with_parents (Glib::build_filename (new_dir, export_formats_dir_name).c_str(), 0755);
383 find_files_matching_pattern (export_formats, old_name, X_("*.format"));
384 for (vector<string>::iterator i = export_formats.begin(); i != export_formats.end(); ++i) {
385 std::string from = *i;
386 std::string to = Glib::build_filename (new_name, Glib::path_get_basename (*i));
387 copy_file (from, to);
395 ARDOUR::check_for_old_configuration_files ()
397 int current_version = atoi (X_(PROGRAM_VERSION));
399 if (current_version <= 1) {
403 int old_version = current_version - 1;
405 string old_config_dir = user_config_directory (old_version);
406 /* pass in the current version explicitly to avoid creation */
407 string current_config_dir = user_config_directory (current_version);
409 if (!Glib::file_test (current_config_dir, Glib::FILE_TEST_IS_DIR)) {
410 if (Glib::file_test (old_config_dir, Glib::FILE_TEST_IS_DIR)) {
411 have_old_configuration_files = true;
417 ARDOUR::handle_old_configuration_files (boost::function<bool (std::string const&, std::string const&, int)> ui_handler)
419 if (have_old_configuration_files) {
420 int current_version = atoi (X_(PROGRAM_VERSION));
421 assert (current_version > 1); // established in check_for_old_configuration_files ()
422 int old_version = current_version - 1;
423 string old_config_dir = user_config_directory (old_version);
424 string current_config_dir = user_config_directory (current_version);
426 if (ui_handler (old_config_dir, current_config_dir, old_version)) {
427 copy_configuration_files (old_config_dir, current_config_dir, old_version);
435 ARDOUR::init (bool use_windows_vst, bool try_optimization, const char* localedir)
437 if (libardour_initialized) {
442 if (getenv("LUA_METATABLES")) {
443 luabridge::Security::setHideMetatables (false);
447 if (!PBD::init()) return false;
450 (void) bindtextdomain(PACKAGE, localedir);
451 (void) bind_textdomain_codeset (PACKAGE, "UTF-8");
454 SessionEvent::init_event_pool ();
456 Operations::make_operations_quarks ();
457 SessionObject::make_property_quarks ();
458 Region::make_property_quarks ();
459 MidiRegion::make_property_quarks ();
460 AudioRegion::make_property_quarks ();
461 RouteGroup::make_property_quarks ();
462 Playlist::make_property_quarks ();
463 AudioPlaylist::make_property_quarks ();
464 PresentationInfo::make_property_quarks ();
465 TransportMaster::make_property_quarks ();
467 /* this is a useful ready to use PropertyChange that many
468 things need to check. This avoids having to compose
469 it every time we want to check for any of the relevant
473 bounds_change.add (ARDOUR::Properties::start);
474 bounds_change.add (ARDOUR::Properties::position);
475 bounds_change.add (ARDOUR::Properties::length);
477 /* provide a state version for the few cases that need it and are not
478 driven by reading state from disk (e.g. undo/redo)
481 Stateful::current_state_version = CURRENT_SESSION_FILE_VERSION;
483 ARDOUR::setup_enum_writer ();
485 // allow ardour the absolute maximum number of open files
486 lotsa_files_please ();
491 Library = new AudioLibrary;
493 BootMessage (_("Loading configuration"));
495 Config = new RCConfiguration;
497 if (Config->load_state ()) {
501 Config->set_use_windows_vst (use_windows_vst);
503 Config->set_use_lxvst(true);
506 Profile = new RuntimeProfile;
509 #ifdef WINDOWS_VST_SUPPORT
510 if (Config->get_use_windows_vst() && fst_init (0)) {
516 if (Config->get_use_lxvst() && vstfx_init (0)) {
521 #ifdef AUDIOUNIT_SUPPORT
522 AUPluginInfo::load_cached_info ();
525 setup_hardware_optimization (try_optimization);
527 SourceFactory::init ();
530 /* singletons - first object is "it" */
531 (void) PluginManager::instance();
533 (void) URIMap::instance();
535 (void) EventTypeMap::instance();
537 ControlProtocolManager::instance().discover_control_protocols ();
539 /* for each control protocol, check for a request buffer factory method
540 and if it exists, store it in the EventLoop list of such
541 methods. This allows the relevant threads to register themselves
542 with EventLoops so that signal emission can be RT-safe.
545 ControlProtocolManager::instance().register_request_buffer_factories ();
546 /* it would be nice if this could auto-register itself in the
547 constructor, since MidiControlUI is a singleton, but it can't be
548 created until after the engine is running. Therefore we have to
549 explicitly register it here.
551 EventLoop::register_request_buffer_factory (X_("midiUI"), MidiControlUI::request_factory);
553 ProcessThread::init ();
554 /* the + 4 is a bit of a handwave. i don't actually know
555 how many more per-thread buffer sets we need above
556 the h/w concurrency, but its definitely > 1 more.
558 BufferManager::init (hardware_concurrency() + 4);
560 PannerManager::instance().discover_panners();
562 ARDOUR::AudioEngine::create ();
564 /* it is unfortunate that we need to include reserved names here that
565 refer to control surfaces. But there's no way to ensure a complete
566 lack of collisions without doing this, since the control surface
567 support may not even be active. Without adding an API to control
568 surface support that would list their port names, we do have to
571 We also need to know if the given I/O is an actual route.
572 For routes (e.g. "master"), bus creation needs to be allowed the first time,
573 while for pure I/O (e.g. "Click") track/bus creation must always fail.
576 reserved_io_names[_("Monitor")] = true;
577 reserved_io_names[_("Master")] = true;
578 reserved_io_names["auditioner"] = true; // auditioner.cc Track (s, "auditioner",...)
581 reserved_io_names[X_("Click")] = false; // session.cc ClickIO (*this, X_("Click")
582 reserved_io_names[_("Control")] = false;
583 reserved_io_names[_("Mackie")] = false;
584 reserved_io_names[_("FaderPort Recv")] = false;
585 reserved_io_names[_("FaderPort Send")] = false;
586 reserved_io_names[_("FaderPort2 Recv")] = false;
587 reserved_io_names[_("FaderPort2 Send")] = false;
588 reserved_io_names[_("FaderPort8 Recv")] = false;
589 reserved_io_names[_("FaderPort8 Send")] = false;
590 reserved_io_names[_("FaderPort16 Recv")] = false;
591 reserved_io_names[_("FaderPort16 Send")] = false;
593 libardour_initialized = true;
599 ARDOUR::init_post_engine (uint32_t start_cnt)
603 if (start_cnt == 0) {
607 ARDOUR::PluginManager::instance().refresh (!Config->get_discover_vst_on_start());
610 if (start_cnt == 0) {
612 if ((node = Config->control_protocol_state()) != 0) {
613 ControlProtocolManager::instance().set_state (*node, 0 /* here: global-config state */);
616 TransportMasterManager::instance().restart ();
623 if (!libardour_initialized) {
627 engine_startup_connection.disconnect ();
629 delete &ControlProtocolManager::instance();
630 ARDOUR::AudioEngine::destroy ();
636 #ifdef WINDOWS_VST_SUPPORT
643 delete &PluginManager::instance();
651 ARDOUR::no_auto_connect()
653 return getenv ("ARDOUR_NO_AUTOCONNECT") != 0;
659 FPU* fpu = FPU::instance ();
661 if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
662 // valgrind doesn't understand this assembler stuff
663 // September 10th, 2007
667 #if defined(ARCH_X86) && defined(USE_XMMINTRIN)
671 if (!fpu->has_flush_to_zero() && !fpu->has_denormals_are_zero()) {
675 MXCSR = _mm_getcsr();
677 #ifdef DEBUG_DENORMAL_EXCEPTION
678 /* This will raise a FP exception if a denormal is detected */
679 MXCSR &= ~_MM_MASK_DENORM;
682 switch (Config->get_denormal_model()) {
684 MXCSR &= ~(_MM_FLUSH_ZERO_ON | 0x40);
688 if (fpu->has_flush_to_zero()) {
689 MXCSR |= _MM_FLUSH_ZERO_ON;
694 MXCSR &= ~_MM_FLUSH_ZERO_ON;
695 if (fpu->has_denormals_are_zero()) {
701 if (fpu->has_flush_to_zero()) {
702 if (fpu->has_denormals_are_zero()) {
703 MXCSR |= _MM_FLUSH_ZERO_ON | 0x40;
705 MXCSR |= _MM_FLUSH_ZERO_ON;
716 /* this can be changed to modify the translation behaviour for
717 cases where the user has never expressed a preference.
719 static const bool translate_by_default = true;
722 ARDOUR::translation_enable_path ()
724 return Glib::build_filename (user_config_directory(), ".translate");
728 ARDOUR::translations_are_enabled ()
730 int fd = g_open (ARDOUR::translation_enable_path().c_str(), O_RDONLY, 0444);
733 return translate_by_default;
739 if (::read (fd, &c, 1) == 1 && c == '1') {
749 ARDOUR::set_translations_enabled (bool yn)
751 string i18n_enabler = ARDOUR::translation_enable_path();
752 int fd = g_open (i18n_enabler.c_str(), O_WRONLY|O_CREAT|O_TRUNC, 0644);
766 (void) ::write (fd, &c, 1);
769 Config->ParameterChanged ("enable-translation");
775 ARDOUR::get_available_sync_options ()
777 vector<SyncSource> ret;
779 boost::shared_ptr<AudioBackend> backend = AudioEngine::instance()->current_backend();
780 if (backend && backend->name() == "JACK") {
781 ret.push_back (Engine);
785 ret.push_back (MIDIClock);
791 /** Return a monotonic value for the number of microseconds that have elapsed
792 * since an arbitrary zero origin.
796 /* Thanks Apple for not implementing this basic SUSv2, POSIX.1-2001 function
798 #include <mach/mach_time.h>
799 #define CLOCK_REALTIME 0
800 #define CLOCK_MONOTONIC 0
802 clock_gettime (int /*clk_id*/, struct timespec *t)
804 static bool initialized = false;
805 static mach_timebase_info_data_t timebase;
807 mach_timebase_info(&timebase);
811 time = mach_absolute_time();
812 double nseconds = ((double)time * (double)timebase.numer)/((double)timebase.denom);
813 double seconds = ((double)time * (double)timebase.numer)/((double)timebase.denom * 1e9);
815 t->tv_nsec = nseconds;
821 ARDOUR::get_microseconds ()
823 #ifdef PLATFORM_WINDOWS
824 microseconds_t ret = 0;
825 LARGE_INTEGER freq, time;
827 if (QueryPerformanceFrequency(&freq))
828 if (QueryPerformanceCounter(&time))
829 ret = (microseconds_t)((time.QuadPart * 1000000) / freq.QuadPart);
834 if (clock_gettime (CLOCK_MONOTONIC, &ts) != 0) {
838 return (microseconds_t) ts.tv_sec * 1000000 + (ts.tv_nsec/1000);
842 /** Return the number of bits per sample for a given sample format.
844 * This is closely related to sndfile_data_width() but does NOT
845 * return a "magic" value to differentiate between 32 bit integer
846 * and 32 bit floating point values.
850 ARDOUR::format_data_width (ARDOUR::SampleFormat format)
856 case ARDOUR::FormatInt16:
858 case ARDOUR::FormatInt24: