374 lines
9.7 KiB
C++
374 lines
9.7 KiB
C++
/**********************************************************************
|
|
Copyright (c) 1996 - 1998 Microsoft Corporation. All Rights Reserved.
|
|
|
|
TimeCode
|
|
|
|
A class to describe and manipulate SMPTE timecodes.
|
|
|
|
If we extend this class, fix its bugs, and use it in all applications,
|
|
then we will have consistent and error free code!
|
|
|
|
NOTE: I have provided the dropframe math derivations in the code along
|
|
with references to the appropriate texts.
|
|
|
|
TODO: PAL Dropframe math. (fairly consistent, base it on the NTSC drop code)
|
|
Check values and generate EXCEPTIONS on errs!
|
|
Extend timecode class to other video types/rates
|
|
Flesh out the operator overloads (+=,-=,+,- all make good sense)
|
|
|
|
Ken Greenebaum, November 1996
|
|
**********************************************************************/
|
|
#include <wtypes.h>
|
|
#include <stdio.h>
|
|
#include "timecode.h"
|
|
|
|
// Initialize constants!
|
|
const char TimeCode::NTSC_MODE = (char)0x01;
|
|
const char TimeCode::PAL_MODE = (char)0x00;
|
|
const char TimeCode::FORMAT_MASK = (char)0xFE;
|
|
|
|
const char TimeCode::DROPFRAME_MODE = (char)0x02;
|
|
const char TimeCode::NO_DROPFRAME_MODE = (char)0x00;
|
|
const char TimeCode::DROPFRAME_MASK = (char)0xFD;
|
|
|
|
const char TimeCode::NTSC_NODROP = NTSC_MODE | NO_DROPFRAME_MODE;
|
|
const char TimeCode::NTSC_DROP = NTSC_MODE | DROPFRAME_MODE;
|
|
const char TimeCode::PAL_NODROP = PAL_MODE | NO_DROPFRAME_MODE;
|
|
const char TimeCode::PAL_DROP = PAL_MODE | DROPFRAME_MODE;
|
|
|
|
|
|
TimeCode::TimeCode()
|
|
{
|
|
SetFormat(TRUE, FALSE); // NTSC, no dropframe
|
|
SetTime(0, 0, 0, 0); // 00:00:00:00
|
|
}
|
|
|
|
|
|
TimeCode::TimeCode(char *string, BOOL ntsc, BOOL drop)
|
|
{
|
|
SetFormat(ntsc, drop);
|
|
SetTime(string);
|
|
}
|
|
|
|
|
|
TimeCode::TimeCode(int h, int m, int s, int f, BOOL ntsc, BOOL d)
|
|
{
|
|
SetFormat(ntsc, d);
|
|
SetTime(h, m, s, f);
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::operator++(int unusedPostfixThingy) // postfix
|
|
{
|
|
operator++(); // call the prefix operator for the sake of consistency
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::operator++() // prefix
|
|
{
|
|
if(_frames.dirty)
|
|
_FramesFromHMSF();
|
|
|
|
_frames.frames++;
|
|
_frames.dirty = FALSE;
|
|
_hmsf.dirty = TRUE;
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::operator--(int unusedPostfixThingy) // postfix
|
|
{
|
|
operator--(); // call the prefix operator for the sake of consistency
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::operator--() // prefix
|
|
{
|
|
if(_frames.dirty)
|
|
_FramesFromHMSF();
|
|
|
|
_frames.frames--; // XXX shouldn't we check for wrap?
|
|
_frames.dirty = FALSE;
|
|
_hmsf.dirty = TRUE;
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::SetFormat(BOOL ntsc, BOOL drop)
|
|
{
|
|
_timeCodeFormat = (ntsc ? NTSC_MODE : PAL_MODE) |
|
|
(drop ? DROPFRAME_MODE : NO_DROPFRAME_MODE);
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::SetTime(int hours, int minutes, int seconds, int frames)
|
|
{
|
|
_hmsf.hours = hours;
|
|
_hmsf.minutes = minutes;
|
|
_hmsf.seconds = seconds;
|
|
_hmsf.frames = frames;
|
|
_hmsf.dirty = FALSE;
|
|
_frames.dirty = TRUE; // invalidate the frames cache
|
|
|
|
// XXX should we sanity check the timecode value?
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::SetTime(char *string)
|
|
{
|
|
sscanf(string, "%d:%d:%d:%d",
|
|
&_hmsf.hours, &_hmsf.minutes, &_hmsf.seconds, &_hmsf.frames);
|
|
_hmsf.dirty = FALSE;
|
|
_frames.dirty = TRUE; // invalidate the frames cache
|
|
|
|
// XXX should we sanity check the timecode value?
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::GetTime(int *hours, int *minutes, int *seconds, int *frames)
|
|
{
|
|
if(_hmsf.dirty)
|
|
_HMSFfromFrames();
|
|
|
|
*hours = _hmsf.hours;
|
|
*minutes = _hmsf.minutes;
|
|
*seconds = _hmsf.seconds;
|
|
*frames = _hmsf.frames;
|
|
}
|
|
|
|
|
|
LONGLONG
|
|
TimeCode::GetTime()
|
|
{
|
|
if(_frames.dirty)
|
|
_FramesFromHMSF();
|
|
|
|
return(_frames.frames);
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::GetString(char *string) {
|
|
if(_hmsf.dirty)
|
|
_HMSFfromFrames();
|
|
|
|
wsprintf(string, "%02d:%02d:%02d:%02d",
|
|
_hmsf.hours, _hmsf.minutes, _hmsf.seconds, _hmsf.frames);
|
|
}
|
|
|
|
/**********************************************************************
|
|
Dropframe math derivation:
|
|
|
|
NTSC dropframe Pg208 Video Demystified:
|
|
|
|
To resolve the color timing error, the first two frame numbers
|
|
(0, and 1) at the start of each minute, except for minutes 0, 10, 20, 30,
|
|
40, and 50, are omitted from the count.
|
|
|
|
So:
|
|
|
|
The number of frames of video in an NTSC dropframe hour =
|
|
30 frames/second * 60 seconds/minute * 60 minutes/hour
|
|
- 60 minutes * 2 frames dropped/minute
|
|
+ 6 excepted minutes * 2 frames not dropped
|
|
|
|
= 107892
|
|
|
|
The number of frames of video in an NTSC dropframe minute =
|
|
30 frames/second * 60 seconds/minute - 2 if minute != 0,10,20,30,40 or 50!
|
|
|
|
There are 6 10 minute cycles in an hour.
|
|
|
|
Each cycle has 17982 frames:
|
|
9 dropframe min * ((30 frames/sec * 60 sec/min) - 2 dropframes/min) frames/min
|
|
1 nondrop min * 30 frames/second * 60 sec/min
|
|
|
|
**********************************************************************/
|
|
void
|
|
TimeCode::_HMSFfromFrames()
|
|
{
|
|
LONGLONG frames = _frames.frames;
|
|
int units;
|
|
int tmp;
|
|
|
|
switch(_timeCodeFormat) {
|
|
case NTSC_NODROP:
|
|
_hmsf.hours = (int)(frames / 108000.0);
|
|
frames-= _hmsf.hours * 108000;
|
|
|
|
_hmsf.minutes = (int)(frames / 1800.0);
|
|
frames-= _hmsf.minutes * 1800;
|
|
|
|
_hmsf.seconds = (int)(frames / 30.0);
|
|
frames-= _hmsf.seconds * 30;
|
|
|
|
_hmsf.frames = (int)frames;
|
|
break;
|
|
|
|
case NTSC_DROP:
|
|
_hmsf.hours = (int)(frames / 107892.0);
|
|
frames-= _hmsf.hours * 107892;
|
|
|
|
// remove 10 minute cycles
|
|
tmp = (int)(frames / 17982.0);
|
|
_hmsf.minutes = 10 * tmp;
|
|
frames-= tmp * 17982;
|
|
|
|
// remaining minutes < complete 10 minute cycle
|
|
|
|
// first minute (0) would not drop frames
|
|
if(frames >= 1800) {
|
|
_hmsf.minutes++;
|
|
frames-=1800;
|
|
|
|
tmp = (int)(frames / 1798.0);
|
|
_hmsf.minutes+= tmp;
|
|
frames-= tmp * 1798;
|
|
}
|
|
|
|
|
|
// remaining seconds <= 60
|
|
|
|
_hmsf.seconds = 0;
|
|
units = _hmsf.minutes - 10*(_hmsf.minutes/10); // remove 10s
|
|
if(!units) { // the 0, 10, 20, 30, 40, 50 minute
|
|
_hmsf.seconds = (int)(frames / 30.0);
|
|
frames-= _hmsf.seconds * 30;
|
|
}
|
|
else { // not an exception min(the 1st secof this min has 28frames)
|
|
if(frames>=28) {
|
|
frames-=28;
|
|
_hmsf.seconds = 1;
|
|
|
|
// the rest are 30 frame seconds
|
|
_hmsf.seconds+= (int)(frames / 30.0);
|
|
frames-= (_hmsf.seconds-1) * 30;
|
|
}
|
|
|
|
}
|
|
|
|
_hmsf.frames = (int)frames;
|
|
_hmsf.frames += ((units)&&(_hmsf.seconds==0))?2:0; // a drop second
|
|
break;
|
|
|
|
case PAL_NODROP:
|
|
_hmsf.hours = (int)(frames / 90000.0);
|
|
frames-= _hmsf.hours * 90000;
|
|
|
|
_hmsf.minutes = (int)(frames / 1500.0);
|
|
frames-= _hmsf.minutes * 1500;
|
|
|
|
_hmsf.seconds = (int)(frames / 25.0);
|
|
frames-= _hmsf.seconds * 25;
|
|
|
|
_hmsf.frames = (int)frames;
|
|
break;
|
|
|
|
case PAL_DROP: fprintf(stderr,
|
|
"TimeCode::_HMSfromFrames: PAL_DROP not implemented!\n");
|
|
break;
|
|
|
|
default:
|
|
// XXX really should throw an exception!
|
|
fprintf(stderr,
|
|
"TimeCode::_HMSfromFrames: unknown _timeCodeFormat %d\n",
|
|
_timeCodeFormat);
|
|
break;
|
|
}
|
|
_hmsf.dirty = FALSE;
|
|
}
|
|
|
|
|
|
void
|
|
TimeCode::_FramesFromHMSF()
|
|
{
|
|
LONGLONG frames;
|
|
//int exceptionalMinutes;
|
|
|
|
switch(_timeCodeFormat) {
|
|
case NTSC_NODROP:
|
|
frames = _hmsf.frames;
|
|
frames+= _hmsf.seconds * 30;
|
|
frames+= _hmsf.minutes * 1800; // 30f/s * 60s/min
|
|
frames+= _hmsf.hours * 108000; //30f/s*60s/min*60min/hr
|
|
break;
|
|
|
|
case NTSC_DROP: // see derivation for details!
|
|
frames = _hmsf.hours * 107892; // for every hour
|
|
frames+= _hmsf.minutes * 1800; // for every minute, except...
|
|
|
|
// now take away 2 frames per non-exempted minute!
|
|
frames-= ((_hmsf.minutes - _hmsf.minutes/10) * 2);
|
|
|
|
frames+= _hmsf.seconds * 30;
|
|
frames+= _hmsf.frames;
|
|
break;
|
|
|
|
case PAL_NODROP:
|
|
frames = _hmsf.frames;
|
|
frames+= _hmsf.seconds * 25;
|
|
frames+= _hmsf.minutes * 1500; // 25f/s * 60s/min
|
|
frames+= _hmsf.hours * 90000; //25f/s*60s/min*60min/hr
|
|
break;
|
|
|
|
case PAL_DROP: fprintf(stderr,
|
|
"TimeCode::_HMSfromFrames: PAL_DROP not implemented!\n");
|
|
break;
|
|
|
|
default:
|
|
// XXX really should throw an exception!
|
|
fprintf(stderr,
|
|
"TimeCode::_HMSfromFrames: unknown _timeCodeFormat %d\n",
|
|
_timeCodeFormat);
|
|
break;
|
|
}
|
|
|
|
_frames.frames = frames; // ;)
|
|
_frames.dirty = FALSE;
|
|
}
|
|
|
|
|
|
#ifdef TEST
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
__cdecl
|
|
main()
|
|
{
|
|
// TimeCode tc; // NTSC nondrop
|
|
// TimeCode tc("0:0:0:0", TRUE, FALSE); // NTSC nondrop
|
|
// TimeCode tc("0:0:0:0", FALSE, FALSE); // PAL nondrop
|
|
TimeCode tc1("0:0:0:0", TRUE, TRUE); // NTSC drop
|
|
TimeCode tc2("0:0:0:0", TRUE, TRUE); // NTSC drop
|
|
|
|
char string[TIMECODE_STRING_LENGTH];
|
|
|
|
/* strcpy(string, "1:2:3:4"); */
|
|
strcpy(string, "0:0:0:0");
|
|
|
|
tc1.SetTime(string);
|
|
tc1.GetString(string);
|
|
printf("timecode = <%s>\n", string);
|
|
|
|
int x;
|
|
for (x= 0; x < 200000; x++) {
|
|
tc1++;
|
|
tc1.GetString(string);
|
|
|
|
tc2.SetTime(string);
|
|
|
|
printf("timecode = <%s> %s (%d)\n",
|
|
string, tc1==tc2?"ok":"BAD!!!", (int)tc1.GetTime());
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
#endif /* TEST */
|