Java example source code file (README)

This example Java source code file (README) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

decode, fetch, floyd\-steinberg, maskbits, name, note, return, rgb, store, the, these, this, topdownleftright

The README Java example source code

/* 
 * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 * 
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 * 
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 * 
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

This directory contains source code to perform a wide variety of image
conversions for the Java AWT.

The image conversion process is controlled by a function skeleton
defined in the include file <img_scaleloop.h> which invokes a number
of macros in different categories to perform the work of reading and
decoding the input pixels and then scaling, dithering, and storing the
pixels in the destination image structure.  Each part of that process
can be implemented in one of several different ways depending on the
type of input data and output representation needed and depending on
the speed and quality desired.

The conversion process as defined by <img_scaleloop.h> can be broken
down into the following categories:

	Fetching	retrieving pixels from the source pixel data
	Decoding	decoding source pixels into color/alpha information
	Scaling		resampling source data for a different resolution
	Encoding	converting source colors into a destination pixel
	Alpha		converting alpha values into masks or alpha channels
	Storing		storing the final pixels in the destination image

Each category defines a number of different macros that are used by the
code skeleton in <img_scaleloop.h> to perform the work of converting
the images.  The macros for each category are all implemented by a
number of other header files with multiple implementations provided
for each category depending on the particular type of input or output
data desired.  The files which implement the various categories are as
follows:

    Fetching
	<img_input8.h>		Fetch 8 bit pixels from a byte array
	<img_input32.h>		Fetch 32 bit pixels from a int array
	<img_input8_32.h>	Fetch 8 or 32 bit pixels

    Decoding
    	<img_icm.h>		Decode IndexColorModel pixels
    	<img_dcm.h>		Decode DirectColorModel pixels
    	<img_dcm8.h>		Decode DirectColorModel pixels with at
				    least 8 bits per component
    	<img_anycm.h>		Decode any type of ColorModel's pixels (with
				    native handling of Index and Direct)

    Scaling
    	<img_noscale.h>		Don't scale input data at all
	<img_replscale.h>	Nearest Neighbor scaling - replicate or
				    omit pixels as necessary

    Encoding
	<img_nodither.h>	No encoding at all (only for 24-bit images)
	<img_dir8dither.h>	Compose DirectColor pixels, 8-bits/component 
	<img_dirdither.h>	Compose DirectColor pixels up to 8-bits/comp
	<img_fsgray.h>		Floyd-Steinberg error diffusion, gray ramp
				    (requires TopDownLeftRight source data)
	<img_fscolor.h>		Floyd-Steinberg error diffusion, RGB color map
				    (requires TopDownLeftRight source data)
	<img_fsdither.h>	Floyd-Steinberg error diffusion, RGB or gray
				    (requires TopDownLeftRight source data)
	<img_ordgray.h>		unsigned ordered dither error, gray ramp
	<img_ordclruns.h>	unsigned ordered dither error, RGB color map
	<img_ordclrsgn.h>	signed ordered dither error, RGB color map
	<img_orddither.h>	unsigned ordered dither error, RGB or gray
				    (must also include ordclrsgn or ordclruns)

    Alpha
    	<img_opaque.h>		No alpha processing (must be opaque input)
    	<img_alpha.h>		Produce 1-bit transparency masks from alpha
				    data using an ordered dithering technique

    Storing
    	<img_output8.h>		Store 8-bit pixels in a byte array
    	<img_output16.h>	Store 16-bit pixels in a short array
    	<img_output24.h>	Store 24-bit pixels in a byte triplet array
    	<img_output32.h>	Store 32-bit pixels in an int array
    	<img_output8_16_24.h>	Store 8, 16 or 24 bit pixels
    	<img_output8_16_32.h>	Store 8, 16 or 32 bit pixels
    	<img_output8_32.h>	Store 8 or 32 bit pixels

Some of these header files also require a number of definitions to be
provided by the platform implementor.  These definitions are usually
placed in a file called "img_util_md.h" and included when defining an
actual image scaling function (see below).  Most of the definitions
can be implemented using either macros or functions unless indicated
below.  Here is a list of the various required definitions and the
files or categories which rely on them:

used by <img_alpha.h>

    typedef [integer base type] MaskBits;
	Specifies the base type for transparency mask manipulation.
	Some platforms may manipulate masks 8-bits at a time and others
	may manipulate them 32-bits at a time.

    MaskBits *ImgInitMask(cvdata);
	Create a transparency mask buffer and return a handle to it.
	The buffer will be created on the fly whenever the first
	transparent pixel is encountered.  If no transparent pixels
	are ever encountered, there will be no reason to create a
	mask.  The buffer should be initialized to opacity values
	where any existing opaque converted data resides and to
	transparency values where there is no data yet.

    int MaskScan(cvdata);
    	Return the size of a single scan line in the output mask buffer
	in MaskBits sized units.  If the mask data is being buffered a
	scan line at a time, then return 0 to indicate that successive
	scan lines should overwrite each other in the single row-sized
	buffer.

    int MaskOffset(x);
    	Return the index into an array of MaskBits elements where the
	data for the indicated x coordinate resides.  This is typically
	(x >> (sizeof(MaskBits) * 8)).

    int MaskInit(x);
    	Return a number with the appropriate single bit set for modifying
	the mask location for the indicated x coordinate.  This is
	typically (1 << (x & ((sizeof(MaskBits) * 8) - 1))).

    void SetOpaqueBit(mask, bit);
    	Perform the necessary logical operation on the accumulator "mask"
	with the indicated "bit" to indicate an opaque pixel.  If bits set
	to 1 represent opacity, then this operation is typically defined
	as (mask |= bit).  Note that SetOpaqueBit must be implemented as
	a macro since the first argument, the mask accumulator, must be
	modified.

    void SetTransparentBit(mask, bit);
    	Perform the necessary logical operation on the accumulator "mask"
	with the indicated "bit" to indicate a transparent pixel.  If bits
	set to 0 represent transparency, then this operation is typically
	defined as (mask &= (~bit)).  Note that SetTransparentBit must
	be implemented as a macro since the first argument, the mask
	accumulator, must be modified.

used directly by <img_scaleloop.h>

    void BufComplete(cvdata, dstX1, dstY1, dstX2, dstY2);
	Called at the end of the image conversion function to perform any
	final processing on the buffer, the x1,y1,x2,y2 coordinates specify
	the rectangular region of the output buffer that was modified.

used by all <img_output*.h> variants

    void SendRow(ird, dstY, dstX1, dstX2);
    	Called at the end of the processing for a given row to allow
	the platform to buffer converted data by row and then move the
	data into place a row at a time (for instance under X11, you
	might want to convert a row of pixels in a row-sized local
	buffer and then execute XPutImage to send that one row to the
	server to save on the client side memory requirements)

    int ScanBytes(cvdata);
    	Return the size in bytes of a single scan line in the output
	buffer.  If the data is being buffered a scan line at a time,
	then return 0 to indicate that successive scan lines should
	overwrite each other in the single row-sized buffer.

used by <img_fscolor.h> and 

    int ColorCubeFSMap(red, green, blue);
	Return the pixel value of the closest color to the requested
	red, green, and blue components.  The components are already
	bound to the range 0 <= component <= 255.

used by all <img_fs*.h> variants

    void GetPixelRGB(pixel, red, green, blue);
    	Store the appropriate color components for the indicated output
	"pixel" into the red, green, and blue arguments.  Note that
	GetPixelRGB must be implemented as a macro since the last three
	arguments must be modified, but the macro could be implemented
	to call a function.  You can expect that the red, green, and
	blue arguments are simple variables if you need to reference
	them.

used by <img_ordclruns.h> (used to be known as img_ordcolor.h)

    extern uns_ordered_dither_array img_oda_red;
    extern uns_ordered_dither_array img_oda_green;
    extern uns_ordered_dither_array img_oda_blue;
    	These names can be #defined to refer to some other global
	variables.

    int ColorCubeOrdMapUns(red, green, blue);
	Return the pixel value of the next color darker than the
	requested red, green, and blue components.  The components
	are already bound to the range 0 <= component <= 256, where
	256 represents maximum intensity, but 255 represents the
	next to highest intensity.

used by <img_ordclrsgn.h>

    extern sgn_ordered_dither_array img_oda_red;
    extern sgn_ordered_dither_array img_oda_green;
    extern sgn_ordered_dither_array img_oda_blue;
    	These names can be #defined to refer to some other global
	variables.

    int ColorCubeOrdMapSgn(red, green, blue);
	Return the pixel value of the closest color to the requested
	red, green, and blue components.  The components are already
	bound to the range 0 <= component <= 255.
	(Typically equivalent to ColorCubeFSMap(r, g, b))

used by all <img_*gray.h> variants

    extern unsigned char img_grays[256];
    extern unsigned char img_bwgamma[256];
	The img_bwgamma table allows a gamma curve to be placed on the
	grayscale dithering to improve the output match when the gray
	ramp has very few gray values in it.  The img_grays table is
	a simple best match lookup for an 8-bit gray value to the best
	pixel value in the available gray ramp.
    	These names can be #defined to refer to some other global
	variables.

used by <img_ordgray.h>

    extern sgn_ordered_dither_array img_oda_gray;
    	This name can be #defined to refer to some other global
	variable.

To implement a given conversion function, simply create a file which
includes the necessary header files from the above list which match
the properties that you are trying to handle.  In some cases, you can
choose a very general header file to handle more cases as a default
implementation, or a very specific header file to handle common cases
more efficiently.  Then simply define the macro "NAME" to represent
the name of the function you wish to create and then include the skeleton
file <img_scaleloop.h> to do the actual work.  When you compile this file
it will generate an object file which defines a function with the given
name that performs the indicated image conversion.  An example of a file
which defines a very generalized function to convert any input data into
an 8-bit output image with an associated transparency mask (if needed)
would be:

--------genimgcv8.c----------
#include "img_util.h"		/* always needed */
#include "img_util_md.h"	/* supplies platform definitions */

#include "img_input8_32.h"	/* any type of input pixels */
#include "img_anycm.h"		/* any type of input ColorModel */
#include "img_replscale.h"	/* scale if necessary */
#include "img_orddither.h"	/* color or grayscale dithering */
#include "img_alpha.h"		/* generate 1-bit mask if necessary */
#include "img_output8.h"	/* store byte pixels */

#define NAME ImgConvert8	/* Name our function */

#include "img_scaleloop.h"	/* include the skeleton */
-----end of genimgcv8.c------