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
 297         /* load session, if given */
 298         string name, path;
 299
 300         if (session_name.length()){
 301                 bool isnew;
 302
 303                 if (Session::find_session (session_name, path, name, isnew)) {
 304                         error << string_compose(_("could not load command line session \"%1\""), session_name) << endmsg;
 305                 } else {
 306
 307                         if (new_session) {
 308
 309                                 /* command line required that the session be new */
 310
 311                                 if (isnew) {
 312
 313                                         /* popup the new session dialog
 314                                            once everything else is OK.
 315                                         */
 316
 317                                         Glib::signal_idle().connect (bind (mem_fun (*ui, &ARDOUR_UI::cmdline_new_session), path));
 318                                         ui->set_will_create_new_session_automatically (true);
 319
 320                                 } else {
 321
 322                                         /* it wasn't new, but we require a new session */
 323
 324                                         error << string_compose (_("\n\nA session named \"%1\" already exists.\n\
 325 To avoid this message, start ardour as \"ardour %1"), path)
 326                                               << endmsg;
 327                                         return false;
 328                                 }
 329
 330                         } else {
 331
 332                                 /* command line didn't require a new session */
 333
 334                                 if (isnew) {
 335                                         error << string_compose (_("\n\nNo session named \"%1\" exists.\n\
 336 To create it from the command line, start ardour as \"ardour --new %1"), path)
 337                                               << endmsg;
 338                                         return false;
 339                                 }
 340
 341                                 ui->load_session (path, name);
 342                         }
 343                 }
 344
 345                 if (no_splash) {
 346                         ui->show();
 347                 }
 348
 349         } else {
 350                 ui->hide_splash ();
 351                 if (!Config->get_no_new_session_dialog()) {
 352                        ui->new_session (true);
 353                 }
 354         }
 355
 356         return true;
 357 }
 358
 359 #ifdef VST_SUPPORT
 360 /* this is called from the entry point of a wine-compiled
 361    executable that is linked against gtk2_ardour built
 362    as a shared library.
 363 */
 364 extern "C" {
 365 int ardour_main (int argc, char *argv[])
 366 #else
 367 int main (int argc, char *argv[])
 368 #endif
 369
 370 {
 371         ARDOUR::AudioEngine *engine;
 372         vector<Glib::ustring> null_file_list;
 373
 374         // needs a better home.
 375         Glib::thread_init();
 376
 377         gtk_set_locale ();
 378
 379         (void)   bindtextdomain (PACKAGE, LOCALEDIR);
 380         (void) textdomain (PACKAGE);
 381
 382         pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, 0);
 383
 384         // catch_signals ();
 385
 386         text_receiver.listen_to (error);
 387         text_receiver.listen_to (info);
 388         text_receiver.listen_to (fatal);
 389         text_receiver.listen_to (warning);
 390
 391         if (parse_opts (argc, argv)) {
 392                 exit (1);
 393         }
 394
 395         if (curvetest_file) {
 396                 return curvetest (curvetest_file);
 397         }
 398
 399         cout << _("Ardour/GTK ")
 400              << VERSIONSTRING
 401              << _("\n   (built using ")
 402              << gtk_ardour_major_version << '.'
 403              << gtk_ardour_minor_version << '.'
 404              << gtk_ardour_micro_version
 405              << _(" with libardour ")
 406              << libardour_major_version << '.'
 407              << libardour_minor_version << '.'
 408              << libardour_micro_version
 409 #ifdef __GNUC__
 410              << _(" and GCC version ") << __VERSION__
 411 #endif
 412              << ')'
 413              << endl;
 414
 415         if (just_version) {
 416                 exit (0);
 417         }
 418
 419         if (no_splash) {
 420                 cerr << _("Copyright (C) 1999-2006 Paul Davis") << endl
 421                      << _("Some portions Copyright (C) Steve Harris, Ari Johnson, Brett Viren, Joel Baker") << endl
 422                      << endl
 423                      << _("Ardour comes with ABSOLUTELY NO WARRANTY") << endl
 424                      << _("not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.") << endl
 425                      << _("This is free software, and you are welcome to redistribute it ") << endl
 426                      << _("under certain conditions; see the source for copying conditions.")
 427                      << endl;
 428         }
 429
 430         try {
 431                 ui = new ARDOUR_UI (&argc, &argv, which_ui_rcfile());
 432         }
 433
 434         catch (failed_constructor& err) {
 435                 error << _("could not create ARDOUR GUI") << endmsg;
 436                 exit (1);
 437         }
 438
 439
 440         if (!no_splash) {
 441                 ui->show_splash ();
 442                 if (session_name.length()) {
 443                         gtk_timeout_add (4000, show_ui_callback, ui);
 444                 }
 445         }
 446
 447         try {
 448                 engine = new ARDOUR::AudioEngine (jack_client_name);
 449                 ARDOUR::init (*engine, use_vst, try_hw_optimization);
 450                 ui->set_engine (*engine);
 451         } catch (AudioEngine::NoBackendAvailable& err) {
 452                 gui_jack_error ();
 453                 error << string_compose (_("Could not connect to JACK server as  \"%1\""), jack_client_name) <<  endmsg;
 454                 return -1;
 455         } catch (failed_constructor& err) {
 456                 error << _("could not initialize Ardour.") << endmsg;
 457                 return -1;
 458         }
 459
 460         if (maybe_load_session ()) {
 461                 ui->run (text_receiver);
 462                 ui = 0;
 463         }
 464
 465         delete engine;
 466         ARDOUR::cleanup ();
 467         shutdown (0);
 468
 469         return 0;
 470 }
 471 #ifdef VST_SUPPORT
 472 } // end of extern C block
 473 #endif
 474