libs/timecode/src/time.cc

   1 /*
   2   Copyright (C) 2006-2010 Paul Davis
   3
   4   This program is free software; you can redistribute it and/or modify it
   5   under the terms of the GNU Lesser General Public License as published by
   6   the Free Software Foundation; either version 2 of the License, or (at your
   7   option) any later version.
   8
   9   This program is distributed in the hope that it will be useful, but WITHOUT
  10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  12   License for more details.
  13
  14   You should have received a copy of the GNU Lesser General Public License
  15   along with this program; if not, write to the Free Software Foundation,
  16   Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #define Timecode_IS_AROUND_ZERO(sm) (!(sm).frames && !(sm).seconds && !(sm).minutes && !(sm).hours)
  20 #define Timecode_IS_ZERO(sm) (!(sm).frames && !(sm).seconds && !(sm).minutes && !(sm).hours && !(sm.subframes))
  21
  22 #include <math.h>
  23 #include <stdio.h>
  24
  25 #include "timecode/time.h"
  26
  27 namespace Timecode {
  28
  29 double Time::default_rate = 30.0;
  30
  31
  32 /** Increment @a timecode by exactly one frame (keep subframes value).
  33  * Realtime safe.
  34  * @return true if seconds wrap.
  35  */
  36 Wrap
  37 increment (Time& timecode, uint32_t subframes_per_frame)
  38 {
  39         Wrap wrap = NONE;
  40
  41         if (timecode.negative) {
  42                 if (Timecode_IS_AROUND_ZERO (timecode) && timecode.subframes) {
  43                         // We have a zero transition involving only subframes
  44                         timecode.subframes = subframes_per_frame - timecode.subframes;
  45                         timecode.negative = false;
  46                         return SECONDS;
  47                 }
  48
  49                 timecode.negative = false;
  50                 wrap = decrement (timecode, subframes_per_frame);
  51                 if (!Timecode_IS_ZERO (timecode)) {
  52                         timecode.negative = true;
  53                 }
  54                 return wrap;
  55         }
  56
  57         switch ((int)ceil (timecode.rate)) {
  58         case 24:
  59                 if (timecode.frames == 23) {
  60                         timecode.frames = 0;
  61                         wrap = SECONDS;
  62                 }
  63                 break;
  64         case 25:
  65                 if (timecode.frames == 24) {
  66                         timecode.frames = 0;
  67                         wrap = SECONDS;
  68                 }
  69                 break;
  70         case 30:
  71                 if (timecode.drop) {
  72                         if (timecode.frames == 29) {
  73                                 if (((timecode.minutes + 1) % 10) && (timecode.seconds == 59)) {
  74                                         timecode.frames = 2;
  75                                 }
  76                                 else {
  77                                         timecode.frames = 0;
  78                                 }
  79                                 wrap = SECONDS;
  80                         }
  81                 } else {
  82
  83                         if (timecode.frames == 29) {
  84                                 timecode.frames = 0;
  85                                 wrap = SECONDS;
  86                         }
  87                 }
  88                 break;
  89         case 60:
  90                 if (timecode.frames == 59) {
  91                         timecode.frames = 0;
  92                         wrap = SECONDS;
  93                 }
  94                 break;
  95         }
  96
  97         if (wrap == SECONDS) {
  98                 if (timecode.seconds == 59) {
  99                         timecode.seconds = 0;
 100                         wrap = MINUTES;
 101                         if (timecode.minutes == 59) {
 102                                 timecode.minutes = 0;
 103                                 wrap = HOURS;
 104                                 timecode.hours++;
 105                         } else {
 106                                 timecode.minutes++;
 107                         }
 108                 } else {
 109                         timecode.seconds++;
 110                 }
 111         } else {
 112                 timecode.frames++;
 113         }
 114
 115         return wrap;
 116 }
 117
 118
 119 /** Decrement @a timecode by exactly one frame (keep subframes value)
 120  * Realtime safe.
 121  * @return true if seconds wrap. */
 122 Wrap
 123 decrement (Time& timecode, uint32_t subframes_per_frame)
 124 {
 125         Wrap wrap = NONE;
 126
 127         if (timecode.negative || Timecode_IS_ZERO (timecode)) {
 128                 timecode.negative = false;
 129                 wrap = increment (timecode, subframes_per_frame);
 130                 timecode.negative = true;
 131                 return wrap;
 132         } else if (Timecode_IS_AROUND_ZERO (timecode) && timecode.subframes) {
 133                 // We have a zero transition involving only subframes
 134                 timecode.subframes = subframes_per_frame - timecode.subframes;
 135                 timecode.negative = true;
 136                 return SECONDS;
 137         }
 138
 139         switch ((int)ceil (timecode.rate)) {
 140         case 24:
 141                 if (timecode.frames == 0) {
 142                         timecode.frames = 23;
 143                         wrap = SECONDS;
 144                 }
 145                 break;
 146         case 25:
 147                 if (timecode.frames == 0) {
 148                         timecode.frames = 24;
 149                         wrap = SECONDS;
 150                 }
 151                 break;
 152         case 30:
 153                 if (timecode.drop) {
 154                         if ((timecode.minutes % 10) && (timecode.seconds == 0)) {
 155                                 if (timecode.frames <= 2) {
 156                                         timecode.frames = 29;
 157                                         wrap = SECONDS;
 158                                 }
 159                         } else if (timecode.frames == 0) {
 160                                 timecode.frames = 29;
 161                                 wrap = SECONDS;
 162                         }
 163
 164                 } else {
 165                         if (timecode.frames == 0) {
 166                                 timecode.frames = 29;
 167                                 wrap = SECONDS;
 168                         }
 169                 }
 170                 break;
 171         case 60:
 172                 if (timecode.frames == 0) {
 173                         timecode.frames = 59;
 174                         wrap = SECONDS;
 175                 }
 176                 break;
 177         }
 178
 179         if (wrap == SECONDS) {
 180                 if (timecode.seconds == 0) {
 181                         timecode.seconds = 59;
 182                         wrap = MINUTES;
 183                         if (timecode.minutes == 0) {
 184                                 timecode.minutes = 59;
 185                                 wrap = HOURS;
 186                                 timecode.hours--;
 187                         }
 188                         else {
 189                                 timecode.minutes--;
 190                         }
 191                 } else {
 192                         timecode.seconds--;
 193                 }
 194         } else {
 195                 timecode.frames--;
 196         }
 197
 198         if (Timecode_IS_ZERO (timecode)) {
 199                 timecode.negative = false;
 200         }
 201
 202         return wrap;
 203 }
 204
 205
 206 /** Go to lowest absolute subframe value in this frame (set to 0 :-)) */
 207 void
 208 frames_floor (Time& timecode)
 209 {
 210         timecode.subframes = 0;
 211         if (Timecode_IS_ZERO (timecode)) {
 212                 timecode.negative = false;
 213         }
 214 }
 215
 216
 217 /** Increment @a timecode by one subframe */
 218 Wrap
 219 increment_subframes (Time& timecode, uint32_t subframes_per_frame)
 220 {
 221         Wrap wrap = NONE;
 222
 223         if (timecode.negative) {
 224                 timecode.negative = false;
 225                 wrap = decrement_subframes (timecode, subframes_per_frame);
 226                 if (!Timecode_IS_ZERO (timecode)) {
 227                         timecode.negative = true;
 228                 }
 229                 return wrap;
 230         }
 231
 232         timecode.subframes++;
 233         if (timecode.subframes >= subframes_per_frame) {
 234                 timecode.subframes = 0;
 235                 increment (timecode, subframes_per_frame);
 236                 return FRAMES;
 237         }
 238         return NONE;
 239 }
 240
 241
 242 /** Decrement @a timecode by one subframe */
 243 Wrap
 244 decrement_subframes (Time& timecode, uint32_t subframes_per_frame)
 245 {
 246         Wrap wrap = NONE;
 247
 248         if (timecode.negative) {
 249                 timecode.negative = false;
 250                 wrap = increment_subframes (timecode, subframes_per_frame);
 251                 timecode.negative = true;
 252                 return wrap;
 253         }
 254
 255         if (timecode.subframes <= 0) {
 256                 timecode.subframes = 0;
 257                 if (Timecode_IS_ZERO (timecode)) {
 258                         timecode.negative = true;
 259                         timecode.subframes = 1;
 260                         return FRAMES;
 261                 } else {
 262                         decrement (timecode, subframes_per_frame);
 263                         timecode.subframes = 79;
 264                         return FRAMES;
 265                 }
 266         } else {
 267                 timecode.subframes--;
 268                 if (Timecode_IS_ZERO (timecode)) {
 269                         timecode.negative = false;
 270                 }
 271                 return NONE;
 272         }
 273 }
 274
 275
 276 /** Go to next whole second (frames == 0 or frames == 2) */
 277 Wrap
 278 increment_seconds (Time& timecode, uint32_t subframes_per_frame)
 279 {
 280         Wrap wrap = NONE;
 281
 282         // Clear subframes
 283         frames_floor (timecode);
 284
 285         if (timecode.negative) {
 286                 // Wrap second if on second boundary
 287                 wrap = increment (timecode, subframes_per_frame);
 288                 // Go to lowest absolute frame value
 289                 seconds_floor (timecode);
 290                 if (Timecode_IS_ZERO (timecode)) {
 291                         timecode.negative = false;
 292                 }
 293         } else {
 294                 // Go to highest possible frame in this second
 295                 switch ((int)ceil (timecode.rate)) {
 296                 case 24:
 297                         timecode.frames = 23;
 298                         break;
 299                 case 25:
 300                         timecode.frames = 24;
 301                         break;
 302                 case 30:
 303                         timecode.frames = 29;
 304                         break;
 305                 case 60:
 306                         timecode.frames = 59;
 307                         break;
 308                 }
 309
 310                 // Increment by one frame
 311                 wrap = increment (timecode, subframes_per_frame);
 312         }
 313
 314         return wrap;
 315 }
 316
 317
 318 /** Go to lowest (absolute) frame value in this second
 319  * Doesn't care about positive/negative */
 320 void
 321 seconds_floor (Time& timecode)
 322 {
 323         // Clear subframes
 324         frames_floor (timecode);
 325
 326         // Go to lowest possible frame in this second
 327         switch ((int)ceil (timecode.rate)) {
 328         case 24:
 329         case 25:
 330         case 30:
 331         case 60:
 332                 if (!(timecode.drop)) {
 333                         timecode.frames = 0;
 334                 } else {
 335                         if ((timecode.minutes % 10) && (timecode.seconds == 0)) {
 336                                 timecode.frames = 2;
 337                         } else {
 338                                 timecode.frames = 0;
 339                         }
 340                 }
 341                 break;
 342         }
 343
 344         if (Timecode_IS_ZERO (timecode)) {
 345                 timecode.negative = false;
 346         }
 347 }
 348
 349
 350 /** Go to next whole minute (seconds == 0, frames == 0 or frames == 2) */
 351 Wrap
 352 increment_minutes (Time& timecode, uint32_t subframes_per_frame)
 353 {
 354         Wrap wrap = NONE;
 355
 356         // Clear subframes
 357         frames_floor (timecode);
 358
 359         if (timecode.negative) {
 360                 // Wrap if on minute boundary
 361                 wrap = increment_seconds (timecode, subframes_per_frame);
 362                 // Go to lowest possible value in this minute
 363                 minutes_floor (timecode);
 364         } else {
 365                 // Go to highest possible second
 366                 timecode.seconds = 59;
 367                 // Wrap minute by incrementing second
 368                 wrap = increment_seconds (timecode, subframes_per_frame);
 369         }
 370
 371         return wrap;
 372 }
 373
 374
 375 /** Go to lowest absolute value in this minute */
 376 void
 377 minutes_floor (Time& timecode)
 378 {
 379         // Go to lowest possible second
 380         timecode.seconds = 0;
 381         // Go to lowest possible frame
 382         seconds_floor (timecode);
 383
 384         if (Timecode_IS_ZERO (timecode)) {
 385                 timecode.negative = false;
 386         }
 387 }
 388
 389
 390 /** Go to next whole hour (minute = 0, second = 0, frame = 0) */
 391 Wrap
 392 increment_hours (Time& timecode, uint32_t subframes_per_frame)
 393 {
 394         Wrap wrap = NONE;
 395
 396         // Clear subframes
 397         frames_floor (timecode);
 398
 399         if (timecode.negative) {
 400                 // Wrap if on hour boundary
 401                 wrap = increment_minutes (timecode, subframes_per_frame);
 402                 // Go to lowest possible value in this hour
 403                 hours_floor(timecode);
 404         } else {
 405                 timecode.minutes = 59;
 406                 wrap = increment_minutes (timecode, subframes_per_frame);
 407         }
 408
 409         return wrap;
 410 }
 411
 412
 413 /** Go to lowest absolute value in this hour */
 414 void
 415 hours_floor(Time& timecode)
 416 {
 417         timecode.minutes   = 0;
 418         timecode.seconds   = 0;
 419         timecode.frames    = 0;
 420         timecode.subframes = 0;
 421
 422         if (Timecode_IS_ZERO (timecode)) {
 423                 timecode.negative = false;
 424         }
 425 }
 426
 427 double
 428 timecode_to_frames_per_second(TimecodeFormat t)
 429 {
 430         switch (t) {
 431                 case timecode_23976:
 432                         return (24000.0/1001.0); //23.976;
 433
 434                         break;
 435                 case timecode_24:
 436                         return 24;
 437
 438                         break;
 439                 case timecode_24976:
 440                         return (25000.0/1001.0); //24.976;
 441
 442                         break;
 443                 case timecode_25:
 444                         return 25;
 445
 446                         break;
 447                 case timecode_2997:
 448                         return (30000.0/1001.0); //29.97;
 449
 450                         break;
 451                 case timecode_2997drop:
 452                         return (30000.0/1001.0); //29.97;
 453
 454                         break;
 455                 case timecode_2997000:
 456                         return 29.97;
 457
 458                         break;
 459                 case timecode_2997000drop:
 460                         return 29.97;
 461
 462                         break;
 463                 case timecode_30:
 464                         return 30;
 465
 466                         break;
 467                 case timecode_30drop:
 468                         return 30;
 469
 470                         break;
 471                 case timecode_5994:
 472                         return (60000.0/1001.0); //59.94;
 473
 474                         break;
 475                 case timecode_60:
 476                         return 60;
 477
 478                         break;
 479                 default:
 480                         //std::cerr << "Editor received unexpected timecode type" << std::endl;
 481                         break;
 482         }
 483         return 30.0;
 484 }
 485
 486 bool
 487 timecode_has_drop_frames(TimecodeFormat t)
 488 {
 489         switch (t) {
 490                 case timecode_23976:
 491                         return false;
 492
 493                         break;
 494                 case timecode_24:
 495                         return false;
 496
 497                         break;
 498                 case timecode_24976:
 499                         return false;
 500
 501                         break;
 502                 case timecode_25:
 503                         return false;
 504
 505                         break;
 506                 case timecode_2997:
 507                         return false;
 508
 509                         break;
 510                 case timecode_2997drop:
 511                         return true;
 512
 513                         break;
 514                 case timecode_2997000:
 515                         return false;
 516
 517                         break;
 518                 case timecode_2997000drop:
 519                         return true;
 520
 521                         break;
 522                 case timecode_30:
 523                         return false;
 524
 525                         break;
 526                 case timecode_30drop:
 527                         return true;
 528
 529                         break;
 530                 case timecode_5994:
 531                         return false;
 532
 533                         break;
 534                 case timecode_60:
 535                         return false;
 536
 537                         break;
 538                 default:
 539                         //error << "Editor received unexpected timecode type" << endmsg;
 540                         break;
 541         }
 542
 543         return false;
 544 }
 545
 546 std::string
 547 timecode_format_name (TimecodeFormat const t)
 548 {
 549         switch (t) {
 550                 case timecode_23976:
 551                         return "23.98";
 552
 553                         break;
 554                 case timecode_24:
 555                         return "24";
 556
 557                         break;
 558                 case timecode_24976:
 559                         return "24.98";
 560
 561                         break;
 562                 case timecode_25:
 563                         return "25";
 564
 565                         break;
 566                 case timecode_2997000:
 567                 case timecode_2997:
 568                         return "29.97";
 569
 570                         break;
 571                 case timecode_2997000drop:
 572                 case timecode_2997drop:
 573                         return "29.97 drop";
 574
 575                         break;
 576                 case timecode_30:
 577                         return "30";
 578
 579                         break;
 580                 case timecode_30drop:
 581                         return "30 drop";
 582
 583                         break;
 584                 case timecode_5994:
 585                         return "59.94";
 586
 587                         break;
 588                 case timecode_60:
 589                         return "60";
 590
 591                         break;
 592                 default:
 593                         break;
 594         }
 595
 596         return "??";
 597 }
 598
 599 std::string timecode_format_time (Timecode::Time TC)
 600 {
 601         char buf[32];
 602         if (TC.negative) {
 603                 snprintf (buf, sizeof (buf), "-%02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 "%c%02" PRIu32,
 604                                 TC.hours, TC.minutes, TC.seconds, TC.drop ? ';' : ':', TC.frames);
 605         } else {
 606                 snprintf (buf, sizeof (buf), " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 "%c%02" PRIu32,
 607                                 TC.hours, TC.minutes, TC.seconds, TC.drop ? ';' : ':', TC.frames);
 608         }
 609         return std::string(buf);
 610 }
 611
 612 std::string timecode_format_sampletime (
 613                 int64_t sample,
 614                 double sample_frame_rate,
 615                 double timecode_frames_per_second, bool timecode_drop_frames)
 616 {
 617         Time t;
 618         sample_to_timecode(
 619                         sample, t, false, false,
 620                         timecode_frames_per_second, timecode_drop_frames,
 621                         sample_frame_rate,
 622                         80, false, 0);
 623         return timecode_format_time(t);
 624 }
 625
 626 bool parse_timecode_format(std::string tc, Timecode::Time &TC) {
 627         char negative[2];
 628         char ignored[2];
 629         TC.subframes = 0;
 630         if (sscanf (tc.c_str(), "%[- ]%" PRId32 ":%" PRId32 ":%" PRId32 "%[:;]%" PRId32,
 631                                 negative, &TC.hours, &TC.minutes, &TC.seconds, ignored, &TC.frames) != 6) {
 632                 TC.hours = TC.minutes = TC.seconds = TC.frames = 0;
 633                 TC.negative = false;
 634                 return false;
 635         }
 636         if (negative[0]=='-') {
 637                 TC.negative = true;
 638         } else {
 639                 TC.negative = false;
 640         }
 641         return true;
 642 }
 643
 644 void
 645 timecode_to_sample(
 646                 Timecode::Time& timecode, int64_t& sample,
 647                 bool use_offset, bool use_subframes,
 648     /* Note - framerate info is taken from Timecode::Time& */
 649                 double sample_frame_rate /**< may include pull up/down */,
 650                 uint32_t subframes_per_frame,
 651     /* optional offset  - can be improved: function pointer to lazily query this*/
 652                 bool offset_is_negative, int64_t offset_samples
 653                 )
 654 {
 655         const double frames_per_timecode_frame = (double) sample_frame_rate / (double) timecode.rate;
 656
 657         if (timecode.drop) {
 658                 // The drop frame format was created to better approximate the 30000/1001 = 29.97002997002997....
 659                 // framerate of NTSC color TV. The used frame rate of drop frame is 29.97, which drifts by about
 660                 // 0.108 frame per hour, or about 1.3 frames per 12 hours. This is not perfect, but a lot better
 661                 // than using 30 non drop, which will drift with about 1.8 frame per minute.
 662                 // Using 29.97, drop frame real time can be accurate only every 10th minute (10 minutes of 29.97 fps
 663                 // is exactly 17982 frames). One minute is 1798.2 frames, but we count 30 frames per second
 664                 // (30 * 60 = 1800). This means that at the first minute boundary (at the end of 0:0:59:29) we
 665                 // are 1.8 frames too late relative to real time. By dropping 2 frames (jumping to 0:1:0:2) we are
 666                 // approx. 0.2 frames too early. This adds up with 0.2 too early for each minute until we are 1.8
 667                 // frames too early at 0:9:0:2 (9 * 0.2 = 1.8). The 10th minute brings us 1.8 frames later again
 668                 // (at end of 0:9:59:29), which sums up to 0 (we are back to zero at 0:10:0:0 :-).
 669                 //
 670                 // In table form:
 671                 //
 672                 // Timecode value    frames offset   subframes offset   seconds (rounded)  44100 sample (rounded)
 673                 //  0:00:00:00        0.0             0                     0.000                0 (accurate)
 674                 //  0:00:59:29        1.8           144                    60.027          2647177
 675                 //  0:01:00:02       -0.2           -16                    60.060          2648648
 676                 //  0:01:59:29        1.6           128                   120.020          5292883
 677                 //  0:02:00:02       -0.4           -32                   120.053          5294354
 678                 //  0:02:59:29        1.4           112                   180.013          7938588
 679                 //  0:03:00:02       -0.6           -48                   180.047          7940060
 680                 //  0:03:59:29        1.2            96                   240.007         10584294
 681                 //  0:04:00:02       -0.8           -64                   240.040         10585766
 682                 //  0:04:59:29        1.0            80                   300.000         13230000
 683                 //  0:05:00:02       -1.0           -80                   300.033         13231471
 684                 //  0:05:59:29        0.8            64                   359.993         15875706
 685                 //  0:06:00:02       -1.2           -96                   360.027         15877177
 686                 //  0:06:59:29        0.6            48                   419.987         18521411
 687                 //  0:07:00:02       -1.4          -112                   420.020         18522883
 688                 //  0:07:59:29        0.4            32                   478.980         21167117
 689                 //  0:08:00:02       -1.6          -128                   480.013         21168589
 690                 //  0:08:59:29        0.2            16                   539.973         23812823
 691                 //  0:09:00:02       -1.8          -144                   540.007         23814294
 692                 //  0:09:59:29        0.0+            0+                  599.967         26458529
 693                 //  0:10:00:00        0.0             0                   600.000         26460000 (accurate)
 694                 //
 695                 //  Per Sigmond <per@sigmond.no>
 696                 //
 697                 //  This schma would compensate exactly for a frame-rate of 30 * 0.999. but the
 698                 //  actual rate is 30000/1001 - which results in an offset of -3.6ms per hour or
 699                 //  about -86ms over a 24-hour period. (SMPTE 12M-1999)
 700                 //
 701                 //  Robin Gareus <robin@gareus.org>
 702
 703                 const int64_t fps_i = ceil(timecode.rate);
 704                 int64_t totalMinutes = 60 * timecode.hours + timecode.minutes;
 705                 int64_t frameNumber  = fps_i * 3600 * timecode.hours
 706                         + fps_i * 60 * timecode.minutes
 707                         + fps_i * timecode.seconds + timecode.frames
 708                         - 2 * (totalMinutes - totalMinutes / 10);
 709                 sample = frameNumber * sample_frame_rate / (double) timecode.rate;
 710         } else {
 711                 /*
 712                    Non drop is easy.. just note the use of
 713                    rint(timecode.rate) * frames_per_timecode_frame
 714                    (frames per Timecode second), which is larger than
 715                    frame_rate() in the non-integer Timecode rate case.
 716                 */
 717
 718                 sample = (int64_t)rint((((timecode.hours * 60 * 60) + (timecode.minutes * 60) + timecode.seconds) * (rint(timecode.rate) * frames_per_timecode_frame)) + (timecode.frames * frames_per_timecode_frame));
 719         }
 720
 721         if (use_subframes) {
 722                 sample += (int64_t) rint(((double)timecode.subframes * frames_per_timecode_frame) / (double)subframes_per_frame);
 723         }
 724
 725         if (use_offset) {
 726                 if (offset_is_negative) {
 727                         if (sample >= offset_samples) {
 728                                 sample -= offset_samples;
 729                         } else {
 730                                 /* Prevent song-time from becoming negative */
 731                                 sample = 0;
 732                         }
 733                 } else {
 734                         if (timecode.negative) {
 735                                 if (sample <= offset_samples) {
 736                                         sample = offset_samples - sample;
 737                                 } else {
 738                                         sample = 0;
 739                                 }
 740                         } else {
 741                                 sample += offset_samples;
 742                         }
 743                 }
 744         }
 745 }
 746
 747
 748 void
 749 sample_to_timecode (
 750                 int64_t sample, Timecode::Time& timecode,
 751                 bool use_offset, bool use_subframes,
 752     /* framerate info */
 753                 double timecode_frames_per_second,
 754                 bool   timecode_drop_frames,
 755                 double sample_frame_rate/**< can include pull up/down */,
 756                 uint32_t subframes_per_frame,
 757     /* optional offset  - can be improved: function pointer to lazily query this*/
 758                 bool offset_is_negative, int64_t offset_samples
 759                 )
 760 {
 761         int64_t offset_sample;
 762
 763         if (!use_offset) {
 764                 offset_sample = sample;
 765                 timecode.negative = false;
 766         } else {
 767                 if (offset_is_negative) {
 768                         offset_sample = sample + offset_samples;
 769                         timecode.negative = false;
 770                 } else {
 771                         if (sample < offset_samples) {
 772                                 offset_sample = (offset_samples - sample);
 773                                 timecode.negative = true;
 774                         } else {
 775                                 offset_sample =  sample - offset_samples;
 776                                 timecode.negative = false;
 777                         }
 778                 }
 779         }
 780
 781         if (timecode_drop_frames) {
 782                 int64_t frameNumber = floor( (double)offset_sample * timecode_frames_per_second / sample_frame_rate);
 783
 784                 /* there are 17982 frames in 10 min @ 29.97df */
 785                 const int64_t D = frameNumber / 17982;
 786                 const int64_t M = frameNumber % 17982;
 787
 788                 timecode.subframes = floor(subframes_per_frame
 789                                 * ((double)offset_sample * timecode_frames_per_second / sample_frame_rate - (double)frameNumber));
 790
 791                 frameNumber +=  18*D + 2*((M - 2) / 1798);
 792
 793                 timecode.frames  =    frameNumber % 30;
 794                 timecode.seconds =   (frameNumber / 30) % 60;
 795                 timecode.minutes =  ((frameNumber / 30) / 60) % 60;
 796                 timecode.hours   = (((frameNumber / 30) / 60) / 60);
 797
 798         } else {
 799                 double timecode_frames_left_exact;
 800                 double timecode_frames_fraction;
 801                 int64_t timecode_frames_left;
 802                 const double frames_per_timecode_frame = sample_frame_rate / timecode_frames_per_second;
 803                 const int64_t frames_per_hour = (int32_t)(3600 * rint(timecode_frames_per_second) * frames_per_timecode_frame);
 804
 805                 timecode.hours = offset_sample / frames_per_hour;
 806
 807                 // Extract whole hours. Do this to prevent rounding errors with
 808                 // high sample numbers in the calculations that follow.
 809                 timecode_frames_left_exact = (double)(offset_sample % frames_per_hour) / frames_per_timecode_frame;
 810                 timecode_frames_fraction = timecode_frames_left_exact - floor( timecode_frames_left_exact );
 811
 812                 timecode.subframes = (int32_t) rint(timecode_frames_fraction * subframes_per_frame);
 813                 timecode_frames_left = (int64_t) floor (timecode_frames_left_exact);
 814
 815                 if (timecode.subframes == subframes_per_frame) {
 816                         timecode_frames_left++;
 817                         timecode.subframes = 0;
 818                 }
 819
 820                 timecode.minutes = timecode_frames_left / ((int32_t) rint (timecode_frames_per_second) * 60);
 821                 timecode_frames_left = timecode_frames_left % ((int32_t) rint (timecode_frames_per_second) * 60);
 822                 timecode.seconds = timecode_frames_left / (int32_t) rint(timecode_frames_per_second);
 823                 timecode.frames = timecode_frames_left % (int32_t) rint(timecode_frames_per_second);
 824         }
 825
 826         if (!use_subframes) {
 827                 timecode.subframes = 0;
 828         }
 829         /* set frame rate and drop frame */
 830         timecode.rate = timecode_frames_per_second;
 831         timecode.drop = timecode_drop_frames;
 832 }
 833
 834 } // namespace Timecode
 835
 836 std::ostream&
 837 operator<<(std::ostream& ostr, const Timecode::Time& t)
 838 {
 839         return t.print (ostr);
 840 }