Free bitzi metadata lookup software for linux

Phex is a P2P filesharing client which is based on the Gnutella network. Phex offers advanced functions and integrates all common Gnutella extensions like multi-source downloads and advanced search features.
Main features:
Phex is a FREE of spyware and adware
- Phex never containd any kind of spyware, adware or any other kind of bundled software.
Multi-plattform support
- Whether you use MAC OS X, Linux, Solaris, or Windows Phex is able to run on them all. All you need is a operation system that offers a Java 1.4 Runtime Environment.
Multi-source downloads (Swarming)
- Often the file you like to download is available on different hosts. Phex will request different segment of the file from each host in parallel. After successfully downloading a segment Phex will merge it with the other segments of the file. This results in a much higher download speed. If a host is too slow the segment is split during download and given to an another host. To make sure you never run out of hosts Phex is able to find new download hosts by itself with the automatic search functionality.
Advanced configuration options
- Phex offers very advanced configuration options. Much more then many other clients can offer. Especially advanced user can configure Phex according to there needs and are able to tune and see the effect of different settings.
Passive searching and snooping for files
- With the passive search functionality Phex is able to constantly monitor the traffic that goes through the network and collect search results that match your passive search term. Also Phex snoops the traffic for new download candidates you need to finish your downloads faster. This type of searching is usefull for longtime monitoring of available files on the network.
Other features include:
- Multiple searches.
- Ultrapeer and compression technology for reduced bandwidth.
- Integrated chat.
- Browse host support.
- Bitzi metadata lookup.
- MAGMA support.
Enhancements:
- The GUI received many smaller improvements and a multitude of lesser and bigger changes happened under the hood.
- Download-side THEX integration was added, so poisoned files are no longer possible.
- The upload architecture was redesigned and a far leaner security system is used for better performance and a vastly reduced memory footprint.
- Many bugs were fixed.

jBitcollider is an application which can be used to lookup/submit files to Bitzi.
The Bitcollider utility allows users to uniquely identify and submit files to Bitzis community metadatabase project.
The Bitcollider can be used to identify any local file and has support for extracting metadata from MP3, WAV, Vorbis, JPEG, PNG, GIF, AVI, MPEG-1, MPEG-2, and QuickTime files.
Users can quickly look up all the known information about the given file in Bitzis metadatabase.
Main features:
- Processes files larger than 2GB in size.
- Offers the graphical interface, and drag-and-drop Bitcolliding, on non-Windows systems for the first time.
- Improves reliability of submission via browser

WWW::Blog::Metadata::Microsummary is a Perl module to extract Microsummary URI from a page.

SYNOPSIS

use WWW::Blog::Metadata;
my $meta = WWW::Blog::Metadata->extract_from_uri($uri)
or die WWW::Blog::Metadata->errstr;

## or

my $meta = WWW::Blog::Metadata->extract_from_html($html, $base_uri)
or die WWW::Blog::Metadata->errstr;

my $microsummary_uri = $meta->microsummary_uri;

WWW::Blog::Metadata::Microsummary is a WWW::Blog::Metadata plugin to look for and extract a URI which idendifies where a microsummary or a microsummary generator of a page is located in.

Image::MetaData::JPEG is a Perl extension for showing/modifying JPEG (meta)data.

SYNOPSIS

use Image::MetaData::JPEG;

# Create a new JPEG file structure object
my $image = new Image::MetaData::JPEG(somepicture.jpg);
die Error: . Image::MetaData::JPEG::Error() unless $image;

# Get a list of references to comment segments
my @segments = $image->get_segments(COM, INDEXES);

# Get the JPEG picture dimensions
my ($dim_x, $dim_y) = $image->get_dimensions();

# Show all JPEG segments and their content
print $image->get_description();

# Retrieve a specific value from Exif meta-data
my $image_data = $image->get_Exif_data(IMAGE_DATA, TEXTUAL);
print $image_data->{DateTimeOriginal}->[0], "n";

# Modify the DateTime tag for the main image
$image->set_Exif_data({DateTime => 1994:07:23 12:14:51},
IMAGE_DATA, ADD);

# Delete all meta-data segments (please, dont)
$image->drop_segments(METADATA);

# Rewrite file to disk after your modifications
$image->save(new_file_name.jpg);

# ... and a lot more methods for viewing/modifying meta-data, which
# are accessed through the $file or $segments[$index] references.

The purpose of this module is to read/modify/rewrite meta-data segments in JPEG (Joint Photographic Experts Group format) files, which can contain comments, thumbnails, Exif information (photographic parameters), IPTC information (editorial parameters) and similar data.

Each JPEG file is made of consecutive segments (tagged data blocks), and the actual row picture data. Most of these segments specify parameters for decoding the picture data into a bitmap; some of them, namely the COMment and APPlication segments, contain instead meta-data, i.e., information about how the photo was shot (usually added by a digital camera) and additional notes from the photograph. These additional pieces of information are especially valuable for picture databases, since the meta-data can be saved together with the picture without resorting to additional database structures. See the appendix about the structure of JPEG files for technical details.

This module works by breaking a JPEG file into individual segments. Each file is associated to an Image::MetaData::JPEG structure object, which contains one Image::MetaData::JPEG::Segment object for each segment. Segments with a known format are then parsed, and their content can be accessed in a structured way for display. Some of them can even be modified and then rewritten to disk.

$JPEG::show_warnings

This package variable must be used to inhibit the printing of warnings: if it is false, warnings are silently ignored. Otherwise, warning messages come with a detailed back-trace and description of the warning location.

$Image::MetaData::JPEG::show_warnings = undef;

Image::MetaData::JPEG::Structures is a Perl module that describes the structure of a JPEG file; it is an appendix to the main manual page of the Image::MetaData::JPEG module, which the reader should refer to for further details and the general scope.

THE STRUCTURE OF JPEG PICTURES

The JPEG (Joint Photographic Experts Group) ISO standard is a lossy image compression mechanism developed before 1990, designed for compressing colour or gray-scale photo-realistic images (it performs poorly on line-art drawings). The JPEG mechanism is designed to exploit known limitations of the human eye, in particular the fact that colour changes are perceived less accurately than changes in brightness.

Note that although the "baseline" JPEG format is patent-free, there are patents associated with some optional features, namely arithmetic coding and hierarchical storage. For this reason, these optional features are never used on the Web (good job, patent fans ...). JPEG refers only to a class of compression algorithms, not to a specific file format. In order to produce files with embedded JPEG streams, a number of file format (semi-)standards have been adapted or devised, some of which are listed in the format section. The structure of a well formed JPEG file can be described by the following pseudo production rules (for sake of simplicity, some additional constraints between tables and SOF segments are neglected).

JPEG --> (SOI)(misc)*(image)?(EOI)
(image) --> (hierarch.)|(non-hier.)
(hierarch.) --> (DHP)(frame)+
(frame) --> (misc)*(EXP)?(non-hier.)
(non-hier.) --> (SOF)(scan)+
(scan) --> (misc)*(SOS)(data)*(ECS)(DNL)?
(data) --> (ECS)(RST)
(misc) --> (DQT)|(DHT)|(DAC)|(DRI)|(COM)|(APP)

(SOI) = Start Of Image
(EOI) = End Of Image
(SOF) = Start Of Frame header (10 types)
(SOS) = Start Of Scan header
(ECS) = Entropy Coded Segment (row data, not a real segment)
(DNL) = Define Number of Lines segment
(DHP) = Define Hierarchical P??? segment
(EXP) = EXPansion segment
(RST) = ReSTart segment (8 types)
(DQT) = Define Quantisation Table
(DHT) = Define Huffman coding Table
(DAC) = Define Arithmetic coding Table
(DRI) = Define Restart Interval
(COM) = COMment segment
(APP) = APPlication segment

This package does not check that a JPEG file is really correct; it accepts a looser syntax, were segments and ECS blocks are just contiguous (basically, because it does not need to display the image!). All meta-data information is concentrated in the (COM*) and (APP) Segments, exception made for some records in the (SOF*) segment (e.g. image dimensions).

Reference: B< "Digital compression and coding of continuous-tone still
images: requirements and guidelines", CCITT recommend. T.81, 1992,
The International Telegraph and Telephone Consultative Committee,
standard ISO/IEC IS 10918-1 or ITU-T Recommendation T.81 >.
Also: B< "The JPEG still picture compression standard", G.K.Wallace,
1991, IEEE Transactions on Consumer Electronics >.

SVG::Metadata is a Perl module to capture metadata info about an SVG file.

SYNOPSIS

use SVG::Metadata;

my $svgmeta = new SVG::Metadata;

$svgmeta->parse($filename)
or die "Could not parse $filename: " . $svgmeta->errormsg();
$svgmeta2->parse($filename2)
or die "Could not parse $filename: " . $svgmeta->errormsg();

# Do the files have the same metadata (author, title, license)?
if (! $svgmeta->compare($svgmeta2) ) {
print "$filename is different than $filename2n";
}

if ($svgmeta->title() eq ) {
$svgmeta->title(Unknown);
}

if ($svgmeta->author() eq ) {
$svgmeta->author(Unknown);
}

if ($svgmeta->license() eq ) {
$svgmeta->license(Unknown);
}

if (! $svgmeta->keywords()) {
$svgmeta->addKeyword(unsorted);
} elsif ($svgmeta->hasKeyword(unsorted) && $svgmeta->keywords()>1) {
$svgmeta->removeKeyword(unsorted);
}

print $svgmeta->to_text();

This module provides a way of extracting, browsing and using RDF metadata embedded in an SVG file.

The SVG spec itself does not provide any particular mechanisms for handling metadata, but instead relies on embedded, namespaced RDF sections, as per XML philosophy. Unfortunately, many SVG tools dont support the concept of RDF metadata; indeed many dont support the idea of embedded XML "islands" at all. Some will even ignore and drop the rdf data entirely when encountered.
The motivation for this module is twofold. First, it provides a mechanism for accessing this metadata from the SVG files. Second, it provides a means of validating SVG files to detect if they have the metadata.

The motivation for this script is primarily for the Open Clip Art Library (http://www.openclipart.org), as a way of filtering out submissions that lack metadata from being included in the official distributions. A secondary motivation is to serve as a testing tool for SVG editors like Inkscape (http://www.inkscape.org).