Free timing software for linux

Race Timing lets you manage races by describing a race and the rules associated with it. You can time the racers and provide realtime standing of the race participants.

You can manage various race events (pilot changes, refuelling, laps, intermediate sprints, etc.) and broadcast various information to the participants. Race Timing is best used with transponders, but manual operation is also provided.

TinySID project is the smallest SID player available. Its most advantage lies in its unique HardSID support, that is:
- exact C64 PC cycle syncronizing
- multispeed tunes will use the same timing a real C64 does
- improved HardSID sample output (includes mixer)
- support for multiprocessor systems
- Previous versions required just 20kbyte disk space. This was however skipped due to 64bit support.
Main features:
- Multiplatform
- Native 32/64 bit windows support
- Runs on Unix/linux platform
- Playstation Portable (PSP) version available
- Also incorporated in rockbox for portable mp3 players
- Accurate playback on both hardsid and software emulation, includes multispeed tunes
- Digitized sample playback on both hardsid and software emulation
- 99% 6510 cpu emulation (still some bugs to fix)
- Fat 6581 SID emulation, including filters. Sounds different than other players!
Please note that TinySID has nothing to do with other projects such as SIDPlay. The 6510/6581 emulation is based on routines by Tammo Hinrichs (kb) and has been further developed.
Enhancements:
- This release added support for multi-speed tunes and digi-playback.
- Bugs in CPU emulation and endian neutral code were fixed.
- Speedups were achieved in the synth renderer.

Time::Skew is a Perl module that computes local clock skew with respect to a remote clock.

SYNOPISI

use Time::Skew

# Init Convex Hull and timing data
my $hull=[];
my $result={};

# Iterate data point introduction
Time::Skew::convexhull($result,$datapoint,$hull);

This module supports the computation of the skew between two clocks: the (relative) skew is the speed with which two clocks diverge. For instance, if yesterday two clocks, at the same time, showed respectively 10:00 and 10:05, while today when the former shows 10:00 the latter shows 10:04, we say that their relative skew is 1 minute/24 hours, roughly 7E-4.

The module contains one single subroutine, which accepts as input a pair of timestamps, associated to a message from host A to host B: the timestamps correspond to the time when the message was sent, and to the time when message is received. Each timestamp reflects the value of the local clock where the operation takes place: the clock of host A for the send, the clock of B for the receive.

Please note that the module does _not_ contain any message exchange facility, but only the mathematics needed to perform the skew approximation, once timestamps are known.

The subroutine takes as argument:

a reference to a hash where values related to the timing of the network path from A to B;
a 2-elems array (a data point in the sequel) containing the timestamp of the receive event, and the differece between the send timestamp and the receive timestamp for one message;
a stack containing some data points, those that form the convex hull.

The usage is very simple, and is illustrated by the following example:

#!/usr/bin/perl -w
use strict;
use Time::Skew;

# Initialize data
my $hull=[];
my $result={};
while ( 1 ) {
# Exchange message and acquire a new data point
my $datapoint = acquire();
# Call the convexhull subroutine
Time::Skew::convexhull($result,$datapoint,$hull);
# After first message some results are still undefined
( defined $result->{skewjitter} ) || next;
# here you can use the results

};
}

The data returned in the "result" hash is the following:

result->{skew} the clock skew;
result->{skewjitter} the variance of the skew estimate, used to estimate convergence;
result->{jitter} difference between the current delay and the previous delay;
result->{delay} the communication delay, decremented by a constant (yet unknown) value, used to compute communication jitter;
result->{elems} the number of data points in the convex hull;
result->{select} the index of the data point in the convex hull used to compute the skew;
result->{itimestamp} the timestamp, first element in the data point just passed to the subroutine;
result->{delta} the timestamp difference, second element in the data point just passed to the subroutine;

The data returned in the "hull" stack is a series of data points, selected from those passed to successive calls of the subroutine. The number of data points in the "hull" stack usually does not exceed 20 units.

The algorithm is very fast: each call consists in scanning at most all data points in the "hull" stack, performing simple arithmetic operations for each element.

The algorithm must be fed with a sequence of data points before returning significant results. The accuracy of the estimate keeps growing while new data points are passed to the subroutine. A rough rule of thumb to evaluate estimate accuracy is to observe the skew jitter, and assume it corresponds to the skew estimate accuracy. Paths with quite regular communication delay (small jitter) converge faster.

wmmge is a small Window Maker dockapp for monitoring an MGE UPS.
It shows the remaining time, and it blinks if this time is short.
It uses PSP (Personal Solution-Pac) monitor, which can be downloaded from the MGE website: http://www.mgeups.com.
It needs root permissions to send messages to the UPS.
Enhancements:
- now a black background color :)
- added the consommation, and the load.
- modified little things about timing.

Eiffel Windowing System (EWS) is an Eiffel library which provides a small, stand-alone windowing system.
The current implementation is based on the Simple Directmedia Library (SDL), but the design allows other graphical backends.
Besides the basic windowing system functionality (overlapping windows, event passing and handling, graphical operations, input froum mouse and keyboard), a small widget-toolkit is included (buttons, scrollbars, labels, etc.).
Its specially well suited for applications where a fine degree of control over presentation and timing is required. Multimedia applications and games are the usual examples.
Main features:
- Transparency (alpha channel) support
- Can load most standard image formats via libSDL_image (PNG, JPEG, GIF, Windows bitmap...)
- Mostly coded in OO Eiffel. Only a small C module handling SDL interface. All the API is OO.
- Complete control over application appearance.
- Simple design, easily extendible for new event kinds, new widgets, etc.
- Quite fast even in old slow computers (if you compile at require_check level or lower).
- Licensed under the LGPL
Supported widgets:
- The UI toolkit coming with EWS includes
- Buttons: push buttons triggering commands
- Toggle buttons: controls that toggle its state (they may be used to implement checkboxes and radio buttons)
- Text entries: One line text entries, handling cursor keys. Selection not implemented yet (the core is selection capable, but the UI not).
- Labels: A simple text label
- Multiline labels: Labels spanning several lines with optional word-wrapping
- Marquees: Like a label, but scrolling a longer message sideways
- Images: A fixed image
- Animations: An animated area of the screen
- Drag handles: An area that can be dragged to move other window. Useful as titlebars.
- Scrollbars: The usual thing, with buttons at the end and a slider which can be dragged. (only vertical scrollbar implemented now)
- Adding widgets to the toolkit is very simple

Audio Daemon is a perl module to daemonize various players and support a single UDP interace for different players. Currently you can set up a server for MPG123, Xmms and an icecast stream (using libshout).

Audio::Daemon is made of two parts, the client and server.

The Client (Audio::Daemon::Client) remains the same across the board no matter what server you are communicating with, with a few exceptions noted in the pods.

The Server currently can be configured to be MPG123, Xmms or an Icecast (libshout) stream. Neither the Client nor the Servers need to be run as root and I strongly advise against it.

Audio::Daemon::MPG132:
Requires Audio::Play::MPG123 an optionally Audio::Mixer for volume control. It automatically spawns mpg123 in the background so there is no need to prestart it.

Audio::Daemon::Xmms:
Requires the Xmms and MP3::Info perl module and xmms installed. Id suggest getting the latest version of the Xmms perl module. It uses the volume and random feature built into xmms and if it doesnt find an xmms running it will try to spawn its own copy. Bear in mind that
xmms MUST HAVE an X display to export to, and that xmms must be running as the same user Audio::Daemon::Xmms is.

Audio::Daemon::Shout:
This wasnt easy to do. It requires MP3::Info and libshout to be installed (http://developer.icecast.org/libshout/) as well as a functioning icecast server. The timing here is pretty critical so I recomend being careful not to be polling the server too much. Be sure to read the icecast docs as Im still confused on how I got this part to work.

DBIx::Timeout is a Perl module that provides a safe method of timing out DBI requests.

The method described in the DBI documentation uses unsafe signals, which may cause memory corruption. DBIx::Timeout instead uses a separate timeout process.

The problem with using POSIX sigaction() is that it relies on unsafe signals to work. Unsafe signals are well known to cause instability. For example, imagine your DB client code is in the middle of updating some global state when the signal arrives. That global state could be left in an inconsitent state, just wait for the next time it is needed to cause problems. Since this will likely occur far from the cause, and only ocur rarely, it can be a very difficult problem to track down.

Instead, this module:

- Forks a child process which sleeps for $timeout seconds.
- Runs your long-running query in the parent process.
- If the parent process finishes first it kills the child and returns.
- If the child process wakes up it kills the parents DB thread and exits with a code so the parent knows it was timed out.

NOTE: After this call your database connection may be killed even if no timeout occurred. This is due to a race condition - the child may wake up just as parent process finishes. Patches addressing this bug are welcome. Until this is fixed you should be ready to reconnect after call_with_timeout().

GTick project is a desktop metronome application.
GNU GTick is a metronome application. It features a scale from 10 beats per minute to 1000 BPM and arbitrary beat modes (meters). It uses GTK+2 and OSS.
Main features:
- Very easy handling
- Reliable timing
- Volume control
- Different meters (Even, 2/4, 3/4, 4/4, more)
- Configurable speed (10 to 1000 BPM)
- Manual tapping input
- Customizable ticking sound
- Native language support for Afrikaans, Basque, Catalan, Dutch, English, Finnish, French, German, Irish, Italian, Brazilian Portuguese, Romanian, Russian, Spanish, Swedish and Vietnamese
- Separate audio thread for better realtime performance
- Customizable commands for metronome start / stop, e.g. for switching off the screensaver
- Options saved to rc file
- Customizable sound device
- Visual Tick
- Accent Attack Padding
- Configurable Accent Table