overhaul timecode calculations

in particular proper SMPTE12M drop-frame support
and subframe rounding.

git-svn-id: svn://localhost/ardour2/branches/3.0@13473 d708f5d6-7413-0410-9779-e7cbd77b26cf

diff --git a/libs/timecode/src/time.cc b/libs/timecode/src/time.cc
index 4609fbea87e9e7ab58ce02eb8b5bdb49afd13d9f..10dfd2fb59df110358d712fe605de86203a8364e 100644 (file)
--- a/libs/timecode/src/time.cc
+++ b/libs/timecode/src/time.cc
@@ -675,16 +675,20 @@ timecode_to_sample(
                //  0:10:00:00        0.0             0                   600.000         26460000 (accurate)
                //
                //  Per Sigmond <per@sigmond.no>
-
-               // Samples inside time dividable by 10 minutes (real time accurate)
-               int64_t base_samples = (int64_t) (((timecode.hours * 107892) + ((timecode.minutes / 10) * 17982)) * frames_per_timecode_frame);
-
-               // Samples inside time exceeding the nearest 10 minutes (always offset, see above)
-               int32_t exceeding_df_minutes = timecode.minutes % 10;
-               int32_t exceeding_df_seconds = (exceeding_df_minutes * 60) + timecode.seconds;
-               int32_t exceeding_df_frames = (30 * exceeding_df_seconds) + timecode.frames - (2 * exceeding_df_minutes);
-               int64_t exceeding_samples = (int64_t) rint(exceeding_df_frames * frames_per_timecode_frame);
-               sample = base_samples + exceeding_samples;
+               //
+               //  This schma would compensate exactly for a frame-rate of 30 * 0.999. but the
+               //  actual rate is 30000/1001 - which results in an offset of -3.6ms per hour or
+               //  about -86ms over a 24-hour period. (SMPTE 12M-1999)
+               //
+               //  Robin Gareus <robin@gareus.org>
+
+               const int64_t fps_i = ceil(timecode.rate);
+               int64_t totalMinutes = 60 * timecode.hours + timecode.minutes;
+               int64_t frameNumber  = fps_i * 3600 * timecode.hours
+                       + fps_i * 60 * timecode.minutes
+                       + fps_i * timecode.seconds + timecode.frames
+                       - 2 * (totalMinutes - totalMinutes / 10);
+               sample = frameNumber * sample_frame_rate / (double) timecode.rate;
        } else {
                /*
                   Non drop is easy.. just note the use of
@@ -697,7 +701,7 @@ timecode_to_sample(
        }
 
        if (use_subframes) {
-               sample += (int64_t) (((double)timecode.subframes * frames_per_timecode_frame) / subframes_per_frame);
+               sample += (int64_t) rint(((double)timecode.subframes * frames_per_timecode_frame) / (double)subframes_per_frame);
        }
 
        if (use_offset) {
@@ -736,16 +740,6 @@ sample_to_timecode (
                bool offset_is_negative, int64_t offset_samples
                )
 {
-       const double frames_per_timecode_frame = (double) sample_frame_rate / (double) timecode_frames_per_second;
-       int32_t frames_per_hour;
-
-       if (timecode_drop_frames) {
-         frames_per_hour = (int32_t)(107892 * frames_per_timecode_frame);
-       } else {
-         frames_per_hour = (int32_t)(3600 * rint(timecode_frames_per_second) * frames_per_timecode_frame);
-       }
-
-  /* do the work */
        int64_t offset_sample;
 
        if (!use_offset) {
@@ -766,66 +760,45 @@ sample_to_timecode (
                }
        }
 
-       double timecode_frames_left_exact;
-       double timecode_frames_fraction;
-       uint64_t timecode_frames_left;
+       if (timecode_drop_frames) {
+               int64_t frameNumber = floor( (double)offset_sample * timecode_frames_per_second / sample_frame_rate);
 
-       // Extract whole hours. Do this to prevent rounding errors with
-       // high sample numbers in the calculations that follow.
-       timecode.hours = offset_sample / frames_per_hour;
-       offset_sample = offset_sample % frames_per_hour;
+               /* there are 17982 frames in 10 min @ 29.97df */
+               const int64_t D = frameNumber / 17982;
+               const int64_t M = frameNumber % 17982;
 
-       // Calculate exact number of (exceeding) timecode frames and fractional frames
-       timecode_frames_left_exact = (double) offset_sample / frames_per_timecode_frame;
-       timecode_frames_fraction = timecode_frames_left_exact - floor( timecode_frames_left_exact );
-       timecode.subframes = (int32_t) floor(timecode_frames_fraction * subframes_per_frame);
+               timecode.subframes = floor(subframes_per_frame
+                               * ((double)offset_sample * timecode_frames_per_second / sample_frame_rate - (double)frameNumber));
 
-       // XXX Not sure if this is necessary anymore...
-       if (timecode.subframes == subframes_per_frame) {
-               // This can happen with 24 fps (and 29.97 fps ?)
-               timecode_frames_left_exact = ceil( timecode_frames_left_exact );
-               timecode.subframes = 0;
-       }
+               frameNumber +=  18*D + 2*((M - 2) / 1798);
 
-       // Extract hour-exceeding frames for minute, second and frame calculations
-       timecode_frames_left = (uint64_t) floor (timecode_frames_left_exact);
+               timecode.frames  =    frameNumber % 30;
+               timecode.seconds =   (frameNumber / 30) % 60;
+               timecode.minutes =  ((frameNumber / 30) / 60) % 60;
+               timecode.hours   = (((frameNumber / 30) / 60) / 60);
 
-       if (timecode_drop_frames) {
-               // See int32_t explanation in timecode_to_sample()...
-
-               // Number of 10 minute chunks
-               timecode.minutes = (timecode_frames_left / 17982) * 10; // exactly 17982 frames in 10 minutes
-               // frames exceeding the nearest 10 minute barrier
-               int32_t exceeding_df_frames = timecode_frames_left % 17982;
-
-               // Find minutes exceeding the nearest 10 minute barrier
-               if (exceeding_df_frames >= 1800) { // nothing to do if we are inside the first minute (0-1799)
-                       exceeding_df_frames -= 1800; // take away first minute (different number of frames than the others)
-                       int32_t extra_minutes_minus_1 = exceeding_df_frames / 1798; // how many minutes after the first one
-                       exceeding_df_frames -= extra_minutes_minus_1 * 1798; // take away the (extra) minutes just found
-                       timecode.minutes += extra_minutes_minus_1 + 1; // update with exceeding minutes
-               }
+       } else {
+               double timecode_frames_left_exact;
+               double timecode_frames_fraction;
+               int64_t timecode_frames_left;
+               const double frames_per_timecode_frame = sample_frame_rate / timecode_frames_per_second;
+               const int64_t frames_per_hour = (int32_t)(3600 * rint(timecode_frames_per_second) * frames_per_timecode_frame);
 
-               // Adjust frame numbering for dropped frames (frame 0 and 1 skipped at start of every minute except every 10th)
-               if (timecode.minutes % 10) {
-                       // Every minute except every 10th
-                       if (exceeding_df_frames < 28) {
-                               // First second, frames 0 and 1 are skipped
-                               timecode.seconds = 0;
-                               timecode.frames = exceeding_df_frames + 2;
-                       } else {
-                               // All other seconds, all 30 frames are counted
-                               exceeding_df_frames -= 28;
-                               timecode.seconds = (exceeding_df_frames / 30) + 1;
-                               timecode.frames = exceeding_df_frames % 30;
-                       }
-               } else {
-                       // Every 10th minute, all 30 frames counted in all seconds
-                       timecode.seconds = exceeding_df_frames / 30;
-                       timecode.frames = exceeding_df_frames % 30;
+               timecode.hours = offset_sample / frames_per_hour;
+
+               // Extract whole hours. Do this to prevent rounding errors with
+               // high sample numbers in the calculations that follow.
+               timecode_frames_left_exact = (double)(offset_sample % frames_per_hour) / frames_per_timecode_frame;
+               timecode_frames_fraction = timecode_frames_left_exact - floor( timecode_frames_left_exact );
+
+               timecode.subframes = (int32_t) rint(timecode_frames_fraction * subframes_per_frame);
+               timecode_frames_left = (int64_t) floor (timecode_frames_left_exact);
+
+               if (timecode.subframes == subframes_per_frame) {
+                       timecode_frames_left++;
+                       timecode.subframes = 0;
                }
-       } else {
-               // Non drop is easy
+
                timecode.minutes = timecode_frames_left / ((int32_t) rint (timecode_frames_per_second) * 60);
                timecode_frames_left = timecode_frames_left % ((int32_t) rint (timecode_frames_per_second) * 60);
                timecode.seconds = timecode_frames_left / (int32_t) rint(timecode_frames_per_second);