libs/ardour/globals.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   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
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #ifdef WAF_BUILD
  20 #include "libardour-config.h"
  21 #endif
  22
  23 #ifdef interface
  24 #undef interface
  25 #endif
  26
  27 #include <cstdio> // Needed so that libraptor (included in lrdf) won't complain
  28 #include <cstdlib>
  29 #include <sys/stat.h>
  30 #include <sys/types.h>
  31 #include <sys/time.h>
  32 #ifndef PLATFORM_WINDOWS
  33 #include <sys/resource.h>
  34 #endif
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #include <errno.h>
  38 #include <time.h>
  39
  40 #include <glib.h>
  41 #include "pbd/gstdio_compat.h"
  42
  43 #ifdef PLATFORM_WINDOWS
  44 #include <stdio.h> // for _setmaxstdio
  45 #include <windows.h> // for LARGE_INTEGER
  46 #endif
  47
  48 #ifdef WINDOWS_VST_SUPPORT
  49 #include <fst.h>
  50 #endif
  51
  52 #ifdef LXVST_SUPPORT
  53 #include "ardour/linux_vst_support.h"
  54 #endif
  55
  56 #ifdef AUDIOUNIT_SUPPORT
  57 #include "ardour/audio_unit.h"
  58 #endif
  59
  60 #if defined(__SSE__) || defined(USE_XMMINTRIN)
  61 #include <xmmintrin.h>
  62 #endif
  63
  64 #ifdef check
  65 #undef check /* stupid Apple and their un-namespaced, generic Carbon macros */
  66 #endif
  67
  68 #include <glibmm/fileutils.h>
  69 #include <glibmm/miscutils.h>
  70
  71 #ifdef HAVE_LRDF
  72 #include <lrdf.h>
  73 #endif
  74
  75 #include "pbd/cpus.h"
  76 #include "pbd/error.h"
  77 #include "pbd/id.h"
  78 #include "pbd/pbd.h"
  79 #include "pbd/strsplit.h"
  80 #include "pbd/fpu.h"
  81 #include "pbd/file_utils.h"
  82 #include "pbd/enumwriter.h"
  83
  84 #include "midi++/port.h"
  85 #include "midi++/mmc.h"
  86
  87 #include "LuaBridge/LuaBridge.h"
  88
  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"
 117 #ifdef LV2_SUPPORT
 118 #include "ardour/uri_map.h"
 119 #endif
 120 #include "audiographer/routines.h"
 121
 122 #if defined (__APPLE__)
 123 #include <CoreFoundation/CoreFoundation.h>
 124 #endif
 125
 126 #include "pbd/i18n.h"
 127
 128 ARDOUR::RCConfiguration* ARDOUR::Config = 0;
 129 ARDOUR::RuntimeProfile* ARDOUR::Profile = 0;
 130 ARDOUR::AudioLibrary* ARDOUR::Library = 0;
 131
 132 using namespace ARDOUR;
 133 using namespace std;
 134 using namespace PBD;
 135
 136 bool libardour_initialized = false;
 137
 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;
 144
 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;
 150
 151 std::map<std::string, bool> ARDOUR::reserved_io_names;
 152
 153 static bool have_old_configuration_files = false;
 154
 155 namespace ARDOUR {
 156 extern void setup_enum_writer ();
 157 }
 158
 159 /* this is useful for quite a few things that want to check
 160    if any bounds-related property has changed
 161 */
 162 PBD::PropertyChange ARDOUR::bounds_change;
 163
 164 void
 165 setup_hardware_optimization (bool try_optimization)
 166 {
 167         bool generic_mix_functions = true;
 168
 169         if (try_optimization) {
 170
 171                 FPU* fpu = FPU::instance();
 172
 173 #if defined (ARCH_X86) && defined (BUILD_SSE_OPTIMIZATIONS)
 174
 175 #ifdef PLATFORM_WINDOWS
 176                 /* We have AVX-optimized code for Windows */
 177
 178                 if (fpu->has_avx()) {
 179 #else
 180                 /* AVX code doesn't compile on Linux yet */
 181
 182                 if (false) {
 183 #endif
 184                         info << "Using AVX optimized routines" << endmsg;
 185
 186                         // AVX SET
 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;
 193
 194                         generic_mix_functions = false;
 195
 196                 } else if (fpu->has_sse()) {
 197
 198                         info << "Using SSE optimized routines" << endmsg;
 199
 200                         // SSE SET
 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;
 207
 208                         generic_mix_functions = false;
 209
 210                 }
 211
 212 #elif defined (__APPLE__) && defined (BUILD_VECLIB_OPTIMIZATIONS)
 213
 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;
 221
 222                         generic_mix_functions = false;
 223
 224                         info << "Apple VecLib H/W specific optimizations in use" << endmsg;
 225                 }
 226 #endif
 227
 228                 /* consider FPU denormal handling to be "h/w optimization" */
 229
 230                 setup_fpu ();
 231         }
 232
 233         if (generic_mix_functions) {
 234
 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;
 241
 242                 info << "No H/W specific optimizations in use" << endmsg;
 243         }
 244
 245         AudioGrapher::Routines::override_compute_peak (compute_peak);
 246         AudioGrapher::Routines::override_apply_gain_to_buffer (apply_gain_to_buffer);
 247 }
 248
 249 static void
 250 lotsa_files_please ()
 251 {
 252 #ifndef PLATFORM_WINDOWS
 253         struct rlimit rl;
 254
 255         if (getrlimit (RLIMIT_NOFILE, &rl) == 0) {
 256
 257 #ifdef __APPLE__
 258                 /* See the COMPATIBILITY note on the Apple setrlimit() man page */
 259                 rl.rlim_cur = min ((rlim_t) OPEN_MAX, rl.rlim_max);
 260 #else
 261                 rl.rlim_cur = rl.rlim_max;
 262 #endif
 263
 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;
 267                         } else {
 268                                 error << string_compose (_("Could not set system open files limit to %1"), rl.rlim_cur) << endmsg;
 269                         }
 270                 } else {
 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;
 273                         }
 274                 }
 275         } else {
 276                 error << string_compose (_("Could not get system open files limit (%1)"), strerror (errno)) << endmsg;
 277         }
 278 #else
 279         /* this only affects stdio. 2048 is the maxium possible (512 the default).
 280          *
 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.
 283          *
 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
 286          */
 287         int newmax = _setmaxstdio (2048);
 288         if (newmax > 0) {
 289                 info << string_compose (_("Your system is configured to limit %1 to only %2 open files"), PROGRAM_NAME, newmax) << endmsg;
 290         } else {
 291                 error << string_compose (_("Could not set system open files limit. Current limit is %1 open files"), _getmaxstdio())  << endmsg;
 292         }
 293 #endif
 294 }
 295
 296 static int
 297 copy_configuration_files (string const & old_dir, string const & new_dir, int old_version)
 298 {
 299         string old_name;
 300         string new_name;
 301
 302         /* ensure target directory exists */
 303
 304         if (g_mkdir_with_parents (new_dir.c_str(), 0755)) {
 305                 return -1;
 306         }
 307
 308         if (old_version >= 3) {
 309
 310                 old_name = Glib::build_filename (old_dir, X_("recent"));
 311                 new_name = Glib::build_filename (new_dir, X_("recent"));
 312
 313                 copy_file (old_name, new_name);
 314
 315                 old_name = Glib::build_filename (old_dir, X_("sfdb"));
 316                 new_name = Glib::build_filename (new_dir, X_("sfdb"));
 317
 318                 copy_file (old_name, new_name);
 319
 320                 /* can only copy ardour.rc/config - UI config is not compatible */
 321
 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.
 326                  */
 327
 328                 string old_name = Glib::build_filename (old_dir, X_("config"));
 329
 330                 if (!Glib::file_test (old_name, Glib::FILE_TEST_EXISTS)) {
 331                         old_name = Glib::build_filename (old_dir, X_("ardour.rc"));
 332                 }
 333
 334                 new_name = Glib::build_filename (new_dir, X_("config"));
 335
 336                 copy_file (old_name, new_name);
 337
 338                 /* copy templates and route templates */
 339
 340                 old_name = Glib::build_filename (old_dir, X_("templates"));
 341                 new_name = Glib::build_filename (new_dir, X_("templates"));
 342
 343                 copy_recurse (old_name, new_name);
 344
 345                 old_name = Glib::build_filename (old_dir, X_("route_templates"));
 346                 new_name = Glib::build_filename (new_dir, X_("route_templates"));
 347
 348                 copy_recurse (old_name, new_name);
 349
 350                 /* presets */
 351
 352                 old_name = Glib::build_filename (old_dir, X_("presets"));
 353                 new_name = Glib::build_filename (new_dir, X_("presets"));
 354
 355                 copy_recurse (old_name, new_name);
 356
 357                 /* plugin status */
 358                 g_mkdir_with_parents (Glib::build_filename (new_dir, plugin_metadata_dir_name).c_str(), 0755);
 359
 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 */
 363
 364                 old_name = Glib::build_filename (old_dir, plugin_metadata_dir_name, X_("plugin_statuses"));
 365                 copy_file (old_name, new_name);
 366
 367                 /* plugin tags */
 368
 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"));
 371
 372                 copy_file (old_name, new_name);
 373
 374                 /* export formats */
 375
 376                 old_name = Glib::build_filename (old_dir, export_formats_dir_name);
 377                 new_name = Glib::build_filename (new_dir, export_formats_dir_name);
 378
 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);
 386                 }
 387         }
 388
 389         return 0;
 390 }
 391
 392 void
 393 ARDOUR::check_for_old_configuration_files ()
 394 {
 395         int current_version = atoi (X_(PROGRAM_VERSION));
 396
 397         if (current_version <= 1) {
 398                 return;
 399         }
 400
 401         int old_version = current_version - 1;
 402
 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);
 406
 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;
 410                 }
 411         }
 412 }
 413
 414 int
 415 ARDOUR::handle_old_configuration_files (boost::function<bool (std::string const&, std::string const&, int)> ui_handler)
 416 {
 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);
 423
 424                 if (ui_handler (old_config_dir, current_config_dir, old_version)) {
 425                         copy_configuration_files (old_config_dir, current_config_dir, old_version);
 426                         return 1;
 427                 }
 428         }
 429         return 0;
 430 }
 431
 432 bool
 433 ARDOUR::init (bool use_windows_vst, bool try_optimization, const char* localedir)
 434 {
 435         if (libardour_initialized) {
 436                 return true;
 437         }
 438
 439 #ifndef NDEBUG
 440         if (getenv("LUA_METATABLES")) {
 441                 luabridge::Security::setHideMetatables (false);
 442         }
 443 #endif
 444
 445         if (!PBD::init()) return false;
 446
 447 #ifdef ENABLE_NLS
 448         (void) bindtextdomain(PACKAGE, localedir);
 449         (void) bind_textdomain_codeset (PACKAGE, "UTF-8");
 450 #endif
 451
 452         SessionEvent::init_event_pool ();
 453
 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 ();
 463
 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
 467            property changes.
 468         */
 469
 470         bounds_change.add (ARDOUR::Properties::start);
 471         bounds_change.add (ARDOUR::Properties::position);
 472         bounds_change.add (ARDOUR::Properties::length);
 473
 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)
 476         */
 477
 478         Stateful::current_state_version = CURRENT_SESSION_FILE_VERSION;
 479
 480         ARDOUR::setup_enum_writer ();
 481
 482         // allow ardour the absolute maximum number of open files
 483         lotsa_files_please ();
 484
 485 #ifdef HAVE_LRDF
 486         lrdf_init();
 487 #endif
 488         Library = new AudioLibrary;
 489
 490         BootMessage (_("Loading configuration"));
 491
 492         Config = new RCConfiguration;
 493
 494         if (Config->load_state ()) {
 495                 return false;
 496         }
 497
 498         Config->set_use_windows_vst (use_windows_vst);
 499 #ifdef LXVST_SUPPORT
 500         Config->set_use_lxvst(true);
 501 #endif
 502
 503         Profile = new RuntimeProfile;
 504
 505
 506 #ifdef WINDOWS_VST_SUPPORT
 507         if (Config->get_use_windows_vst() && fst_init (0)) {
 508                 return false;
 509         }
 510 #endif
 511
 512 #ifdef LXVST_SUPPORT
 513         if (Config->get_use_lxvst() && vstfx_init (0)) {
 514                 return false;
 515         }
 516 #endif
 517
 518 #ifdef AUDIOUNIT_SUPPORT
 519         AUPluginInfo::load_cached_info ();
 520 #endif
 521
 522         setup_hardware_optimization (try_optimization);
 523
 524         SourceFactory::init ();
 525         Analyser::init ();
 526
 527         /* singletons - first object is "it" */
 528         (void) PluginManager::instance();
 529 #ifdef LV2_SUPPORT
 530         (void) URIMap::instance();
 531 #endif
 532         (void) EventTypeMap::instance();
 533
 534         ControlProtocolManager::instance().discover_control_protocols ();
 535
 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.
 540         */
 541
 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.
 547         */
 548         EventLoop::register_request_buffer_factory (X_("midiUI"), MidiControlUI::request_factory);
 549
 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.
 554         */
 555         BufferManager::init (hardware_concurrency() + 4);
 556
 557         PannerManager::instance().discover_panners();
 558
 559         ARDOUR::AudioEngine::create ();
 560
 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
 566            list them here.
 567
 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.
 571         */
 572
 573         reserved_io_names[_("Monitor")] = true;
 574         reserved_io_names[_("Master")] = true;
 575         reserved_io_names["auditioner"] = true; // auditioner.cc  Track (s, "auditioner",...)
 576
 577         /* pure I/O */
 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;
 589
 590         libardour_initialized = true;
 591
 592         return true;
 593 }
 594
 595 void
 596 ARDOUR::init_post_engine ()
 597 {
 598         XMLNode* node;
 599
 600         if ((node = Config->control_protocol_state()) != 0) {
 601                 ControlProtocolManager::instance().set_state (*node, Stateful::loading_state_version);
 602         }
 603
 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;
 607                         /* XXX now what? */
 608                 }
 609         } else {
 610                 if (TransportMasterManager::instance().init ()) {
 611                         error << _("Cannot initialize transport master manager") << endmsg;
 612                         /* XXX now what? */
 613                 }
 614         }
 615
 616         /* find plugins */
 617
 618         ARDOUR::PluginManager::instance().refresh (!Config->get_discover_vst_on_start());
 619 }
 620
 621 void
 622         ARDOUR::cleanup ()
 623 {
 624         if (!libardour_initialized) {
 625                 return;
 626         }
 627
 628         delete &ControlProtocolManager::instance();
 629         ARDOUR::AudioEngine::destroy ();
 630
 631         delete Library;
 632 #ifdef HAVE_LRDF
 633         lrdf_cleanup ();
 634 #endif
 635 #ifdef WINDOWS_VST_SUPPORT
 636         fst_exit ();
 637 #endif
 638
 639 #ifdef LXVST_SUPPORT
 640         vstfx_exit();
 641 #endif
 642         delete &PluginManager::instance();
 643         delete Config;
 644         PBD::cleanup ();
 645
 646         return;
 647 }
 648
 649 bool
 650 ARDOUR::no_auto_connect()
 651 {
 652         return getenv ("ARDOUR_NO_AUTOCONNECT") != 0;
 653 }
 654
 655 void
 656 ARDOUR::setup_fpu ()
 657 {
 658         FPU* fpu = FPU::instance ();
 659
 660         if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
 661                 // valgrind doesn't understand this assembler stuff
 662                 // September 10th, 2007
 663                 return;
 664         }
 665
 666 #if defined(ARCH_X86) && defined(USE_XMMINTRIN)
 667
 668         int MXCSR;
 669
 670         if (!fpu->has_flush_to_zero() && !fpu->has_denormals_are_zero()) {
 671                 return;
 672         }
 673
 674         MXCSR  = _mm_getcsr();
 675
 676 #ifdef DEBUG_DENORMAL_EXCEPTION
 677         /* This will raise a FP exception if a denormal is detected */
 678         MXCSR &= ~_MM_MASK_DENORM;
 679 #endif
 680
 681         switch (Config->get_denormal_model()) {
 682         case DenormalNone:
 683                 MXCSR &= ~(_MM_FLUSH_ZERO_ON | 0x40);
 684                 break;
 685
 686         case DenormalFTZ:
 687                 if (fpu->has_flush_to_zero()) {
 688                         MXCSR |= _MM_FLUSH_ZERO_ON;
 689                 }
 690                 break;
 691
 692         case DenormalDAZ:
 693                 MXCSR &= ~_MM_FLUSH_ZERO_ON;
 694                 if (fpu->has_denormals_are_zero()) {
 695                         MXCSR |= 0x40;
 696                 }
 697                 break;
 698
 699         case DenormalFTZDAZ:
 700                 if (fpu->has_flush_to_zero()) {
 701                         if (fpu->has_denormals_are_zero()) {
 702                                 MXCSR |= _MM_FLUSH_ZERO_ON | 0x40;
 703                         } else {
 704                                 MXCSR |= _MM_FLUSH_ZERO_ON;
 705                         }
 706                 }
 707                 break;
 708         }
 709
 710         _mm_setcsr (MXCSR);
 711
 712 #endif
 713 }
 714
 715 /* this can be changed to modify the translation behaviour for
 716    cases where the user has never expressed a preference.
 717 */
 718 static const bool translate_by_default = true;
 719
 720 string
 721 ARDOUR::translation_enable_path ()
 722 {
 723         return Glib::build_filename (user_config_directory(), ".translate");
 724 }
 725
 726 bool
 727 ARDOUR::translations_are_enabled ()
 728 {
 729         int fd = g_open (ARDOUR::translation_enable_path().c_str(), O_RDONLY, 0444);
 730
 731         if (fd < 0) {
 732                 return translate_by_default;
 733         }
 734
 735         char c;
 736         bool ret = false;
 737
 738         if (::read (fd, &c, 1) == 1 && c == '1') {
 739                 ret = true;
 740         }
 741
 742         ::close (fd);
 743
 744         return ret;
 745 }
 746
 747 bool
 748 ARDOUR::set_translations_enabled (bool yn)
 749 {
 750         string i18n_enabler = ARDOUR::translation_enable_path();
 751         int fd = g_open (i18n_enabler.c_str(), O_WRONLY|O_CREAT|O_TRUNC, 0644);
 752
 753         if (fd < 0) {
 754                 return false;
 755         }
 756
 757         char c;
 758
 759         if (yn) {
 760                 c = '1';
 761         } else {
 762                 c = '0';
 763         }
 764
 765         (void) ::write (fd, &c, 1);
 766         (void) ::close (fd);
 767
 768         Config->ParameterChanged ("enable-translation");
 769         return true;
 770 }
 771
 772
 773 vector<SyncSource>
 774 ARDOUR::get_available_sync_options ()
 775 {
 776         vector<SyncSource> ret;
 777
 778         boost::shared_ptr<AudioBackend> backend = AudioEngine::instance()->current_backend();
 779         if (backend && backend->name() == "JACK") {
 780                 ret.push_back (Engine);
 781         }
 782
 783         ret.push_back (MTC);
 784         ret.push_back (MIDIClock);
 785         ret.push_back (LTC);
 786
 787         return ret;
 788 }
 789
 790 /** Return a monotonic value for the number of microseconds that have elapsed
 791  * since an arbitrary zero origin.
 792  */
 793
 794 #ifdef __MACH__
 795 /* Thanks Apple for not implementing this basic SUSv2, POSIX.1-2001 function
 796  */
 797 #include <mach/mach_time.h>
 798 #define CLOCK_REALTIME 0
 799 #define CLOCK_MONOTONIC 0
 800 int
 801 clock_gettime (int /*clk_id*/, struct timespec *t)
 802 {
 803         static bool initialized = false;
 804         static mach_timebase_info_data_t timebase;
 805         if (!initialized) {
 806                 mach_timebase_info(&timebase);
 807                 initialized = true;
 808         }
 809         uint64_t time;
 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);
 813         t->tv_sec = seconds;
 814         t->tv_nsec = nseconds;
 815         return 0;
 816 }
 817 #endif
 818
 819 microseconds_t
 820 ARDOUR::get_microseconds ()
 821 {
 822 #ifdef PLATFORM_WINDOWS
 823         microseconds_t ret = 0;
 824         LARGE_INTEGER freq, time;
 825
 826         if (QueryPerformanceFrequency(&freq))
 827                 if (QueryPerformanceCounter(&time))
 828                         ret = (microseconds_t)((time.QuadPart * 1000000) / freq.QuadPart);
 829
 830         return ret;
 831 #else
 832         struct timespec ts;
 833         if (clock_gettime (CLOCK_MONOTONIC, &ts) != 0) {
 834                 /* EEEK! */
 835                 return 0;
 836         }
 837         return (microseconds_t) ts.tv_sec * 1000000 + (ts.tv_nsec/1000);
 838 #endif
 839 }
 840
 841 /** Return the number of bits per sample for a given sample format.
 842  *
 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.
 846  */
 847
 848 int
 849 ARDOUR::format_data_width (ARDOUR::SampleFormat format)
 850 {
 851
 852
 853
 854         switch (format) {
 855         case ARDOUR::FormatInt16:
 856                 return 16;
 857         case ARDOUR::FormatInt24:
 858                 return 24;
 859         default:
 860                 return 32;
 861         }
 862 }