allanger/ardour
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Activity

change the use of "SMPTE" to "Timecode" to reflect the global economy and the end of american dominance on the world audio production stage

Browse Source 
git-svn-id: svn://localhost/ardour2/branches/3.0@5924 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Paul Davis
2009-10-26 14:38:58 +00:00
parent 5dd8dc0db3
commit fa5aeb7892
52 changed files with 1231 additions and 1216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
libs/surfaces/control_protocol/basic_ui.cc
View File

@@ -270,25 +270,25 @@ BasicUI::locked ()
}
nframes_t
BasicUI::smpte_frames_per_hour ()
BasicUI::timecode_frames_per_hour ()
{
return session->smpte_frames_per_hour ();
return session->timecode_frames_per_hour ();
}
void
BasicUI::smpte_time (nframes_t where, SMPTE::Time& smpte)
BasicUI::timecode_time (nframes_t where, Timecode::Time& timecode)
{
session->smpte_time (where, *((SMPTE::Time *) &smpte));
session->timecode_time (where, *((Timecode::Time *) &timecode));
}
void
BasicUI::smpte_to_sample (SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes) const
BasicUI::timecode_to_sample (Timecode::Time& timecode, nframes_t& sample, bool use_offset, bool use_subframes) const
{
session->smpte_to_sample (*((SMPTE::Time*)&smpte), sample, use_offset, use_subframes);
session->timecode_to_sample (*((Timecode::Time*)&timecode), sample, use_offset, use_subframes);
}
void
BasicUI::sample_to_smpte (nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes) const
BasicUI::sample_to_timecode (nframes_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const
{
session->sample_to_smpte (sample, *((SMPTE::Time*)&smpte), use_offset, use_subframes);
session->sample_to_timecode (sample, *((Timecode::Time*)&timecode), use_offset, use_subframes);
}

10
libs/surfaces/control_protocol/control_protocol/basic_ui.h
View File

@@ -24,7 +24,7 @@
#include <string>
#include <jack/types.h>
#include <control_protocol/smpte.h>
#include <control_protocol/timecode.h>
namespace ARDOUR {
class Session;
@@ -72,11 +72,11 @@ class BasicUI {
void rec_enable_toggle ();
void toggle_all_rec_enables ();
jack_nframes_t smpte_frames_per_hour ();
jack_nframes_t timecode_frames_per_hour ();
void smpte_time (jack_nframes_t where, SMPTE::Time&);
void smpte_to_sample (SMPTE::Time& smpte, jack_nframes_t& sample, bool use_offset, bool use_subframes) const;
void sample_to_smpte (jack_nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes) const;
void timecode_time (jack_nframes_t where, Timecode::Time&);
void timecode_to_sample (Timecode::Time& timecode, jack_nframes_t& sample, bool use_offset, bool use_subframes) const;
void sample_to_timecode (jack_nframes_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
protected:
BasicUI ();

36
libs/surfaces/control_protocol/control_protocol/smpte.h → libs/surfaces/control_protocol/control_protocol/timecode.h
View File

@@ -16,12 +16,12 @@
675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __ardour_smpte_h__
#define __ardour_smpte_h__
#ifndef __ardour_timecode_h__
#define __ardour_timecode_h__
#include <inttypes.h>
namespace SMPTE {
namespace Timecode {
enum Wrap {
NONE = 0,
@@ -36,11 +36,11 @@ struct Time {
uint32_t hours;
uint32_t minutes;
uint32_t seconds;
uint32_t frames; ///< SMPTE frames (not audio samples)
uint32_t frames; ///< Timecode frames (not audio samples)
uint32_t subframes; ///< Typically unused
float rate; ///< Frame rate of this Time
static float default_rate;///< Rate to use for default constructor
bool drop; ///< Whether this Time uses dropframe SMPTE
bool drop; ///< Whether this Time uses dropframe Timecode
Time(float a_rate = default_rate) {
negative = false;
@@ -53,18 +53,18 @@ struct Time {
}
};
Wrap increment( Time& smpte, uint32_t );
Wrap decrement( Time& smpte, uint32_t );
Wrap increment_subframes( Time& smpte, uint32_t );
Wrap decrement_subframes( Time& smpte, uint32_t );
Wrap increment_seconds( Time& smpte, uint32_t );
Wrap increment_minutes( Time& smpte, uint32_t );
Wrap increment_hours( Time& smpte, uint32_t );
void frames_floor( Time& smpte );
void seconds_floor( Time& smpte );
void minutes_floor( Time& smpte );
void hours_floor( Time& smpte );
Wrap increment( Time& timecode, uint32_t );
Wrap decrement( Time& timecode, uint32_t );
Wrap increment_subframes( Time& timecode, uint32_t );
Wrap decrement_subframes( Time& timecode, uint32_t );
Wrap increment_seconds( Time& timecode, uint32_t );
Wrap increment_minutes( Time& timecode, uint32_t );
Wrap increment_hours( Time& timecode, uint32_t );
void frames_floor( Time& timecode );
void seconds_floor( Time& timecode );
void minutes_floor( Time& timecode );
void hours_floor( Time& timecode );
} // namespace SMPTE
} // namespace Timecode
#endif // __ardour_smpte_h__
#endif // __ardour_timecode_h__

302
libs/surfaces/control_protocol/smpte.cc
View File

@@ -16,186 +16,186 @@
675 Mass Ave, Cambridge, MA 02139, USA.
*/
#define SMPTE_IS_AROUND_ZERO( sm ) (!(sm).frames && !(sm).seconds && !(sm).minutes && !(sm).hours)
#define SMPTE_IS_ZERO( sm ) (!(sm).frames && !(sm).seconds && !(sm).minutes && !(sm).hours && !(sm.subframes))
#define Timecode_IS_AROUND_ZERO( sm ) (!(sm).frames && !(sm).seconds && !(sm).minutes && !(sm).hours)
#define Timecode_IS_ZERO( sm ) (!(sm).frames && !(sm).seconds && !(sm).minutes && !(sm).hours && !(sm.subframes))
#include "control_protocol/smpte.h"
#include "control_protocol/timecode.h"
#include "ardour/rc_configuration.h"
namespace SMPTE {
namespace Timecode {
float Time::default_rate = 30.0;
/** Increment @a smpte by exactly one frame (keep subframes value).
/** Increment @a timecode by exactly one frame (keep subframes value).
* Realtime safe.
* @return true if seconds wrap.
*/
Wrap
increment( Time& smpte, uint32_t subframes_per_frame )
increment( Time& timecode, uint32_t subframes_per_frame )
{
Wrap wrap = NONE;
if (smpte.negative) {
if (SMPTE_IS_AROUND_ZERO(smpte) && smpte.subframes) {
if (timecode.negative) {
if (Timecode_IS_AROUND_ZERO(timecode) && timecode.subframes) {
// We have a zero transition involving only subframes
smpte.subframes = subframes_per_frame - smpte.subframes;
smpte.negative = false;
timecode.subframes = subframes_per_frame - timecode.subframes;
timecode.negative = false;
return SECONDS;
}
smpte.negative = false;
wrap = decrement( smpte, subframes_per_frame );
if (!SMPTE_IS_ZERO( smpte )) {
smpte.negative = true;
timecode.negative = false;
wrap = decrement( timecode, subframes_per_frame );
if (!Timecode_IS_ZERO( timecode )) {
timecode.negative = true;
}
return wrap;
}
switch ((int)ceil(smpte.rate)) {
switch ((int)ceil(timecode.rate)) {
case 24:
if (smpte.frames == 23) {
smpte.frames = 0;
if (timecode.frames == 23) {
timecode.frames = 0;
wrap = SECONDS;
}
break;
case 25:
if (smpte.frames == 24) {
smpte.frames = 0;
if (timecode.frames == 24) {
timecode.frames = 0;
wrap = SECONDS;
}
break;
case 30:
if (smpte.drop) {
if (smpte.frames == 29) {
if ( ((smpte.minutes + 1) % 10) && (smpte.seconds == 59) ) {
smpte.frames = 2;
if (timecode.drop) {
if (timecode.frames == 29) {
if ( ((timecode.minutes + 1) % 10) && (timecode.seconds == 59) ) {
timecode.frames = 2;
}
else {
smpte.frames = 0;
timecode.frames = 0;
}
wrap = SECONDS;
}
} else {
if (smpte.frames == 29) {
smpte.frames = 0;
if (timecode.frames == 29) {
timecode.frames = 0;
wrap = SECONDS;
}
}
break;
case 60:
if (smpte.frames == 59) {
smpte.frames = 0;
if (timecode.frames == 59) {
timecode.frames = 0;
wrap = SECONDS;
}
break;
}
if (wrap == SECONDS) {
if (smpte.seconds == 59) {
smpte.seconds = 0;
if (timecode.seconds == 59) {
timecode.seconds = 0;
wrap = MINUTES;
if (smpte.minutes == 59) {
smpte.minutes = 0;
if (timecode.minutes == 59) {
timecode.minutes = 0;
wrap = HOURS;
smpte.hours++;
timecode.hours++;
} else {
smpte.minutes++;
timecode.minutes++;
}
} else {
smpte.seconds++;
timecode.seconds++;
}
} else {
smpte.frames++;
timecode.frames++;
}
return wrap;
}
/** Decrement @a smpte by exactly one frame (keep subframes value)
/** Decrement @a timecode by exactly one frame (keep subframes value)
* Realtime safe.
* @return true if seconds wrap. */
Wrap
decrement( Time& smpte, uint32_t subframes_per_frame )
decrement( Time& timecode, uint32_t subframes_per_frame )
{
Wrap wrap = NONE;
if (smpte.negative || SMPTE_IS_ZERO(smpte)) {
smpte.negative = false;
wrap = increment( smpte, subframes_per_frame );
smpte.negative = true;
if (timecode.negative || Timecode_IS_ZERO(timecode)) {
timecode.negative = false;
wrap = increment( timecode, subframes_per_frame );
timecode.negative = true;
return wrap;
} else if (SMPTE_IS_AROUND_ZERO(smpte) && smpte.subframes) {
} else if (Timecode_IS_AROUND_ZERO(timecode) && timecode.subframes) {
// We have a zero transition involving only subframes
smpte.subframes = subframes_per_frame - smpte.subframes;
smpte.negative = true;
timecode.subframes = subframes_per_frame - timecode.subframes;
timecode.negative = true;
return SECONDS;
}
switch ((int)ceil(smpte.rate)) {
switch ((int)ceil(timecode.rate)) {
case 24:
if (smpte.frames == 0) {
smpte.frames = 23;
if (timecode.frames == 0) {
timecode.frames = 23;
wrap = SECONDS;
}
break;
case 25:
if (smpte.frames == 0) {
smpte.frames = 24;
if (timecode.frames == 0) {
timecode.frames = 24;
wrap = SECONDS;
}
break;
case 30:
if (smpte.drop) {
if ((smpte.minutes % 10) && (smpte.seconds == 0)) {
if (smpte.frames <= 2) {
smpte.frames = 29;
if (timecode.drop) {
if ((timecode.minutes % 10) && (timecode.seconds == 0)) {
if (timecode.frames <= 2) {
timecode.frames = 29;
wrap = SECONDS;
}
} else if (smpte.frames == 0) {
smpte.frames = 29;
} else if (timecode.frames == 0) {
timecode.frames = 29;
wrap = SECONDS;
}
} else {
if (smpte.frames == 0) {
smpte.frames = 29;
if (timecode.frames == 0) {
timecode.frames = 29;
wrap = SECONDS;
}
}
break;
case 60:
if (smpte.frames == 0) {
smpte.frames = 59;
if (timecode.frames == 0) {
timecode.frames = 59;
wrap = SECONDS;
}
break;
}
if (wrap == SECONDS) {
if (smpte.seconds == 0) {
smpte.seconds = 59;
if (timecode.seconds == 0) {
timecode.seconds = 59;
wrap = MINUTES;
if (smpte.minutes == 0) {
smpte.minutes = 59;
if (timecode.minutes == 0) {
timecode.minutes = 59;
wrap = HOURS;
smpte.hours--;
timecode.hours--;
}
else {
smpte.minutes--;
timecode.minutes--;
}
} else {
smpte.seconds--;
timecode.seconds--;
}
} else {
smpte.frames--;
timecode.frames--;
}
if (SMPTE_IS_ZERO( smpte )) {
smpte.negative = false;
if (Timecode_IS_ZERO( timecode )) {
timecode.negative = false;
}
return wrap;
@@ -204,68 +204,68 @@ decrement( Time& smpte, uint32_t subframes_per_frame )
/** Go to lowest absolute subframe value in this frame (set to 0 :-) ) */
void
frames_floor( Time& smpte )
frames_floor( Time& timecode )
{
smpte.subframes = 0;
if (SMPTE_IS_ZERO(smpte)) {
smpte.negative = false;
timecode.subframes = 0;
if (Timecode_IS_ZERO(timecode)) {
timecode.negative = false;
}
}
/** Increment @a smpte by one subframe */
/** Increment @a timecode by one subframe */
Wrap
increment_subframes( Time& smpte, uint32_t subframes_per_frame )
increment_subframes( Time& timecode, uint32_t subframes_per_frame )
{
Wrap wrap = NONE;
if (smpte.negative) {
smpte.negative = false;
wrap = decrement_subframes( smpte, subframes_per_frame );
if (!SMPTE_IS_ZERO(smpte)) {
smpte.negative = true;
if (timecode.negative) {
timecode.negative = false;
wrap = decrement_subframes( timecode, subframes_per_frame );
if (!Timecode_IS_ZERO(timecode)) {
timecode.negative = true;
}
return wrap;
}
smpte.subframes++;
if (smpte.subframes >= subframes_per_frame) {
smpte.subframes = 0;
increment( smpte, subframes_per_frame );
timecode.subframes++;
if (timecode.subframes >= subframes_per_frame) {
timecode.subframes = 0;
increment( timecode, subframes_per_frame );
return FRAMES;
}
return NONE;
}
/** Decrement @a smpte by one subframe */
/** Decrement @a timecode by one subframe */
Wrap
decrement_subframes( Time& smpte, uint32_t subframes_per_frame )
decrement_subframes( Time& timecode, uint32_t subframes_per_frame )
{
Wrap wrap = NONE;
if (smpte.negative) {
smpte.negative = false;
wrap = increment_subframes( smpte, subframes_per_frame );
smpte.negative = true;
if (timecode.negative) {
timecode.negative = false;
wrap = increment_subframes( timecode, subframes_per_frame );
timecode.negative = true;
return wrap;
}
if (smpte.subframes <= 0) {
smpte.subframes = 0;
if (SMPTE_IS_ZERO(smpte)) {
smpte.negative = true;
smpte.subframes = 1;
if (timecode.subframes <= 0) {
timecode.subframes = 0;
if (Timecode_IS_ZERO(timecode)) {
timecode.negative = true;
timecode.subframes = 1;
return FRAMES;
} else {
decrement( smpte, subframes_per_frame );
smpte.subframes = 79;
decrement( timecode, subframes_per_frame );
timecode.subframes = 79;
return FRAMES;
}
} else {
smpte.subframes--;
if (SMPTE_IS_ZERO(smpte)) {
smpte.negative = false;
timecode.subframes--;
if (Timecode_IS_ZERO(timecode)) {
timecode.negative = false;
}
return NONE;
}
@@ -274,40 +274,40 @@ decrement_subframes( Time& smpte, uint32_t subframes_per_frame )
/** Go to next whole second (frames == 0 or frames == 2) */
Wrap
increment_seconds( Time& smpte, uint32_t subframes_per_frame )
increment_seconds( Time& timecode, uint32_t subframes_per_frame )
{
Wrap wrap = NONE;
// Clear subframes
frames_floor( smpte );
frames_floor( timecode );
if (smpte.negative) {
if (timecode.negative) {
// Wrap second if on second boundary
wrap = increment(smpte, subframes_per_frame);
wrap = increment(timecode, subframes_per_frame);
// Go to lowest absolute frame value
seconds_floor( smpte );
if (SMPTE_IS_ZERO(smpte)) {
smpte.negative = false;
seconds_floor( timecode );
if (Timecode_IS_ZERO(timecode)) {
timecode.negative = false;
}
} else {
// Go to highest possible frame in this second
switch ((int)ceil(smpte.rate)) {
switch ((int)ceil(timecode.rate)) {
case 24:
smpte.frames = 23;
timecode.frames = 23;
break;
case 25:
smpte.frames = 24;
timecode.frames = 24;
break;
case 30:
smpte.frames = 29;
timecode.frames = 29;
break;
case 60:
smpte.frames = 59;
timecode.frames = 59;
break;
}
// Increment by one frame
wrap = increment( smpte, subframes_per_frame );
wrap = increment( timecode, subframes_per_frame );
}
return wrap;
@@ -317,55 +317,55 @@ increment_seconds( Time& smpte, uint32_t subframes_per_frame )
/** Go to lowest (absolute) frame value in this second
* Doesn't care about positive/negative */
void
seconds_floor( Time& smpte )
seconds_floor( Time& timecode )
{
// Clear subframes
frames_floor( smpte );
frames_floor( timecode );
// Go to lowest possible frame in this second
switch ((int)ceil(smpte.rate)) {
switch ((int)ceil(timecode.rate)) {
case 24:
case 25:
case 30:
case 60:
if (!(smpte.drop)) {
smpte.frames = 0;
if (!(timecode.drop)) {
timecode.frames = 0;
} else {
if ((smpte.minutes % 10) && (smpte.seconds == 0)) {
smpte.frames = 2;
if ((timecode.minutes % 10) && (timecode.seconds == 0)) {
timecode.frames = 2;
} else {
smpte.frames = 0;
timecode.frames = 0;
}
}
break;
}
if (SMPTE_IS_ZERO(smpte)) {
smpte.negative = false;
if (Timecode_IS_ZERO(timecode)) {
timecode.negative = false;
}
}
/** Go to next whole minute (seconds == 0, frames == 0 or frames == 2) */
Wrap
increment_minutes( Time& smpte, uint32_t subframes_per_frame )
increment_minutes( Time& timecode, uint32_t subframes_per_frame )
{
Wrap wrap = NONE;
// Clear subframes
frames_floor( smpte );
frames_floor( timecode );
if (smpte.negative) {
if (timecode.negative) {
// Wrap if on minute boundary
wrap = increment_seconds( smpte, subframes_per_frame );
wrap = increment_seconds( timecode, subframes_per_frame );
// Go to lowest possible value in this minute
minutes_floor( smpte );
minutes_floor( timecode );
} else {
// Go to highest possible second
smpte.seconds = 59;
timecode.seconds = 59;
// Wrap minute by incrementing second
wrap = increment_seconds( smpte, subframes_per_frame );
wrap = increment_seconds( timecode, subframes_per_frame );
}
return wrap;
@@ -374,36 +374,36 @@ increment_minutes( Time& smpte, uint32_t subframes_per_frame )
/** Go to lowest absolute value in this minute */
void
minutes_floor( Time& smpte )
minutes_floor( Time& timecode )
{
// Go to lowest possible second
smpte.seconds = 0;
timecode.seconds = 0;
// Go to lowest possible frame
seconds_floor( smpte );
seconds_floor( timecode );
if (SMPTE_IS_ZERO(smpte)) {
smpte.negative = false;
if (Timecode_IS_ZERO(timecode)) {
timecode.negative = false;
}
}
/** Go to next whole hour (minute = 0, second = 0, frame = 0) */
Wrap
increment_hours( Time& smpte, uint32_t subframes_per_frame )
increment_hours( Time& timecode, uint32_t subframes_per_frame )
{
Wrap wrap = NONE;
// Clear subframes
frames_floor(smpte);
frames_floor(timecode);
if (smpte.negative) {
if (timecode.negative) {
// Wrap if on hour boundary
wrap = increment_minutes( smpte, subframes_per_frame );
wrap = increment_minutes( timecode, subframes_per_frame );
// Go to lowest possible value in this hour
hours_floor( smpte );
hours_floor( timecode );
} else {
smpte.minutes = 59;
wrap = increment_minutes( smpte, subframes_per_frame );
timecode.minutes = 59;
wrap = increment_minutes( timecode, subframes_per_frame );
}
return wrap;
@@ -412,17 +412,17 @@ increment_hours( Time& smpte, uint32_t subframes_per_frame )
/** Go to lowest absolute value in this hour */
void
hours_floor( Time& smpte )
hours_floor( Time& timecode )
{
smpte.minutes = 0;
smpte.seconds = 0;
smpte.frames = 0;
smpte.subframes = 0;
timecode.minutes = 0;
timecode.seconds = 0;
timecode.frames = 0;
timecode.subframes = 0;
if (SMPTE_IS_ZERO(smpte)) {
smpte.negative = false;
if (Timecode_IS_ZERO(timecode)) {
timecode.negative = false;
}
}
} // namespace SMPTE
} // namespace Timecode