Free warp software for linux

Time::Warp is a Perl module to control over the flow of time.

SYNOPSIS

use Time::Warp qw(scale to time);

to(time + 5); # 5 seconds ahead
scale(2); # make time flow twice normal

Our external experience unfolds in 3 1/2 dimensions (time has a dimensionality of 1/2). The Time::Warp module offers developers control over the measurement of time.

API

to($desired_time)

The theory of relativity asserts that all physical laws are enforced relative to the observer. Since the starting point of time is arbitrary, it is permissable to change it. This has the effect of making it appear as if time is moving forwards or backward instanteously. For example, on some types of operating systems time starts at Wed Dec 31 19:00:00 1969 (this will likely change as we approach 2030 and with the acceptance of 64-bit CPUs).

to(time + 60*60); # 1 hour ahead

scale($factor)

Changes the speed at which time is progressing.

scale(scale * 2); # double the speed of time

Note that it is not possible to stop time or cause it to reverse since this is forbidden by the second law of thermodynamics.

Config::Model::WarpedThing is a base class for warped classes.

SYNOPSIS

use base qw/Config::Model::WarpedThing/ ;

This class must be inherited by all classes that can be warped by Config::Model::Value. This class provides a set of methods that are expected by a warp master from a warped class.

Currently this class is inherited by Config::Model::Value, Config::Model::AnyId and Config::Model::WarpedNode.

WarpThing does not provide a constructor.

Japa short from JACK and ALSA Perceptual Analyser is a perceptual or psychoacoustic audio spectrum analyser.

In contrast to JAAA, this is more an acoustical or musical tool than a purely technical one.

Possible uses include spectrum monitoring while mixing or mastering, evaluation of ambient noise, and (using pink noise), equalisation of PA systems.

JAPA allows you to measure two inputs at the same time, compare them, store them to memory and compare them to stored traces. It offers a number of resolutions, speeds, and various display options. The dual inputs and memories will find their way into future JAAA versions as well.

Display controls:

The controls below the spectrum window modify only the way things are presented, and not the actual measurement.

Range: Vertical display range, 20, 40, 60 or 80 dB. There are two scales. The one at the left is used for absolute displays. The one at the right always has 0 dB at half scale and is used when comparing two signals.

Scale: Controls the frequency scale. Grid lines are one octave apart, minor ticks are 1/3 octave. The default scale is logarithmic with ticks the standard 1/3 octave frequencies. There are two alternatives:

440 Hz log scale (click ) This follows the filter bandwidths, i.e. all filters will have the same width on the screen. The exact layout of this scale depends on the "warp factor" (see below).

Resp: The normal frequency response is flat in the sense that it will correctly indicate the level of a sine wave at all frequencies. The Prop setting adds a correction that is inversely proportional to the relative bandwidth of each filter. This will give a flat display when the input is pink noise.

Input controls:

There are two channels, called A and B. Each of them can be connected to one of four inputs, or switched off (this conserves CPU cycles - switching off the corresponding trace display does not).

Below the input selection is the gain control. Input gain can be set in steps of 5 dB. There are two more buttons:

Auto: Sets the gain based on the current signal level. This a momentary action.

Lnk: The second channels gain can be linked to the first for stereo operation. This includes the Auto function.

Analyser controls

Resol: Resolution of the filter bank. This sets the FFT size to 128, 256, or 512. The number of filters effectively used is almost equal to this number (japa interpolates between FFT bins to give correct amplitudes at all frequencies).

Warp: JAPA uses a warped FFT to analyse the spectrum. Frequency warping is done by replacing each delay element in the digital processing by an all-pass filter. This control allows you to set the warp factor, and this in turn determines how the filter bandwidths change as a function of the center frequency. You can see the warped scales by selecting the Warp option in the Scale display control. The default setting corresponds closely to the Bark scale. Higher values give more detail in the lower frequency range at the expense of the higher.

Speed: This controls the averaging filters that follow the spectrum analyser. The Low setting is mainly for noise measurement.

Memory store controls:

Each channel has a peak hold function. Note that this operates *after* the averaging done in the analyser and set by the Speed controls. There are two memories called X and Y. The current data for each channel can be stored to either memory. When the peak hold function is active, the current peak values are stored.

Note: the peak hold function and the two memories are reset when either the Resolution or Warp factor are changed. This may change in future versions.

Note: the gain controls are shown as part of the input blocks, but in reality the gain is applied only much later: when a trace is displayed or stored to memory. The result is that the peak hold function is not disturbed by changing the gain.

Trace display controls:

Three traces can be displayed at any time, and each row controls one of them. Options of the form A/B compare two inputs or memories. This means that the difference in dB between them is displayed rather than the actual levels.

ParaView project is an application designed with the need to visualize large data sets in mind. The goals of the ParaView project include the following:
- Develop an open-source, multi-platform visualization application.
- Support distributed computation models to process large data sets.
- Create an open, flexible, and intuitive user interface.
- Develop an extensible architecture based on open standards.
ParaView runs on distributed and shared memory parallel as well as single processor systems and has been succesfully tested on Windows, Linux and various Unix workstations and clusters. Under the hood, ParaView uses the Visualization Toolkit as the data processing and rendering engine and has a user interface written using a unique blend of Tcl/Tk and C++. Please go here for a detailed list of features.
ParaView was created by Kitware in conjunction with Jim Ahrens of the Advanced Computing Laboratory at Los Alamos National Laboratory (LANL). Contributors and developers of ParaView currently include: Kitware, LANL, Sandia National Laboratories, and Army Research Laboratory. ParaView is funded by the US Department of Energy ASCI Views program as part of a three-year contract awarded to Kitware, Inc. by a consortium of three National Labs - Los Alamos, Sandia, and Livermore. The goal of the project is to develop scalable parallel processing tools with an emphasis on distributed memory implementations. The project includes parallel algorithms, infrastructure, I/O, support, and display devices. One significant feature of the contract is that all software developed is to be delivered open source. Hence ParaView is available as an open-source system.
Main features:
- Handles structured (uniform rectilinear, non-uniform rectilinear, and curvilinear grids), unstructured, polygonal and image data.
- All processing operations (filters) produce datasets. This allows the user to either further process or save as a data file the result of every operation. For example, the user can extract a cut surface, reduce the number of points on this surface by masking, and apply glyphs (for example, vector arrows) to the result.
- Contours and isosurfaces can be extracted from all data types using scalars or vector components. The results can be colored by any other variable or processed further. When possible, structured data contours/isosurfaces are extracted with fast and efficient algorithms which make use of the special data layout.
- Vectors fields can be inspected by applying glyphs (arrows, cones, lines, spheres, and various 2D glyphs) to the points in a dataset. The glyphs can be scaled by scalars, vector component or vector magnitude and can be oriented using a vector field.
- A sub-region of a dataset can be extracted by cutting or clipping with an arbitrary plane (all data types), specifying a threshold criteria to exclude cells (all data types) and/or specifying a VOI (volume of interest - structured data types only)
- Streamlines can be generated using constant step or adaptive integrators. The results can be displayed as points, lines, tubes, ribbons, etc., and can be processed by a multitude of filters.
- The points in a dataset can be warped (displaced) with scalars (given a user defined displacement vector) or with vectors (unavailable for non-linear rectilinear grids).
- With the array calculator, new variables can be computed using existing point or cell field arrays. A multitude of scalar and vector operations are supported.
- Data can be probed at a point or along a line. The results are displayed either graphically or as text and can be exported for further analysis.
- ParaView provides many other data sources and filters by default (edge extraction, surface extraction, reflection, decimation, extrusion, smoothing...) and any VTK filter can be added by providing a simple XML description (VTK provides hundreds of sources and filters, see VTK documentation for a complete list).
Enhancements:
- This release adds parallel uniform rectilinear grid volume rendering (vtkImageData).
- It introduces new algorithms for parallel unstructured grid volume rendering.
- Support for hardware accelerated offscreen rendering using OpenGL framebuffers.
- Improved multi-block support.
- Improved AMR support.
- Animation saving with ffmpeg.
- Filters have been added for FLUENT, OpenFOAM, MFIX, LSDyna, and AcuSolve.
- A gradient filter for unstructured data.
- Many other enhancements and bugfixes.

Games::Irrlicht is a Perl module that use the Irrlicht 3D Engine in Perl.

SYNOPSIS

package MyGame;
use strict;

use base Games::Irrlicht;

use Games::Irrlicht::Constants; get EDT_SOFTWARE etc

# override methods:

The Why

When building a game or screensaver displaying some continously running animation, a couple of basics need to be done to get a smooth animation and to care of copying with varying speeds of the system. Ideally, the animation displayed should be always the same, no matter how fast the system is.

This not only includes different systems (a PS/2 for instance would be slower than a 3 Ghz PC system), but also changes in the speed of the system over time, for instance when a background process uses some CPU time or the complexity of the scene changes.

In many old (especial DOS) games, like the famous Wing Commander series, the animation would be drawn simple as fast as the system could, meaning that if you would try to play such a game on a modern machine it we end before you had the chance to click a button, simple because it wizzes a couple 10,000 frames per second past your screen.

While it is quite simple to restrict the maximum framerate possible, care must be taken to not just "burn" surplus CPU cycles. Instead the application should free the CPU whenever possible and give other applications/thread a chance to run. This is especially important for low-priority applications like screensavers.

Games::Irrlicht makes this possible for you without you needing to worry about how this is done. It will restrict the frame rate to a possible maximum and tries to achive the average framerate as close as possible to this maximum.

Games::Irrlicht also monitors the average framerate and gives you access to this value, so that you can, for instance, adjust the scene complexity based on the current framerate. You can access the current framerate, averaged over the last second (1000 ms) by calling current_fps.

Frame-rate Independend Clock

Now that our application is drawing frames (via the method draw_frame, which you should override in a subclass), we need a method to decouple the animation speed from the framerate.
If we would simple put put an animation step every frame, we would get some sort of Death of the Fast Machine" effect ala Wing Commander. E.g. if the system manages only 10 FPS, the animation would be slower than when we do 60 FPS.

To achive this, SDL::App::FPS features a clock, which runs independed of the current frame rate (and actually, independend of the systems clock, but more on this in the next section).
You can access it via a call to current_time, and it will return the ticks e.g. the number of milliseconds elapsed since the start of the application.

To effectively decouple animation speed from FPS, get at each frame the current time, then move all objects (or animation sequences) according to their speed and display them at the location that matches the time at the start of the frame. See examples/ for an example on how to do this.

Note that it is better to draw all objects according to the time at the start of the frame, and not according to the time when you draw a particular object. Or in other words, treat the time like it is standing still when drawing a complete frame. Thus each frame becomes a snapshot in time, and you dont get nasty sideeffects like one object beeing always "behind" the others just because it gets drawn earlier.

Time Warp

Now that we have a constant animation speed independend from framerate or system speed, lets have some fun.

Since all our animation steps are coupled to the current time, we can play tricks with the current time.

The function time_warp lets you access a time warp factor. The default is 1.0, but you can set it to any value you like. If you set it, for instance to 0.5, the time will pass only half as fast as it used to be. This means instant slow motion! And when you really based all your animation on the current time, as you should, then it will really slow down your entire game to a crawl.

Likewise a time warp of 2 lets the time pass twice as fast. There are virtually no restrictions to the time warp.

For instance, a time warp greater than one lets the player pass boring moments in a game, for instance when you need to wait for certain events in a strategy game, like your factory beeing completed.

Try to press the left (fast forward), right (slow motion) and middle (normal) mousebuttons in the example application and watch the effect.

If you are very bored, press the b key and see that even negative time warps are possible...

Ramping Time Warp

Now, setting the time war to factor of N is nice, but sometimes you want to make dramatic effects, like slowly freezing the time into ultra slow motion or speeding it up again.

For this, ramp_time_warp can be used. You give it a time warp factor you want to reach, and a time (based on real time, not the warped, but you can of course change this). Over the course of the time you specified, the time warp factor will be adapted until it reaches the new value. This means it is possible to slowly speeding up or down.

You can also check whether the time warp is constant or currently ramping by using time_is_ramping. When a ramp is in effect, call ramp_time_warp without arguments to get the current parameters. See below for details.

The example application uses the ramping effect instead instant time warp.

Event handlers

This section describes events as external events that typically happen due to user intervention.
Such events are keypresses, mouse movement, mouse button presses, or just the flipping of the power switch. Of course the last event cannot be handled in a sane way by our framework.

All the events are checked and handled by Games::Irrlicht automatically. The event QUIT (which denotes that the application should shut down) is also carried out automatically. If you want to do some tidying up when this happens, override the method quit_handler.

The event checking and handling is done at the start of each frame. This means no event will happen while you draw the current frame. Well, it will happen, but the action caused by that event will delayed until the next frame starts. This simplifies the frame drawing routine tremendously, since you know that your world will be static until the next frame.

NewVideoRecorder is a high quality video capture toolkit for Linux. At the moment it supports v4l1 and v4l2 devices as video sources, oss and alsa as an audio source. It can output to quicktime (in RTjpeg, YUV2, or RAW format, and most ffmpeg formats), AVI (in DivX format), NuppelVideo format, MPEG-1, and streaming multicast/unsicast.
nvrec includes deep buffering to minimise frame drops, in high load situations, and a smooth framedropping algorithm to keep the video as smooth as possible if you do have to drop frames.
It also has a audio "stretcher" to write the exact amount of audio to the output file (this compensates for lack of clock synch between video and audio cards). nvrec is written in an extremely modular way, to make it easy to integrate with existing applications, or add your own output formats.
This engine makes use of deep buffers (2 seconds+) for audio and video. The video is buffered in the driver to avoid too many costly userspace copies. The audio is buffered in a userspace ring buffer. This is expensive, but neccessary, as OSS drivers are often limited to very short buffers.
All buffers are accurately timestamped as they are received: video buffers by the kernel, and audio buffers by gettimeofday() (offset by the current depth of the kernel buffer). At the start, audio or video is dropped until both are in sync, and from then on, only audio and video timestamped for the same period is processed.
Since there will be clock drift between the audio capture and video capture cards, the audio stream is dynamically warped so that exactly the right amount of audio is placed in the output file for each video frame written to the file (NOTE: At the moment the warping is done by a simple line algorithm - could do a lot better here). A simple P-I controller adjusts the warping factor to keep sync.
The code tries to keep the internal buffers between 10% (to make sure we never run out of data) and 40% (to make sure we don;t have uncontrolled dropping) full. When the buffer is less than 10% full, it simply sleeps 1 frame period. When the buffer is more than 40% full, it gradually drops more frames per sencond, until a stable point is reached.
The code is designed to be very modular, so there should be no problem adding an alsa core.
There are currently five output cores: qtfile_core, which produces RTjpeg, YUV2 or RAW encoded quicktime files; divxfile_core, which produces DivX encoded avi files; nuvfile_core, which produces NuppelVideo0.4 files; rtefile_core, which produces mpeg-1 program streams; and ffmpegfile_core, which produces a lot of types of files, like mpeg4, mpeg2, mpeg1, wmv, dv, h263... (see documentation in ffmpeg.sf.net).
Enhancements:
- Added support for recording radio (in devices with support for that
- Fixed ffmpegrec support, updating the code to use the new libavcodec api and new libavformat api (ffmpeg cvs release 2004-07-09 checked)
- Fixed some bugs in the calls to v4l2 api (kernel 2.6.4).
- Added support for split files on the fly, by specify the size of each chunk and the basename used for each file.
- Fixed some compile warnings. The code compiles without problems in gcc 2.95 and gcc 3.3.

Gcover is a cd cover editor program for the Gnome community. Its my first development under Linux/C/Gnome so dont take it too hard. There are two reasons why I release this program:
I think it is quite useful If you want to create nice covers for your "home made" cds (eg.:audio cds from mp3s or data cds).
I couldnt find any good cover editor program for Gnome.
Main features:
- Different kind of covers (One or two back pages,booklet for your front pages or simple 2 paged front)
- Title text,page text with different fonts and colors. Many text formatting opportunities(eg.:margins,alignment,columns,word warp,etc..)
- Picture for every pages with scaling options,border cutting,different interpolation modes(using the power of gdk-pixbuf),etc..
- Printing to postscript output,real printers. Print preview.
- Plain text loading to the page editor or to the internal clipboard
- And so on... Its better if you look the program