ardour/livetrax
13
0
Fork 0
Code

overhaul timecode calculations

Browse Source 
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
This commit is contained in:
Robin Gareus 2012-11-13 02:00:49 +00:00
parent ba54b9583b
commit b8ff65ea1b
1 changed files with 48 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
libs/timecode/src/time.cc
View File

@ -675,16 +675,20 @@ timecode_to_sample(
// 0:10:00:00 0.0 0 600.000 26460000 (accurate)
//
// Per Sigmond <per@sigmond.no>
//
// 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>
// 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;
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;
// 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;
// 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);
// 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;
}
// Extract hour-exceeding frames for minute, second and frame calculations
timecode_frames_left = (uint64_t) floor (timecode_frames_left_exact);
if (timecode_drop_frames) {
// See int32_t explanation in timecode_to_sample()...
int64_t frameNumber = floor( (double)offset_sample * timecode_frames_per_second / sample_frame_rate);
// 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;
/* there are 17982 frames in 10 min @ 29.97df */
const int64_t D = frameNumber / 17982;
const int64_t M = frameNumber % 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
}
timecode.subframes = floor(subframes_per_frame
* ((double)offset_sample * timecode_frames_per_second / sample_frame_rate - (double)frameNumber));
frameNumber += 18*D + 2*((M - 2) / 1798);
timecode.frames = frameNumber % 30;
timecode.seconds = (frameNumber / 30) % 60;
timecode.minutes = ((frameNumber / 30) / 60) % 60;
timecode.hours = (((frameNumber / 30) / 60) / 60);
// 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;
}
} else {
// Non drop is easy
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);
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;
}
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);