src/tX_engine.cc

   1 /*
   2     terminatorX - realtime audio scratching software
   3     Copyright (C) 1999-2003  Alexander König
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19     File: tX_engine.c
  20
  21     Description: Contains the code that does the real "Scratching
  22                  business": XInput, DGA, Mouse and Keyboardgrabbing
  23                  etc.
  24
  25     02 Jun 1999: Implemented high-priority/rt-FIFO-Scheduling use for
  26                  engine-thread.
  27
  28     04 Jun 1999: Changed warp-feature behaviour: still connected to
  29                  mouse-speed (should be changed to maybe) but now
  30                  depends on sample size -> you can warp through all
  31                  samples with the same mouse-distance.
  32
  33     12 Aug 2002: Complete rewrite - tX_engine is now a class and the thread
  34         is created on startup and kept alive until termination
  35 */
  36
  37 #include <config.h>
  38 #include "tX_types.h"
  39 #include "tX_engine.h"
  40 #include "tX_audiodevice.h"
  41 #include "tX_mouse.h"
  42 #include "tX_vtt.h"
  43 #include <pthread.h>
  44 #include <gtk/gtk.h>
  45 #include <gdk/gdkprivate.h>
  46 #include "tX_mastergui.h"
  47 #include "tX_global.h"
  48 #include "tX_tape.h"
  49 #include "tX_widget.h"
  50 #include <config.h>
  51 #include "tX_sequencer.h"
  52 #include <errno.h>
  53 #include <sched.h>
  54 #include "tX_capabilities.h"
  55
  56 #include <sys/time.h>
  57 #include <sys/resource.h>
  58
  59 tX_engine *tX_engine::engine=NULL;
  60
  61 tX_engine *tX_engine::get_instance() {
  62         if (!engine) {
  63                 engine=new tX_engine();
  64         }
  65
  66         return engine;
  67 }
  68
  69 void tX_engine::set_grab_request() {
  70         grab_request=true;
  71 }
  72
  73 int16_t* tX_engine::render_cycle() {
  74         /* Checking whether to grab or not  */
  75         if (grab_request!=grab_active) {
  76                 if (grab_request) {
  77                         /* Activating grab... */
  78                         int result=mouse->grab();
  79                         if (result!=0) {
  80                                 tX_error("tX_engine::render_cycle(): failed to grab mouse - error %i", result);
  81                                 grab_active=false;
  82                                 /* Reseting grab_request, too - doesn't help keeping it, does it ? ;) */
  83                                 grab_request=false;
  84                                 mouse->ungrab();
  85                                 grab_off();
  86                         } else {
  87                                 grab_active=true;
  88                         }
  89                 } else {
  90                         /* Deactivating grab... */
  91                         mouse->ungrab();
  92                         grab_active=false;
  93                         grab_off(); // for the mastergui this is...
  94                 }
  95         }
  96
  97         /* Handling input events... */
  98         if (grab_active) {
  99                 if (mouse->check_event()) {
 100                         /* If we're here the user pressed ESC */
 101                         grab_request=false;
 102                 }
 103         }
 104
 105         /* Forward the sequencer... */
 106         sequencer.step();
 107
 108         /* Render the next block... */
 109         int16_t *data=vtt_class::render_all_turntables();
 110
 111         /* Record the audio if necessary... */
 112         if (is_recording()) tape->eat(data);
 113
 114         return  data;
 115 }
 116
 117 void tX_engine::loop() {
 118         while (!thread_terminate) {
 119                 /* Waiting for the trigger */
 120                 pthread_mutex_lock(&start);
 121                 loop_is_active=true;
 122                 pthread_mutex_unlock(&start);
 123
 124                 if (!stop_flag) device->start(); // Hand flow control over to the device
 125
 126                 /* Stopping engine... */
 127                 loop_is_active=false;
 128         }
 129 }
 130
 131 void *engine_thread_entry(void *engine_void) {
 132         tX_engine *engine=(tX_engine*) engine_void;
 133         int result;
 134
 135         /* Dropping root privileges for the engine thread - if running suid. */
 136
 137         if ((!geteuid()) && (getuid() != geteuid())) {
 138 #ifdef USE_CAPABILITIES
 139                 tX_error("engine_thread_entry(): using capabilities but still suid root?");
 140                 tX_error("engine_thread_entry(): Please report this.");
 141                 exit(-1);
 142 #endif
 143
 144 #ifndef ALLOW_SUID_ROOT
 145                 tX_error("This binary doesn't support running suid-root.");
 146                 tX_error("Reconfigure with --enable-suidroot if you really want that.");
 147                 exit(-1);
 148 #endif
 149                 tX_debug("engine_thread_entry() - Running suid root - dropping privileges.");
 150
 151                 result=setuid(getuid());
 152
 153                 if (result!=0) {
 154                         tX_error("engine_thread_entry() - Failed to drop root privileges.");
 155                         exit(2);
 156                 }
 157         }
 158
 159 #ifdef USE_SCHEDULER
 160         pid_t pid=getpid();
 161
 162 #ifdef USE_CAPABILITIES
 163         if (have_nice_capability()) {
 164                 if (globals.use_realtime) {
 165                         struct sched_param parm;
 166
 167                         sched_getparam(pid, &parm);
 168                         parm.sched_priority=sched_get_priority_max(SCHED_FIFO);
 169                         if (sched_setscheduler(pid, SCHED_FIFO, &parm)) {
 170                                 tX_error("engine_thread_entry(): failed to set realtime priority.");
 171                         }
 172                 }
 173         } else {
 174                 tX_warning("engine_thread_entry(): can't set SCHED_FIFO -> lacking capabilities.");
 175         }
 176 #endif //USE_CAPABILITIES
 177         engine->set_pid(pid);
 178
 179         if (sched_getscheduler(pid)!=SCHED_FIFO) {
 180                 tX_warning("engine_thread_entry() - engine has no realtime priority scheduling.");
 181         }
 182 #endif //USE_SCHEDULER
 183
 184 #ifdef USE_JACK
 185         /* Create the client now, so the user has something to connect to. */
 186         tX_jack_client::get_instance();
 187 #endif
 188
 189         engine->loop();
 190
 191         tX_debug("engine_thread_entry() - Engine thread terminating.");
 192
 193         pthread_exit(NULL);
 194 }
 195
 196 tX_engine :: tX_engine() {
 197         int result;
 198
 199         pthread_mutex_init(&start, NULL);
 200         pthread_mutex_lock(&start);
 201         thread_terminate=false;
 202 #ifdef USE_SCHEDULER
 203         pid=-1;
 204 #endif
 205
 206         /* Creating the actual engine thread.. */
 207 #ifdef USE_SCHEDULER
 208         if (!geteuid() && globals.use_realtime) {
 209                 pthread_attr_t pattr;
 210                 struct sched_param sparm;
 211
 212                 tX_debug("tX_engine() - Have root privileges - using SCHED_FIFO.");
 213
 214                 pthread_attr_init(&pattr);
 215                 pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_JOINABLE);
 216                 pthread_attr_setschedpolicy(&pattr, SCHED_FIFO);
 217
 218                 sched_getparam(getpid(), &sparm);
 219                 sparm.sched_priority=sched_get_priority_max(SCHED_FIFO);
 220
 221                 pthread_attr_setschedparam(&pattr, &sparm);
 222                 pthread_attr_setinheritsched(&pattr, PTHREAD_EXPLICIT_SCHED);
 223                 pthread_attr_setscope(&pattr, PTHREAD_SCOPE_SYSTEM);
 224
 225                 result=pthread_create(&thread, &pattr, engine_thread_entry, (void *) this);
 226         } else {
 227 #endif // USE_SCHEDULER
 228                 result=pthread_create(&thread, NULL, engine_thread_entry, (void *) this);
 229 #ifdef USE_SCHEDULER
 230         }
 231 #endif
 232
 233         if (result!=0) {
 234                 tX_error("tX_engine() - Failed to create engine thread. Errno is %i.", errno);
 235                 exit(1);
 236         }
 237
 238         /* Dropping root privileges for the main thread - if running suid. */
 239
 240         if ((!geteuid()) && (getuid() != geteuid())) {
 241                 tX_debug("tX_engine() - Running suid root - dropping privileges.");
 242
 243                 result=setuid(getuid());
 244
 245                 if (result!=0) {
 246                         tX_error("tX_engine() - Failed to drop root privileges.");
 247                         exit(2);
 248                 }
 249         }
 250
 251         mouse=new tx_mouse();
 252 #ifdef USE_ALSA_MIDI_IN
 253         midi=new tX_midiin();
 254 #endif
 255         tape=new tx_tapedeck();
 256
 257         device=NULL;
 258         recording=false;
 259         recording_request=false;
 260         loop_is_active=false;
 261         grab_request=false;
 262         grab_active=false;
 263 }
 264
 265 void tX_engine :: set_recording_request (bool recording) {
 266         this->recording_request=recording;
 267 }
 268
 269 tX_engine_error tX_engine :: run() {
 270         list <vtt_class *> :: iterator vtt;
 271
 272         if (loop_is_active) return ERROR_BUSY;
 273
 274         switch (globals.audiodevice_type) {
 275 #ifdef USE_OSS
 276                 case OSS:
 277                         device=new tX_audiodevice_oss();
 278                 break;
 279 #endif
 280
 281 #ifdef USE_ALSA
 282                 case ALSA:
 283                         device=new tX_audiodevice_alsa();
 284                 break;
 285 #endif
 286
 287 #ifdef USE_JACK
 288                 case JACK:
 289                         device=new tX_audiodevice_jack();
 290                 break;
 291 #endif
 292
 293                 default:
 294                         device=NULL; return ERROR_AUDIO;
 295         }
 296
 297         if (device->open()) {
 298                 if (device->get_is_open()) device->close();
 299                 delete device;
 300                 device=NULL;
 301                 return ERROR_AUDIO;
 302         }
 303
 304         vtt_class::set_sample_rate(device->get_sample_rate());
 305
 306         if (recording_request) {
 307                 if (tape->start_record(globals.record_filename, vtt_class::get_mix_buffer_size(), device->get_sample_rate())) {
 308                         device->close();
 309                         delete device;
 310                         device=NULL;
 311                         return ERROR_TAPE;
 312                 } else {
 313                         recording=true;
 314                 }
 315         }
 316
 317         for (vtt=vtt_class::main_list.begin(); vtt!=vtt_class::main_list.end(); vtt++) {
 318                 (*vtt)->sync_countdown=0;
 319                 if ((*vtt)->autotrigger) (*vtt)->trigger();
 320         }
 321
 322         sequencer.forward_to_start_timestamp(1);
 323         stop_flag=false;
 324         /* Trigger the engine thread... */
 325         pthread_mutex_unlock(&start);
 326
 327         return NO_ERROR;
 328 }
 329
 330 void tX_engine :: stop() {
 331         list <vtt_class *> :: iterator vtt;
 332
 333         if (!loop_is_active) {
 334                 tX_error("tX_engine::stop() - but loop's not running?");
 335         }
 336
 337         pthread_mutex_lock(&start);
 338         stop_flag=true;
 339
 340         tX_debug("tX_engine::stop() - waiting for loop to stop.");
 341
 342         while (loop_is_active) {
 343                 /* Due to gtk+ signal handling this can cause a deadlock
 344                    on the seqpars' update list. So we need to handle events
 345                    while waiting...
 346                 */
 347                 while (gtk_events_pending()) gtk_main_iteration();
 348                 usleep(50);
 349         }
 350
 351         tX_debug("tX_engine::stop() - loop has stopped.");
 352
 353         if (device->get_is_open()) device->close();
 354         delete device;
 355         device=NULL;
 356
 357         for (vtt=vtt_class::main_list.begin(); vtt!=vtt_class::main_list.end(); vtt++) {
 358                 (*vtt)->stop();
 359                 (*vtt)->ec_clear_buffer();
 360         }
 361
 362         if (is_recording()) tape->stop_record();
 363         recording=false;
 364 }
 365
 366 tX_engine :: ~tX_engine() {
 367         void *dummy;
 368
 369         thread_terminate=true;
 370         stop_flag=true;
 371         pthread_mutex_unlock(&start);
 372         tX_debug("~tX_engine() - Waiting for engine thread to terminate.");
 373         pthread_join(thread, &dummy);
 374
 375         delete mouse;
 376 #ifdef USE_ALSA_MIDI_IN
 377         delete midi;
 378 #endif
 379         delete tape;
 380 }