Free sp software for linux

libspectrum is a library designed to make the input and output of some ZX Spectrum emulator files slightly easier.

libspectrum is intended to be usable on Unix variants, Mac OS X and Win32. Currently, it is mainly (only?) used by Fuse, but other Spectrum emulator and utility authors are encouraged to use it.

Which formats does it support?

Snapshots:

read/write: .z80, .szx, .sna
read only: .zxs, .sp., .snp, +D snapshots

Tape images:

read/write: .tzx, .tap
read only: Warajevo .tap

Input recordings:

read/write: .rzx

Timex cartridges:

read only: .dck

Compressed files: reading of gzipped and bzipped files is transparently supported.

SpeedyCGI is a Perl module to speed up perl scripts by running them persistently.

SYNOPSIS

#!/usr/bin/speedy

### Your Script Here. For example:
print "Content-type: text/htmlnnHello World!n";

##
## Optionally, use the CGI::SpeedyCGI module for various things
##

# Create a SpeedyCGI object
use CGI::SpeedyCGI;
my $sp = CGI::SpeedyCGI->new;

# See if we are running under SpeedyCGI or not.
print "Running under speedy=", $sp->i_am_speedy ? yes : no, "n";

# Register a shutdown handler
$sp->add_shutdown_handler(sub { do something here });

# Register a cleanup handler
$sp->register_cleanup(sub { do something here });

# Set/get some SpeedyCGI options
$sp->setopt(timeout, 30);
print "maxruns=", $sp->getopt(maxruns), "n";

SpeedyCGI is a way to run perl scripts persistently, which can make them run much more quickly. A script can be made to to run persistently by changing the interpreter line at the top of the script from:

#!/usr/bin/perl

to

#!/usr/bin/speedy

After the script is initially run, instead of exiting, the perl interpreter is kept running. During subsequent runs, this interpreter is used to handle new executions instead of starting a new perl interpreter each time. A very fast frontend program, written in C, is executed for each request. This fast frontend then contacts the persistent Perl process, which is usually already running, to do the work and return the results.

By default each perl script runs in its own Unix process, so one perl script cant interfere with another. Command line options can also be used to deal with programs that have memory leaks or other problems that might keep them from otherwise running persistently.

SpeedyCGI can be used to speed up perl CGI scripts. It conforms to the CGI specification, and does not run perl code inside the web server. Since the perl interpreter runs outside the web server, it cant cause problems for the web server itself.

SpeedyCGI also provides an Apache module so that under the Apache web server, scripts can be run without the overhead of doing a fork/exec for each request. With this module a small amount of frontend code is run within the web server - the perl interpreters still run outside the server.

SpeedyCGI and PersistentPerl are currently both names for the same code. SpeedyCGI was the original name, but because people werent sure what it did, the name PersistentPerl was picked as an alias. At some point SpeedyCGI will be replaced by PersistentPerl, or become a sub-class of PersistentPerl to avoid always having two distributions.

smtp_wrapper is a daemon program that acts as an SMTP proxy for Unix-like systems. smtp_wrapper project supports SMTP filtering of spam.
Usage:
smtp_wrapper [-mh hostname] [-mp port] [-q backlog]
[-sh smtpserver_hostname] [-sp smtpserver_port]
[-t timeout_sec] [-d delay_sec] [-if ip_filter]
[-f contents_filter] [-cm child_max] [-i minimum_interval_sec]
[-F]
-mh hostname : my hostname [ANY]
-mp port : my port [25]
-q backlog : socket queue number [5]
-sh smtpserver_hostname : real smtp hostname [localhost]
-sp smtpserver_port : real smtp port [8025]
-t timeout_sec : timeout second [no timeout]
-d delay_sec : delay second for initial connection [0]
-if ip_filter : filter program for IP check [/usr/local/smtp_wrapper/smtp_ip_filter]
-f contents_filter : filter program for contents check [/usr/local/smtp_wrapper/smtp_contents_filter]
-cm child_max : max number of connection to real smtp daemon [10]
-i minimum_interval_sec : minimum interval second of connection from same ip address [0]
-F : run in foreground
Enhancements:
- This release adds -nsc (no sequence check).
- It adds a sample filter script.
- There are minor bugfixes and some enhancements.

SystemC::SystemPerl is a SystemPerl Language Extension to SystemC.

SystemPerl is a version of the SystemC language. It is designed to expand text so that needless repetition in the language is minimized. By using sp_preproc, SystemPerl files can be expanded into C++ files at compile time, or expanded in place to make them valid stand-alone SystemC files.

The concept of SystemPerl is based upon the AUTOS in the verilog-mode package for Emacs, by the same author.

LANGUAGE

#sp
#sp directives are recognized by SystemPerl to split up files and control preprocessing. Use of any #sps forces use of SystemPerl preprocessing, and removes full SystemC compatibility.

/*AUTOS*/

AUTOmatics provide a way of expanding interconnections, while potentially retaining fully compatible SystemC code. The preprocessor can edit the source code file directly, resulting in the source code having the expanded automatics.
Code with expanded AUTOs are fully valid SystemC code, and can be sent to anyone who does not even have system perl. Anyone with SystemPerl has the benefit of being able to automatically regenerate them, and saves coding time.

ruby2shoes combines Emacs and Python to create a sophisticated writing environment for screenplay and fiction writers.

Emacs modes are used to create .sp or .fc files. Spirit, a Python application, then archives these files, converts them to text, HTML, or LaTeX, or prints them in a variety of ways.

Ogle is a real DVD player that supports DVD menus and navigation. It can access CSS-protected DVDs if you have libdvdcss installed, take screen shots, and view movies in fullscreen mode.
It handles angles correctly and automatically uses the correct aspect. You can switch subtitles and audio tracks. It runs on Linux, FreeBSD, NetBSD, OpenBSD, and Solaris.
Main features:
- Supports DVD menus and navigation.
- Reads from mounted, unmounted DVDs and hard drive.
- Reads encrypted and unencrypted DVDs using libdvdread/libdvdcss.
- A new MPEG2 decoder with MMX, Altivec and SUN Solaris mediaLib acceleration.
- Normal X11 and XFree86 Xvideo display support with subpicture overlay.
- Accelerated display on Sun FFB2+ cards.
- Audio and subpicture selection.
- Handles advanced subpicture commands such as fade/scroll and wipe.
- Detects and uses correct aspect for movie and menus.
- Possible to play AC3, DTS, MPEG, LPCM via S/PDIF.
- Hardware yuv2rgb on Sun FFB2+ (Creator3D).
- Fullscreen mode.
- Screenshots with and without subpicture overlay.
- Title/chapter search.
- Audio formats supported: AC-3, MPEG, LPCM (DTS only via SP/DIF).
Version restrictions:
- Reverse play not implemented.
- No angle selection during playback (angle selection in DVD menu works).
- No closed caption support (not the same as subpicture subtitling).
- DTS audio not supported (other than via SP/DIF).
- To play another DVD you have to restart the program.
- Karaoke mode is missing.

Sauerbraten is an experimental engine based on Cube, can be seen as "Next-Gen Cube", or "Cube 2". Much like cube, the aim of this engine is not to produce the most eyecandy possible, but rather allow map/geometry editing to be done dynamically in-game, and make map editing a lot of fun.

Sauerbraten has an even simpler world model than cube (fewer exceptions, just one kind of building block), is quicker to edit geometry with, yet allows for significantly greater class of shapes. One way to see the transition from Cube to Sauerbraten is to say Cube was a 2-directional heightfield (floor and ceiling), and Sauerbraten is a 6-directional heighfield (heighfields can be modeled in all 6 directions).

The world consists of an octree of deformable cubes. It being an octree has just one important effect: it allows the mapper to work at any scale, from large landscape areas to small architectural details. The octree is largely invisible to the mapper though, he can arbitrarily break up larger cubes or merge them, and the engine takes care of the rest.

The deformable cubes are geometric shapes made out of maximally 8 vertices. In its maximum size, it is a regular cube that fills the entire octree node it sits in, as minimum size all 8 vertices coincide which is to say the cube is "empty". Anywhere in between theres a variety of slanted cubes and wedge shapes that are possible to any degree and orientation, and together with neighbouring cubes can form any shape easily.

The editor is similar to the one in Cube but much easier / direct to use, as there arent all the different kinds of cubes to worry about. Here, you can simply "push and pull" geometry with your mousewheel in 6 directions, depending on the orientation of the surface you are looking at. Modifier keys allow you to influence single vertices on a cube, connected vertices touching multiple cubes, edges, faces and entire cubes. Selections can be made to operate on more primitives at once. Many complex shapes are quick and easy to make. It is definitely the most fun way to model architecture to date.

The internal representation of a deformable cube is very different from a vertex based representation, and is based on "edge spans" which allows the engine to represent any kind of shape uniformly in just 12 bytes. This means it can hold great amounts of geometry in memory and maps on disk are small. To render this kind of geometry, the engine goes through a process of converting the internal representation to vertices using plane intersections based on the edge ranges, culls coinciding faces, merges vertices etc. to arrive at something which renders efficiently by hardware and caches this in chunks based on the octree. This allows Sauerbraten a significantly higher polygon throughput than Cube while maintaining its ability to have dynamic geometry.

The current implementation inherents all the non-world geometry related code from Cube, and as such works without modification: entities, AI, gameplay, network, console/script. For the new code, rendering and editing are close to done, physics and lighting are working quite well, level loading/saving is complete, SP & MP work, but plenty of more advanced stuff like occlusion culling & LOD is missing.

UPDATE: Sauerbraten has now started as a Cube community Open Source Engine (& Game) project. It interesting for developers & mappers, but maybe not players yet (though SP & MP do work). If you are interested in checking it out, or even in contributing, I suggest you visit the forums (see below).

NEWS: may 24 2005 release with lightmaps and working MP/SP gameplay! download from sourceforge below.