Free randy software for linux

RPM::Constants is a Perl module with groups of RPM-defined symbols.

SYNOPSIS

use RPM::Constants qw(:rpmerr :rpmtype);

This package is a collection of the constants defined by rpm itself that may be of use to those developing with the RPM Perl bindings.

FakeNES project is a portable, Open Source NES emulator which is written mostly in pure C, while using the Allegro library for multi-platform capabilities.
Currently supported systems are Windows 9x/2000/Me/XP, 32-bit DOS, Linux, FreeBSD, QNX, BeOS, and Mac OS X. However, it should run on any system that Allegro supports. This includes, but is not limited to: any version of Windows released after 1995, any 32-bit DOS compatible, and many POSIX compliant systems and UNIX clones such as Linux, FreeBSD, QNX, BeOS, and Mac OS X.
Configuration
FakeNES uses a standard configuration system similar to that used by many DOS, Windows, and UNIX applications.
Each item in the configuration file that is not surrounded by square brackets ([ and ]) defines an element or key.
The equal sign (=) is used to assign a value to that element.
Items which are surrounded by brackets are called headers. Headers define a section or group of related elements.
Comments are delimeted by the pound (#) sign and are ignored by the configuration file parser.
At this time, command-line options are not supported. However, you may supply the name of an NES ROM file that you would like to load on the command-line instead of loading it from the GUI.
Input engine
Currently, FakeNES supports two different keyboard layouts on a single keyboard, and up to two (2) joystick-like devices such as joypads. Each device may be assigned to any player, you can even assign a single device to multiple players.
All configuration of the controls is done in the configuration file, under the [input] header. You can assign a specific device to each player by modifying the player_#_device elements (replace # with the associated player number).
The following values are permitted:
0: No input (disables all input for this player).
1: Keyboard layout #1
2: Keyboard layout #2
There are two (2) configurable keyboard layouts which are present on the same keyboard, and may define overlapping keys without conflicts. Modifying the key1_scancodes and key2_scancodes elements allow you to customize the key mappings for each layout.
Note that due to portability reasons, FakeNES does not accept standard IBM scancodes. Instead, you need to supply a sequence of 8 integer scancodes as defined by the Allegro multimedia library.
The order in which the scancodes are applied is very important, and corresponds to the associated NES standard controller buttons: A, B, Select, Start, Up, Down, Left, and Right. If a complete sequence of 8 scancodes cannot be found, then the defaults will be used.
For layout #1, they are X, Z, Tab, and Enter, respectively, combined with the arrow keys for directional control.
3: Joystick device #1
4: Joystick device #2
Core timing
FakeNES contains an automatic speed throttling system. By modifying the frame_skip_min and frame_skip_max elements under the [timing] header in the configuration file, you can toggle speed cap and set the parameters for frame skipping.
Frame skipping is a technique that allows the emulation to run much faster, at the cost of fewer frames-per-second (FPS) being rendered, which results in more latent or choppy gameplay.
Speed capping effectively limits the maximum amount of FPS to be rendered to match that of the NES itself, which keeps the emulation from running too fast on fast processors or when frame skipping is being used.
frame_skip_min defines the least amount of frames to be skipped, setting it to zero (0) effectively disables minimum frame skipping and enables the speed capping mechanism.
frame_skip_max defines the highest allowable amount of frames to be skipped. FakeNES will never skip more frames than is defined by this element, even if full speed is not obtained.
Setting frame_skip_min and frame_skip_max to equal values effectively sets a fixed amount of frames to be skipped.
If the speed cap is enabled, you can use the fast forward key to surpass the speed cap and skip frame_skip_max frames as long as the key is being held down. By default, the fast forward key is defined as the tilde key above the Tab key on most keyboards.
The machine_type element allows you to select which standard is to be used by the speed throttling system and sound/graphics engines. Set it to zero (0) for NTSC or one (1) for PAL. There are not many PAL NES games, and many of them should run fine in NTSC mode. Only modify this element if you have problems.
Enhancements:
- AUDIO: Fixed all while() loops in the APU to never be truely infinite (thus preventing hard lock-ups), removed a previous hack that was added to get around such a thing.
- AUDIO: Implemented a new ExSound API.
- AUDIO: Added full save state support to VRC6 Sound and MMC5 Sound.
- AUDIO: Rreduced default audio buffer length from 6 to 4 frames to reduce latency.
- AUDIO: Added in mixing of MMC5s digital audio channel (untested).
- CODE: Moved a bunch of code out of gui.c and into the GUI header files.
- CODE: Various code edits.
- DOCS: Updated docs.
- GUI: Added a GUI menu to configure the audio buffer length.
- GUI: Added a GUI menu to configure video buffer size.
- GUI: Enabled double buffered GUI while in OpenGL mode.
- GUI: Added custom drawing code for the sl_radiobox object.
- GUI: Cleaned up the Help->About dialog and added loomsoft under Special thanks to.
- GUI: Added more splitters to the Audio and Video menus to better group submenus.
- GUI: Added a Close button to the Help->Shortcuts dialog.
- GUI: Hide some menus when their respective features arent available for whatever reason.
- GUI: Made sl_frame object behave properly in a double buffered environment.
- GUI: Removed extended video resolutions, since if anyone wants to actually use any of the obscure things, they can set them manually via the configuration file.
- INPUT: Overhauled input system and input configuration system.
- MISC: Fixed a cosmetic bug where the enabled flag of CPU patches were written to the *.fpt file with the value of 2 instead of 1 when enabled.
- VIDEO: Added (buggy) OpenGL support.
- VIDEO: Added support for a screen buffer smaller or larger than the actual screen (it will be scaled to fit).
- VIDEO: Set all bitmaps to NULL after destroying them in video_exit(), fixes various problems.
- VIDEO: Improved the operation of video_blit().
- VIDEO: Improved efficiency of HQ4X slightly by removing extra assertions.
- VIDEO: Added size checking to the Normal and Stretched blitters.
- VIDEO: Changed blitter error message.

PHP Active Code Library (ACL) is a PHP 5 class used to store and call PHP files that are stored in a database.

The files are stored in a plain text field and not a binary field. PHP ACL also takes care of include/require calls.

If a file includes another file stored in the database, PHP ACL takes care of getting, generating, and including that file.

GD::Image::CopyIFS is a Perl module for fractal-based image copying and resizing.

SYNOPSIS

# zoom in on an area of an image
use GD::Image::CopyIFS;
my $width = 64;
my $height = 60;
my $scale = 4;
my $neww = $scale * $width;
my $newh = $scale * $height;
my $src_file = src.jpeg;
my $src_img = GD::Image->newFromJpeg($src_file, 1);
my $dst_img = GD::Image->new($neww, $newh, 1);
my @opts = ($src_img, 0, 0, 110, 120,
$neww, $newh, $width, $height);
$dst_img->copyIFS(@opts);
my $dst_file = dst.jpeg;
open(my $fh, >, $dst_file) or die "Cannot open $dst_file: $!";
binmode $fh;
print $fh $im->jpeg;
close $fh;

# create a resized image scaled by a factor $scale
use GD::Image::CopyIFS;
my $src_file = src.jpeg;
my $src_img = GD::Image->newFromJpeg($src_file, 1);
my $scale = 2.45;
my $dst_img = GD::Image->thumbIFS($src_img, scale => $scale);
my $dst_file = dst.jpeg;
open(my $fh, >, $dst_file) or die "Cannot open $dst_file: $!";
binmode $fh;
print $fh $im->jpeg;
close $fh;

This module adds to the GD::Image module of GD two methods: copyIFS, used to copy and resize an area of one image onto another image, and thumbIFS, used to create a rescaled image from an original. The copyIFS method is used analagously to the copyResized or copyResampled methods of the GD module.

The algorithm employed uses what is known as a fractal interpolating function, which uses an Iterated Function System (IFS) to interpolate functions specified at discrete points. The basic procedure is to create an IFS based on the pixel colors of an image, and then from this construct a new IFS based on the parameters specified when rescaling an area of the image. A random iteration algorithm is then used to construct an image from this new IFS. For details, see http://ecommons.uwinnipeg.ca/archive/00000026/.

Note that this algorithm may give good results for images of natural objects, as there is generally a fractal nature present in most such shapes. It typically will not give good results for more geometric shapes, such as lettering.

PAR::WebStart::PNLP is a Perl module that can parse pnlp files.
SYNOPSIS
my $file = hello.pnlp;
my $obj = PAR::WebStart::PNLP->new(file => $file);
my $cfg = $obj->parse();
This module is used to parse PNLP files, which are XML files whose syntax is described later in this document. The $cfg data structure returned is a hash reference, the key being the XML elements encountered. The value associated with this key are either
- a reference to an array of hash references, in the cases of the par, argument, module, or description elements,
- a hash reference, for all other elements.
The hash references involved in these values have keys corresponding to the names of any attributes of the element, if found, as well as a key of value, if there is a value of the element. The associated values of these keys are the corresponding values of the attributes or the elements value, as applicable. Except for the cases of par, argument, module, and description, the hash references associated with all elements seen are guaranteed to have one key of seen, of value 1, even if no attribute or value are defined.

Math::Cephes::Polynomial is a Perl interface to the cephes math polynomial routines.

SYNOPSIS

use Math::Cephes::Polynomial qw(poly);
# poly is a shortcut for Math::Cephes::Polynomial->new

require Math::Cephes::Fraction; # if coefficients are fractions
require Math::Cephes::Complex; # if coefficients are complex

my $a = poly([1, 2, 3]); # a(x) = 1 + 2x + 3x^2
my $b = poly([4, 5, 6, 7]; # b(x) = 4 + 5x + 6x^2 + 7x^3
my $c = $a->add($b); # c(x) = 5 + 7x + 9x^2 + 7x^3
my $cc = $c->coef;
for (my $i=0; $ieval($x);
print "At x=$x, c(x) is $rn";

my $u1 = Math::Cephes::Complex->new(2,1);
my $u2 = Math::Cephes::Complex->new(1,-3);
my $v1 = Math::Cephes::Complex->new(1,3);
my $v2 = Math::Cephes::Complex->new(2,4);
my $z1 = Math::Cephes::Polynomial->new([$u1, $u2]);
my $z2 = Math::Cephes::Polynomial->new([$v1, $v2]);
my $z3 = $z1->add($z2);
my $z3c = $z3->coef;
for (my $i=0; $ieval($x);
print "At x=$x, z3(x) has real=", $r->r, " and imag=", $r->i, "n";

my $a1 = Math::Cephes::Fraction->new(1,2);
my $a2 = Math::Cephes::Fraction->new(2,1);
my $b1 = Math::Cephes::Fraction->new(1,2);
my $b2 = Math::Cephes::Fraction->new(2,2);
my $f1 = Math::Cephes::Polynomial->new([$a1, $a2]);
my $f2 = Math::Cephes::Polynomial->new([$b1, $b2]);
my $f3 = $f1->add($f2);
my $f3c = $f3->coef;
for (my $i=0; $ieval($x);
print "At x=$x, f3(x) has num=", $r->n, " and den=", $r->d, "n";
$r = $f3->eval($a1);
print "At x=", $a1->n, "/", $a1->d,
", f3(x) has num=", $r->n, " and den=", $r->d, "n";

PPM::Make is a Perl module that can Make a ppm package from a CPAN distribution.

SYNOPSIS

my $ppm = PPM::Make->new( [options] );
$ppm->make_ppm();

See the supplied make_ppm script for a command-line interface.

This module automates somewhat some of the steps needed to make a ppm (Perl Package Manager) package from a CPAN distribution. It attempts to fill in the ABSTRACT and AUTHOR attributes of Makefile.PL, if these are not supplied, and also uses pod2html to generate a set of html documentation. It also adjusts CODEBASE of package.ppd to reflect the generated package.tar.gz or package.zip archive. Such packages are suitable both for local installation via

C:.cpanbuildpackage_src> ppm install

and for distribution via a repository.

Options can be given as some combination of key/value pairs passed to the new() constructor (described below) and those specified in a configuration file. This file can either be that given by the value of the PPM_CFG environment variable or, if not set, a file called .ppmcfg at the top-level directory (on Win32) or under HOME (on Unix). If the no_cfg argument is passed into new(), this file will be ignored.

The configuration file is of an INI type. If a section default is specified as

[ default ]
option1 = value1
option2 = value2

these values will be used as the default. Architecture-specific values may be specified within their own section:

[ MSWin32-x86-multi-thread-5.8 ]
option1 = new_value1
option3 = value3

In this case, an architecture specified as MSWin32-x86-multi-thread-5.8 within PPM::Make will have option1 = new_value1, option2 = value2, and option3 = value3, while any other architecture will have option1 = value1 and option2 = value2. Options specified within the configuration file can be overridden by passing the option into the new() method of PPM::Make.

Valid options that may be specified within the configuration file are those of PPM::Make, described below. For the program and upload options (which take hash references), the keys (make, zip, unzip, tar, gzip), or (ppd, ar, host, user, passwd), respectively, should be specified. For binary options, a value of yes|on in the configuration file will be interpreted as true, while no|off will be interpreted as false.

PAR::WebStart is a Perl implementation of Javas WebStart.

SYNOPSIS

my $file = hello.pnlp;
my $ws = PAR::WebStart->new(file => $file);
$ws->fetch_pars() or die $ws->{ERROR};

my $tmpdir = $ws->{tmpdir};
chdir($tmpdir) or die qq{Cannot chdir to "$tmpdir": $!});

my @args = @{$ws->run_command()};
die qq{Failed to get WebStart args: $ws->{ERROR}}) unless (@args);
system(@args) == 0 or die qq{Execution of system(@args) failed: $?};

This a Perl version of Javas WebStart technology; see http://java.sun.com/j2se/1.4.2/docs/guide/jws/developersguide/overview.html for details.

PAR-WebStart is a helper application associated with a browser. When a user clicks on a link that points to a PNLP [PAR Network Launch Protocol] launch file (a special XML file), it causes the browser to launch PAR-WebStart, which then automatically downloads, caches, and runs the specified PAR-based application.