awt/org/apache/harmony/x/imageio/plugins/jpeg/JPEGImageWriter.java - platform/frameworks/base - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 /**
  * @author Rustem V. Rafikov
  * @version $Revision: 1.3 $
  */
 package org.apache.harmony.x.imageio.plugins.jpeg;

 import com.android.internal.awt.ImageOutputStreamWrapper;

 import javax.imageio.ImageWriter;
 import javax.imageio.IIOImage;
 import javax.imageio.ImageTypeSpecifier;
 import javax.imageio.ImageWriteParam;
 import javax.imageio.plugins.jpeg.JPEGImageWriteParam;
 import javax.imageio.stream.ImageOutputStream;
 import javax.imageio.spi.ImageWriterSpi;
 import javax.imageio.metadata.IIOMetadata;

 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Bitmap.CompressFormat;

 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.awt.image.*;
 import java.awt.*;
 import java.awt.color.ColorSpace;

 /**
  * @author Rustem V. Rafikov
  * @version $Revision: 1.3 $
  */
 public class JPEGImageWriter extends ImageWriter {

     // /* ???AWT: Debugging
     private static final boolean DEBUG = false;
     private static Bitmap bm;
     public static Bitmap getBitmap() {
         return bm;
     }
     private static BufferedImage bufImg;
     public static BufferedImage getBufImage() {
         return bufImg;
     }
     static private RenderedImage renImg;
     static public RenderedImage getRenImage() {
         return renImg;
     }
     // */

     private long cinfo;
     private RenderedImage image;
     private Raster sourceRaster;
     private WritableRaster scanRaster;
     private int srcXOff = 0;
     private int srcYOff = 0;
     private int srcWidth;
     private int srcHeight;

     //-- y step for image subsampling
     private int deltaY = 1;
     //-- x step for image subsampling
     private int deltaX = 1;

     private ImageOutputStream ios;

     public JPEGImageWriter(ImageWriterSpi imageWriterSpi) {
         super(imageWriterSpi);
         //???AWT: cinfo = initCompressionObj();
         cinfo = System.currentTimeMillis();
     }

     static {
         //???AWT
         /*
         System.loadLibrary("jpegencoder");
         initWriterIds(ImageOutputStream.class);
         */
     }

     @Override
     public void write(IIOMetadata iioMetadata, IIOImage iioImage, ImageWriteParam param)
             throws IOException {

         if (ios == null) {
             throw new IllegalArgumentException("ios == null");
         }
         if (iioImage == null) {
             throw new IllegalArgumentException("Image equals null");
         }

         RenderedImage img = null;
         if (!iioImage.hasRaster()) {
             img = iioImage.getRenderedImage();
             if (img instanceof BufferedImage) {
                 sourceRaster = ((BufferedImage) img).getRaster();
             } else {
                 sourceRaster = img.getData();
             }
         } else {
             sourceRaster = iioImage.getRaster();
         }

         // AWT???: Debugging
         if (DEBUG) {
             if( img==null ) {
                 System.out.println("****J: Image is NULL");
             } else {
                 renImg = img;
                 bufImg = (BufferedImage)img;
             }
         }

         int numBands = sourceRaster.getNumBands();
         int sourceIJGCs = img == null ? JPEGConsts.JCS_UNKNOW : getSourceCSType(img);

         srcWidth = sourceRaster.getWidth();
         srcHeight = sourceRaster.getHeight();

         int destWidth = srcWidth;
         int destHeight = srcHeight;

         boolean progressive = false;

         if (param != null) {
             Rectangle reg = param.getSourceRegion();
             if (reg != null) {
                 srcXOff = reg.x;
                 srcYOff = reg.y;

                 srcWidth = reg.width + srcXOff > srcWidth
                         ? srcWidth - srcXOff
                         : reg.width;
                 srcHeight = reg.height + srcYOff > srcHeight
                         ? srcHeight - srcYOff
                         : reg.height;
             }

             //-- TODO uncomment when JPEGImageWriteParam be implemented
             //-- Only default progressive mode yet
             // progressive = param.getProgressiveMode() ==  ImageWriteParam.MODE_DEFAULT;

             //-- def is 1
             deltaX = param.getSourceXSubsampling();
             deltaY = param.getSourceYSubsampling();

             //-- def is 0
             int offsetX = param.getSubsamplingXOffset();
             int offsetY = param.getSubsamplingYOffset();

             srcXOff += offsetX;
             srcYOff += offsetY;
             srcWidth -= offsetX;
             srcHeight -= offsetY;

             destWidth = (srcWidth + deltaX - 1) / deltaX;
             destHeight = (srcHeight + deltaY - 1) / deltaY;
         }

         //-- default DQTs (see JPEGQTable java doc and JPEG spec K1 & K2 tables)
         //-- at http://www.w3.org/Graphics/JPEG/itu-t81.pdf
         //-- Only figuring out how to set DQT in IJG library for future metadata
         //-- support. IJG def tables are the same.
         //JPEGQTable[] dqt = new JPEGQTable[2];
 //        int[][] dqt = null;
 //        int[][] dqt = new int[2][];
 //        dqt[0] = JPEGQTable.K1Div2Luminance.getTable();
 //        dqt[1] = JPEGQTable.K2Div2Chrominance.getTable();

         //???AWT: I think we don't need this amymore
         /*
         //-- using default color space
         //-- TODO: Take destination cs from param or use default if there is no cs
         int destIJGCs = img == null ? JPEGConsts.JCS_UNKNOW : getDestinationCSType(img);

         DataBufferByte dbuffer = new DataBufferByte(numBands * srcWidth);

         scanRaster = Raster.createInterleavedRaster(dbuffer, srcWidth, 1,
                 numBands * srcWidth, numBands, JPEGConsts.BAND_OFFSETS[numBands], null);

         encode(dbuffer.getData(), srcWidth, destWidth, destHeight, deltaX,
                 sourceIJGCs, destIJGCs, numBands, progressive,
                 null, cinfo);
         */

         SampleModel model = sourceRaster.getSampleModel();

         if (model instanceof SinglePixelPackedSampleModel) {
             DataBufferInt ibuf = (DataBufferInt)sourceRaster.getDataBuffer();
             int[] pixels = ibuf.getData();

             // Create a bitmap with the pixel
             bm = Bitmap.createBitmap(pixels, srcWidth, srcHeight, Bitmap.Config.ARGB_8888);

             // Use Bitmap.compress() to write the image
             ImageOutputStreamWrapper iosw = new ImageOutputStreamWrapper(ios);
             bm.compress(CompressFormat.JPEG, 100, iosw);
         } else {
             // ???AWT: Add support for other color models
             throw new RuntimeException("Color model not supported yet");
         }

     }

     @Override
     public void dispose() {
         super.dispose();
         if (cinfo != 0) {
             //???AWT: dispose(cinfo);
             cinfo = 0;
             ios = null;
         }
     }


     public IIOMetadata getDefaultStreamMetadata(ImageWriteParam imageWriteParam) {
         throw new UnsupportedOperationException("not supported yet");
     }

     public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageTypeSpecifier, ImageWriteParam imageWriteParam) {
         throw new UnsupportedOperationException("not supported yet");
     }

     @Override
     public IIOMetadata convertStreamMetadata(IIOMetadata iioMetadata, ImageWriteParam imageWriteParam) {
         throw new UnsupportedOperationException("not supported yet");
     }

     @Override
     public IIOMetadata convertImageMetadata(IIOMetadata iioMetadata, ImageTypeSpecifier imageTypeSpecifier, ImageWriteParam imageWriteParam) {
         throw new UnsupportedOperationException("not supported yet");
     }

     @Override
     public void setOutput(Object output) {
         super.setOutput(output);
         ios = (ImageOutputStream) output;
         //???AWT: setIOS(ios, cinfo);
         sourceRaster = null;
         scanRaster = null;
         srcXOff = 0;
         srcYOff = 0;
         srcWidth = 0;
         srcHeight = 0;
         deltaY = 1;
     }

     /**
      * Frees resources
      * @param structPointer
      */
     //???AWT: private native void dispose(long structPointer);

     /**
      * Inits methods Ids for native to java callbacks
      * @param iosClass
      */
     //???AWT: private native static void initWriterIds(Class<ImageOutputStream> iosClass);

     /**
      * Inits compression objects
      * @return pointer to the native structure
      */
     //???AWT: private native long initCompressionObj();

     /**
      * Sets image output stream in IJG layer
      * @param stream
      */
     //???AWT: private native void setIOS(ImageOutputStream stream, long structPointer);

     /**
      * Runs encoding process.
      *
      * @param data image data buffer to encode
      * @param srcWidth - source width
      * @param width - destination width
      * @param height destination height
      * @param deltaX - x subsampling step
      * @param inColorSpace - original color space
      * @param outColorSpace - destination color space
      * @param numBands - number of bands
      * @param cinfo - native handler
      * @return
      */
     //???AWT:
     /*
     private native boolean encode(byte[] data, int srcWidth,
                                   int width, int height, int deltaX,
                                   int inColorSpace, int outColorSpace,
                                   int numBands, boolean progressive,
                                   int[][] dqt,
                                   long cinfo);
     */

     /**
      * Callback for getting a next scanline
      * @param scanline scan line number
      */
     @SuppressWarnings("unused")
     private void getScanLine(int scanline) {
         //-- TODO: processImageProgress in ImageWriter
         Raster child = sourceRaster.createChild(srcXOff,
                 srcYOff + scanline * deltaY, srcWidth, 1, 0, 0, null);

         scanRaster.setRect(child);
     }

     /**
      * Maps color space types to IJG color spaces
      * @param image
      * @return
      */
     private int getSourceCSType(RenderedImage image) {
         int type = JPEGConsts.JCS_UNKNOW;
         ColorModel cm = image.getColorModel();

         if (null == cm) {
             return type;
         }

         if (cm instanceof IndexColorModel) {
             throw new UnsupportedOperationException("IndexColorModel is not supported yet");
         }

         boolean hasAlpha = cm.hasAlpha();
         ColorSpace cs = cm.getColorSpace();
         switch(cs.getType()) {
             case ColorSpace.TYPE_GRAY:
                 type = JPEGConsts.JCS_GRAYSCALE;
                 break;
            case ColorSpace.TYPE_RGB:
                 type = hasAlpha ? JPEGConsts.JCS_RGBA : JPEGConsts.JCS_RGB;
                 break;
            case ColorSpace.TYPE_YCbCr:
                 type = hasAlpha ? JPEGConsts.JCS_YCbCrA : JPEGConsts.JCS_YCbCr;
                 break;
            case ColorSpace.TYPE_3CLR:
                  type = hasAlpha ? JPEGConsts.JCS_YCCA : JPEGConsts.JCS_YCC;
                  break;
            case ColorSpace.TYPE_CMYK:
                   type = JPEGConsts.JCS_CMYK;
                   break;
         }
         return type;
     }

     /**
      * Returns destination color space.
      * (YCbCr[A] for RGB)
      *
      * @param image
      * @return
      */
     private int getDestinationCSType(RenderedImage image) {
         int type = JPEGConsts.JCS_UNKNOW;
         ColorModel cm = image.getColorModel();
         if (null != cm) {
             boolean hasAlpha = cm.hasAlpha();
             ColorSpace cs = cm.getColorSpace();

             switch(cs.getType()) {
                 case ColorSpace.TYPE_GRAY:
                     type = JPEGConsts.JCS_GRAYSCALE;
                     break;
                case ColorSpace.TYPE_RGB:
                     type = hasAlpha ? JPEGConsts.JCS_YCbCrA : JPEGConsts.JCS_YCbCr;
                     break;
                case ColorSpace.TYPE_YCbCr:
                     type = hasAlpha ? JPEGConsts.JCS_YCbCrA : JPEGConsts.JCS_YCbCr;
                     break;
                case ColorSpace.TYPE_3CLR:
                      type = hasAlpha ? JPEGConsts.JCS_YCCA : JPEGConsts.JCS_YCC;
                      break;
                case ColorSpace.TYPE_CMYK:
                       type = JPEGConsts.JCS_CMYK;
                       break;
             }
         }
         return type;
     }

     public ImageWriteParam getDefaultWriteParam() {
         return new JPEGImageWriteParam(getLocale());
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	/**
	* @author Rustem V. Rafikov
	* @version $Revision: 1.3 $
	*/
	package org.apache.harmony.x.imageio.plugins.jpeg;

	import com.android.internal.awt.ImageOutputStreamWrapper;

	import javax.imageio.ImageWriter;
	import javax.imageio.IIOImage;
	import javax.imageio.ImageTypeSpecifier;
	import javax.imageio.ImageWriteParam;
	import javax.imageio.plugins.jpeg.JPEGImageWriteParam;
	import javax.imageio.stream.ImageOutputStream;
	import javax.imageio.spi.ImageWriterSpi;
	import javax.imageio.metadata.IIOMetadata;

	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.graphics.Bitmap.CompressFormat;

	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.awt.image.*;
	import java.awt.*;
	import java.awt.color.ColorSpace;

	/**
	* @author Rustem V. Rafikov
	* @version $Revision: 1.3 $
	*/
	public class JPEGImageWriter extends ImageWriter {

	// /* ???AWT: Debugging
	private static final boolean DEBUG = false;
	private static Bitmap bm;
	public static Bitmap getBitmap() {
	return bm;
	}
	private static BufferedImage bufImg;
	public static BufferedImage getBufImage() {
	return bufImg;
	}
	static private RenderedImage renImg;
	static public RenderedImage getRenImage() {
	return renImg;
	}
	// */

	private long cinfo;
	private RenderedImage image;
	private Raster sourceRaster;
	private WritableRaster scanRaster;
	private int srcXOff = 0;
	private int srcYOff = 0;
	private int srcWidth;
	private int srcHeight;

	//-- y step for image subsampling
	private int deltaY = 1;
	//-- x step for image subsampling
	private int deltaX = 1;

	private ImageOutputStream ios;

	public JPEGImageWriter(ImageWriterSpi imageWriterSpi) {
	super(imageWriterSpi);
	//???AWT: cinfo = initCompressionObj();
	cinfo = System.currentTimeMillis();
	}

	static {
	//???AWT
	/*
	System.loadLibrary("jpegencoder");
	initWriterIds(ImageOutputStream.class);
	*/
	}

	@Override
	public void write(IIOMetadata iioMetadata, IIOImage iioImage, ImageWriteParam param)
	throws IOException {

	if (ios == null) {
	throw new IllegalArgumentException("ios == null");
	}
	if (iioImage == null) {
	throw new IllegalArgumentException("Image equals null");
	}

	RenderedImage img = null;
	if (!iioImage.hasRaster()) {
	img = iioImage.getRenderedImage();
	if (img instanceof BufferedImage) {
	sourceRaster = ((BufferedImage) img).getRaster();
	} else {
	sourceRaster = img.getData();
	}
	} else {
	sourceRaster = iioImage.getRaster();
	}

	// AWT???: Debugging
	if (DEBUG) {
	if( img==null ) {
	System.out.println("****J: Image is NULL");
	} else {
	renImg = img;
	bufImg = (BufferedImage)img;
	}
	}

	int numBands = sourceRaster.getNumBands();
	int sourceIJGCs = img == null ? JPEGConsts.JCS_UNKNOW : getSourceCSType(img);

	srcWidth = sourceRaster.getWidth();
	srcHeight = sourceRaster.getHeight();

	int destWidth = srcWidth;
	int destHeight = srcHeight;

	boolean progressive = false;

	if (param != null) {
	Rectangle reg = param.getSourceRegion();
	if (reg != null) {
	srcXOff = reg.x;
	srcYOff = reg.y;

	srcWidth = reg.width + srcXOff > srcWidth
	? srcWidth - srcXOff
	: reg.width;
	srcHeight = reg.height + srcYOff > srcHeight
	? srcHeight - srcYOff
	: reg.height;
	}

	//-- TODO uncomment when JPEGImageWriteParam be implemented
	//-- Only default progressive mode yet
	// progressive = param.getProgressiveMode() == ImageWriteParam.MODE_DEFAULT;

	//-- def is 1
	deltaX = param.getSourceXSubsampling();
	deltaY = param.getSourceYSubsampling();

	//-- def is 0
	int offsetX = param.getSubsamplingXOffset();
	int offsetY = param.getSubsamplingYOffset();

	srcXOff += offsetX;
	srcYOff += offsetY;
	srcWidth -= offsetX;
	srcHeight -= offsetY;

	destWidth = (srcWidth + deltaX - 1) / deltaX;
	destHeight = (srcHeight + deltaY - 1) / deltaY;
	}

	//-- default DQTs (see JPEGQTable java doc and JPEG spec K1 & K2 tables)
	//-- at http://www.w3.org/Graphics/JPEG/itu-t81.pdf
	//-- Only figuring out how to set DQT in IJG library for future metadata
	//-- support. IJG def tables are the same.
	//JPEGQTable[] dqt = new JPEGQTable[2];
	// int[][] dqt = null;
	// int[][] dqt = new int[2][];
	// dqt[0] = JPEGQTable.K1Div2Luminance.getTable();
	// dqt[1] = JPEGQTable.K2Div2Chrominance.getTable();

	//???AWT: I think we don't need this amymore
	/*
	//-- using default color space
	//-- TODO: Take destination cs from param or use default if there is no cs
	int destIJGCs = img == null ? JPEGConsts.JCS_UNKNOW : getDestinationCSType(img);

	DataBufferByte dbuffer = new DataBufferByte(numBands * srcWidth);

	scanRaster = Raster.createInterleavedRaster(dbuffer, srcWidth, 1,
	numBands * srcWidth, numBands, JPEGConsts.BAND_OFFSETS[numBands], null);

	encode(dbuffer.getData(), srcWidth, destWidth, destHeight, deltaX,
	sourceIJGCs, destIJGCs, numBands, progressive,
	null, cinfo);
	*/

	SampleModel model = sourceRaster.getSampleModel();

	if (model instanceof SinglePixelPackedSampleModel) {
	DataBufferInt ibuf = (DataBufferInt)sourceRaster.getDataBuffer();
	int[] pixels = ibuf.getData();

	// Create a bitmap with the pixel
	bm = Bitmap.createBitmap(pixels, srcWidth, srcHeight, Bitmap.Config.ARGB_8888);

	// Use Bitmap.compress() to write the image
	ImageOutputStreamWrapper iosw = new ImageOutputStreamWrapper(ios);
	bm.compress(CompressFormat.JPEG, 100, iosw);
	} else {
	// ???AWT: Add support for other color models
	throw new RuntimeException("Color model not supported yet");
	}

	}

	@Override
	public void dispose() {
	super.dispose();
	if (cinfo != 0) {
	//???AWT: dispose(cinfo);
	cinfo = 0;
	ios = null;
	}
	}


	public IIOMetadata getDefaultStreamMetadata(ImageWriteParam imageWriteParam) {
	throw new UnsupportedOperationException("not supported yet");
	}

	public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageTypeSpecifier, ImageWriteParam imageWriteParam) {
	throw new UnsupportedOperationException("not supported yet");
	}

	@Override
	public IIOMetadata convertStreamMetadata(IIOMetadata iioMetadata, ImageWriteParam imageWriteParam) {
	throw new UnsupportedOperationException("not supported yet");
	}

	@Override
	public IIOMetadata convertImageMetadata(IIOMetadata iioMetadata, ImageTypeSpecifier imageTypeSpecifier, ImageWriteParam imageWriteParam) {
	throw new UnsupportedOperationException("not supported yet");
	}

	@Override
	public void setOutput(Object output) {
	super.setOutput(output);
	ios = (ImageOutputStream) output;
	//???AWT: setIOS(ios, cinfo);
	sourceRaster = null;
	scanRaster = null;
	srcXOff = 0;
	srcYOff = 0;
	srcWidth = 0;
	srcHeight = 0;
	deltaY = 1;
	}

	/**
	* Frees resources
	* @param structPointer
	*/
	//???AWT: private native void dispose(long structPointer);

	/**
	* Inits methods Ids for native to java callbacks
	* @param iosClass
	*/
	//???AWT: private native static void initWriterIds(Class<ImageOutputStream> iosClass);

	/**
	* Inits compression objects
	* @return pointer to the native structure
	*/
	//???AWT: private native long initCompressionObj();

	/**
	* Sets image output stream in IJG layer
	* @param stream
	*/
	//???AWT: private native void setIOS(ImageOutputStream stream, long structPointer);

	/**
	* Runs encoding process.
	*
	* @param data image data buffer to encode
	* @param srcWidth - source width
	* @param width - destination width
	* @param height destination height
	* @param deltaX - x subsampling step
	* @param inColorSpace - original color space
	* @param outColorSpace - destination color space
	* @param numBands - number of bands
	* @param cinfo - native handler
	* @return
	*/
	//???AWT:
	/*
	private native boolean encode(byte[] data, int srcWidth,
	int width, int height, int deltaX,
	int inColorSpace, int outColorSpace,
	int numBands, boolean progressive,
	int[][] dqt,
	long cinfo);
	*/

	/**
	* Callback for getting a next scanline
	* @param scanline scan line number
	*/
	@SuppressWarnings("unused")
	private void getScanLine(int scanline) {
	//-- TODO: processImageProgress in ImageWriter
	Raster child = sourceRaster.createChild(srcXOff,
	srcYOff + scanline * deltaY, srcWidth, 1, 0, 0, null);

	scanRaster.setRect(child);
	}

	/**
	* Maps color space types to IJG color spaces
	* @param image
	* @return
	*/
	private int getSourceCSType(RenderedImage image) {
	int type = JPEGConsts.JCS_UNKNOW;
	ColorModel cm = image.getColorModel();

	if (null == cm) {
	return type;
	}

	if (cm instanceof IndexColorModel) {
	throw new UnsupportedOperationException("IndexColorModel is not supported yet");
	}

	boolean hasAlpha = cm.hasAlpha();
	ColorSpace cs = cm.getColorSpace();
	switch(cs.getType()) {
	case ColorSpace.TYPE_GRAY:
	type = JPEGConsts.JCS_GRAYSCALE;
	break;
	case ColorSpace.TYPE_RGB:
	type = hasAlpha ? JPEGConsts.JCS_RGBA : JPEGConsts.JCS_RGB;
	break;
	case ColorSpace.TYPE_YCbCr:
	type = hasAlpha ? JPEGConsts.JCS_YCbCrA : JPEGConsts.JCS_YCbCr;
	break;
	case ColorSpace.TYPE_3CLR:
	type = hasAlpha ? JPEGConsts.JCS_YCCA : JPEGConsts.JCS_YCC;
	break;
	case ColorSpace.TYPE_CMYK:
	type = JPEGConsts.JCS_CMYK;
	break;
	}
	return type;
	}

	/**
	* Returns destination color space.
	* (YCbCr[A] for RGB)
	*
	* @param image
	* @return
	*/
	private int getDestinationCSType(RenderedImage image) {
	int type = JPEGConsts.JCS_UNKNOW;
	ColorModel cm = image.getColorModel();
	if (null != cm) {
	boolean hasAlpha = cm.hasAlpha();
	ColorSpace cs = cm.getColorSpace();

	switch(cs.getType()) {
	case ColorSpace.TYPE_GRAY:
	type = JPEGConsts.JCS_GRAYSCALE;
	break;
	case ColorSpace.TYPE_RGB:
	type = hasAlpha ? JPEGConsts.JCS_YCbCrA : JPEGConsts.JCS_YCbCr;
	break;
	case ColorSpace.TYPE_YCbCr:
	type = hasAlpha ? JPEGConsts.JCS_YCbCrA : JPEGConsts.JCS_YCbCr;
	break;
	case ColorSpace.TYPE_3CLR:
	type = hasAlpha ? JPEGConsts.JCS_YCCA : JPEGConsts.JCS_YCC;
	break;
	case ColorSpace.TYPE_CMYK:
	type = JPEGConsts.JCS_CMYK;
	break;
	}
	}
	return type;
	}

	public ImageWriteParam getDefaultWriteParam() {
	return new JPEGImageWriteParam(getLocale());
	}
	}