🚀 go-pugleaf

I'll have to admit that I'm not familiar with the deep details of
QuickTime, the X Synchronization Extension and other "multimedia"
systems, so if this is something already available, then all the
better.

One of the problems I've seen with multimedia systems is that they
provide support for developing "all-in-one" programs, but not really
for dealing with multiple synced programs.

As an example, let's say I have a program that can display graphics
along with a digital soundtrack.  Now, let's say I have a video camera
and display that I can control from my computer, and I want to be able
to display "pictures" in sync with my graphics/sountrack program.

One way to deal with this is to develop my own program to display the
graphics/soundtrack so that I can more easily sync to the data.  This
may require quite a bit of work, and it may not really do what I want.

Also, there's an additional problem of how to deal with programming
systems that need different kinds of event loops, as well as those that
aren't event driven at all.  For example, trying to write such a
program using X for graphics, something else for video control
(assuming VEX isn't available and XV doesn't control my device), and
something else for synced sound would be a mess -- doable, but a mess.

It seems to me that the ultimate would be to have a centralized timing
service.  Such a service would allow the user to create named "clocks",
which programs could attach to to get timing events.

With this type of service, one could write programs to add capabilities
to existing programs, or build entire multimedia systems out of
separate programs.  In the example above, I could write a separate
program that would control my video camera and display in sync with the
other program.  I would only have to set the cue points ("hits") and
ask the timing service to tell me when one of these times has occurred,
or when the program has paused, or restarted, or reset, or changed time
base, or whatever.

A real advantage to this is that it would not require continually
extending existing programming systems to add new capabilities.  Another
is that hardware-specific additions could be made without having to
revamp the entire subsystem.