Free jpeg image software for linux

JPEG Fit is a PHP class that can be used to optimize images to fit within a given file size limit. The project takes a picture in any format supported by the GD library and generates a JPEG picture with the maximum quality factor that makes the picture file size not exceed a given limit.

This class is similar to the JPEG Reducer class. It uses the binary search algorithm to reach the ideal quality factor in the smallest number of iterations.

The class stops searching when a given number of limit iterations is reached, or when the quality factor difference between the ideal and the found values is less than the configured precision value

Process Raw Images is a service menu for processing many raw images at once. Supports output to Jpeg, Png and Tiff.

Axmjpeg application retrieves JPEG images from an MJPEG over HTTP stream that conforms to the Axis Video API, HTTP Interface Specification.
Axmjpeg retrieves JPEG images from an MJPEG over HTTP stream. The HTTP stream must conform to Revision 2.x of the "Axis Video API, HTTP Interface Specification" (which is available from "http://www.axis.com/techsup/cam_servers/dev/cam_http_api.htm").
Axmjpeg also supports Revision 1.x of this specification provided the optional "Content-Length:" header is enabled.
This tool was written for cammgr, the web camera management software available from "http://freshmeat.net/projects/cammgr". Specifically, it allows cammgr to support the great range of Axis network cameras available from "http://www.axis.com".
However, its easy to come up with other uses for axmjpeg.
The manual page describes the full range of functionality; the basic list is:
- save JPEG images to the same (optionally renamed) file.
- save each JPEG image to a unique file.
- pipe JPEG images to shell commands (for more processing).
- time-based capturing, where only one image per the specified interval will be selected for processing.
Axmjpeg was developed on FreeBSD and tested on a wide range of Unix systems including several Linux variants, HP-UX, Tru64, and SunOS.
Enhancements:
- The image-fetching code was extended to support cameras that send binary headers in the MJPEG HTTP stream.
- This version of axmjpeg is known to support the "SQ IP Cam" and the "GP-280 Network IP Camera."

jpeg2ps is a utility for converting JPEG images to compressed PostScript Level 2 or 3 files (without uncompressing the images).

The JPEG data is simply >wrapped< with PostScript which yields considerably smaller PS files. This project is a simple command line utility and can be used on DOS, Windows and Unix machines.

Usage: jpeg2ps [options] jpegfile > epsfile
-a auto rotate: produce landscape output if width > height
-b binary mode: output 8 bit data (default: 7 bit with ASCII85)
-h hex mode: output 7 bit data in ASCIIHex encoding
-o < name > output file name
-p < size > page size name. Known names are:
a0, a1, a2, a3, a4, a5, a6, b5, letter, legal, ledger, p11x17
-q quiet mode: suppress all informational messages
-r < dpi > resolution value (dots per inch)
0 means use value given in file, if any (disables autorotate)

ImageInfo is a free Java class to retrieve properties from image files.

The following file formats are currently supported: JPEG, PNG, GIF, BMP, PCX, IFF, RAS, PBM, PGM, PPM and PSD (read why TIFF is not included). ImageInfo can recognize these formats, and in addition determine image width, height and color depth (bits per pixel).

Also check out ffident, my file format (group) and MIME type identification library. It extracts less information than ImageInfo (it only recognizes the format, no metadata), but it supports more formats and new formats can be added by editing a text file. Similar to file(1) / magic(5).

Using ImageInfo from within a Java application or applet

The image file can be any InputStream object or an instance of a class implementing DataInput (like RandomAccessFile). Here is some sample code on how to use the class:

ImageInfo ii = new ImageInfo();
// in can be InputStream or RandomAccessFile (or DataInput)
ii.setInput(in);
/* if you want to know how many images there are in a file,
uncomment the following line; will slow down ImageInfo
with animated GIFs */
//ii.setDetermineImageNumber(true);

// check does the actual work, you wont get results before
// you have called it
if (!ii.check())
{
System.err.println("Not a supported image file format.");
}
else
{
System.out.println(
ii.getFormatName() + ", " +
ii.getMimeType() + ", " +
ii.getWidth() + " x " + ii.getHeight() + " pixels, " +
ii.getBitsPerPixel() + " bits per pixel, " +
ii.getNumberOfImages() + " image(s).");
// there are other properties, check out the API documentation
}

Using ImageInfo as a command line program

ImageInfo also has a main method that makes it a command line tool. Assuming that ImageInfo.class is in your classpath, giving the class to java with some file names as arguments will be sufficient. Here is an example call including output:

$ java ImageInfo test.jpg
test.jpg
File format: JPEG
MIME type: image/jpeg
Width (pixels): 1556
Height (pixels): 2048
Bits per pixel: 24
Progressive: false
Number of images: 1
Physical width (dpi): 300
Physical height (dpi): 300
Physical width (inches): 5.1866665
Physical height (inches): 6.826667

JImage-Analyst is a JAVA based library for extracting meta information from various image file formats.
Main features:
- Supported Image formats: BMP, CUR, GIF, ICO, IFF, JPEG, PCX, PNG, PNM (PBM, PGM, PPM), PSD, RAS, SWF, TGA, TIFF, XCF
- The following information are available:
- The format
- The mime type
- Dimension (width / height)
- Physical width and height (in DPI and inch)
- Bits per pixel
- Whether the image is progressive
- Comments from the image (such as in JPEG files)
- Number of images (such as with animated GIFs)
- High speed and low memory consumption
- No dependencies on 3rd party libraries
- No dependencies on AWT classes
- An architecture that allows to ass further formats very easily
Examples:
File file = new File("test.gif");
JImageAnalyst analyst = JImageAnalystFactory.getDefaultInstance();
ImageInfo imageInfo = analyst.analyze(file);
System.out.println("Format: " + imageInfo.getFormat());
System.out.println("MIME-Type: " + imageInfo.getMimeType());
System.out.println("Width: " + imageInfo.getWidth());
System.out.println("Height: " + imageInfo.getHeight());
System.out.println("BitsPerPixel: " + imageInfo.getBitsPerPixel());
// ... more information is available in imageInfo ...