Free foo 0.993 software for linux

Video::Info::FOO is a Perl module for video information.

Video::Info::FOO - what is it useful for? an example list:

-video codec
-audio codec
-frame height
-frame width
-frame count
and more!

SYNOPSIS

use Video::Info::FOO;

my $video;

$video->vcodec; #video codec
$video->acodec; #audio codec
...

What does the module do? What are its limitations? Is it built on top of other code? If so, what are the details and where can I get it?

rconftool is a reimplementation of Sam Varshavchiks sysconftool in Ruby. Its purpose is to keep configuration files "fresh" when upgrading an application from one version to another, ensuring that all necessary settings are present and obsolete ones removed.

To use it, application writers need to distribute their config files marked up with some simple metadata in comments, and arrange for the make install or make install-configure target to invoke rconftool.

rconftool can be called as a library function or from the command line. It can also install groups of files recursively from one directory tree into another.

rconftool is distributed under the MIT licence.

Installation

You can just use rconftool.rb from the current directory, or copy it anywhere into Rubys library search path. The following command will do this for you:

# ruby install.rb

Usage

(1) As a command-line tool

# ./rconftool.rb foo.dist

Installs foo.dist to foo (option --strip-suffix .dist is the default)

# ./rconftool.rb --strip-suffix .orig --add-suffix .txt *.orig

Installs files foo.orig and bar.orig as foo.txt and bar.txt

# ./rconftool.rb --recursive --targetdir /etc/foo .

Installs all files in the current directory and its subdirectories into /etc/foo recursively. (Suffix .dist is still stripped off by default, unless you specify --strip-suffix ""). /etc/foo itself must exist, but subdirectories are created if necessary.

(2) As a library

require rconftool

# install single files
Rconftool::install(foo.dist, foo)
Rconftool::install(foo.dist, nil, nil, :strip_regexp=>/.dist$/)
Rconftool::install(foo.orig, foo.txt)
Rconftool::install(bar.orig, nil, nil, :strip_regexp=>/.orig$/,
:add_suffix=>.txt)

# using the command-line interface
argv = [--recursive,--targetdir,/etc/foo,.]
rct = Rconftool::Processor.new(argv)
rct.run(argv)

Clone is a Perl module that can recursively copy Perl datatypes.

SYNOPSIS

use Clone;

push @Foo::ISA, Clone;

$a = new Foo;
$b = $a->clone();

# or

use Clone qw(clone);

$a = { foo => bar, move => zig };
$b = [ alpha, beta, gamma, vlissides ];
$c = new Foo();

$d = clone($a);
$e = clone($b);
$f = clone($c);

This module provides a clone() method which makes recursive copies of nested hash, array, scalar and reference types, including tied variables and objects.

clone() takes a scalar argument and an optional parameter that can be used to limit the depth of the copy. To duplicate lists, arrays or hashes, pass them in by reference. e.g.

my $copy = clone (@array);

# or

my %copy = %{ clone (%hash) };

For a slower, but more flexible solution see Storables dclone().

Video::Info::MPEG is a basic MPEG bitstream attribute parser.

SYNOPSIS

use strict;
use Video::Info::MPEG;

my $video = Video::Info::MPEG->new( -file => $filename );
$video->probe();

print $file->type; ## MPEG

## Audio information
print $file->acodec; ## MPEG Layer 1/2
print $file->acodecraw; ## 80
print $file->achans; ## 1
print $file->arate; ## 128000 (bits/sec)
print $file->astreams ## 1

## Video information
printf "%0.2f", $file->fps ## 29.97
print $file->height ## 240
print $file->width ## 352
print $file->vstreams ## 1
print $file->vcodec ## MPEG1
print $file->vframes ## 529
print $file->vrate ## 1000000 (bits/sec)

The Moving Picture Experts Group (MPEG) is a working group in charge of the development of standards for coded representation of digital audio and video.
MPEG audio and video clips are ubiquitous but using Perl to programmatically collect information about these bitstreams has to date been a kludge at best.

This module parses the raw bitstreams and extracts information from the packet headers. It supports Audio, Video, and System (multiplexed audio and video) packets so it can be used on nearly every MPEG you encounter.

Scalar::Footnote is a Perl module that can attach hidden scalars to references.

SYNOPSIS

use Data::Dumper;
use Scalar::Footnote;

my $obj = Foo->new;

# attach invisible footnote to $obj:
$obj->Scalar::Footnote::set( my_key => my footnote );
print Dumper( $obj );

# get it back:
my $note = $obj->Scalar::Footnote::get( my_key );
print "footnote: $noten";

# remove it:
my $note = $obj->Scalar::Footnote::remove( my_key );

Scalar::Footnote lets you attach scalar footnotes to an object (or any kind of reference, really) that are essentially invisible from Perl. For example, if you try dumping an object that has a footnote attached to it, you wont actually see the footnote:

my $obj = bless [qw( foo bar )], Foo;
$obj->Scalar::Footnote::set( Foo => foo note );
print Dumper( $obj );
prints:
$VAR1 = bless [
foo,
bar
], Foo;

You can of course still access the footnote with Scalar::Footnote::get.

Video::Info is a suite of modules to probe video files for various attributes.

Previous versions of Video::Info depended on external modules, such as RIFF::Info and ASF::Info. This is no longer the case, you dont need to install them. All the functionality is now included with the Video::Info distribution.

INSTALLATION:

To install this module type the following:

perl Makefile.PL
make
make test (optional)
make install

Pod::XML is a Perl module to convert POD to XML.

SYNOPSIS

use Pod::XML;
my $parser = Pod::XML->new();
$parser->parse_from_file("foo.pod");

This module uses Pod::Parser to parse POD and generates XML from the resulting parse stream. It uses its own format, described below.

DBIx::OO is a database to Perl objects abstraction.

SYNOPSIS

package MyDB;
use base DBIx::OO;

# We need to overwrite get_dbh since its an abstract function.
# The way you connect to the DB is really your job; this function
# should return the database handle. The default get_dbh() croaks.

my $dbh;
sub get_dbh {
$dbh = DBI->connect_cached(dbi:mysql:test, user, passwd)
if !defined $dbh;
return $dbh;
}

package MyDB::Users;
use base MyDB;

__PACKAGE__->table(Users);
__PACKAGE__->columns(P => [ id ],
E => [qw/ first_name last_name email /]);
__PACKAGE__->has_many(pages => MyDB::Pages, user);

package MyDB::Pages;
use base MyDB;

__PACKAGE__->table(Pages);
__PACKAGE__->columns(P => [ id ],
E => [qw/ title content user /]);
__PACKAGE__->has_a(user => MyDB::Users);

package main;

my $u = MyDB::Users->create({ id => userid,
first_name => Q,
last_name => W });

my $foo = MyDB::Users->retrieve(userid);
my @p = @{ $foo->fk_pages };
print "User: ", $foo->first_name, " ", $foo->last_name, " pages:n";
foreach (@p) {
print $_->title, "n";
}

$foo->first_name(John);
$foo->last_name(Doe);
# or
$foo->set(first_name => John, last_name => Doe);
$foo->update;