Free meta data software for linux

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;

Class::Meta is a Perl class automation, introspection, and data validation.

SYNOPSIS

Generate a class:
package MyApp::Thingy;
use strict;
use Class::Meta;
use Class::Meta::Types::String;
use Class::Meta::Types::Numeric;

BEGIN {

# Create a Class::Meta object for this class.
my $cm = Class::Meta->new( key => thingy );

# Add a constructor.
$cm->add_constructor(
name => new,
create => 1,
);

# Add a couple of attributes with generated methods.
$cm->add_attribute(
name => uuid,
authz => Class::Meta::READ,
type => string,
required => 1,
default => sub { Data::UUID->new->create_str },
);
$cm->add_attribute(
name => name,
is => string,
required => 1,
default => undef,
);
$cm->add_attribute(
name => age,
is => integer,
default => undef,
);

# Add a custom method.
$cm->add_method(
name => chk_pass,
view => Class::Meta::PUBLIC,
);
$cm->build;
}
Then use the class:
use MyApp::Thingy;

my $thingy = MyApp::Thingy->new;
print "ID: ", $thingy->id, $/;
$thingy->name(Larry);
print "Name: ", $thingy->name, $/;
$thingy->age(42);
print "Age: ", $thingy->age, $/;
Or make use of the introspection API:
use MyApp::Thingy;

my $class = MyApp::Thingy->my_class;
my $thingy;

print "Examining object of class ", $class->package, $/;

print "nConstructors:n";
for my $ctor ($class->constructors) {
print " o ", $ctor->name, $/;
$thingy = $ctor->call($class->package);
}

print "nAttributes:n";
for my $attr ($class->attributes) {
print " o ", $attr->name, " => ", $attr->get($thingy), $/;
if ($attr->authz >= Class::Meta::SET && $attr->type eq string) {
$attr->get($thingy, hey there!);
print " Changed to: ", $attr->get($thingy), $/;
}
}

print "nMethods:n";
for my $meth ($class->methods) {
print " o ", $meth->name, $/;
$meth->call($thingy);
}

Class::Meta provides an interface for automating the creation of Perl classes with attribute data type validation. It differs from other such modules in that it includes an introspection API that can be used as a unified interface for all Class::Meta-generated classes. In this sense, it is an implementation of the "Facade" design pattern.

Mar project is a simple binary file format for storing arbitrary meta and user data.
Both the mar library and the accompanying utility are written in C with the intention of porting to many platforms. A set of C++ wrapper classes (along with a test file that utilises these classes) are included.
These classes provide familar stream and iterator abstractions over the mar library. The package has currently been tested on PCs running FreeBSD, Linux and Windows ME, 2000 & XP. Some testing has also been conducted on architectures running HPUX & Solaris
Enhancements:
- The general portability of the package has been improved.
- Alignment issues have been resolved on non-i386 architectures.
- A Makefile has now been added to the source directory.
- Additional debug output has been added.
- A number of API calls now return MAR_NOMATCH.

Image::MetaData::JPEG::TagLists contains a collection of tag tables for JPEG segments. Image::MetaData::JPEG::TagLists 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.

Valid tags for Exif APP1 data

The Japan Electronics and Information Technology Industries Association (JEITA) set up a standard for an exchange format for digital still cameras pictures, known as Exif. This standard defines a structure for embedding meta-data in a JPEG picture, to be written in the APP1 segment. The generalities and the reference documents about this structure are introduced in the Structure appendix; this section and its subsections list the valid interoperability record tags as well as their format.

Canonical Exif 2.2 and TIFF 6.0 tags for IFD0 and IFD1

In general, IFD0 and IFD1 can host tags from the same set. These tags are divided in three categories: canonical, additional and registered to companies. The tags listed in the following table are to be considered canonical; they are described at length in the Exif standard document, and can be found both in the IFD0 and in the IFD1 (some of them, in fact, must be present in both directories).

The class column carries the tag class; possible values are: A (image data structure), B (offsets), C (image data characteristics), D (other tags) and P (pointers to other IFDs). The two following columns show tag hexadecimal codes and names. The type column specifies the (always unsigned) tag type: I (short or long), S (short), L (long), R (rational) and A (ASCII, always null terminated). The count column obviously carries the tag count (- for a variable count, either because it is a variable length string or because it depends on other tags).

The IFD0 and IFD1 columns specify the support level in the respective directory; each column comprises four letters, because both the primary image (IFD0) and the thumbnail (IFD1) can come in four varieties (uncompressed chunky, uncompressed planar, uncompressed YCC and JPEG compressed).

This module currently focuses only on JPEG pictures (not TIFF), so only the fourth letter of the IFD0 column is interesting, but note that the thumbnail of a JPEG image can be uncompressed. The support level codes stand for: M (mandatory), R (recommended), O (optional), N (not_recorded) and J (included in JPEG marker and so not recorded).

The thumbnail-only column shows a T for those records which cannot be set/changed by the user exception made during a thumbnail update action (and some of them are calculated automatically anyway). Note that, in some cases, it is possible to set a tag when its support level is N (e.g., the YCbCr stuff in IFD1): picture displaying programs should however simply ignore it. Some other tags, concerning offsets or thumbnail specific information, cannot be set by the module user (they are calculated automatically, more reliably): these are marked by calculated in the notes, or by a T in the thumbnail-only column.

Hexadecimal code count IFD0 IFD1 thumbnail-only
class | Tag name type | supp.supp.| notes
| | | | | | | | |
A 100 ImageWidth I 1 MMMJ MMMJ T (not JPEG) pixels/row
A 101 ImageLength I 1 MMMJ MMMJ T (not JPEG) num. rows
A 102 BitsPerSample S 3 MMMJ MMMJ T (not JPEG) 8,8,8
A 103 Compression S 1 MMMJ MMMM T 1(uncompr.) or 6(JPEG)
A 106 PhotometricInterpretation S 1 MMMN MMMJ 2(RGB) or 6(YCbCr)
D 10e ImageDescription A - RRRR OOOO (see note 1)
D 10f Make A - RRRR OOOO camera manufacturer
D 110 Model A - RRRR OOOO camera model
B 111 StripOffsets I - MMMN MMMN calculated
A 112 Orientation S 1 RRRR OOOO (see note 2)
A 115 SamplesPerPixel S 1 MMMJ MMMJ T (not JPEG) 3 compon.
B 116 RowsPerStrip I 1 MMMN MMMN T (not JPEG)
B 117 StripByteCounts I - MMMN MMMN T (not JPEG)
A 11a XResolution R 1 MMMM MMMM (see note 3)
A 11b YResolution R 1 MMMM MMMM (see note 3)
A 11c PlanarConfiguration S 1 OMOJ OMOJ (see note 4)
A 128 ResolutionUnit S 1 MMMM MMMM (see note 3)
C 12d TransferFunction S 768 RRRR OOOO (see note 5)
D 131 Software A - OOOO OOOO Exif software/firmware
D 132 DateTime A 20 RRRR OOOO (see note 6)
D 13b Artist A - OOOO OOOO owner/photogr./creator
C 13e WhitePoint R 2 OOOO OOOO (see note 5)
C 13f PrimaryChromaticities R 6 OOOO OOOO (see note 5)
B 201 JPEGInterchangeFormat L 1 NNNN NNNM calculated
B 202 JPEGInterchangeFormatLength L 1 NNNN NNNM T (only JPEG)
C 211 YCbCrCoefficients R 3 NNOO NNOO (see note 7)
A 212 YCbCrSubSampling S 2 NNMJ NNMJ (see note 7)
A 213 YCbCrPositioning S 1 NNMM NNOO (see note 7)
C 214 ReferenceBlackWhite R 6 OOOO OOOO (see note 8)
D 8298 Copyright A - OOOO OOOO of photogr./editor
P 8769 ExifOffset L 1 MMMM OOOO calculated
P 8825 GPSInfo L 1 OOOO OOOO calculated

Object::Relation::DataType is a Perl module with complex data types for TKP.

The Object::Relation::DataType name space is set aside for the creation of complex data types for TKP. By "complex" I mean serializable objects, such as dates, durations, states, etc. It also is designed to create a distinction from simpler data types, which are defined in Object::Relation::Meta::DataTypes.

What creates the distinction? Well, first and foremost is that fact that it doesnt usually take much to create the simple data types, while the complex data types might need more code to handle serialization and deserialization, overloading, etc.

But another criterion is that, while the data types in Object::Relation::Meta::DataTypes are always loaded by TKP, since it uses them for its own classes, the complex data types in the Object::Relation::DataType name space tend to be loaded only as needed by the Object::Relation business classes that need them.

Okay, so its somewhat arbitrary, but you get the idea. The remainder of this document is dedicated to documenting how to add new data types to TKP.

weta-dfs is a distributed file system. weta-dfs is designed to be fail-safe through replications of files, fast and easy to install, platform independent, and to have fast recovery from crashes.

It consists of Data Node Servers and one Meta Data Server and a java.io.File-like client API.

Class::Meta::Type is a Perl module for data type validation and accessor building.

SYNOPSIS

package MyApp::TypeDef;

use strict;
use Class::Meta::Type;
use IO::Socket;

my $type = Class::Meta::Type->add( key => io_socket,
desc => IO::Socket object,
name => IO::Socket Object );

This class stores the various data types used by Class::Meta. It manages all aspects of data type validation and method creation. New data types can be added to Class::Meta::Type by means of the add() constructor. This is useful for creating custom types for your Class::Meta-built classes.

Note:This class manages the most advanced features of Class::Meta. Before deciding to create your own accessor closures as described in add(), you should have a thorough working knowledge of how Class::Meta works, and have studied the add() method carefully. Simple data type definitions such as that shown in the SYNOPSIS, on the other hand, are encouraged.