Free offset software for linux

Tie::OffsetArray can tie one array to another, with index offset.

SYNOPSIS

use Tie::OffsetArray;

tie @a, Tie::OffsetArray, 1, @b; # offset=1; use given array.

tie @c, Tie::OffsetArray, 2; # use anonymous array.

$a[0] = x; # assign to $b[1];

tied(@a)->array->[0] = y; # assign to $b[0].

When tied to this class, an arrays behavior is completely normal. For its internal storage, it uses another array, either one supplied by the caller, or a new anonymous one. Accesses to the tied array are mapped down to the storage array by offsetting the index by some constant amount.

A special method on the tied object returns a reference to the storage array, so that the elements below the offset can be accessed. This is particularly useful if the storage array was not supplied by the caller.

PicoStorage allows you to store hierarhical information (similar to "files and directories") inside a single file. The functionality offered is largely equivalent to the one offered by any filesystem, or by the Structured Storage and Compound Files.

PicoStorage can efficiently handle huge numbers of small files, with very economical disk usage; it also allows you to keep open (in RAM) simultaneously a large number of files. Transaction support guarantees data integrity.

Learn more about the distinctive advantages of PicoStorage. or look at the benchmark.

The library is available on a dual-license basis: under GPL for free, and under a commercial license for use in closed-source applications.

Using

The library contains the classes File and Dir to represent files and directories. On a File you can read or write a number of bytes from a given offset, and set/get the file size. On a Dir you can create entries (either files or subdirectories), open entries, delete entries, and iterate over the directorys content.

The storage itself (i.e. the whole hierarchical structure, contained in a filesystem file) is represented by the class Storage. Using this class, you can create or open a storage, obtain the root directory of the storage, close the storage and do commit or rollback.

convert2tifgrayscale is a GIMP plugin that can batch convert to tif grayscale for Offset-Printing.

Converts all images in a specified directory to grayscale, then uses unsharp mask and adjusts levels.

DBIx::FetchLoop is a Perl module that can fetch with change detection and aggregates.

SYNOPSIS

use DBIx::FetchLoop;

$lph = DBIx::FetchLoop->new($sth, $dbi_method);

$hash_ref = $lph->fetch_current_data;
$rowset = $hash_ref->{previous};
$rowset = $hash_ref->{current};
$rowset = $hash_ref->{next};

$rowset = $lph->fetch_current_row;

$rowset = $lph->previous;
$rowset = $lph->current;
$rowset = $lph->next;

$lph->set_aggregate($new_field, $field);
$lph->reset_aggregate($new_field);

$lph->set_concatenate($new_field, $field);
$lph->reset_concatenate($new_field);

$boolean = $lph->pre_loop($field);
$boolean = $lph->post_loop($field);

$boolean = $lph->pre_loop_substr($field,$offset,$length);
$boolean = $lph->post_loop_substr($field,$offset,$length);

$boolean = $lph->is_first;
$boolean = $lph->is_last;

$count = $lph->count;

DBIx::FetchLoop is a supplemental approach for data retrieval with DBI. Result rows are queued with hash references to previous, current and next rows. Utility functions allow for simplified comparison of a field between previous and current or current and next rows. Additional functions allow you automatically create new fields for aggregating or concatenating based on fields in the resulting dataset.

Note: This module was created with ease of use and performance in mind. This module is intended to eliminate the need for temporary variables for loop detection as well as aggregation and concatenation. The reason that not all DBI methods for data retrieval are not implemented (such as selectall_arrayref) is that the modules design for performance would be defeated.

In essence you can write cleaner looking, more efficient code minus a few hassles.

Unicode Utilities project are a set of programs for manipulating and analyzing Unicode text. uniname defaults to printing the character offset of each character, its byte offset, its hex code value, its encoding, the glyph itself, and its name. Command line options allow undesired information to be suppressed and the Unicode range to be added.
unidesc reports the character ranges to which different portions of the text belong. unihist generates a histogram of the characters in its input. ExplicateUTF8 is intended for debugging or for learning about Unicode. It determines and explains the validity of a sequence of bytes as a UTF-8 encoding. unirev reverses UTF-8 strings.
Enhancements:
- Adds to unidesc the option -r which causes it to list the ranges detected after reading all input rather than listing them as they are encountered, and adds to uniname the option -B which causes it to ignore characters within the Basic Multilingual Plane.

Audio::FindChunks can breaks audio files into sound/silence parts.

SYNOPSIS

use Audio::FindChunks;

# Duplicate input to output, caching RMS values to a file (as a side effect)
Audio::FindChunks->new(rms_filename => x.rms, filter => 1)->get(rms_data);

# Output human-readable info, using RMS cache file xxx.rms if present:
Audio::FindChunks->new(cache_rms => 1, filename => xxx.mp3,
stem_strip_extension => 1)->output_blocks();

# Remove start/end silence (if longer than 0.2sec):
Audio::FindChunks->new(cache_rms => 1, filename => xxx.mp3,
min_actual_silence_sec => 1e100)->split_file();

# Split a multiple-sides tape recording
Audio::FindChunks->new(filename => xxx.mp3, min_actual_silence_sec => 11
)->split_file({verbose => 1});

Audio sequence is broken into parts which contain only noise ("gaps"), and parts with usable signal ("tracks").

The following configuration settings (and defaults) are supported:

# For getting PCM flow (and if averaging data is read from cache)
frequency => 44100, # If raw_pcm or override_header_info only
bytes_per_sample => 4, # likewise
channels => 2, # likewise
sizedata => MY_INF, # likewise (how many bytes of PCM to read)
out_fh => *STDOUT, # mirror WAV/PCM to this FH if filter
# Process non-WAV data:
preprocess => {mp3 => [[qw(lame --silent --decode)], [], [-]]}, # Second contains extra args to read stdin
# RMS cache (used if valid_rms)
rms_extension => .rms, # Appended to the filestem
# Averaging to RMS info
sec_per_chunk => 0.1, # The window for taking mean square
# thresholds picking from the list of sorted 3-medians of RMS data
threshold_in_sorted_min_rel => 0, # relative position of threashold_min
threshold_in_sorted_min_sec => 1, # shifted by this amount in the list
threshold_factor_min => 1, # the list elt is multiplied by this
threshold_in_sorted_max_rel => 0.5, # likewise
threshold_in_sorted_max_sec => 0, # likewise
threshold_factor_max => 1, # likewise
threshold_ratio => 0.15, # relative position between min/max
# Chunkification: smoothification
above_thres_window => 11, # in units of chunks
above_thres_window_rel => 0.25, # fractions of chunks above threshold
# in a window to make chunk signal
# Splitting into runs of signal/noise
max_tracks => 9999, # fail if more signal/noise runs
min_signal_sec => 5, # such runs of signal are forced
min_silence_sec => 2, # likewise
ignore_signal_sec => 1, # short runs of signal are ignored
min_silence_chunks_merge (see below) # and long resulting runs of silence
# are forced
# Calculate average signal in an interval "deeply inside" silence runs
local_level_ignore_pre_sec => 0.3, # offset the start of this interval
local_level_ignore_pre_rel => 0.02, # additional relative offset
local_level_ignore_post_sec => 0.3, # likewise for end of the interval
local_level_ignore_post_rel => 0.02, # likewise
# Enlargement of signal runs: attach consequent chunks with signal this much
# above this average over the neighbour silence run
local_threshold_factor => 1.05,
# Final enlargement of runs of signal
extend_track_end_sec => 0.5, # Unconditional enlargement
extend_track_begin_sec => 0.3, # likewise
min_boundary_silence_sec => 0.2, # Ignore short silence at start/end

Note that above_thres_window is the only value specified directly in units of chunks; the other *_sec may be optionally specified in units of chunks by setting the corresponding *_chunks value. Note also that this window should better be decreased if minimal allowed silence length parameters are decreased.

These values are mirrored from other values if not explicitly specified:

min_actual_silence_sec<<less