libjack/transclient.c

   1 /*
   2     JACK transport client interface -- runs in the client process.
   3
   4     Copyright (C) 2001-2003 Paul Davis
   5     Copyright (C) 2003 Jack O'Quin
   6
   7     This program is free software; you can redistribute it and/or
   8     modify it under the terms of the GNU Lesser General Public License
   9     as published by the Free Software Foundation; either version 2.1
  10     of the License, or (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15     Lesser General Public License for more details.
  16
  17     You should have received a copy of the GNU Lesser General Public
  18     License along with this program; if not, write to the Free
  19     Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20     02111-1307, USA.
  21 */
  22
  23 #include <config.h>
  24 #include <errno.h>
  25 #include <math.h>
  26 #include <stdio.h>
  27 #include <jack/atomicity.h>
  28 #include <jack/internal.h>
  29 #include "local.h"
  30
  31
  32 /********************* Internal functions *********************/
  33
  34 /* generate a unique non-zero ID, different for each call */
  35 jack_unique_t
  36 jack_generate_unique_id (jack_control_t *ectl)
  37 {
  38         /* The jack_unique_t is an opaque type. */
  39         return exchange_and_add(&ectl->seq_number, 1);
  40 }
  41
  42 static inline void
  43 jack_read_frame_time (const jack_client_t *client, jack_frame_timer_t *copy)
  44 {
  45         int tries = 0;
  46         long timeout = 1000;
  47
  48         do {
  49                 /* throttle the busy wait if we don't get
  50                    the answer very quickly.
  51
  52                    XXX This is disgusting. on a UP
  53                    system, it needs to sleep
  54                    if the first try didn't work. on an SMP
  55                    system, it should wait for half of
  56                    the context switch time before
  57                    sleeping.
  58                 */
  59
  60                 if (tries > 10) {
  61                         usleep (20);
  62                         tries = 0;
  63
  64                         /* debug code to avoid system hangs... */
  65                         if (--timeout == 0) {
  66                                 jack_error ("hung in loop copying position A");
  67                                 abort();
  68                         }
  69                 }
  70
  71                 *copy = client->engine->frame_timer;
  72
  73                 tries++;
  74
  75         } while (copy->guard1 != copy->guard2);
  76 }
  77
  78 /* copy a JACK transport position structure (thread-safe) */
  79 void
  80 jack_transport_copy_position (jack_position_t *from, jack_position_t *to)
  81 {
  82         int tries = 0;
  83         long timeout = 1000;
  84
  85         do {
  86                 /* throttle the busy wait if we don't get the answer
  87                  * very quickly. See comment above about this
  88                  * design.
  89                  */
  90                 if (tries > 10) {
  91                         usleep (20);
  92                         tries = 0;
  93
  94                         /* debug code to avoid system hangs... */
  95                         if (--timeout == 0) {
  96                                 jack_error ("hung in loop copying position B");
  97                                 abort();
  98                         }
  99                 }
 100                 *to = *from;
 101                 tries++;
 102
 103         } while (to->unique_1 != to->unique_2);
 104 }
 105
 106 static inline int
 107 jack_transport_request_new_pos (jack_client_t *client, jack_position_t *pos)
 108 {
 109         jack_control_t *ectl = client->engine;
 110
 111         /* distinguish this request from all others */
 112         pos->unique_1 = pos->unique_2 = jack_generate_unique_id(ectl);
 113
 114         /* clients may not set these fields */
 115         pos->usecs = ectl->current_time.usecs;
 116         pos->frame_rate = ectl->current_time.frame_rate;
 117
 118         /* carefully copy requested postion into shared memory */
 119         jack_transport_copy_position (pos, &ectl->request_time);
 120
 121         return 0;
 122 }
 123
 124
 125 /******************** Callback invocations ********************/
 126
 127 void
 128 jack_call_sync_client (jack_client_t *client)
 129 {
 130         jack_client_control_t *control = client->control;
 131         jack_control_t *ectl = client->engine;
 132
 133         /* Make sure still active and slow-sync; active_slowsync is
 134          * set in a critical section; sync_cb is not. */
 135         if ((ectl->new_pos || control->sync_poll || control->sync_new) &&
 136             control->active_slowsync) {
 137
 138                 if (client->sync_cb (ectl->transport_state,
 139                                       &ectl->current_time,
 140                                       client->sync_arg)) {
 141
 142                         if (control->sync_poll) {
 143                                 control->sync_poll = 0;
 144                                 ectl->sync_remain--;
 145                         }
 146                 }
 147                 control->sync_new = 0;
 148         }
 149 }
 150
 151 void
 152 jack_call_timebase_master (jack_client_t *client)
 153 {
 154         jack_client_control_t *control = client->control;
 155         jack_control_t *ectl = client->engine;
 156         int new_pos = (int) ectl->pending_pos;
 157
 158
 159         /* Make sure this is still the master; is_timebase is set in a
 160          * critical section; timebase_cb is not. */
 161         if (control->is_timebase) {
 162
 163                 if (control->timebase_new) {    /* first callback? */
 164                         control->timebase_new = 0;
 165                         new_pos = 1;
 166                 }
 167
 168
 169                 if ((ectl->transport_state == JackTransportRolling) ||
 170                     new_pos) {
 171
 172                         client->timebase_cb (ectl->transport_state,
 173                                               control->nframes,
 174                                               &ectl->pending_time,
 175                                               new_pos,
 176                                               client->timebase_arg);
 177                 }
 178
 179         } else {
 180
 181                 /* another master took over, so resign */
 182                 client->timebase_cb = NULL;
 183                 client->timebase_arg = NULL;
 184                 control->timebase_cb_cbset = FALSE;
 185         }
 186 }
 187
 188
 189 /************************* API functions *************************/
 190
 191 jack_nframes_t
 192 jack_get_current_transport_frame (const jack_client_t *client)
 193 {
 194         jack_position_t position;
 195         float usecs;
 196         jack_nframes_t elapsed;
 197         jack_transport_state_t tstate;
 198
 199         /* get the current transport position information.
 200            this is thread-safe and atomic with respect
 201            to the structure contents.
 202         */
 203
 204         tstate = jack_transport_query (client, &position);
 205
 206         if (tstate != JackTransportRolling) {
 207                 return position.frame;
 208         }
 209
 210         /* compute the elapsed usecs then audio frames since
 211            the transport info was last updated
 212         */
 213
 214         usecs = jack_get_microseconds() - position.usecs;
 215         elapsed = (jack_nframes_t) floor ((((float) position.frame_rate)
 216                                            / 1000000.0f) * usecs);
 217
 218         /* return the estimated transport frame position
 219          */
 220
 221         return position.frame + elapsed;
 222 }
 223
 224 jack_nframes_t
 225 jack_frames_since_cycle_start (const jack_client_t *client)
 226 {
 227         float usecs;
 228         jack_control_t *ectl = client->engine;
 229
 230         usecs = jack_get_microseconds() - ectl->current_time.usecs;
 231         return (jack_nframes_t) floor ((((float) ectl->current_time.frame_rate)
 232                                         / 1000000.0f) * usecs);
 233 }
 234
 235 jack_time_t
 236 jack_get_time()
 237 {
 238         return jack_get_microseconds();
 239 }
 240
 241 jack_nframes_t
 242 jack_time_to_frames(const jack_client_t *client, jack_time_t now)
 243 {
 244         jack_frame_timer_t time;
 245         jack_control_t *ectl = client->engine;
 246
 247         jack_read_frame_time (client, &time);
 248
 249         if (time.initialized) {
 250 #if 0
 251                 jack_info ("now = %Lu current wakeup = %Lu next = %Lu frames = %lu + %f => %lu FC = %f SOI = %f",
 252                          now, time.current_wakeup, time.next_wakeup, time.frames,
 253                          (double) (now - time.current_wakeup)/ (time.next_wakeup - time.current_wakeup),
 254                          time.frames +
 255                            (long) rint (((double) ((long long) now - time.current_wakeup)/
 256                                          (long long) (time.next_wakeup - time.current_wakeup)) * ectl->buffer_size),
 257                            time.filter_coefficient,
 258                            time.second_order_integrator);
 259 #endif
 260
 261                 return time.frames +
 262                         (long) rint (((double) ((long long) (now - time.current_wakeup))/
 263                                                 ((long long) (time.next_wakeup - time.current_wakeup))) * ectl->buffer_size);
 264         }
 265         return 0;
 266 }
 267
 268 jack_nframes_t
 269 jack_frame_time (const jack_client_t *client)
 270 {
 271         jack_time_t now = jack_get_microseconds();
 272         return jack_time_to_frames(client, now);
 273 }
 274
 275 jack_nframes_t
 276 jack_last_frame_time (const jack_client_t *client)
 277 {
 278         return client->engine->frame_timer.frames;
 279 }
 280
 281 jack_time_t
 282 jack_frames_to_time(const jack_client_t *client, jack_nframes_t frames)
 283 {
 284         jack_frame_timer_t time;
 285         jack_control_t *ectl = client->engine;
 286
 287         jack_read_frame_time (client, &time);
 288
 289         if (time.initialized) {
 290                 return time.current_wakeup +
 291                         (long) rint (((double) ((long long) (frames - time.frames)) *
 292                                                 ((long long) (time.next_wakeup - time.current_wakeup)) / ectl->buffer_size) );
 293         }
 294
 295         return 0;
 296 }
 297
 298 jack_nframes_t
 299 jack_get_sample_rate (jack_client_t *client)
 300 {
 301         return client->engine->current_time.frame_rate;
 302 }
 303
 304 int
 305 jack_set_sample_rate_callback (jack_client_t *client,
 306                                JackSampleRateCallback callback, void *arg)
 307 {
 308         if (client->control->active) {
 309                 jack_error ("You cannot set callbacks on an active client.");
 310                 return -1;
 311         }
 312         client->srate_arg = arg;
 313         client->srate = callback;
 314         client->control->srate_cbset = (callback != NULL);
 315
 316         /* Now invoke it */
 317
 318         callback (client->engine->current_time.frame_rate, arg);
 319
 320         return 0;
 321 }
 322
 323 int
 324 jack_release_timebase (jack_client_t *client)
 325 {
 326         int rc;
 327         jack_request_t req;
 328         jack_client_control_t *ctl = client->control;
 329
 330         req.type = ResetTimeBaseClient;
 331         req.x.client_id = ctl->id;
 332
 333         rc = jack_client_deliver_request (client, &req);
 334         if (rc == 0) {
 335                 client->timebase_cb = NULL;
 336                 client->timebase_arg = NULL;
 337                 ctl->timebase_cb_cbset = 0;
 338         }
 339
 340         return rc;
 341 }
 342
 343 int
 344 jack_set_sync_callback (jack_client_t *client,
 345                         JackSyncCallback sync_callback, void *arg)
 346 {
 347         jack_client_control_t *ctl = client->control;
 348         jack_request_t req;
 349         int rc;
 350
 351         if (sync_callback)
 352                 req.type = SetSyncClient;
 353         else
 354                 req.type = ResetSyncClient;
 355         req.x.client_id = ctl->id;
 356
 357         rc = jack_client_deliver_request (client, &req);
 358         if (rc == 0) {
 359                 client->sync_cb = sync_callback;
 360                 client->sync_arg = arg;
 361                 ctl->sync_cb_cbset = TRUE;
 362         }
 363         return rc;
 364 }
 365
 366 int
 367 jack_set_sync_timeout (jack_client_t *client, jack_time_t usecs)
 368 {
 369         jack_request_t req;
 370
 371         req.type = SetSyncTimeout;
 372         req.x.timeout = usecs;
 373
 374         return jack_client_deliver_request (client, &req);
 375 }
 376
 377 int
 378 jack_set_timebase_callback (jack_client_t *client, int conditional,
 379                             JackTimebaseCallback timebase_cb, void *arg)
 380 {
 381         int rc;
 382         jack_request_t req;
 383         jack_client_control_t *ctl = client->control;
 384
 385         req.type = SetTimeBaseClient;
 386         req.x.timebase.client_id = ctl->id;
 387         req.x.timebase.conditional = conditional;
 388
 389         rc = jack_client_deliver_request (client, &req);
 390         if (rc == 0) {
 391                 client->timebase_arg = arg;
 392                 client->timebase_cb = timebase_cb;
 393                 ctl->timebase_cb_cbset = TRUE;
 394         }
 395         return rc;
 396 }
 397
 398 int
 399 jack_transport_locate (jack_client_t *client, jack_nframes_t frame)
 400 {
 401         jack_position_t pos;
 402
 403         pos.frame = frame;
 404         pos.valid = 0;
 405         return jack_transport_request_new_pos (client, &pos);
 406 }
 407
 408 jack_transport_state_t
 409 jack_transport_query (const jack_client_t *client, jack_position_t *pos)
 410 {
 411         jack_control_t *ectl = client->engine;
 412
 413         if (pos) {
 414                 /* the guarded copy makes this function work in any
 415                  * thread
 416                  */
 417                 jack_transport_copy_position (&ectl->current_time, pos);
 418         }
 419
 420         return ectl->transport_state;
 421 }
 422
 423 int
 424 jack_transport_reposition (jack_client_t *client, jack_position_t *pos)
 425 {
 426         /* copy the input, to avoid modifying its contents */
 427         jack_position_t tmp = *pos;
 428
 429         /* validate input */
 430         if (tmp.valid & ~JACK_POSITION_MASK) /* unknown field present? */
 431                 return EINVAL;
 432
 433         return jack_transport_request_new_pos (client, &tmp);
 434 }
 435
 436 void
 437 jack_transport_start (jack_client_t *client)
 438 {
 439         client->engine->transport_cmd = TransportCommandStart;
 440 }
 441
 442 void
 443 jack_transport_stop (jack_client_t *client)
 444 {
 445         client->engine->transport_cmd = TransportCommandStop;
 446 }
 447
 448
 449 #ifdef OLD_TRANSPORT
 450
 451 /************* Compatibility with old transport API. *************/
 452
 453 int
 454 jack_engine_takeover_timebase (jack_client_t *client)
 455 {
 456         jack_error ("jack_engine_takeover_timebase() is no longer supported.");
 457         return ENOSYS;
 458 }
 459
 460 void
 461 jack_get_transport_info (jack_client_t *client,
 462                          jack_transport_info_t *info)
 463 {
 464         jack_control_t *ectl = client->engine;
 465         static int first_time = 1;
 466
 467         if (first_time)
 468                 jack_error ("jack_get_transport_info() is deprecated.");
 469         first_time = 0;
 470
 471         /* check that this is the process thread */
 472         if (!pthread_equal(client->thread_id, pthread_self())) {
 473                 jack_error("Invalid thread for jack_get_transport_info().");
 474                 abort();                /* kill this client */
 475         }
 476
 477         info->usecs = ectl->current_time.usecs;
 478         info->frame_rate = ectl->current_time.frame_rate;
 479         info->transport_state = ectl->transport_state;
 480         info->frame = ectl->current_time.frame;
 481         info->valid = (ectl->current_time.valid |
 482                        JackTransportState | JackTransportPosition);
 483
 484         if (info->valid & JackTransportBBT) {
 485                 info->bar = ectl->current_time.bar;
 486                 info->beat = ectl->current_time.beat;
 487                 info->tick = ectl->current_time.tick;
 488                 info->bar_start_tick = ectl->current_time.bar_start_tick;
 489                 info->beats_per_bar = ectl->current_time.beats_per_bar;
 490                 info->beat_type = ectl->current_time.beat_type;
 491                 info->ticks_per_beat = ectl->current_time.ticks_per_beat;
 492                 info->beats_per_minute = ectl->current_time.beats_per_minute;
 493         }
 494 }
 495
 496 void
 497 jack_set_transport_info (jack_client_t *client,
 498                          jack_transport_info_t *info)
 499 {
 500         static int first_time = 1;
 501
 502         if (first_time)
 503                 jack_error ("jack_set_transport_info() no longer supported.");
 504         first_time = 0;
 505 }
 506
 507 #endif /* OLD_TRANSPORT */