Free film software for linux

thin liquid film project is an application which allows linux users to quickly and easily convert video files into a format suitable for playing on the video capable ipods. I wrote this application, after purchasing a video ipod, and being frustrated that the only real option for converting video was either via command-line, or via a servicemenu with no ability to configure the resulting video file.
TLF uses the ffmpeg engine to do the encoding. It is written in pyqt, so it should work with a default kde installation, and is very easy to install.
features ...
Main features:
- Batch process any number of files;
- Display detailed information about source video files;
- Change output settings for one or many files;
- Save default settings for future sessions;
- Configure output quality settings;
- Choose between mpeg4 and h264 as output codec;
- Choose between 320 and 640 output video width, while maintaining aspect ratio;
- Choose between 1 or 2 pass encoding;
- Progress bar to show encoding progress;
- Uses ffmpeg as the encoding engine;
- Upload encoded files to your ipod directly;
- Set file information for upload to your ipod;
- Add files to existing or new video playlists on your ipod;
- Add files for encoding via the included servicemenu.

SLMotion is a small prog for a small request. Ive to make a film with a special effect : slow a video and speed up after ... like prof films. I search a tool and dont find one on Linux, so i make it myself.

To run :

Untar the archive
./slmotion

Usage :

1 - Load a video
2 - Select a part of the video to apply effect. Take most frame that you need its more easy to reimplement your video after.
3 - Select precisely the first and last image to apply the effect
4 - Choose the value to reduce speed
5 - Lets go and enjoy

labTimer is a set of timer suited to black and white film processing. At the moment, the program can follow a basic sequence of development, fixing, and washing, with nice countdowns and reminders.

Self processing of black and white films is an unexciting, dull and tedious task. If you are here, you probably already know what I mean. Taking pictures, framing, sensing the light, choosing models and points of view is creative. Turning on the red light, making a contact sheet, selecting snapshots and printing a good negative with carefully forethought masking is creative. But between the shooting and the the proud display of the print, stands the prosaic duty of processing the film.

If youre so new to photography, or masochistic enough, as to wonder why, the answer is that film processing is done inside a dark, sealed, cylinder. From the moment you open the film canister in the complete darkness, until the end of the processing, you have zero opportunity to willingly influence the result. Therefore, processing is a completely "industrialized" process, where you have to follow blindly some procedures and just hope the result will match your expectations.

Dont misinterpret me ! During that process, there are numerous options to influence the outcome, but parameters cannot be chosen depending on the current state of the film. Therefore the choice of the values given to those parameters depends on previous results, manufacturers figures, and personal experience. Todays industrial norms are so strict that processing a film can be considered deterministic. If the pictures are ultimately over or under exposed, blurred or whatever, then its the photographers sole responsability.

GlobMoeSt means Global Motion eStimation.

Currently, the program works by determining the global motion vectors between each two subsequent frames via an exhaustive search within a specified motion search range, which can tweaked depending on the input data.

Nonlinear motion is supported. Motion vectors can be saved to a file, allowing for speedier tinkering with options (like construction mode or cropping of input frames), after a first pass.

The image difference function can use different color spaces (RGB and YUV) and can be influenced via user supplied coefficients, which allows the user to assign different weightings to different color components.

After determining the best motion vectors, the image is assembled, using one of currently three modes, one of which tries to avoid any intra-frame motion, while another one blends areas in which frames overlap.

The blending mode is able to reduce (film or compression) noise (especially for animated content, when there is little to no intra-frame motion, but only global motion), and can give a (blurry) impression of movement in case of intra-frame motion (which may, or may not be wanted). It can also be used to blend pictures, without using the motion estimation component.

diskWriggler is a benchmark tool for testing disk-based storage throughput. diskWriggler has been designed to provide a report that is meaningful to systems engineers working in the film and post-production industries.
diskWriggler source code is available free and is licensed under the GNU GPL. By providing an Open Source benchmark application XDT enables users to determine comparative throughput with any hardware vendor whilst maintaining a level playing field.
Enhancements:
- Support for large files (> 2 GB) under Linux was fixed.
- Compilation under the Fedora Core 5 distribution was fixed.

DBIx::Class::FormTools is a utility module for building forms with multiple related DBIx::Class objects.

SYNOPSIS

In the examples I use 3 objects, a Film, an Actor and a Role. Role is a many to many relation between Film and Actor.

package MySchema;
use base DBIx::Class::Schema;
__PACKAGE__->load_classes(qw[
Film
Actor
Role
]);

package MySchema::Film;
__PACKAGE__->table(films);
__PACKAGE__->add_columns(qw[
id
title
]);
__PACKAGE__->set_primary_key(id);
__PACKAGE__->has_many(roles => MySchema::Role, film_id);


package MySchema::Actor;
__PACKAGE__->table(films);
__PACKAGE__->add_columns(qw[
id
name
]);
__PACKAGE__->set_primary_key(id);
__PACKAGE__->has_many(roles => MySchema::Role, actor_id);

package MySchema::Role;
__PACKAGE__->table(roles);
__PACKAGE__->add_columns(qw[
film_id
actor_id
]);
__PACKAGE__->set_primary_key(qw[
film_id
actor_id
]);

__PACKAGE__->belongs_to(film_id => MySchema::Film);
__PACKAGE__->belongs_to(actor_id => MySchema::Actor);
In your Model class
use base qw/DBIx::Class/;
__PACKAGE__->load_components(qw/PK::Auto::Pg Core FormTools/);
In your view - HTML::Mason example
< %init >
my $film = $schema->resultset(Film)->find(42);
my $actor = $schema->resultset(Actor)->find(24);
< /%init >
< form >
< input
name="< % $film->form_fieldname(title, o1) => Title % >"
type="text"
value="< % $film->title % >"
/ >
< input
name="< % $film->form_fieldname(length, o1) % >"
type="text"
value="< % $film->length % >"
/ >
< input
name="< % $film->form_fieldname(comment, o1) % >"
type="text"
value="< % $film->comment % >"
/ >
< input
name="< % $actor->form_fieldname(name, o2) % >"
type="text"
value="< % $actor->name % >"
/ >


In your controller (or cool helper module, used in your controller)
my @objects = DBIx::Class::FormTools->formdata_to_objects($querystring);
foreach my $object ( @objects ) {
# Assert and Manupulate $object as you like
$object->insert_or_update;
}

jrMan is an open source version of the REYES rendering algorithm used by Pixars PhotoRealistic Renderman.
Almost all digital production work in the film industry is rendered using this algorithm, yet most computer graphics textbooks fail to mention it or only provide a very superficial description of how it works.
jrMans main objective is to provide an open source implementation of the REYES rendering algorithm to permit, both students and teachers, to understand how it works and experiment with it.
To achieve this objective the source code must be easy to read and should run on most operating systems. This is the one of the reasons we are implementing it in Java.
Main features:
- NURBS
- Curves
- Rational bicubic patches
- Patch meshes
- Smooth micropolygon interpolation
- Delayed ReadArchive
- Alpha output in RGBA images
- Many bug fixes
- Smaller RAM footprint when rendering large/complex scenes

Hierarchical Data Format is a general purpose library and file format for storing scientific data.
HDF5 can store two primary objects: datasets and groups. A dataset is essentially a multidimensional array of data elements, and a group is a structure for organizing objects in an HDF5 file. Using these two basic objects, one can create and store almost any kind of scientific data structure, such as images, arrays of vectors, and structured and unstructured grids. You can also mix and match them in HDF5 files according to your needs.
Efficient storage and I/O.
HDF5 was created to address the data management needs of scientists and engineers working in high performance, data intensive computing environments. As a result, the HDF5 library and format emphasize storage and I/O efficiency. For instance, the HDF5 format can accommodate data in a variety of ways, such as compressed or chunked. And the library is tuned and adapted to read and write data efficiently on parallel computing systems.
Software.
NCSA maintains a suite of free, open source software, including the HDF5 I/O library and several utilities. The HDF5 user community also develops and contributes software, much of it freely available. Unlike HDF4, there is little commercial support for HDF5 at this time, but we are successfully working with vendors to change this.
Emphasis on standards.
Data can be stored in HDF5 in an endless variety of ways, so it is important for communities of users to standardize on how their data is to be organized in HDF5. This makes it possible to share data easily, and also to build and share tools for accessing and analyzing data stored in HDF5. The NCSA HDF team works with users to encourage them to organize HDF5 files in standard ways.
Large and varied user community.
HDF5 users range across a variety of engineering and scientific fields, and even some non-technical fields. Data stored in HDF5 is used for a wide range of applications, from computational fluid dynamics to film making.
Main features:
- Parallel HDF5 - Information on installing and using Parallel HDF5
- SZIP Compression - Information about SZIP Compression in HDF5
- Thread Safe HDF5 - Information on thread-safe capabilities of HDF5 and how to install
- The High Level HDF5 APIs, previously distributed separately, are now distributed as part of the main HDF5 Library:
- High Level HDF5 APIs - Information on installing and using the High Level HDF5 APIs
Applications:
- HDF Java Products - HDF4/HDF5 Java interfaces and viewer, HDFView.
- HDF Web-browser Plug-in - The HDF Web-browser plug-in is a windowed browser plug-in that is launched from a web browser to display HDF4 and HDF5 files.
- netCDF-4 - The NCSA and NetCDF groups are collaborating on a version of NetCDF built on top of HDF5.
- HDF5 XML Information Page - DTD and tools for using HDF5 with XML
- HDF5 WRF I/O Module - I/O module that reads HDF5 datasets for the Weather Research and Forecasting Model
- HDF5 Mesh API (prototype) - API for storing and retrieving structured and unstructured mesh data
Enhancements:
- The default Fortran was switched to G95 when using GCC.
- The autoconf build tools were updated. Fortran interfaces were added for the Image, Table, and Lite APIs.
- A Dimension Scale API (H5DS) was added.
- FreeBSD is now supported on AMD64 with GNU C and Fortran compilers.
- Support for sequential and parallel libraries was added for Intel 64 Linux clusters.
- Several bugs with writing fill values for datasets that have a variable-length datatype or component datatype were fixed.