Free file data software for linux

Daizu::File is a Perl class representing files in working copies.

Each object of this class represents a particular file in a Daizu CMS working copy (a record in the wc_file table).

METHODS

Note that all the functions which return the value of a Subversion property will strip leading and trailing whitespace, and treat a value which is empty or entirely whitespace as if it wasnt set at all.

Daizu::File->new($cms, $file_id)

Return a new Daizu::File object for the file with the specified ID number.

$file->data

Return a reference to a string containing the file data (content).

$file->wc

Return a Daizu::Wc object representing the working copy in which this file lives.

$file->guid_uri

Return the GUID URI for this file.

$file->directory_path

Returns the path of a directory, either the same as the file if its a directory itself, or the path of its parent directory, or if its at the top level.

$file->permalink

Returns the first URL generated by the file, which will be the URL you want to link to most of the time. For articles this will always be the normal HTML version of the article, even if there are also other URLs available for it, and it will always be the first page of multipage articles. For non-article files there is no guarantee about what this will return, but most will only generate a single URL anyway, and for those that dont generators are likely to return the most linkable URL first.

The URL returned is an absolute URL provided as a URI object.

Returns nothing if the file doesnt generate any URLs.

There are some cases where this might not be what you want. For example, the root directory of a website using Daizu::Gen will either not generate a URL at all, or will generate one for a Google sitemap XML file, neither of which is likely to be useful for linking. To get the URL of the website you would probably need to find a file called something like _index.html. On the other hand, the Daizu::Gen::Blog generator will give you a sensible URL for the blog homepage if you call this on its root directory.

$file->urls_in_db($method, $argument)

Return a list of the URLs (plain strings, each an absolute URI) of the file which have the specified method and argument values, drawing from the url table in the database.

$file->article_urls

Return information about the URLs which the file should have, if it is an article. Fails if it isnt.

Config::File is a Perl module to parse a simple configuration file.

SYNOPSIS

use Config::File;
my $config_hash = Config::File::read_config_file($configuration_file);

read_config_file parses a simple configuration file and stores its values in an anonymous hash reference. The syntax of the configuration file is quite simple:

# This is a comment
VALUE_ONE = foo
VALUE_TWO = $VALUE_ONE/bar
VALUE_THREE = The value contains a # (hash). # This is a comment.

Options can be clustered when creating groups:

CLUSTER_ONE[data] = data cluster one
CLUSTER_ONE[value] = value cluster one
CLUSTER_TWO[data] = data cluster two
CLUSTER_TWO[value] = value cluster two

Then values can be fetched using this syntax:

$hash_config->{CLUSTER_ONE}{data};

There can be as many sub-options in a cluster as needed.

BIG_CLUSTER[part1][part2][part3] = data

is fetched by: $hash_config->{BIG_CLUSTER}{part1}{part2}{part3};
There are a couple of restrictions as for the names of the keys. First of all, all the characters should be alphabetic, numeric, underscores or hyphens, with square brackets allowed for the clustering. That is, the keys should conform to /^[A-Za-z0-9_-]+$/

This means also that no space is allowed in the key part of the line.

CLUSTER_ONE[data] = data cluster one # Right
CLUSTER_ONE[ data ] = data cluster one # Wrong

Audio::Data is a module for representing audio data to perl.

SYNOPSIS

use Audio::Data;
my $audio = Audio::Data->new(rate => , ...);

$audio->method(...)

$audio OP ...

Audio::Data represents audio data to perl in a fairly compact and efficient manner using C via XS to hold data as a C array of float values. The use of float avoids many issues with dynamic range, and typical float has 24-bit mantissa so quantization noise should be acceptable. Many machines have floating point hardware these days, and in such cases operations on float should be as fast or faster than some kind of "scaled integer".

Nominally data is expected to be between +1.0 and -1.0 - although only code which interacts with outside world (reading/writing files or devices) really cares.
It can also represent elements (samples) which are "complex numbers" which simplifies many Digital Signal Processing methods.

Methods

The interface is object-oriented, and provides the methods below.
$audio = Audio::Data->new([method => value ...])
The "constructor" - takes a list of method/value pairs and calls $audio->method(value) on the object in order. Typically first "method" will be rate to set sampling rate of the object.

$rate = $audio->rate
Get sampling rate of object.
$audio->rate($newrate)
Set sampling rate of the object. If object contains existing data it is re-sampled to the new rate. (Code to do this was derived from a now dated version of sox.)
$audio->comment($string)
Sets simple string comment associated with data.
$string = $audio->comment
Get the comment
$time = $audio->duration
Return duration of object (in seconds).
$time = $audio->samples
Return number of samples in the object.
@data = $audio->data
Return data as list of values - not recommended for large data.
$audio->data(@data)
Sets elements from @data.
$audio->length($N)
Set number of samples to $N - tuncating or padding with zeros (silence).
($max,$min) = $audio->bounds([$start_time[,$end_time]])
Returns a list of two values representing the limits of the values between the two times if $end_time isnt specified it defaults to the duration of the object, and if start time isnt specified it defaults to zero.
$copy = $audio->clone
Creates copy of data carrying over sample rate and complex-ness of data.
$slice = $audio->timerange($start_time,$end_time);
Returns a time-slice between specified times.
$audio->Load($fh)
Reads Sun/NeXT .au data from the perl file handle (which should have binmode() applied to it.)
This will eventually change - to allow it to load other formats and perhaps to return list of Audio::Data objects to represnt multiple channels (e.g. stereo).
$audio->Save($fh[,$comment])
Write a Sun/NeXT .au file to perl file handle. $comment if specified is used as the comment.
$audio->tone($freq,$dur,$amp);
Append a sinusoidal tone of specified freqency (in Hz) and duration (in seconds), and peak amplitude $amp.
$audio->silence($dur);
Append a period of 0 value of specified duration.
$audio->noise($dur,$amp);
Append burst of (white) noise of specified duration and peak amplitude.
$window = $audio->hamming($SIZE,$start_sample[,$k])
Returns a "raised cosine window" sample of $SIZE samples starting at specified sample. If $k is specified it overrides the default value of 0.46 (e.g. a value of 0.5 would give a Hanning window as opposed to a Hamming window.)
windowed = ((1.0-k)+k*cos(x*PI))
$freq = $audio->fft($SIZE)
$time = $freq->ifft($SIZE);
Perform a Fast Fourier Transform (or its inverse). (Note that in general result of these methods have complex numbers as the elements. $SIZE should be a power-of-two (if it isnt next larger power of two is used). Data is padded with zeros as necessary to get to $SIZE samples.
@values = $audio->amplitude([$N[,$count]])
Return values of amplitude for sample $N..$N+$count inclusive. if $N is not specified it defaults to zero. If $count is not specified it defaults to 1 for scalar context and rest-of-data in array context.
@values = $audio->dB([$N[,$count]])
Return amplitude - in deci-Bells. (0dB is 1/2**15 i.e. least detectable value to 16-bit device.) Defaults as for amplitude.
@values = $audio->phase([$N [,$count]])
Return Phase - (if data are real returns 0). Defaults as for amplitude.
$diff = $audio->difference
Returns the first difference between successive elements of the data - so result is one sample shorter. This is a simple high-pass filter and is much used to remove DC offsets.
$Avalues = $audio->lpc($NUM_POLES,[$auto [,$refl]])
Perform Linear Predictive Coding analysis of $audio and return coefficents of resulting All-Pole filter. 0th Element is not a filter coefficent (there is no A[0] in such a filter) - but is a measure of the "error" in the matching process. $auto is an output argument and returns computed autocorrelation. $refl is also output and are so-called reflection coefficents used in "lattice" realization of the filter. (Code for this lifted from "Festival" speech systems speech_tools.)
$auto = $audio->autocorrelation($LENGTH)
Returns an (unscaled) autocorrelation function - can be used to cause peaks when data is periodic - and is used as a precursor to LPC analysis.

Firebird .NET Data Provider is an ADO.NET data provider for Firebird. Firebird .NET Data Provider is written in C# and provides a high-performance native implementation of the Firebird API. It also includes an implementation of the Firebird Services API and Firebird array datatype support.

Firebird is a relational database offering many ANSI SQL standard features that runs on Linux, Windows, and a variety of Unix platforms. Firebird offers excellent concurrency, high performance, and powerful language support for stored procedures and triggers. It has been used in production systems, under a variety of names since 1981.

Firebird is a commercially independent project of C and C++ programmers, technical advisors and supporters developing and enhancing a multi-platform relational database management system based on the source code released by Inprise Corp (now known as Borland Software Corp) on 25 July, 2000 under the InterBase Public License v.1.0

FLV::VideoTag is a flash video file data structure Perl module.

METHODS

This is a subclass of FLV::Base.

$self->parse($fileinst)

Takes a FLV::File instance and extracts an FLV video tag from the file stream. This method throws exceptions if the stream is not a valid FLV v1.0 or v1.1 file.

There is no return value.

Note: this method needs more work to extract the codec specific data.

$self->serialize()

Returns a byte string representation of the tag data. Throws an exception via croak() on error.

$self->get_info()

Returns a hash of FLV metadata. See File::Info for more details.

Fast Data Transfer is an application for efficient data transfers that is capable of reading and writing at disk speed over wide area networks (with standard TCP).
It can be used to stream a large set of files across the network, so a large dataset composed of thousands of files can be sent or received at full speed, without the network transfer restarting between files.
The project is written in Java, runs an all major platforms, and is easy to use.
Main features:
- Streams a dataset (list of files) continuously, using a managed pool of buffers through one or more TCP sockets.
- Uses independent threads to read and write on each physical device
- Transfers data in parallel on multiple TCP streams, when necessary
- Uses appropriate-sized buffers for disk I/O and for the network
- Restores the files from buffers asynchronously
- Resumes a file transfer session without loss, when needed

Google::Adwords::Data is base class for the Data modules.

This module is not supposed to be used directly. Use the child data modules.