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