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