imagetorawtool.java

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

/*
 *   
 *
 * Copyright  1990-2007 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program 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.
 * 
 * This program 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 at /legal/license.txt).
 * 
 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 *
 */

/**
 * This tool takes list of input images and XML description of raw image
 * format and then converts the input images into raw format images stored
 * in the specified output directory.
 *
 * It understands following command line arguments:
 * -format <filename> : XML file with raw image format description
 * -out <dirname>     : output folder to place converted images to
 * <filename>+        : filenames of input images
 *
 */

package com.sun.midp.imageutil;

import java.io.*;

import javax.xml.parsers.*;

import org.w3c.dom.*;

import java.awt.image.*;
import java.awt.*;
import java.util.Vector;

/**
 * Represents image to raw conversion job
 */
class ImageToRawJob {
    /** XML file name with raw image format */
    public String formatXMLFileName = "";

    /** Input images file list */
    public Vector inImagesFiles = new Vector();

    /** Output images directory name */
    public String outImagesDirName = "";
}

/**
 * Main tool class
 */
public class ImageToRawTool {
    /**
     * for converting image into raw format
     */
    com.sun.midp.imageutil.ImageToRawConverter converter;

    /**
     * Romization job to perform
     */
    private static ImageToRawJob imageToRawJob = null;

    /**
     * Print debug output while running
     */
    private static boolean debug = false;

    /**
     * Print usage info and exit
     */
    private static boolean printHelp = false;

    /**
     * raw image file format
     */
    int rawFormat = ImageToRawConverter.FORMAT_INVALID;

    /**
     * raw image color format
     */
    int colorFormat = ImageToRawConverter.FORMAT_INVALID;

    /**
     * raw image data endianess
     */
    int endianFormat = ImageToRawConverter.FORMAT_INVALID;

    /**
     * array of strings used in XML file to specify raw image format
     */
    static String[] imageFormatStrings = {
            // raw file formats
            "Putpixel",
            "ARGB",
            // endianess
            "Little",
            "Big",
            // supported pixel formats
            "565",
            "888",
    };

    /**
     * array of constants corresponding to strings above
     */
    static int[] imageFormats = {
            // raw file formats
            ImageToRawConverter.RAW_FORMAT_PP,
            ImageToRawConverter.RAW_FORMAT_ARGB,
            // endianess
            ImageToRawConverter.INT_FORMAT_LITTLE_ENDIAN,
            ImageToRawConverter.INT_FORMAT_BIG_ENDIAN,
            // supported pixel formats
            ImageToRawConverter.COLOR_FORMAT_565,
            ImageToRawConverter.COLOR_FORMAT_888
    };

    /**
     * Main method
     *
     * @param args Command line arguments
     */
    public static void main(String[] args) {
        try {
            parseArgs(args);
            if (printHelp) {
                printHelp();
                return;
            }
            if (!validateParsedArgs()) {
                System.exit(1);
            }
            ImageToRawTool tool = new ImageToRawTool();
            tool.convert(imageToRawJob);

        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    /**
     * Parses command line arguments
     *
     * @param args command line arguments
     */
    private static void parseArgs(String[] args) {
        imageToRawJob = new ImageToRawJob();

        if (args.length < 1) printHelp = true;
        for (int i = 0; i < args.length; ++i) {
            String arg = args[i];
            if (arg.equals("-format")) {
                imageToRawJob.formatXMLFileName = args[++i];
            } else if (arg.equals("-out")) {
                imageToRawJob.outImagesDirName = args[++i];
            } else if (arg.equals("-debug")) {
                debug = true;
            } else if (arg.equals("-help")) {
                printHelp = true;
            } else {
                imageToRawJob.inImagesFiles.add(arg);
            }
        }
    }

    /**
     * Creates a directory structure.
     *
     * @param fullDirName Full directory path to be created.
     * @throws IOException is thrown if directory couldn't be created
     */
    private static void makeDirectoryTree(String fullDirName)
            throws IOException {

        if (debug) {
            System.out.println("mkdir: " + fullDirName);
        }
    }

    /**
     * Validates parsed arguments, printing error message
     * if some arg is invalid.
     *
     * @return true, if all arguments are valid
     */
    private static boolean validateParsedArgs() {
        // XML file with raw image format description
        File f = new File(imageToRawJob.formatXMLFileName);
        if (!f.isFile()) {
            System.err.println("Couldn't find raw image format XML file: "
                    + '"' + imageToRawJob.formatXMLFileName + '"');

            return false;
        }
        // input images file list
        if (imageToRawJob.inImagesFiles.isEmpty()) {
            System.err.println("No input images are specified");
            return false;
        }

        // output images directory
        try {
            File outDir = new File(imageToRawJob.outImagesDirName);
            if (!(outDir).exists()) {
                if (!(outDir).mkdirs()) {
                    System.err.println("Failed to create output directory: "
                            + '"' + imageToRawJob.outImagesDirName + '"');

                    return false;
                }
            }
            imageToRawJob.outImagesDirName = outDir.getCanonicalPath();
        } catch (IOException ioe) {
            return false;
        }
        return true;
    }

    /**
     * Prints usage information
     */
    private static void printHelp() {
        /**
         * Following options are recognized:
         * -format:     XML file describing raw image format.
         * -out:        Output images folder.
         * -help:       Print usage information
         * -debug:      Be verbose: print some debug info while running.
         */
        System.err.println("\n"
                + "  ImageToRawTool arguments:\n\n"
                + "    [-help] \n"
                + "    [-debug] \n"
                + "    -format <formatXMLFile> \n"
                + "    -out <outputImagesDirectory> \n"
                + "    <imageToConvert>+");
    }

    /**
     * Does the actual romization
     *
     * @param imageToRawJob romization to perform
     * @throws Exception if there was an error during romization
     */
    public void convert(ImageToRawJob imageToRawJob)
            throws Exception {

        // load XML file as DOM tree
        DocumentBuilderFactory domFactory =
                DocumentBuilderFactory.newInstance();

        // do not validate input XML file,
        // we assume it has been validated before
        domFactory.setValidating(false);

        DocumentBuilder domBuilder = domFactory.newDocumentBuilder();
        Document domDoc = domBuilder.parse(
                new File(imageToRawJob.formatXMLFileName));
        if (!searchImageFormat(domDoc.getDocumentElement())) {
            throw new Exception(
                "XML document contains no raw image format description");
        };
        converter = new ImageToRawConverter(
                rawFormat, colorFormat, endianFormat);

        // convert and save images
        Vector images = imageToRawJob.inImagesFiles;
        for (int i = 0;  i < images.size(); i++) {
            String inputFile = (String)images.elementAt(i);
            String fileName = new File(inputFile).getName();
            if (fileName.lastIndexOf('.') > 0) {
                fileName = fileName.replaceFirst("\\.[^.]*?$", ".raw");
            } else fileName += ".raw";
            String outputFile = imageToRawJob.outImagesDirName +
                    File.separator + fileName;
            convertImageToRaw(inputFile, outputFile);
        }
    }

    /**
     * Utility method. Gets BuffredImage data as in array.
     *
     * @param image BufferedImage to return data for
     * @return image data as byte array
     */
    private int[] getBufferedImageData(BufferedImage image) {
        int width = image.getWidth(null);
        int height = image.getHeight(null);
        BufferedImage bi = new BufferedImage(width, height,
                BufferedImage.TYPE_INT_ARGB);

        Graphics g = bi.getGraphics();
        try {
            g.drawImage(image, 0, 0, width, height, null);
        } finally {
            g.dispose();
        }

        DataBuffer srcBuf = bi.getData().getDataBuffer();
        return ((DataBufferInt) srcBuf).getData();
    }


    private void convertImageToRaw(String sourceName, String destName)
            throws Exception {

        // load image
        BufferedImage image =
                javax.imageio.ImageIO.read(new File(sourceName));
        int width = image.getWidth(null);
        int height = image.getHeight(null);
        boolean hasAlpha = image.getColorModel().hasAlpha();
        int[] imageData = getBufferedImageData(image);

        // convert image
        byte[] rawData = converter.convertToRaw(
                imageData, width, height, hasAlpha);

        // save image
        if (new File(destName).exists())
            System.out.println("Overwrite raw image: " + destName);
        else System.out.println("Produce raw image: " + destName);

        FileOutputStream writer = new FileOutputStream(destName);
        writer.write(rawData);
        writer.close();
    }

    /**
     * Walks the XML tree and search for raw image format node
     *
     * @param n current DOM node in document
     */
    private boolean searchImageFormat(Node n) throws Exception {

        if (n.getNodeName().equals("rawimage") &&
                (n instanceof Element)) {
            readRawImageFormat(n);
            return true;
        } else {
            NodeList list = n.getChildNodes();
            for (int i = 0; i < list.getLength(); i++) {
                if (searchImageFormat(list.item(i)))
                    return true;
            }
        }
        // Image format description is not found
        return false;
    }

    /**
     * Collects raw image format specification
     *
     * @param n current DOM node in document
     * @throws Exception if there was an error during romization
     */
    private void readRawImageFormat(Node n) throws Exception {
        Element e = (Element) n;

        String rawFormatStr = e.getAttribute("Format");
        rawFormat = ImageToRawConverter.FORMAT_INVALID;
        for (int i = 0; i < imageFormatStrings.length; ++i) {
            if (imageFormatStrings[i].equals(rawFormatStr)) {
                rawFormat = imageFormats[i];
                break;
            }
        }
        if (rawFormat == ImageToRawConverter.FORMAT_INVALID) {
            throw new IllegalArgumentException("Invalid raw file format "
                    + '"' + rawFormatStr + '"');
        }

        String colorFormatStr = e.getAttribute("Colors");
        colorFormat = ImageToRawConverter.FORMAT_INVALID;
        for (int i = 0; i < imageFormatStrings.length; ++i) {
            if (imageFormatStrings[i].equals(colorFormatStr)) {
                colorFormat = imageFormats[i];
                break;
            }
        }
        if (colorFormat == ImageToRawConverter.FORMAT_INVALID) {
            throw new IllegalArgumentException("Invalid color format "
                    + '"' + colorFormatStr + '"');
        }

        String endianFormatStr = e.getAttribute("Endian");
        endianFormat = ImageToRawConverter.FORMAT_INVALID;
        for (int i = 0; i < imageFormatStrings.length; ++i) {
            if (imageFormatStrings[i].equals(endianFormatStr)) {
                endianFormat = imageFormats[i];
                break;
            }
        }
        if (endianFormat == ImageToRawConverter.FORMAT_INVALID) {
            throw new IllegalArgumentException("Invalid color format "
                    + '"' + endianFormatStr + '"');
        }

        if (!ImageToRawConverter.isFormatSupported(rawFormat, colorFormat))
        {
            throw new IllegalArgumentException(
                    "Unsupported row image type: "
                            + " format " + '"' + rawFormat + '"'
                            + ", color " + '"' + colorFormat + '"');
        }
    }

}