gtk2_ardour/main.cc

   1 /*
   2     Copyright (C) 2001-2006 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     $Id$
  19 */
  20
  21 #include <sys/types.h>
  22 #include <sys/mman.h>
  23 #include <sys/wait.h>
  24 #include <cerrno>
  25 #include <cstdlib>
  26 #include <signal.h>
  27 #include <unistd.h>
  28
  29 #include <sigc++/bind.h>
  30 #include <gtkmm/settings.h>
  31
  32 #include <pbd/error.h>
  33 #include <pbd/textreceiver.h>
  34 #include <pbd/failed_constructor.h>
  35 #include <pbd/pthread_utils.h>
  36
  37 #include <jack/jack.h>
  38
  39 #include <ardour/version.h>
  40 #include <ardour/ardour.h>
  41 #include <ardour/audioengine.h>
  42
  43 #include <gtkmm/main.h>
  44 #include <gtkmm2ext/popup.h>
  45 #include <gtkmm2ext/utils.h>
  46
  47 #include "version.h"
  48 #include "ardour_ui.h"
  49 #include "opts.h"
  50
  51 #include "i18n.h"
  52
  53 using namespace Gtk;
  54 using namespace GTK_ARDOUR;
  55 using namespace ARDOUR;
  56 using namespace PBD;
  57 using namespace sigc;
  58
  59 TextReceiver text_receiver ("ardour");
  60
  61 extern int curvetest (string);
  62
  63 static ARDOUR_UI  *ui = 0;
  64
  65 static void
  66 shutdown (int status)
  67 {
  68         char* msg;
  69
  70         if (status) {
  71
  72                 msg = _("ardour is killing itself for a clean exit\n");
  73                 write (1, msg, strlen (msg));
  74                 /* drastic, but perhaps necessary */
  75                 kill (-getpgrp(), SIGKILL);
  76                 /*NOTREACHED*/
  77
  78         } else {
  79
  80                 if (ui) {
  81                         msg = _("stopping user interface\n");
  82                         write (1, msg, strlen (msg));
  83                         ui->kill();
  84                 }
  85
  86                 pthread_cancel_all ();
  87         }
  88
  89         exit (status);
  90 }
  91
  92
  93 static void
  94 handler (int sig)
  95 {
  96         char buf[64];
  97         int n;
  98
  99         /* XXX its doubtful that snprintf() is async-safe */
 100         n = snprintf (buf, sizeof(buf), _("%d(%d): received signal %d\n"), getpid(), (int) pthread_self(), sig);
 101         write (1, buf, n);
 102
 103         shutdown (1);
 104 }
 105
 106 static void *
 107 signal_thread (void *arg)
 108 {
 109         int sig;
 110         sigset_t blocked;
 111
 112         PBD::ThreadCreated (pthread_self(), X_("Signal"));
 113
 114         pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, 0);
 115
 116         /* find out what's blocked right now */
 117
 118         //sigprocmask (SIG_SETMASK, 0, &blocked);
 119         if (pthread_sigmask (SIG_SETMASK, 0, &blocked)) {
 120                 cerr << "getting blocked signals failed\n";
 121         }
 122
 123         /* wait for any of the currently blocked signals.
 124
 125            According to the man page found in linux 2.6 and 2.4, sigwait()
 126            never returns an error. This is incorrect. Checking the man
 127            pages for some other *nix systems makes it clear that
 128            sigwait() can return several error codes, one of which
 129            is EINTR. This happens if the thread receives a signal
 130            which is not in the blocked set.
 131
 132            We do not expect that to happen, and if it did we should generally
 133            exit as planned. However, under 2.6, the ptrace facility used
 134            by gdb seems to also cause sigwait() to return with EINTR
 135            but with a signal that sigwait cannot understand. As a result,
 136            "sig" is set to zero, an impossible signal number.
 137
 138            Handling the EINTR code makes it possible to debug
 139            ardour on a 2.6 kernel.
 140
 141         */
 142
 143         int swerr;
 144
 145   again:
 146         if ((swerr = sigwait (&blocked, &sig))) {
 147                 if (swerr == EINTR) {
 148                         goto again;
 149                 } else {
 150                         cerr << "sigwait failed with " << swerr << endl;
 151                 }
 152         }
 153
 154         cerr << "Signal " << sig << " received\n";
 155
 156         if (sig != SIGSEGV) {
 157
 158                 /* unblock signals so we can see them during shutdown.
 159                    this will help prod developers not to lose sight
 160                    of bugs that cause segfaults etc. during shutdown.
 161                 */
 162
 163                 sigprocmask (SIG_UNBLOCK, &blocked, 0);
 164         }
 165
 166         shutdown (1);
 167         /*NOTREACHED*/
 168         return 0;
 169 }
 170
 171 int
 172 catch_signals (void)
 173 {
 174         struct sigaction action;
 175         pthread_t signal_thread_id;
 176         sigset_t signals;
 177
 178 //      if (setpgid (0,0)) {
 179         if (setsid ()) {
 180                 warning << string_compose (_("cannot become new process group leader (%1)"),
 181                                     strerror (errno))
 182                         << endmsg;
 183         }
 184
 185         sigemptyset (&signals);
 186         sigaddset(&signals, SIGHUP);
 187         sigaddset(&signals, SIGINT);
 188         sigaddset(&signals, SIGQUIT);
 189         sigaddset(&signals, SIGPIPE);
 190         sigaddset(&signals, SIGTERM);
 191         sigaddset(&signals, SIGUSR1);
 192         sigaddset(&signals, SIGUSR2);
 193
 194
 195         /* install a handler because otherwise
 196            pthreads behaviour is undefined when we enter
 197            sigwait.
 198         */
 199
 200         action.sa_handler = handler;
 201         action.sa_mask = signals;
 202         action.sa_flags = SA_RESTART|SA_RESETHAND;
 203
 204         for (int i = 1; i < 32; i++) {
 205                 if (sigismember (&signals, i)) {
 206                         if (sigaction (i, &action, 0)) {
 207                                 cerr << string_compose (_("cannot setup signal handling for %1"), i) << endl;
 208                                 return -1;
 209                         }
 210                 }
 211         }
 212
 213         /* this sets the signal mask for this and all
 214            subsequent threads that do not reset it.
 215         */
 216
 217         if (pthread_sigmask (SIG_SETMASK, &signals, 0)) {
 218                 cerr << string_compose (_("cannot set default signal mask (%1)"), strerror (errno)) << endl;
 219                 return -1;
 220         }
 221
 222         /* start a thread to wait for signals */
 223
 224         if (pthread_create_and_store ("signal", &signal_thread_id, 0, signal_thread, 0)) {
 225                 cerr << "cannot create signal catching thread" << endl;
 226                 return -1;
 227         }
 228
 229         pthread_detach (signal_thread_id);
 230         return 0;
 231 }
 232
 233 string
 234 which_ui_rcfile ()
 235 {
 236         string rcfile;
 237         char* env;
 238
 239         if ((env = getenv ("ARDOUR2_UI_RC")) != 0 && strlen (env)) {
 240                 rcfile = env;
 241         } else {
 242                 rcfile = "ardour2_ui.rc";
 243         }
 244
 245         rcfile = find_config_file (rcfile);
 246
 247         if (rcfile.empty()) {
 248                 warning << _("Without a UI style file, ardour will look strange.\n Please set ARDOUR2_UI_RC to point to a valid UI style file") << endmsg;
 249         } else {
 250                 cerr << "Loading ui configuration file " << rcfile << endl;
 251         }
 252
 253         return rcfile;
 254 }
 255
 256 gint
 257 show_ui_callback (void *arg)
 258 {
 259         ARDOUR_UI * ui = (ARDOUR_UI *) arg;
 260
 261         ui->hide_splash();
 262         ui->show ();
 263
 264         return FALSE;
 265 }
 266
 267 void
 268 gui_jack_error ()
 269 {
 270   MessageDialog win (_("Ardour could not connect to JACK."),
 271                      false,
 272                      Gtk::MESSAGE_INFO,
 273                      (Gtk::ButtonsType)(Gtk::BUTTONS_NONE));
 274 win.set_secondary_text(_("There are several possible reasons:\n\
 275 \n\
 276 1) JACK is not running.\n\
 277 2) JACK is running as another user, perhaps root.\n\
 278 3) There is already another client called \"ardour\".\n\
 279 \n\
 280 Please consider the possibilities, and perhaps (re)start JACK."));
 281
 282         win.add_button (Stock::QUIT, RESPONSE_CLOSE);
 283         win.set_default_response (RESPONSE_CLOSE);
 284
 285         win.show_all ();
 286         win.set_position (Gtk::WIN_POS_CENTER);
 287
 288         /* we just don't care about the result */
 289
 290         win.run ();
 291 }
 292
 293 static bool
 294 maybe_load_session ()
 295 {
 296         /* If no session name is given: we're not loading a session yet, nor creating a new one */
 297         if (!session_name.length()) {
 298                 ui->hide_splash ();
 299                 if (!Config->get_no_new_session_dialog()) {
 300                        ui->new_session (true);
 301                 }
 302
 303                 return true;
 304         }
 305
 306         /* Load session or start the new session dialog */
 307         string name, path;
 308
 309         bool isnew;
 310
 311         if (Session::find_session (session_name, path, name, isnew)) {
 312                 error << string_compose(_("could not load command line session \"%1\""), session_name) << endmsg;
 313                 return false;
 314         }
 315
 316         if (!new_session) {
 317
 318                 /* Loading a session, but the session doesn't exist */
 319                 if (isnew) {
 320                         error << string_compose (_("\n\nNo session named \"%1\" exists.\n\
 321 To create it from the command line, start ardour as \"ardour --new %1"), path) << endmsg;
 322                         return false;
 323                 }
 324
 325                 ui->load_session (path, name);
 326
 327         } else {
 328         /*  TODO: This bit of code doesn't work properly yet
 329                 Glib::signal_idle().connect (bind (mem_fun (*ui, &ARDOUR_UI::cmdline_new_session), path));
 330                 ui->set_will_create_new_session_automatically (true); */
 331
 332                 /* Show the NSD */
 333                 ui->hide_splash ();
 334                 if (!Config->get_no_new_session_dialog()) {
 335                        ui->new_session (true);
 336                 }
 337         }
 338
 339         return true;
 340 }
 341
 342 #ifdef VST_SUPPORT
 343 /* this is called from the entry point of a wine-compiled
 344    executable that is linked against gtk2_ardour built
 345    as a shared library.
 346 */
 347 extern "C" {
 348 int ardour_main (int argc, char *argv[])
 349 #else
 350 int main (int argc, char *argv[])
 351 #endif
 352
 353 {
 354         ARDOUR::AudioEngine *engine;
 355         vector<Glib::ustring> null_file_list;
 356
 357         // needs a better home.
 358         Glib::thread_init();
 359
 360         gtk_set_locale ();
 361
 362         (void)   bindtextdomain (PACKAGE, LOCALEDIR);
 363         (void) textdomain (PACKAGE);
 364
 365         pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, 0);
 366
 367         // catch_signals ();
 368
 369         text_receiver.listen_to (error);
 370         text_receiver.listen_to (info);
 371         text_receiver.listen_to (fatal);
 372         text_receiver.listen_to (warning);
 373
 374         if (parse_opts (argc, argv)) {
 375                 exit (1);
 376         }
 377
 378         if (curvetest_file) {
 379                 return curvetest (curvetest_file);
 380         }
 381
 382         cout << _("Ardour/GTK ")
 383              << VERSIONSTRING
 384              << _("\n   (built using ")
 385              << gtk_ardour_major_version << '.'
 386              << gtk_ardour_minor_version << '.'
 387              << gtk_ardour_micro_version
 388              << _(" with libardour ")
 389              << libardour_major_version << '.'
 390              << libardour_minor_version << '.'
 391              << libardour_micro_version
 392 #ifdef __GNUC__
 393              << _(" and GCC version ") << __VERSION__
 394 #endif
 395              << ')'
 396              << endl;
 397
 398         if (just_version) {
 399                 exit (0);
 400         }
 401
 402         if (no_splash) {
 403                 cerr << _("Copyright (C) 1999-2006 Paul Davis") << endl
 404                      << _("Some portions Copyright (C) Steve Harris, Ari Johnson, Brett Viren, Joel Baker") << endl
 405                      << endl
 406                      << _("Ardour comes with ABSOLUTELY NO WARRANTY") << endl
 407                      << _("not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.") << endl
 408                      << _("This is free software, and you are welcome to redistribute it ") << endl
 409                      << _("under certain conditions; see the source for copying conditions.")
 410                      << endl;
 411         }
 412
 413         try {
 414                 ui = new ARDOUR_UI (&argc, &argv, which_ui_rcfile());
 415         }
 416
 417         catch (failed_constructor& err) {
 418                 error << _("could not create ARDOUR GUI") << endmsg;
 419                 exit (1);
 420         }
 421
 422
 423         if (!no_splash) {
 424                 ui->show_splash ();
 425                 if (session_name.length()) {
 426                         gtk_timeout_add (4000, show_ui_callback, ui);
 427                 }
 428         }
 429
 430         try {
 431                 engine = new ARDOUR::AudioEngine (jack_client_name);
 432                 ARDOUR::init (use_vst, try_hw_optimization);
 433                 ui->set_engine (*engine);
 434         } catch (AudioEngine::NoBackendAvailable& err) {
 435                 gui_jack_error ();
 436                 error << string_compose (_("Could not connect to JACK server as  \"%1\""), jack_client_name) <<  endmsg;
 437                 return -1;
 438         } catch (failed_constructor& err) {
 439                 error << _("could not initialize Ardour.") << endmsg;
 440                 return -1;
 441         }
 442
 443         if (maybe_load_session ()) {
 444                 ui->run (text_receiver);
 445                 ui = 0;
 446         }
 447
 448         delete engine;
 449         ARDOUR::cleanup ();
 450         shutdown (0);
 451
 452         return 0;
 453 }
 454 #ifdef VST_SUPPORT
 455 } // end of extern C block
 456 #endif
 457