libs/ardour/session_time.cc

   1
   2 /*
   3   Copyright (C) 1999-2002 Paul Davis
   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   $Id$
  20 */
  21
  22 #include <iostream>
  23 #include <cmath>
  24 #include <unistd.h>
  25
  26 #include <ardour/timestamps.h>
  27
  28 #include <pbd/error.h>
  29
  30 #include <ardour/ardour.h>
  31 #include <ardour/configuration.h>
  32 #include <ardour/audioengine.h>
  33 #include <ardour/session.h>
  34 #include <ardour/tempo.h>
  35
  36 #include "i18n.h"
  37
  38 using namespace ARDOUR;
  39 //using namespace sigc;
  40
  41 /* BBT TIME*/
  42
  43 void
  44 Session::bbt_time (jack_nframes_t when, BBT_Time& bbt)
  45 {
  46         _tempo_map->bbt_time (when, bbt);
  47 }
  48
  49 /* SMPTE TIME */
  50
  51 int
  52 Session::set_smpte_type (float fps, bool drop_frames)
  53 {
  54         smpte_frames_per_second = fps;
  55         smpte_drop_frames = drop_frames;
  56         _frames_per_smpte_frame = (double) _current_frame_rate / (double) smpte_frames_per_second;
  57         _frames_per_hour = _current_frame_rate * 3600;
  58         _smpte_frames_per_hour = (unsigned long) (smpte_frames_per_second * 3600.0);
  59
  60
  61         last_smpte_valid = false;
  62         // smpte type bits are the middle two in the upper nibble
  63         switch ((int) ceil (fps)) {
  64         case 24:
  65                 mtc_smpte_bits = 0;
  66                 break;
  67
  68         case 25:
  69                 mtc_smpte_bits = 0x20;
  70                 break;
  71
  72         case 30:
  73         default:
  74                 if (drop_frames) {
  75                         mtc_smpte_bits = 0x40;
  76                 } else {
  77                         mtc_smpte_bits =  0x60;
  78                 }
  79                 break;
  80         };
  81
  82         SMPTETypeChanged (); /* EMIT SIGNAL */
  83
  84         set_dirty();
  85
  86         return 0;
  87 }
  88
  89 void
  90 Session::set_smpte_offset (jack_nframes_t off)
  91 {
  92         _smpte_offset = off;
  93         last_smpte_valid = false;
  94         SMPTEOffsetChanged (); /* EMIT SIGNAL */
  95 }
  96
  97 void
  98 Session::set_smpte_offset_negative (bool neg)
  99 {
 100         _smpte_offset_negative = neg;
 101         last_smpte_valid = false;
 102         SMPTEOffsetChanged (); /* EMIT SIGNAL */
 103 }
 104
 105 #define SMPTE_IS_AROUND_ZERO( sm ) (!(sm).frames && !(sm).seconds && !(sm).minutes && !(sm).hours)
 106 #define SMPTE_IS_ZERO( sm ) (!(sm).frames && !(sm).seconds && !(sm).minutes && !(sm).hours && !(sm.subframes))
 107
 108 // Increment by exactly one frame (keep subframes value)
 109 // Return true if seconds wrap
 110 smpte_wrap_t
 111 Session::smpte_increment( SMPTE_Time& smpte ) const
 112 {
 113         smpte_wrap_t wrap = smpte_wrap_none;
 114
 115         if (smpte.negative) {
 116                 if (SMPTE_IS_AROUND_ZERO(smpte) && smpte.subframes) {
 117                         // We have a zero transition involving only subframes
 118                         smpte.subframes = 80 - smpte.subframes;
 119                         smpte.negative = false;
 120                         return smpte_wrap_seconds;
 121                 }
 122
 123                 smpte.negative = false;
 124                 wrap = smpte_decrement( smpte );
 125                 if (!SMPTE_IS_ZERO( smpte )) {
 126                         smpte.negative = true;
 127                 }
 128                 return wrap;
 129         }
 130
 131         switch (mtc_smpte_bits >> 5) {
 132         case MIDI::MTC_24_FPS:
 133                 if (smpte.frames == 23) {
 134                         smpte.frames = 0;
 135                         wrap = smpte_wrap_seconds;
 136                 }
 137                 break;
 138         case MIDI::MTC_25_FPS:
 139                 if (smpte.frames == 24) {
 140                         smpte.frames = 0;
 141                         wrap = smpte_wrap_seconds;
 142                 }
 143                 break;
 144         case MIDI::MTC_30_FPS_DROP:
 145                 if (smpte.frames == 29) {
 146                         if ( ((smpte.minutes + 1) % 10) && (smpte.seconds == 59) ) {
 147                                 smpte.frames = 2;
 148                         }
 149                         else {
 150                                 smpte.frames = 0;
 151                         }
 152                         wrap = smpte_wrap_seconds;
 153                 }
 154                 break;
 155         case MIDI::MTC_30_FPS:
 156                 if (smpte.frames == 29) {
 157                         smpte.frames = 0;
 158                         wrap = smpte_wrap_seconds;
 159                 }
 160                 break;
 161         }
 162
 163         if (wrap == smpte_wrap_seconds) {
 164                 if (smpte.seconds == 59) {
 165                         smpte.seconds = 0;
 166                         wrap = smpte_wrap_minutes;
 167                         if (smpte.minutes == 59) {
 168                                 smpte.minutes = 0;
 169                                 wrap = smpte_wrap_hours;
 170                                 smpte.hours++;
 171                         } else {
 172                                 smpte.minutes++;
 173                         }
 174                 } else {
 175                         smpte.seconds++;
 176                 }
 177         } else {
 178                 smpte.frames++;
 179         }
 180
 181         return wrap;
 182 }
 183
 184 // Decrement by exactly one frame (keep subframes value)
 185 smpte_wrap_t
 186 Session::smpte_decrement( SMPTE_Time& smpte ) const
 187 {
 188         smpte_wrap_t wrap = smpte_wrap_none;
 189
 190
 191         if (smpte.negative || SMPTE_IS_ZERO(smpte)) {
 192                 smpte.negative = false;
 193                 wrap = smpte_increment( smpte );
 194                 smpte.negative = true;
 195                 return wrap;
 196         } else if (SMPTE_IS_AROUND_ZERO(smpte) && smpte.subframes) {
 197                 // We have a zero transition involving only subframes
 198                 smpte.subframes = 80 - smpte.subframes;
 199                 smpte.negative = true;
 200                 return smpte_wrap_seconds;
 201         }
 202
 203         switch (mtc_smpte_bits >> 5) {
 204         case MIDI::MTC_24_FPS:
 205                 if (smpte.frames == 0) {
 206                         smpte.frames = 23;
 207                         wrap = smpte_wrap_seconds;
 208                 }
 209                 break;
 210         case MIDI::MTC_25_FPS:
 211                 if (smpte.frames == 0) {
 212                         smpte.frames = 24;
 213                         wrap = smpte_wrap_seconds;
 214                 }
 215                 break;
 216         case MIDI::MTC_30_FPS_DROP:
 217                 if ((smpte.minutes % 10) && (smpte.seconds == 0)) {
 218                         if (smpte.frames <= 2) {
 219                                 smpte.frames = 29;
 220                                 wrap = smpte_wrap_seconds;
 221                         }
 222                 } else if (smpte.frames == 0) {
 223                         smpte.frames = 29;
 224                         wrap = smpte_wrap_seconds;
 225                 }
 226                 break;
 227         case MIDI::MTC_30_FPS:
 228                 if (smpte.frames == 0) {
 229                         smpte.frames = 29;
 230                         wrap = smpte_wrap_seconds;
 231                 }
 232                 break;
 233         }
 234
 235         if (wrap == smpte_wrap_seconds) {
 236                 if (smpte.seconds == 0) {
 237                         smpte.seconds = 59;
 238                         wrap = smpte_wrap_minutes;
 239                         if (smpte.minutes == 0) {
 240                                 smpte.minutes = 59;
 241                                 wrap = smpte_wrap_hours;
 242                                 smpte.hours--;
 243                         }
 244                         else {
 245                                 smpte.minutes--;
 246                         }
 247                 } else {
 248                         smpte.seconds--;
 249                 }
 250         } else {
 251                 smpte.frames--;
 252         }
 253
 254         if (SMPTE_IS_ZERO( smpte )) {
 255                 smpte.negative = false;
 256         }
 257
 258         return wrap;
 259 }
 260
 261 // Go to lowest absolute subframe value in this frame (set to 0 :-)
 262 void
 263 Session::smpte_frames_floor( SMPTE_Time& smpte ) const
 264 {
 265         smpte.subframes = 0;
 266         if (SMPTE_IS_ZERO(smpte)) {
 267                 smpte.negative = false;
 268         }
 269 }
 270
 271 // Increment by one subframe
 272 smpte_wrap_t
 273 Session::smpte_increment_subframes( SMPTE_Time& smpte ) const
 274 {
 275         smpte_wrap_t wrap = smpte_wrap_none;
 276
 277         if (smpte.negative) {
 278                 smpte.negative = false;
 279                 wrap = smpte_decrement_subframes( smpte );
 280                 if (!SMPTE_IS_ZERO(smpte)) {
 281                         smpte.negative = true;
 282                 }
 283                 return wrap;
 284         }
 285
 286         smpte.subframes++;
 287         if (smpte.subframes >= 80) {
 288                 smpte.subframes = 0;
 289                 smpte_increment( smpte );
 290                 return smpte_wrap_frames;
 291         }
 292         return smpte_wrap_none;
 293 }
 294
 295
 296 // Decrement by one subframe
 297 smpte_wrap_t
 298 Session::smpte_decrement_subframes( SMPTE_Time& smpte ) const
 299 {
 300         smpte_wrap_t wrap = smpte_wrap_none;
 301
 302         if (smpte.negative) {
 303                 smpte.negative = false;
 304                 wrap = smpte_increment_subframes( smpte );
 305                 smpte.negative = true;
 306                 return wrap;
 307         }
 308
 309         if (smpte.subframes <= 0) {
 310                 smpte.subframes = 0;
 311                 if (SMPTE_IS_ZERO(smpte)) {
 312                         smpte.negative = true;
 313                         smpte.subframes = 1;
 314                         return smpte_wrap_frames;
 315                 } else {
 316                         smpte_decrement( smpte );
 317                         smpte.subframes = 79;
 318                         return smpte_wrap_frames;
 319                 }
 320         } else {
 321                 smpte.subframes--;
 322                 if (SMPTE_IS_ZERO(smpte)) {
 323                         smpte.negative = false;
 324                 }
 325                 return smpte_wrap_none;
 326         }
 327 }
 328
 329
 330 // Go to next whole second (frames == 0 or frames == 2)
 331 smpte_wrap_t
 332 Session::smpte_increment_seconds( SMPTE_Time& smpte ) const
 333 {
 334         smpte_wrap_t wrap = smpte_wrap_none;
 335
 336         // Clear subframes
 337         smpte_frames_floor( smpte );
 338
 339         if (smpte.negative) {
 340                 // Wrap second if on second boundary
 341                 wrap = smpte_increment(smpte);
 342                 // Go to lowest absolute frame value
 343                 smpte_seconds_floor( smpte );
 344                 if (SMPTE_IS_ZERO(smpte)) {
 345                         smpte.negative = false;
 346                 }
 347         } else {
 348                 // Go to highest possible frame in this second
 349                 switch (mtc_smpte_bits >> 5) {
 350                 case MIDI::MTC_24_FPS:
 351                         smpte.frames = 23;
 352                         break;
 353                 case MIDI::MTC_25_FPS:
 354                         smpte.frames = 24;
 355                         break;
 356                 case MIDI::MTC_30_FPS_DROP:
 357                 case MIDI::MTC_30_FPS:
 358                         smpte.frames = 29;
 359                         break;
 360                 }
 361
 362                 // Increment by one frame
 363                 wrap = smpte_increment( smpte );
 364         }
 365
 366         return wrap;
 367 }
 368
 369 // Go to lowest (absolute) frame value in this second
 370 // Doesn't care about positive/negative
 371 void
 372 Session::smpte_seconds_floor( SMPTE_Time& smpte ) const
 373 {
 374         // Clear subframes
 375         smpte_frames_floor( smpte );
 376
 377         // Go to lowest possible frame in this second
 378         switch (mtc_smpte_bits >> 5) {
 379         case MIDI::MTC_24_FPS:
 380         case MIDI::MTC_25_FPS:
 381         case MIDI::MTC_30_FPS:
 382                 smpte.frames = 0;
 383                 break;
 384         case MIDI::MTC_30_FPS_DROP:
 385                 if ((smpte.minutes % 10) && (smpte.seconds == 0)) {
 386                         smpte.frames = 2;
 387                 } else {
 388                         smpte.frames = 0;
 389                 }
 390                 break;
 391         }
 392
 393         if (SMPTE_IS_ZERO(smpte)) {
 394                 smpte.negative = false;
 395         }
 396 }
 397
 398
 399 // Go to next whole minute (seconds == 0, frames == 0 or frames == 2)
 400 smpte_wrap_t
 401 Session::smpte_increment_minutes( SMPTE_Time& smpte ) const
 402 {
 403         smpte_wrap_t wrap = smpte_wrap_none;
 404
 405         // Clear subframes
 406         smpte_frames_floor( smpte );
 407
 408         if (smpte.negative) {
 409                 // Wrap if on minute boundary
 410                 wrap = smpte_increment_seconds( smpte );
 411                 // Go to lowest possible value in this minute
 412                 smpte_minutes_floor( smpte );
 413         } else {
 414                 // Go to highest possible second
 415                 smpte.seconds = 59;
 416                 // Wrap minute by incrementing second
 417                 wrap = smpte_increment_seconds( smpte );
 418         }
 419
 420         return wrap;
 421 }
 422
 423 // Go to lowest absolute value in this minute
 424 void
 425 Session::smpte_minutes_floor( SMPTE_Time& smpte ) const
 426 {
 427         // Go to lowest possible second
 428         smpte.seconds = 0;
 429         // Go to lowest possible frame
 430         smpte_seconds_floor( smpte );
 431
 432         if (SMPTE_IS_ZERO(smpte)) {
 433                 smpte.negative = false;
 434         }
 435 }
 436
 437 // Go to next whole hour (minute = 0, second = 0, frame = 0)
 438 smpte_wrap_t
 439 Session::smpte_increment_hours( SMPTE_Time& smpte ) const
 440 {
 441         smpte_wrap_t wrap = smpte_wrap_none;
 442
 443         // Clear subframes
 444         smpte_frames_floor(smpte);
 445
 446         if (smpte.negative) {
 447                 // Wrap if on hour boundary
 448                 wrap = smpte_increment_minutes( smpte );
 449                 // Go to lowest possible value in this hour
 450                 smpte_hours_floor( smpte );
 451         } else {
 452                 smpte.minutes = 59;
 453                 wrap = smpte_increment_minutes( smpte );
 454         }
 455
 456         return wrap;
 457 }
 458
 459 // Go to lowest absolute value in this hour
 460 void
 461 Session::smpte_hours_floor( SMPTE_Time& smpte ) const
 462 {
 463         smpte.minutes = 0;
 464         smpte.seconds = 0;
 465         smpte.frames = 0;
 466         smpte.subframes = 0;
 467
 468         if (SMPTE_IS_ZERO(smpte)) {
 469                 smpte.negative = false;
 470         }
 471 }
 472
 473
 474 void
 475 Session::smpte_to_sample( SMPTE_Time& smpte, jack_nframes_t& sample, bool use_offset, bool use_subframes ) const
 476 {
 477         if (smpte_drop_frames) {
 478                 // The drop frame format was created to better approximate the 30000/1001 = 29.97002997002997....
 479                 // framerate of NTSC color TV. The used frame rate of drop frame is 29.97, which drifts by about
 480                 // 0.108 frame per hour, or about 1.3 frames per 12 hours. This is not perfect, but a lot better
 481                 // than using 30 non drop, which will drift with about 1.8 frame per minute.
 482                 // Using 29.97, drop frame real time can be accurate only every 10th minute (10 minutes of 29.97 fps
 483                 // is exactly 17982 frames). One minute is 1798.2 frames, but we count 30 frames per second
 484                 // (30 * 60 = 1800). This means that at the first minute boundary (at the end of 0:0:59:29) we
 485                 // are 1.8 frames too late relative to real time. By dropping 2 frames (jumping to 0:1:0:2) we are
 486                 // approx. 0.2 frames too early. This adds up with 0.2 too early for each minute until we are 1.8
 487                 // frames too early at 0:9:0:2 (9 * 0.2 = 1.8). The 10th minute brings us 1.8 frames later again
 488                 // (at end of 0:9:59:29), which sums up to 0 (we are back to zero at 0:10:0:0 :-).
 489                 //
 490                 // In table form:
 491                 //
 492                 // SMPTE value    frames offset   subframes offset   seconds (rounded)  44100 sample (rounded)
 493                 //  0:00:00:00        0.0             0                     0.000                0 (accurate)
 494                 //  0:00:59:29        1.8           144                    60.027          2647177
 495                 //  0:01:00:02       -0.2           -16                    60.060          2648648
 496                 //  0:01:59:29        1.6           128                   120.020          5292883
 497                 //  0:02:00:02       -0.4           -32                   120.053          5294354
 498                 //  0:02:59:29        1.4           112                   180.013          7938588
 499                 //  0:03:00:02       -0.6           -48                   180.047          7940060
 500                 //  0:03:59:29        1.2            96                   240.007         10584294
 501                 //  0:04:00:02       -0.8           -64                   240.040         10585766
 502                 //  0:04:59:29        1.0            80                   300.000         13230000
 503                 //  0:05:00:02       -1.0           -80                   300.033         13231471
 504                 //  0:05:59:29        0.8            64                   359.993         15875706
 505                 //  0:06:00:02       -1.2           -96                   360.027         15877177
 506                 //  0:06:59:29        0.6            48                   419.987         18521411
 507                 //  0:07:00:02       -1.4          -112                   420.020         18522883
 508                 //  0:07:59:29        0.4            32                   478.980         21167117
 509                 //  0:08:00:02       -1.6          -128                   480.013         21168589
 510                 //  0:08:59:29        0.2            16                   539.973         23812823
 511                 //  0:09:00:02       -1.8          -144                   540.007         23814294
 512                 //  0:09:59:29        0.0+            0+                  599.967         26458529
 513                 //  0:10:00:00        0.0             0                   600.000         26460000 (accurate)
 514                 //
 515                 //  Per Sigmond <per@sigmond.no>
 516
 517                 // Samples inside time dividable by 10 minutes (real time accurate)
 518                 jack_nframes_t base_samples = ((smpte.hours * 60 * 60) + ((smpte.minutes / 10) * 10 * 60)) * frame_rate();
 519                 // Samples inside time exceeding the nearest 10 minutes (always offset, see above)
 520                 long exceeding_df_minutes = smpte.minutes % 10;
 521                 long exceeding_df_seconds = (exceeding_df_minutes * 60) + smpte.seconds;
 522                 long exceeding_df_frames = (30 * exceeding_df_seconds) + smpte.frames - (2 * exceeding_df_minutes);
 523                 jack_nframes_t exceeding_samples = (jack_nframes_t) rint(exceeding_df_frames * _frames_per_smpte_frame);
 524                 sample = base_samples + exceeding_samples;
 525         } else {
 526                 // Non drop is easy:
 527                 sample = (((smpte.hours * 60 * 60) + (smpte.minutes * 60) + smpte.seconds) * frame_rate()) + (jack_nframes_t)rint(smpte.frames * _frames_per_smpte_frame);
 528         }
 529
 530         if (use_subframes) {
 531                 sample += (long) (((double)smpte.subframes * _frames_per_smpte_frame) / 80.0);
 532         }
 533
 534         if (use_offset) {
 535                 if (smpte_offset_negative()) {
 536                         if (sample >= smpte_offset()) {
 537                                 sample -= smpte_offset();
 538                         } else {
 539                                 /* Prevent song-time from becoming negative */
 540                                 sample = 0;
 541                         }
 542                 } else {
 543                         if (smpte.negative) {
 544                                 if (sample <= smpte_offset()) {
 545                                         sample = smpte_offset() - sample;
 546                                 } else {
 547                                         sample = 0;
 548                                 }
 549                         } else {
 550                                 sample += smpte_offset();
 551                         }
 552                 }
 553         }
 554 }
 555
 556
 557 void
 558 Session::sample_to_smpte( jack_nframes_t sample, SMPTE_Time& smpte, bool use_offset, bool use_subframes ) const
 559 {
 560         jack_nframes_t offset_sample;
 561
 562         if (!use_offset) {
 563                 offset_sample = sample;
 564                 smpte.negative = false;
 565         } else {
 566                 if (_smpte_offset_negative) {
 567                         offset_sample =  sample + _smpte_offset;
 568                         smpte.negative = false;
 569                 } else {
 570                         if (sample < _smpte_offset) {
 571                                 offset_sample = (_smpte_offset - sample);
 572                                 smpte.negative = true;
 573                         } else {
 574                                 offset_sample =  sample - _smpte_offset;
 575                                 smpte.negative = false;
 576                         }
 577                 }
 578         }
 579
 580         double smpte_frames_left_exact;
 581         double smpte_frames_fraction;
 582         unsigned long smpte_frames_left;
 583
 584         // Extract whole hours. Do this to prevent rounding errors with
 585         // high sample numbers in the calculations that follow.
 586         smpte.hours = offset_sample / _frames_per_hour;
 587         offset_sample = offset_sample % _frames_per_hour;
 588
 589         // Calculate exact number of (exceeding) smpte frames and fractional frames
 590         smpte_frames_left_exact = (double) offset_sample / _frames_per_smpte_frame;
 591         smpte_frames_fraction = smpte_frames_left_exact - floor( smpte_frames_left_exact );
 592         smpte.subframes = (long) rint(smpte_frames_fraction * 80.0);
 593
 594         // XXX Not sure if this is necessary anymore...
 595         if (smpte.subframes == 80) {
 596                 // This can happen with 24 fps (and 29.97 fps ?)
 597                 smpte_frames_left_exact = ceil( smpte_frames_left_exact );
 598                 smpte.subframes = 0;
 599         }
 600
 601         // Extract hour-exceeding frames for minute, second and frame calculations
 602         smpte_frames_left = ((long) floor( smpte_frames_left_exact ));
 603
 604         if (smpte_drop_frames) {
 605                 // See long explanation in smpte_to_sample()...
 606
 607                 // Number of 10 minute chunks
 608                 smpte.minutes = (smpte_frames_left / 17982) * 10; // exactly 17982 frames in 10 minutes
 609                 // frames exceeding the nearest 10 minute barrier
 610                 long exceeding_df_frames = smpte_frames_left % 17982;
 611
 612                 // Find minutes exceeding the nearest 10 minute barrier
 613                 if (exceeding_df_frames >= 1800) { // nothing to do if we are inside the first minute (0-1799)
 614                         exceeding_df_frames -= 1800; // take away first minute (different number of frames than the others)
 615                         long extra_minutes_minus_1 = exceeding_df_frames / 1798; // how many minutes after the first one
 616                         exceeding_df_frames -= extra_minutes_minus_1 * 1798; // take away the (extra) minutes just found
 617                         smpte.minutes += extra_minutes_minus_1 + 1; // update with exceeding minutes
 618                 }
 619
 620                 // Adjust frame numbering for dropped frames (frame 0 and 1 skipped at start of every minute except every 10th)
 621                 if (smpte.minutes % 10) {
 622                         // Every minute except every 10th
 623                         if (exceeding_df_frames < 28) {
 624                                 // First second, frames 0 and 1 are skipped
 625                                 smpte.seconds = 0;
 626                                 smpte.frames = exceeding_df_frames + 2;
 627                         } else {
 628                                 // All other seconds, all 30 frames are counted
 629                                 exceeding_df_frames -= 28;
 630                                 smpte.seconds = (exceeding_df_frames / 30) + 1;
 631                                 smpte.frames = exceeding_df_frames % 30;
 632                         }
 633                 } else {
 634                         // Every 10th minute, all 30 frames counted in all seconds
 635                         smpte.seconds = exceeding_df_frames / 30;
 636                         smpte.frames = exceeding_df_frames % 30;
 637                 }
 638         } else {
 639                 // Non drop is easy
 640                 smpte.minutes = smpte_frames_left / ((long) smpte_frames_per_second * 60);
 641                 smpte_frames_left = smpte_frames_left % ((long) smpte_frames_per_second * 60);
 642                 smpte.seconds = smpte_frames_left / (long) smpte_frames_per_second;
 643                 smpte.frames = smpte_frames_left % (long) smpte_frames_per_second;
 644         }
 645
 646         if (!use_subframes) {
 647                 smpte.subframes = 0;
 648         }
 649 }
 650
 651 void
 652 Session::smpte_time (jack_nframes_t when, SMPTE_Time& smpte)
 653 {
 654         if (last_smpte_valid && when == last_smpte_when) {
 655                 smpte = last_smpte;
 656                 return;
 657         }
 658
 659         sample_to_smpte( when, smpte, true /* use_offset */, false /* use_subframes */ );
 660
 661         last_smpte_when = when;
 662         last_smpte = smpte;
 663         last_smpte_valid = true;
 664 }
 665
 666 void
 667 Session::smpte_time_subframes (jack_nframes_t when, SMPTE_Time& smpte)
 668 {
 669         if (last_smpte_valid && when == last_smpte_when) {
 670                 smpte = last_smpte;
 671                 return;
 672         }
 673
 674         sample_to_smpte( when, smpte, true /* use_offset */, true /* use_subframes */ );
 675
 676         last_smpte_when = when;
 677         last_smpte = smpte;
 678         last_smpte_valid = true;
 679 }
 680
 681 void
 682 Session::smpte_duration (jack_nframes_t when, SMPTE_Time& smpte) const
 683 {
 684         sample_to_smpte( when, smpte, false /* use_offset */, true /* use_subframes */ );
 685 }
 686
 687 void
 688 Session::smpte_duration_string (char* buf, jack_nframes_t when) const
 689 {
 690         SMPTE_Time smpte;
 691
 692         smpte_duration (when, smpte);
 693         snprintf (buf, sizeof (buf), "%02ld:%02ld:%02ld:%02ld", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
 694 }
 695
 696 void
 697 Session::smpte_time (SMPTE_Time &t)
 698
 699 {
 700         smpte_time (_transport_frame, t);
 701 }
 702
 703 int
 704 Session::jack_sync_callback (jack_transport_state_t state,
 705                              jack_position_t* pos)
 706 {
 707         bool slave = synced_to_jack();
 708
 709         switch (state) {
 710         case JackTransportStopped:
 711                 if (slave && _transport_frame != pos->frame && post_transport_work == 0) {
 712                         request_locate (pos->frame, false);
 713                         // cerr << "SYNC: stopped, locate to " << pos->frame << " from " << _transport_frame << endl;
 714                         return false;
 715                 } else {
 716                         return true;
 717                 }
 718
 719         case JackTransportStarting:
 720                 // cerr << "SYNC: starting @ " << pos->frame << " a@ " << _transport_frame << " our work = " <<  post_transport_work << " pos matches ? " << (_transport_frame == pos->frame) << endl;
 721                 if (slave) {
 722                         return _transport_frame == pos->frame && post_transport_work == 0;
 723                 } else {
 724                         return true;
 725                 }
 726                 break;
 727
 728         case JackTransportRolling:
 729                 // cerr << "SYNC: rolling slave = " << slave << endl;
 730                 if (slave) {
 731                         start_transport ();
 732                 }
 733                 break;
 734
 735         default:
 736                 error << string_compose (_("Unknown JACK transport state %1 in sync callback"), state)
 737                       << endmsg;
 738         }
 739
 740         return true;
 741 }
 742
 743 void
 744 Session::jack_timebase_callback (jack_transport_state_t state,
 745                                  jack_nframes_t nframes,
 746                                  jack_position_t* pos,
 747                                  int new_position)
 748 {
 749         BBT_Time bbt;
 750
 751         /* frame info */
 752
 753         pos->frame = _transport_frame;
 754         pos->valid = JackPositionTimecode;
 755
 756         /* BBT info */
 757
 758         if (_tempo_map) {
 759
 760                 TempoMap::Metric metric (_tempo_map->metric_at (_transport_frame));
 761                 _tempo_map->bbt_time_with_metric (_transport_frame, bbt, metric);
 762
 763                 pos->bar = bbt.bars;
 764                 pos->beat = bbt.beats;
 765                 pos->tick = bbt.ticks;
 766
 767                 // XXX still need to set bar_start_tick
 768
 769                 pos->beats_per_bar = metric.meter().beats_per_bar();
 770                 pos->beat_type = metric.meter().note_divisor();
 771                 pos->ticks_per_beat = Meter::ticks_per_beat;
 772                 pos->beats_per_minute = metric.tempo().beats_per_minute();
 773
 774                 pos->valid = jack_position_bits_t (pos->valid | JackPositionBBT);
 775         }
 776
 777 #if 0
 778         /* SMPTE info */
 779
 780         t.smpte_offset = _smpte_offset;
 781         t.smpte_frame_rate = smpte_frames_per_second;
 782
 783         if (_transport_speed) {
 784
 785                 if (auto_loop) {
 786
 787                         Location* location = _locations.auto_loop_location();
 788
 789                         if (location) {
 790
 791                                 t.transport_state = JackTransportLooping;
 792                                 t.loop_start = location->start();
 793                                 t.loop_end = location->end();
 794                                 t.valid = jack_transport_bits_t (t.valid | JackTransportLoop);
 795
 796                         } else {
 797
 798                                 t.loop_start = 0;
 799                                 t.loop_end = 0;
 800                                 t.transport_state = JackTransportRolling;
 801
 802                         }
 803
 804                 } else {
 805
 806                         t.loop_start = 0;
 807                         t.loop_end = 0;
 808                         t.transport_state = JackTransportRolling;
 809
 810                 }
 811
 812         }
 813
 814 #endif
 815 }
 816
 817 jack_nframes_t
 818 Session::convert_to_frames_at (jack_nframes_t position, AnyTime& any)
 819 {
 820         double secs;
 821
 822         switch (any.type) {
 823         case AnyTime::BBT:
 824                 return _tempo_map->frame_time ( any.bbt);
 825                 break;
 826
 827         case AnyTime::SMPTE:
 828                 /* XXX need to handle negative values */
 829                 secs = any.smpte.hours * 60 * 60;
 830                 secs += any.smpte.minutes * 60;
 831                 secs += any.smpte.seconds;
 832                 secs += any.smpte.frames / smpte_frames_per_second;
 833                 if (_smpte_offset_negative)
 834                 {
 835                         return (jack_nframes_t) floor (secs * frame_rate()) - _smpte_offset;
 836                 }
 837                 else
 838                 {
 839                         return (jack_nframes_t) floor (secs * frame_rate()) + _smpte_offset;
 840                 }
 841                 break;
 842
 843         case AnyTime::Seconds:
 844                 return (jack_nframes_t) floor (any.seconds * frame_rate());
 845                 break;
 846
 847         case AnyTime::Frames:
 848                 return any.frames;
 849                 break;
 850         }
 851
 852         return any.frames;
 853 }