下面列出了java.awt.image.DataBufferShort#javax.imageio.ImageWriteParam 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public byte[] writeTest(BufferedImage bi,
ImageWriteParam p,
IIOMetadata m) throws IOException {
ByteArrayOutputStream baos =
new ByteArrayOutputStream();
// write test image as jpeg
ImageOutputStream ios =
ImageIO.createImageOutputStream(baos);
w.setOutput(ios);
w.write(null,
new IIOImage(bi, null, m),
p);
ios.close();
return baos.toByteArray();
}
public static void main(String args[]) throws Exception {
try {
int mode = ImageWriteParam.MODE_EXPLICIT;
String type = "BI_RLE4";
doTest(type, mode);
type = "BI_RLE8";
doTest(type, mode);
mode = ImageWriteParam.MODE_DEFAULT;
type = "BI_RLE4";
doTest(type, mode);
type = "BI_RLE8";
doTest(type, mode);
System.out.println("Test 4bpp image.");
encodeRLE4Test();
System.out.println("Test 8bpp image.");
encodeRLE8Test();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("Unexpected exception. Test failed");
}
}
private boolean jfifOK(ImageTypeSpecifier imageType,
ImageWriteParam param,
IIOMetadata streamMetadata,
IIOMetadata imageMetadata) {
// If the image type and metadata are JFIF compatible, return true
if ((imageType != null) &&
(!JPEG.isJFIFcompliant(imageType, true))) {
return false;
}
if (imageMetadata != null) {
JPEGMetadata metadata = null;
if (imageMetadata instanceof JPEGMetadata) {
metadata = (JPEGMetadata) imageMetadata;
} else {
metadata = (JPEGMetadata)convertImageMetadata(imageMetadata,
imageType,
param);
}
// metadata must have a jfif node
if (metadata.findMarkerSegment
(JFIFMarkerSegment.class, true) == null){
return false;
}
}
return true;
}
private static Image createTestImage() throws IOException {
BufferedImage frame1 = createFrame(new int[] { 0xffff0000, 0xffff0000 });
BufferedImage frame2 = createFrame(new int[] { 0xff0000ff, 0xffff0000 });
ImageWriter writer = ImageIO.getImageWritersByFormatName("GIF").next();
ImageOutputStream ios = ImageIO.createImageOutputStream(new File("lut_test.gif"));
ImageWriteParam param = writer.getDefaultWriteParam();
writer.setOutput(ios);
writer.prepareWriteSequence(null);
writer.writeToSequence(new IIOImage(frame1, null, null), param);
writer.writeToSequence(new IIOImage(frame2, null, null), param);
writer.endWriteSequence();
writer.reset();
writer.dispose();
ios.flush();
ios.close();
return Toolkit.getDefaultToolkit().createImage("lut_test.gif");
}
private static void encodeRLE8Test() throws IOException {
// create 8bpp image
byte[] r = new byte[256];
r[0] = (byte)0xff;
byte[] g = new byte[256];
g[1] = (byte)0xff;
byte[] b = new byte[256];
b[2] = (byte)0xff;
IndexColorModel icm = new IndexColorModel(8, 256, r, g, b);
BufferedImage bimg = new BufferedImage(100, 100,
BufferedImage.TYPE_BYTE_INDEXED,
icm);
Graphics gr = bimg.getGraphics();
gr.setColor(Color.green);
gr.fillRect(0, 0, 100, 100);
doTest(bimg, "BI_RLE8", ImageWriteParam.MODE_EXPLICIT);
}
public static ImageWriteParam getWriterParam(ImageAttributes attributes,
ImageWriter writer) {
try {
ImageWriteParam param = writer.getDefaultWriteParam();
if (param.canWriteCompressed()) {
param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
if (attributes != null && attributes.getCompressionType() != null) {
param.setCompressionType(attributes.getCompressionType());
} else {
String[] compressionTypes = param.getCompressionTypes();
if (compressionTypes != null) {
param.setCompressionType(compressionTypes[0]);
}
}
if (attributes != null && attributes.getQuality() > 0) {
param.setCompressionQuality(attributes.getQuality() / 100.0f);
} else {
param.setCompressionQuality(1.0f);
}
}
return param;
} catch (Exception e) {
logger.error(e.toString());
return null;
}
}
private boolean jfifOK(ImageTypeSpecifier imageType,
ImageWriteParam param,
IIOMetadata streamMetadata,
IIOMetadata imageMetadata) {
// If the image type and metadata are JFIF compatible, return true
if ((imageType != null) &&
(!JPEG.isJFIFcompliant(imageType, true))) {
return false;
}
if (imageMetadata != null) {
JPEGMetadata metadata = null;
if (imageMetadata instanceof JPEGMetadata) {
metadata = (JPEGMetadata) imageMetadata;
} else {
metadata = (JPEGMetadata)convertImageMetadata(imageMetadata,
imageType,
param);
}
// metadata must have a jfif node
if (metadata.findMarkerSegment
(JFIFMarkerSegment.class, true) == null){
return false;
}
}
return true;
}
public void writeToSequence(IIOImage image, ImageWriteParam param)
throws IOException {
if (stream == null) {
throw new IllegalStateException("output == null!");
}
if (image == null) {
throw new IllegalArgumentException("image == null!");
}
if (image.hasRaster()) {
throw new UnsupportedOperationException("canWriteRasters() == false!");
}
if (!isWritingSequence) {
throw new IllegalStateException("prepareWriteSequence() was not invoked!");
}
write(!wroteSequenceHeader, false, theStreamMetadata,
image, param);
if (!wroteSequenceHeader) {
wroteSequenceHeader = true;
}
this.imageIndex++;
}
public static void main(String[] args) {
ImageWriter w = ImageIO.getImageWritersByFormatName(format).next();
if (w == null) {
throw new RuntimeException("No available writers for format " + format);
}
ImageWriteParam p = w.getDefaultWriteParam();
ImageTypeSpecifier t =
ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
IIOMetadata m = w.getDefaultImageMetadata(t, p);
System.out.println("Default image metadata is " + m);
testWritableMetadata(m);
IIOMetadata sm = w.getDefaultStreamMetadata(p);
System.out.println("Default stream metadata is " + sm);
testWritableMetadata(sm);
}
public void write(IIOMetadata sm,
IIOImage iioimage,
ImageWriteParam p) throws IOException {
if (stream == null) {
throw new IllegalStateException("output == null!");
}
if (iioimage == null) {
throw new IllegalArgumentException("iioimage == null!");
}
if (iioimage.hasRaster()) {
throw new UnsupportedOperationException("canWriteRasters() == false!");
}
resetLocal();
GIFWritableStreamMetadata streamMetadata;
if (sm == null) {
streamMetadata =
(GIFWritableStreamMetadata)getDefaultStreamMetadata(p);
} else {
streamMetadata =
(GIFWritableStreamMetadata)convertStreamMetadata(sm, p);
}
write(true, true, streamMetadata, iioimage, p);
}
public void write(IIOMetadata sm,
IIOImage iioimage,
ImageWriteParam p) throws IOException {
if (stream == null) {
throw new IllegalStateException("output == null!");
}
if (iioimage == null) {
throw new IllegalArgumentException("iioimage == null!");
}
if (iioimage.hasRaster()) {
throw new UnsupportedOperationException("canWriteRasters() == false!");
}
resetLocal();
GIFWritableStreamMetadata streamMetadata;
if (sm == null) {
streamMetadata =
(GIFWritableStreamMetadata)getDefaultStreamMetadata(p);
} else {
streamMetadata =
(GIFWritableStreamMetadata)convertStreamMetadata(sm, p);
}
write(true, true, streamMetadata, iioimage, p);
}
public void writeToSequence(IIOImage image, ImageWriteParam param)
throws IOException {
if (stream == null) {
throw new IllegalStateException("output == null!");
}
if (image == null) {
throw new IllegalArgumentException("image == null!");
}
if (image.hasRaster()) {
throw new UnsupportedOperationException("canWriteRasters() == false!");
}
if (!isWritingSequence) {
throw new IllegalStateException("prepareWriteSequence() was not invoked!");
}
write(!wroteSequenceHeader, false, theStreamMetadata,
image, param);
if (!wroteSequenceHeader) {
wroteSequenceHeader = true;
}
this.imageIndex++;
}
protected File writeImageWithHist(BufferedImage bi) throws IOException {
File f = File.createTempFile("hist_", ".png", new File("."));
ImageWriter writer = ImageIO.getImageWritersByFormatName("PNG").next();
ImageOutputStream ios = ImageIO.createImageOutputStream(f);
writer.setOutput(ios);
ImageWriteParam param = writer.getDefaultWriteParam();
ImageTypeSpecifier type = new ImageTypeSpecifier(bi);
IIOMetadata imgMetadata = writer.getDefaultImageMetadata(type, param);
/* add hIST node to image metadata */
imgMetadata = upgradeMetadata(imgMetadata, bi);
IIOImage iio_img = new IIOImage(bi,
null, // no thumbnails
imgMetadata);
writer.write(iio_img);
ios.flush();
ios.close();
return f;
}
public void writeToSequence(IIOImage image, ImageWriteParam param)
throws IOException {
if (stream == null) {
throw new IllegalStateException("output == null!");
}
if (image == null) {
throw new IllegalArgumentException("image == null!");
}
if (image.hasRaster()) {
throw new UnsupportedOperationException("canWriteRasters() == false!");
}
if (!isWritingSequence) {
throw new IllegalStateException("prepareWriteSequence() was not invoked!");
}
write(!wroteSequenceHeader, false, theStreamMetadata,
image, param);
if (!wroteSequenceHeader) {
wroteSequenceHeader = true;
}
this.imageIndex++;
}
public void writeToSequence(IIOImage image, ImageWriteParam param)
throws IOException {
if (stream == null) {
throw new IllegalStateException("output == null!");
}
if (image == null) {
throw new IllegalArgumentException("image == null!");
}
if (image.hasRaster()) {
throw new UnsupportedOperationException("canWriteRasters() == false!");
}
if (!isWritingSequence) {
throw new IllegalStateException("prepareWriteSequence() was not invoked!");
}
write(!wroteSequenceHeader, false, theStreamMetadata,
image, param);
if (!wroteSequenceHeader) {
wroteSequenceHeader = true;
}
this.imageIndex++;
}
public void createAnimatedImage(BufferedImage bi, IIOMetadata metadata,
ImageWriter writer, File outputFile) {
try {
fos = new FileOutputStream(outputFile);
ImageOutputStream ios = ImageIO.createImageOutputStream(fos);
System.out.println(ios);
writer.setOutput(ios);
ImageWriteParam param = writer.getDefaultWriteParam();
IIOMetadata streamData = writer.getDefaultStreamMetadata(param);
writer.prepareWriteSequence(streamData);
ImageTypeSpecifier specify = new ImageTypeSpecifier(bi);
IIOMetadata imgData = writer.convertImageMetadata(
(IIOMetadata) metadata, specify, param);
GIFImageMetadata gifData = setAnimationProperties(imgData);
IIOImage iim = new IIOImage(bi, null, gifData);
param.setProgressiveMode(param.MODE_DISABLED);
writer.writeToSequence(iim, param);
writer.endWriteSequence();
ios.close();
} catch (Exception e) {
e.printStackTrace();
}
}
private void writeInternal(BufferedImage image, MediaType contentType, OutputStream body)
throws IOException, HttpMessageNotWritableException {
ImageOutputStream imageOutputStream = null;
ImageWriter imageWriter = null;
try {
Iterator<ImageWriter> imageWriters = ImageIO.getImageWritersByMIMEType(contentType.toString());
if (imageWriters.hasNext()) {
imageWriter = imageWriters.next();
ImageWriteParam iwp = imageWriter.getDefaultWriteParam();
process(iwp);
imageOutputStream = createImageOutputStream(body);
imageWriter.setOutput(imageOutputStream);
imageWriter.write(null, new IIOImage(image, null, null), iwp);
}
else {
throw new HttpMessageNotWritableException(
"Could not find javax.imageio.ImageWriter for Content-Type [" + contentType + "]");
}
}
finally {
if (imageWriter != null) {
imageWriter.dispose();
}
if (imageOutputStream != null) {
try {
imageOutputStream.close();
}
catch (IOException ex) {
// ignore
}
}
}
}
private static void test4434886() {
ImageWriteParam iwp = new ImageWriteParam4434886();
iwp.setTilingMode(ImageWriteParam.MODE_EXPLICIT);
try {
iwp.setTiling(-1,-2,-3,-4);
throw new RuntimeException("Failed to get IAE!");
} catch (IllegalArgumentException e) {
}
}
private static String getModeName(int mode) {
switch(mode) {
case ImageWriteParam.MODE_COPY_FROM_METADATA:
return "MODE_COPY_FROM_METADATA";
case ImageWriteParam.MODE_DEFAULT:
return "MODE_DEFAULT";
case ImageWriteParam.MODE_DISABLED:
return "MODE_DISABLED";
case ImageWriteParam.MODE_EXPLICIT:
return "MODE_EXPLICIT";
default:
throw new IllegalArgumentException("Unknown mode: " + mode);
}
}
public int getNumThumbnailsSupported(ImageTypeSpecifier imageType,
ImageWriteParam param,
IIOMetadata streamMetadata,
IIOMetadata imageMetadata) {
if (jfifOK(imageType, param, streamMetadata, imageMetadata)) {
return Integer.MAX_VALUE;
}
return 0;
}
public Dimension[] getPreferredThumbnailSizes(ImageTypeSpecifier imageType,
ImageWriteParam param,
IIOMetadata streamMetadata,
IIOMetadata imageMetadata) {
if (jfifOK(imageType, param, streamMetadata, imageMetadata)) {
return (Dimension [])preferredThumbSizes.clone();
}
return null;
}
/**
* Shrink a PDF
* @param f {@code File} pointing to the PDF to shrink
* @param compQual Compression quality parameter. 0 is
* smallest file, 1 is highest quality.
* @return The compressed {@code PDDocument}
* @throws FileNotFoundException
* @throws IOException
*/
private PDDocument shrinkMe()
throws FileNotFoundException, IOException {
if(compQual < 0)
compQual = compQualDefault;
final RandomAccessBufferedFileInputStream rabfis =
new RandomAccessBufferedFileInputStream(input);
final PDFParser parser = new PDFParser(rabfis);
parser.parse();
final PDDocument doc = parser.getPDDocument();
final PDPageTree pages = doc.getPages();
final ImageWriter imgWriter;
final ImageWriteParam iwp;
if(tiff) {
final Iterator<ImageWriter> tiffWriters =
ImageIO.getImageWritersBySuffix("png");
imgWriter = tiffWriters.next();
iwp = imgWriter.getDefaultWriteParam();
//iwp.setCompressionMode(ImageWriteParam.MODE_DISABLED);
} else {
final Iterator<ImageWriter> jpgWriters =
ImageIO.getImageWritersByFormatName("jpeg");
imgWriter = jpgWriters.next();
iwp = imgWriter.getDefaultWriteParam();
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwp.setCompressionQuality(compQual);
}
for(PDPage p : pages) {
scanResources(p.getResources(), doc, imgWriter, iwp);
}
return doc;
}
public int getNumThumbnailsSupported(ImageTypeSpecifier imageType,
ImageWriteParam param,
IIOMetadata streamMetadata,
IIOMetadata imageMetadata) {
if (jfifOK(imageType, param, streamMetadata, imageMetadata)) {
return Integer.MAX_VALUE;
}
return 0;
}
public void prepareWriteEmpty(IIOMetadata streamMetadata,
ImageTypeSpecifier imageType,
int width,
int height,
IIOMetadata imageMetadata,
List<? extends BufferedImage> thumbnails,
ImageWriteParam param) throws IOException {
if (stream == null) {
throw new IllegalStateException("output == null!");
}
checkParamsEmpty(imageType, width, height, thumbnails);
this.isWritingEmpty = true;
SampleModel emptySM = imageType.getSampleModel();
RenderedImage emptyImage =
new EmptyImage(0, 0, width, height,
0, 0, emptySM.getWidth(), emptySM.getHeight(),
emptySM, imageType.getColorModel());
markPositions();
write(streamMetadata, new IIOImage(emptyImage, null, imageMetadata),
param, true, false);
if (abortRequested()) {
resetPositions();
}
}
public Dimension[] getPreferredThumbnailSizes(ImageTypeSpecifier imageType,
ImageWriteParam param,
IIOMetadata streamMetadata,
IIOMetadata imageMetadata) {
if (jfifOK(imageType, param, streamMetadata, imageMetadata)) {
return (Dimension [])preferredThumbSizes.clone();
}
return null;
}
public void write(IIOMetadata streamMetadata,
IIOImage image,
ImageWriteParam param) throws IOException {
setThreadLock();
try {
cbLock.check();
writeOnThread(streamMetadata, image, param);
} finally {
clearThreadLock();
}
}
/**
* Creates a default image metadata object and merges in the
* supplied metadata.
*/
public IIOMetadata convertImageMetadata(IIOMetadata inData,
ImageTypeSpecifier imageType,
ImageWriteParam param) {
if (inData == null) {
throw new IllegalArgumentException("inData == null!");
}
if (imageType == null) {
throw new IllegalArgumentException("imageType == null!");
}
GIFWritableImageMetadata im =
(GIFWritableImageMetadata)getDefaultImageMetadata(imageType,
param);
// Save interlace flag state.
boolean isProgressive = im.interlaceFlag;
convertMetadata(IMAGE_METADATA_NAME, inData, im);
// Undo change to interlace flag if not MODE_COPY_FROM_METADATA.
if (param != null && param.canWriteProgressive() &&
param.getProgressiveMode() != param.MODE_COPY_FROM_METADATA) {
im.interlaceFlag = isProgressive;
}
return im;
}
public void compressJPG(String inputFilePath, String outputFilePath, String fileType) {
InputOutput io = IOProvider.getDefault().getIO(Bundle.CTL_Base64Encode(), false);
try {
File imageFile = new File(inputFilePath);
File compressedImageFile = new File(outputFilePath);
InputStream is = new FileInputStream(imageFile);
OutputStream os = new FileOutputStream(compressedImageFile);
float quality = 0.5f;
// create a BufferedImage as the result of decoding the supplied InputStream
BufferedImage image = ImageIO.read(is);
// get all image writers for JPG format
Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(fileType);
if (!writers.hasNext()) {
throw new IllegalStateException("No writers found");
}
ImageWriter writer = writers.next();
ImageOutputStream ios = ImageIO.createImageOutputStream(os);
writer.setOutput(ios);
ImageWriteParam param = writer.getDefaultWriteParam();
param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
param.setCompressionQuality(quality);
// appends a complete image stream containing a single image and
//associated stream and image metadata and thumbnails to the output
writer.write(null, new IIOImage(image, null, null), param);
is.close();
os.close();
ios.close();
writer.dispose();
} catch (IOException ex) {
io.getOut().println("Exception: " + ex.toString());
}
}
@Test
public void lossyWrite() throws Exception {
File f = File.createTempFile("test-jpeg2000-lossy", ".jp2");
f.deleteOnExit();
Iterator<ImageWriter> writers = ImageIO.getImageWritersBySuffix("jp2");
assertTrue(writers.hasNext());
ImageWriter writer = writers.next();
J2KImageWriteParam writeParams = (J2KImageWriteParam) writer.getDefaultWriteParam();
writeParams.setLossless(false);
writeParams.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
writeParams.setCompressionType("JPEG2000");
// writeParams.setFilter(J2KImageWriteParam.FILTER_97);
writeParams.setCompressionQuality(0.0f);
writeParams.setEncodingRate(0.5f);
ImageOutputStream ios = ImageIO.createImageOutputStream(f);
writer.setOutput(ios);
writer.write(null, new IIOImage(image, null, null), writeParams);
writer.dispose();
ios.close();
assertTrue("Expected file size < 1MB", f.length() < 128*1024);
//System.out.println(f.length());
BufferedImage read = ImageIO.read(f);
assertEquals(SIZE, read.getWidth());
}
public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageType,
ImageWriteParam param) {
BMPMetadata meta = new BMPMetadata();
meta.bmpVersion = VERSION_3;
meta.compression = getPreferredCompressionType(imageType);
if (param != null
&& param.getCompressionMode() == ImageWriteParam.MODE_EXPLICIT) {
meta.compression = BMPCompressionTypes.getType(param.getCompressionType());
}
meta.bitsPerPixel = (short)imageType.getColorModel().getPixelSize();
return meta;
}