1 /*
2 * Copyright (c) 2000, 2005, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.imageio.plugins.png;
27
28 import java.awt.Rectangle;
29 import java.awt.image.ColorModel;
30 import java.awt.image.IndexColorModel;
31 import java.awt.image.Raster;
32 import java.awt.image.WritableRaster;
33 import java.awt.image.RenderedImage;
34 import java.awt.image.SampleModel;
35 import java.io.ByteArrayOutputStream;
36 import java.io.DataOutput;
37 import java.io.IOException;
38 import java.io.OutputStream;
39 import java.util.Iterator;
40 import java.util.Locale;
41 import java.util.zip.Deflater;
42 import java.util.zip.DeflaterOutputStream;
43 import javax.imageio.IIOException;
44 import javax.imageio.IIOImage;
45 import javax.imageio.ImageTypeSpecifier;
46 import javax.imageio.ImageWriteParam;
47 import javax.imageio.ImageWriter;
48 import javax.imageio.metadata.IIOMetadata;
49 import javax.imageio.metadata.IIOMetadata;
50 import javax.imageio.spi.ImageWriterSpi;
51 import javax.imageio.stream.ImageOutputStream;
52 import javax.imageio.stream.ImageOutputStreamImpl;
53
54 class CRC {
55
56 private static int[] crcTable = new int[256];
57 private int crc = 0xffffffff;
58
59 static {
60 // Initialize CRC table
61 for (int n = 0; n < 256; n++) {
62 int c = n;
63 for (int k = 0; k < 8; k++) {
64 if ((c & 1) == 1) {
65 c = 0xedb88320 ^ (c >>> 1);
66 } else {
67 c >>>= 1;
68 }
69
70 crcTable[n] = c;
71 }
72 }
73 }
74
75 public CRC() {}
76
77 public void reset() {
78 crc = 0xffffffff;
79 }
80
81 public void update(byte[] data, int off, int len) {
82 for (int n = 0; n < len; n++) {
83 crc = crcTable[(crc ^ data[off + n]) & 0xff] ^ (crc >>> 8);
84 }
85 }
86
87 public void update(int data) {
88 crc = crcTable[(crc ^ data) & 0xff] ^ (crc >>> 8);
89 }
90
91 public int getValue() {
92 return crc ^ 0xffffffff;
93 }
94 }
95
96
97 final class ChunkStream extends ImageOutputStreamImpl {
98
99 private ImageOutputStream stream;
100 private long startPos;
101 private CRC crc = new CRC();
102
103 public ChunkStream(int type, ImageOutputStream stream) throws IOException {
104 this.stream = stream;
105 this.startPos = stream.getStreamPosition();
106
107 stream.writeInt(-1); // length, will backpatch
108 writeInt(type);
109 }
110
111 public int read() throws IOException {
112 throw new RuntimeException("Method not available");
113 }
114
115 public int read(byte[] b, int off, int len) throws IOException {
116 throw new RuntimeException("Method not available");
117 }
118
119 public void write(byte[] b, int off, int len) throws IOException {
120 crc.update(b, off, len);
121 stream.write(b, off, len);
122 }
123
124 public void write(int b) throws IOException {
125 crc.update(b);
126 stream.write(b);
127 }
128
129 public void finish() throws IOException {
130 // Write CRC
131 stream.writeInt(crc.getValue());
132
133 // Write length
134 long pos = stream.getStreamPosition();
135 stream.seek(startPos);
136 stream.writeInt((int)(pos - startPos) - 12);
137
138 // Return to end of chunk and flush to minimize buffering
139 stream.seek(pos);
140 stream.flushBefore(pos);
141 }
142
143 protected void finalize() throws Throwable {
144 // Empty finalizer (for improved performance; no need to call
145 // super.finalize() in this case)
146 }
147 }
148
149 // Compress output and write as a series of 'IDAT' chunks of
150 // fixed length.
151 final class IDATOutputStream extends ImageOutputStreamImpl {
152
153 private static byte[] chunkType = {
154 (byte)'I', (byte)'D', (byte)'A', (byte)'T'
155 };
156
157 private ImageOutputStream stream;
158 private int chunkLength;
159 private long startPos;
160 private CRC crc = new CRC();
161
162 Deflater def = new Deflater(Deflater.BEST_COMPRESSION);
163 byte[] buf = new byte[512];
164
165 private int bytesRemaining;
166
167 public IDATOutputStream(ImageOutputStream stream, int chunkLength)
168 throws IOException {
169 this.stream = stream;
170 this.chunkLength = chunkLength;
171 startChunk();
172 }
173
174 private void startChunk() throws IOException {
175 crc.reset();
176 this.startPos = stream.getStreamPosition();
177 stream.writeInt(-1); // length, will backpatch
178
179 crc.update(chunkType, 0, 4);
180 stream.write(chunkType, 0, 4);
181
182 this.bytesRemaining = chunkLength;
183 }
184
185 private void finishChunk() throws IOException {
186 // Write CRC
187 stream.writeInt(crc.getValue());
188
189 // Write length
190 long pos = stream.getStreamPosition();
191 stream.seek(startPos);
192 stream.writeInt((int)(pos - startPos) - 12);
193
194 // Return to end of chunk and flush to minimize buffering
195 stream.seek(pos);
196 try {
197 stream.flushBefore(pos);
198 } catch (IOException e) {
199 /*
200 * If flushBefore() fails we try to access startPos in finally
201 * block of write_IDAT(). We should update startPos to avoid
202 * IndexOutOfBoundException while seek() is happening.
203 */
204 this.startPos = stream.getStreamPosition();
205 throw e;
206 }
207 }
208
209 public int read() throws IOException {
210 throw new RuntimeException("Method not available");
211 }
212
213 public int read(byte[] b, int off, int len) throws IOException {
214 throw new RuntimeException("Method not available");
215 }
216
217 public void write(byte[] b, int off, int len) throws IOException {
218 if (len == 0) {
219 return;
220 }
221
222 if (!def.finished()) {
223 def.setInput(b, off, len);
224 while (!def.needsInput()) {
225 deflate();
226 }
227 }
228 }
229
230 public void deflate() throws IOException {
231 int len = def.deflate(buf, 0, buf.length);
232 int off = 0;
233
234 while (len > 0) {
235 if (bytesRemaining == 0) {
236 finishChunk();
237 startChunk();
238 }
239
240 int nbytes = Math.min(len, bytesRemaining);
241 crc.update(buf, off, nbytes);
242 stream.write(buf, off, nbytes);
243
244 off += nbytes;
245 len -= nbytes;
246 bytesRemaining -= nbytes;
247 }
248 }
249
250 public void write(int b) throws IOException {
251 byte[] wbuf = new byte[1];
252 wbuf[0] = (byte)b;
253 write(wbuf, 0, 1);
254 }
255
256 public void finish() throws IOException {
257 try {
258 if (!def.finished()) {
259 def.finish();
260 while (!def.finished()) {
261 deflate();
262 }
263 }
264 finishChunk();
265 } finally {
266 def.end();
267 }
268 }
269
270 protected void finalize() throws Throwable {
271 // Empty finalizer (for improved performance; no need to call
272 // super.finalize() in this case)
273 }
274 }
275
276
277 class PNGImageWriteParam extends ImageWriteParam {
278
279 public PNGImageWriteParam(Locale locale) {
280 super();
281 this.canWriteProgressive = true;
282 this.locale = locale;
283 }
284 }
285
286 /**
287 */
288 public class PNGImageWriter extends ImageWriter {
289
290 ImageOutputStream stream = null;
291
292 PNGMetadata metadata = null;
293
294 // Factors from the ImageWriteParam
295 int sourceXOffset = 0;
296 int sourceYOffset = 0;
297 int sourceWidth = 0;
298 int sourceHeight = 0;
299 int[] sourceBands = null;
300 int periodX = 1;
301 int periodY = 1;
302
303 int numBands;
304 int bpp;
305
306 RowFilter rowFilter = new RowFilter();
307 byte[] prevRow = null;
308 byte[] currRow = null;
309 byte[][] filteredRows = null;
310
311 // Per-band scaling tables
312 //
313 // After the first call to initializeScaleTables, either scale and scale0
314 // will be valid, or scaleh and scalel will be valid, but not both.
315 //
316 // The tables will be designed for use with a set of input but depths
317 // given by sampleSize, and an output bit depth given by scalingBitDepth.
318 //
319 int[] sampleSize = null; // Sample size per band, in bits
320 int scalingBitDepth = -1; // Output bit depth of the scaling tables
321
322 // Tables for 1, 2, 4, or 8 bit output
323 byte[][] scale = null; // 8 bit table
324 byte[] scale0 = null; // equivalent to scale[0]
325
326 // Tables for 16 bit output
327 byte[][] scaleh = null; // High bytes of output
328 byte[][] scalel = null; // Low bytes of output
329
330 int totalPixels; // Total number of pixels to be written by write_IDAT
331 int pixelsDone; // Running count of pixels written by write_IDAT
332
333 public PNGImageWriter(ImageWriterSpi originatingProvider) {
334 super(originatingProvider);
335 }
336
337 public void setOutput(Object output) {
338 super.setOutput(output);
339 if (output != null) {
340 if (!(output instanceof ImageOutputStream)) {
341 throw new IllegalArgumentException("output not an ImageOutputStream!");
342 }
343 this.stream = (ImageOutputStream)output;
344 } else {
345 this.stream = null;
346 }
347 }
348
349 private static int[] allowedProgressivePasses = { 1, 7 };
350
351 public ImageWriteParam getDefaultWriteParam() {
352 return new PNGImageWriteParam(getLocale());
353 }
354
355 public IIOMetadata getDefaultStreamMetadata(ImageWriteParam param) {
356 return null;
357 }
358
359 public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageType,
360 ImageWriteParam param) {
361 PNGMetadata m = new PNGMetadata();
362 m.initialize(imageType, imageType.getSampleModel().getNumBands());
363 return m;
364 }
365
366 public IIOMetadata convertStreamMetadata(IIOMetadata inData,
367 ImageWriteParam param) {
368 return null;
369 }
370
371 public IIOMetadata convertImageMetadata(IIOMetadata inData,
372 ImageTypeSpecifier imageType,
373 ImageWriteParam param) {
374 // TODO - deal with imageType
375 if (inData instanceof PNGMetadata) {
376 return (PNGMetadata)((PNGMetadata)inData).clone();
377 } else {
378 return new PNGMetadata(inData);
379 }
380 }
381
382 private void write_magic() throws IOException {
383 // Write signature
384 byte[] magic = { (byte)137, 80, 78, 71, 13, 10, 26, 10 };
385 stream.write(magic);
386 }
387
388 private void write_IHDR() throws IOException {
389 // Write IHDR chunk
390 ChunkStream cs = new ChunkStream(PNGImageReader.IHDR_TYPE, stream);
391 cs.writeInt(metadata.IHDR_width);
392 cs.writeInt(metadata.IHDR_height);
393 cs.writeByte(metadata.IHDR_bitDepth);
394 cs.writeByte(metadata.IHDR_colorType);
395 if (metadata.IHDR_compressionMethod != 0) {
396 throw new IIOException(
397 "Only compression method 0 is defined in PNG 1.1");
398 }
399 cs.writeByte(metadata.IHDR_compressionMethod);
400 if (metadata.IHDR_filterMethod != 0) {
401 throw new IIOException(
402 "Only filter method 0 is defined in PNG 1.1");
403 }
404 cs.writeByte(metadata.IHDR_filterMethod);
405 if (metadata.IHDR_interlaceMethod < 0 ||
406 metadata.IHDR_interlaceMethod > 1) {
407 throw new IIOException(
408 "Only interlace methods 0 (node) and 1 (adam7) are defined in PNG 1.1");
409 }
410 cs.writeByte(metadata.IHDR_interlaceMethod);
411 cs.finish();
412 }
413
414 private void write_cHRM() throws IOException {
415 if (metadata.cHRM_present) {
416 ChunkStream cs = new ChunkStream(PNGImageReader.cHRM_TYPE, stream);
417 cs.writeInt(metadata.cHRM_whitePointX);
418 cs.writeInt(metadata.cHRM_whitePointY);
419 cs.writeInt(metadata.cHRM_redX);
420 cs.writeInt(metadata.cHRM_redY);
421 cs.writeInt(metadata.cHRM_greenX);
422 cs.writeInt(metadata.cHRM_greenY);
423 cs.writeInt(metadata.cHRM_blueX);
424 cs.writeInt(metadata.cHRM_blueY);
425 cs.finish();
426 }
427 }
428
429 private void write_gAMA() throws IOException {
430 if (metadata.gAMA_present) {
431 ChunkStream cs = new ChunkStream(PNGImageReader.gAMA_TYPE, stream);
432 cs.writeInt(metadata.gAMA_gamma);
433 cs.finish();
434 }
435 }
436
437 private void write_iCCP() throws IOException {
438 if (metadata.iCCP_present) {
439 ChunkStream cs = new ChunkStream(PNGImageReader.iCCP_TYPE, stream);
440 cs.writeBytes(metadata.iCCP_profileName);
441 cs.writeByte(0); // null terminator
442
443 cs.writeByte(metadata.iCCP_compressionMethod);
444 cs.write(metadata.iCCP_compressedProfile);
445 cs.finish();
446 }
447 }
448
449 private void write_sBIT() throws IOException {
450 if (metadata.sBIT_present) {
451 ChunkStream cs = new ChunkStream(PNGImageReader.sBIT_TYPE, stream);
452 int colorType = metadata.IHDR_colorType;
453 if (metadata.sBIT_colorType != colorType) {
454 processWarningOccurred(0,
455 "sBIT metadata has wrong color type.\n" +
456 "The chunk will not be written.");
457 return;
458 }
459
460 if (colorType == PNGImageReader.PNG_COLOR_GRAY ||
461 colorType == PNGImageReader.PNG_COLOR_GRAY_ALPHA) {
462 cs.writeByte(metadata.sBIT_grayBits);
463 } else if (colorType == PNGImageReader.PNG_COLOR_RGB ||
464 colorType == PNGImageReader.PNG_COLOR_PALETTE ||
465 colorType == PNGImageReader.PNG_COLOR_RGB_ALPHA) {
466 cs.writeByte(metadata.sBIT_redBits);
467 cs.writeByte(metadata.sBIT_greenBits);
468 cs.writeByte(metadata.sBIT_blueBits);
469 }
470
471 if (colorType == PNGImageReader.PNG_COLOR_GRAY_ALPHA ||
472 colorType == PNGImageReader.PNG_COLOR_RGB_ALPHA) {
473 cs.writeByte(metadata.sBIT_alphaBits);
474 }
475 cs.finish();
476 }
477 }
478
479 private void write_sRGB() throws IOException {
480 if (metadata.sRGB_present) {
481 ChunkStream cs = new ChunkStream(PNGImageReader.sRGB_TYPE, stream);
482 cs.writeByte(metadata.sRGB_renderingIntent);
483 cs.finish();
484 }
485 }
486
487 private void write_PLTE() throws IOException {
488 if (metadata.PLTE_present) {
489 if (metadata.IHDR_colorType == PNGImageReader.PNG_COLOR_GRAY ||
490 metadata.IHDR_colorType == PNGImageReader.PNG_COLOR_GRAY_ALPHA) {
491 // PLTE cannot occur in a gray image
492
493 processWarningOccurred(0,
494 "A PLTE chunk may not appear in a gray or gray alpha image.\n" +
495 "The chunk will not be written");
496 return;
497 }
498
499 ChunkStream cs = new ChunkStream(PNGImageReader.PLTE_TYPE, stream);
500
501 int numEntries = metadata.PLTE_red.length;
502 byte[] palette = new byte[numEntries*3];
503 int index = 0;
504 for (int i = 0; i < numEntries; i++) {
505 palette[index++] = metadata.PLTE_red[i];
506 palette[index++] = metadata.PLTE_green[i];
507 palette[index++] = metadata.PLTE_blue[i];
508 }
509
510 cs.write(palette);
511 cs.finish();
512 }
513 }
514
515 private void write_hIST() throws IOException, IIOException {
516 if (metadata.hIST_present) {
517 ChunkStream cs = new ChunkStream(PNGImageReader.hIST_TYPE, stream);
518
519 if (!metadata.PLTE_present) {
520 throw new IIOException("hIST chunk without PLTE chunk!");
521 }
522
523 cs.writeChars(metadata.hIST_histogram,
524 0, metadata.hIST_histogram.length);
525 cs.finish();
526 }
527 }
528
529 private void write_tRNS() throws IOException, IIOException {
530 if (metadata.tRNS_present) {
531 ChunkStream cs = new ChunkStream(PNGImageReader.tRNS_TYPE, stream);
532 int colorType = metadata.IHDR_colorType;
533 int chunkType = metadata.tRNS_colorType;
534
535 // Special case: image is RGB and chunk is Gray
536 // Promote chunk contents to RGB
537 int chunkRed = metadata.tRNS_red;
538 int chunkGreen = metadata.tRNS_green;
539 int chunkBlue = metadata.tRNS_blue;
540 if (colorType == PNGImageReader.PNG_COLOR_RGB &&
541 chunkType == PNGImageReader.PNG_COLOR_GRAY) {
542 chunkType = colorType;
543 chunkRed = chunkGreen = chunkBlue =
544 metadata.tRNS_gray;
545 }
546
547 if (chunkType != colorType) {
548 processWarningOccurred(0,
549 "tRNS metadata has incompatible color type.\n" +
550 "The chunk will not be written.");
551 return;
552 }
553
554 if (colorType == PNGImageReader.PNG_COLOR_PALETTE) {
555 if (!metadata.PLTE_present) {
556 throw new IIOException("tRNS chunk without PLTE chunk!");
557 }
558 cs.write(metadata.tRNS_alpha);
559 } else if (colorType == PNGImageReader.PNG_COLOR_GRAY) {
560 cs.writeShort(metadata.tRNS_gray);
561 } else if (colorType == PNGImageReader.PNG_COLOR_RGB) {
562 cs.writeShort(chunkRed);
563 cs.writeShort(chunkGreen);
564 cs.writeShort(chunkBlue);
565 } else {
566 throw new IIOException("tRNS chunk for color type 4 or 6!");
567 }
568 cs.finish();
569 }
570 }
571
572 private void write_bKGD() throws IOException {
573 if (metadata.bKGD_present) {
574 ChunkStream cs = new ChunkStream(PNGImageReader.bKGD_TYPE, stream);
575 int colorType = metadata.IHDR_colorType & 0x3;
576 int chunkType = metadata.bKGD_colorType;
577
578 // Special case: image is RGB(A) and chunk is Gray
579 // Promote chunk contents to RGB
580 int chunkRed = metadata.bKGD_red;
581 int chunkGreen = metadata.bKGD_red;
582 int chunkBlue = metadata.bKGD_red;
583 if (colorType == PNGImageReader.PNG_COLOR_RGB &&
584 chunkType == PNGImageReader.PNG_COLOR_GRAY) {
585 // Make a gray bKGD chunk look like RGB
586 chunkType = colorType;
587 chunkRed = chunkGreen = chunkBlue =
588 metadata.bKGD_gray;
589 }
590
591 // Ignore status of alpha in colorType
592 if (chunkType != colorType) {
593 processWarningOccurred(0,
594 "bKGD metadata has incompatible color type.\n" +
595 "The chunk will not be written.");
596 return;
597 }
598
599 if (colorType == PNGImageReader.PNG_COLOR_PALETTE) {
600 cs.writeByte(metadata.bKGD_index);
601 } else if (colorType == PNGImageReader.PNG_COLOR_GRAY ||
602 colorType == PNGImageReader.PNG_COLOR_GRAY_ALPHA) {
603 cs.writeShort(metadata.bKGD_gray);
604 } else { // colorType == PNGImageReader.PNG_COLOR_RGB ||
605 // colorType == PNGImageReader.PNG_COLOR_RGB_ALPHA
606 cs.writeShort(chunkRed);
607 cs.writeShort(chunkGreen);
608 cs.writeShort(chunkBlue);
609 }
610 cs.finish();
611 }
612 }
613
614 private void write_pHYs() throws IOException {
615 if (metadata.pHYs_present) {
616 ChunkStream cs = new ChunkStream(PNGImageReader.pHYs_TYPE, stream);
617 cs.writeInt(metadata.pHYs_pixelsPerUnitXAxis);
618 cs.writeInt(metadata.pHYs_pixelsPerUnitYAxis);
619 cs.writeByte(metadata.pHYs_unitSpecifier);
620 cs.finish();
621 }
622 }
623
624 private void write_sPLT() throws IOException {
625 if (metadata.sPLT_present) {
626 ChunkStream cs = new ChunkStream(PNGImageReader.sPLT_TYPE, stream);
627
628 cs.writeBytes(metadata.sPLT_paletteName);
629 cs.writeByte(0); // null terminator
630
631 cs.writeByte(metadata.sPLT_sampleDepth);
632 int numEntries = metadata.sPLT_red.length;
633
634 if (metadata.sPLT_sampleDepth == 8) {
635 for (int i = 0; i < numEntries; i++) {
636 cs.writeByte(metadata.sPLT_red[i]);
637 cs.writeByte(metadata.sPLT_green[i]);
638 cs.writeByte(metadata.sPLT_blue[i]);
639 cs.writeByte(metadata.sPLT_alpha[i]);
640 cs.writeShort(metadata.sPLT_frequency[i]);
641 }
642 } else { // sampleDepth == 16
643 for (int i = 0; i < numEntries; i++) {
644 cs.writeShort(metadata.sPLT_red[i]);
645 cs.writeShort(metadata.sPLT_green[i]);
646 cs.writeShort(metadata.sPLT_blue[i]);
647 cs.writeShort(metadata.sPLT_alpha[i]);
648 cs.writeShort(metadata.sPLT_frequency[i]);
649 }
650 }
651 cs.finish();
652 }
653 }
654
655 private void write_tIME() throws IOException {
656 if (metadata.tIME_present) {
657 ChunkStream cs = new ChunkStream(PNGImageReader.tIME_TYPE, stream);
658 cs.writeShort(metadata.tIME_year);
659 cs.writeByte(metadata.tIME_month);
660 cs.writeByte(metadata.tIME_day);
661 cs.writeByte(metadata.tIME_hour);
662 cs.writeByte(metadata.tIME_minute);
663 cs.writeByte(metadata.tIME_second);
664 cs.finish();
665 }
666 }
667
668 private void write_tEXt() throws IOException {
669 Iterator<String> keywordIter = metadata.tEXt_keyword.iterator();
670 Iterator<String> textIter = metadata.tEXt_text.iterator();
671
672 while (keywordIter.hasNext()) {
673 ChunkStream cs = new ChunkStream(PNGImageReader.tEXt_TYPE, stream);
674 String keyword = keywordIter.next();
675 cs.writeBytes(keyword);
676 cs.writeByte(0);
677
678 String text = textIter.next();
679 cs.writeBytes(text);
680 cs.finish();
681 }
682 }
683
684 private byte[] deflate(byte[] b) throws IOException {
685 ByteArrayOutputStream baos = new ByteArrayOutputStream();
686 DeflaterOutputStream dos = new DeflaterOutputStream(baos);
687 dos.write(b);
688 dos.close();
689 return baos.toByteArray();
690 }
691
692 private void write_iTXt() throws IOException {
693 Iterator<String> keywordIter = metadata.iTXt_keyword.iterator();
694 Iterator<Boolean> flagIter = metadata.iTXt_compressionFlag.iterator();
695 Iterator<Integer> methodIter = metadata.iTXt_compressionMethod.iterator();
696 Iterator<String> languageIter = metadata.iTXt_languageTag.iterator();
697 Iterator<String> translatedKeywordIter =
698 metadata.iTXt_translatedKeyword.iterator();
699 Iterator<String> textIter = metadata.iTXt_text.iterator();
700
701 while (keywordIter.hasNext()) {
702 ChunkStream cs = new ChunkStream(PNGImageReader.iTXt_TYPE, stream);
703
704 cs.writeBytes(keywordIter.next());
705 cs.writeByte(0);
706
707 Boolean compressed = flagIter.next();
708 cs.writeByte(compressed ? 1 : 0);
709
710 cs.writeByte(methodIter.next().intValue());
711
712 cs.writeBytes(languageIter.next());
713 cs.writeByte(0);
714
715
716 cs.write(translatedKeywordIter.next().getBytes("UTF8"));
717 cs.writeByte(0);
718
719 String text = textIter.next();
720 if (compressed) {
721 cs.write(deflate(text.getBytes("UTF8")));
722 } else {
723 cs.write(text.getBytes("UTF8"));
724 }
725 cs.finish();
726 }
727 }
728
729 private void write_zTXt() throws IOException {
730 Iterator<String> keywordIter = metadata.zTXt_keyword.iterator();
731 Iterator<Integer> methodIter = metadata.zTXt_compressionMethod.iterator();
732 Iterator<String> textIter = metadata.zTXt_text.iterator();
733
734 while (keywordIter.hasNext()) {
735 ChunkStream cs = new ChunkStream(PNGImageReader.zTXt_TYPE, stream);
736 String keyword = keywordIter.next();
737 cs.writeBytes(keyword);
738 cs.writeByte(0);
739
740 int compressionMethod = (methodIter.next()).intValue();
741 cs.writeByte(compressionMethod);
742
743 String text = textIter.next();
744 cs.write(deflate(text.getBytes("ISO-8859-1")));
745 cs.finish();
746 }
747 }
748
749 private void writeUnknownChunks() throws IOException {
750 Iterator<String> typeIter = metadata.unknownChunkType.iterator();
751 Iterator<byte[]> dataIter = metadata.unknownChunkData.iterator();
752
753 while (typeIter.hasNext() && dataIter.hasNext()) {
754 String type = typeIter.next();
755 ChunkStream cs = new ChunkStream(chunkType(type), stream);
756 byte[] data = dataIter.next();
757 cs.write(data);
758 cs.finish();
759 }
760 }
761
762 private static int chunkType(String typeString) {
763 char c0 = typeString.charAt(0);
764 char c1 = typeString.charAt(1);
765 char c2 = typeString.charAt(2);
766 char c3 = typeString.charAt(3);
767
768 int type = (c0 << 24) | (c1 << 16) | (c2 << 8) | c3;
769 return type;
770 }
771
772 private void encodePass(ImageOutputStream os,
773 RenderedImage image,
774 int xOffset, int yOffset,
775 int xSkip, int ySkip) throws IOException {
776 int minX = sourceXOffset;
777 int minY = sourceYOffset;
778 int width = sourceWidth;
779 int height = sourceHeight;
780
781 // Adjust offsets and skips based on source subsampling factors
782 xOffset *= periodX;
783 xSkip *= periodX;
784 yOffset *= periodY;
785 ySkip *= periodY;
786
787 // Early exit if no data for this pass
788 int hpixels = (width - xOffset + xSkip - 1)/xSkip;
789 int vpixels = (height - yOffset + ySkip - 1)/ySkip;
790 if (hpixels == 0 || vpixels == 0) {
791 return;
792 }
793
794 // Convert X offset and skip from pixels to samples
795 xOffset *= numBands;
796 xSkip *= numBands;
797
798 // Create row buffers
799 int samplesPerByte = 8/metadata.IHDR_bitDepth;
800 int numSamples = width*numBands;
801 int[] samples = new int[numSamples];
802
803 int bytesPerRow = hpixels*numBands;
804 if (metadata.IHDR_bitDepth < 8) {
805 bytesPerRow = (bytesPerRow + samplesPerByte - 1)/samplesPerByte;
806 } else if (metadata.IHDR_bitDepth == 16) {
807 bytesPerRow *= 2;
808 }
809
810 IndexColorModel icm_gray_alpha = null;
811 if (metadata.IHDR_colorType == PNGImageReader.PNG_COLOR_GRAY_ALPHA &&
812 image.getColorModel() instanceof IndexColorModel)
813 {
814 // reserve space for alpha samples
815 bytesPerRow *= 2;
816
817 // will be used to calculate alpha value for the pixel
818 icm_gray_alpha = (IndexColorModel)image.getColorModel();
819 }
820
821 currRow = new byte[bytesPerRow + bpp];
822 prevRow = new byte[bytesPerRow + bpp];
823 filteredRows = new byte[5][bytesPerRow + bpp];
824
825 int bitDepth = metadata.IHDR_bitDepth;
826 for (int row = minY + yOffset; row < minY + height; row += ySkip) {
827 Rectangle rect = new Rectangle(minX, row, width, 1);
828 Raster ras = image.getData(rect);
829 if (sourceBands != null) {
830 ras = ras.createChild(minX, row, width, 1, minX, row,
831 sourceBands);
832 }
833
834 ras.getPixels(minX, row, width, 1, samples);
835
836 if (image.getColorModel().isAlphaPremultiplied()) {
837 WritableRaster wr = ras.createCompatibleWritableRaster();
838 wr.setPixels(wr.getMinX(), wr.getMinY(),
839 wr.getWidth(), wr.getHeight(),
840 samples);
841
842 image.getColorModel().coerceData(wr, false);
843 wr.getPixels(wr.getMinX(), wr.getMinY(),
844 wr.getWidth(), wr.getHeight(),
845 samples);
846 }
847
848 // Reorder palette data if necessary
849 int[] paletteOrder = metadata.PLTE_order;
850 if (paletteOrder != null) {
851 for (int i = 0; i < numSamples; i++) {
852 samples[i] = paletteOrder[samples[i]];
853 }
854 }
855
856 int count = bpp; // leave first 'bpp' bytes zero
857 int pos = 0;
858 int tmp = 0;
859
860 switch (bitDepth) {
861 case 1: case 2: case 4:
862 // Image can only have a single band
863
864 int mask = samplesPerByte - 1;
865 for (int s = xOffset; s < numSamples; s += xSkip) {
866 byte val = scale0[samples[s]];
867 tmp = (tmp << bitDepth) | val;
868
869 if ((pos++ & mask) == mask) {
870 currRow[count++] = (byte)tmp;
871 tmp = 0;
872 pos = 0;
873 }
874 }
875
876 // Left shift the last byte
877 if ((pos & mask) != 0) {
878 tmp <<= ((8/bitDepth) - pos)*bitDepth;
879 currRow[count++] = (byte)tmp;
880 }
881 break;
882
883 case 8:
884 if (numBands == 1) {
885 for (int s = xOffset; s < numSamples; s += xSkip) {
886 currRow[count++] = scale0[samples[s]];
887 if (icm_gray_alpha != null) {
888 currRow[count++] =
889 scale0[icm_gray_alpha.getAlpha(0xff & samples[s])];
890 }
891 }
892 } else {
893 for (int s = xOffset; s < numSamples; s += xSkip) {
894 for (int b = 0; b < numBands; b++) {
895 currRow[count++] = scale[b][samples[s + b]];
896 }
897 }
898 }
899 break;
900
901 case 16:
902 for (int s = xOffset; s < numSamples; s += xSkip) {
903 for (int b = 0; b < numBands; b++) {
904 currRow[count++] = scaleh[b][samples[s + b]];
905 currRow[count++] = scalel[b][samples[s + b]];
906 }
907 }
908 break;
909 }
910
911 // Perform filtering
912 int filterType = rowFilter.filterRow(metadata.IHDR_colorType,
913 currRow, prevRow,
914 filteredRows,
915 bytesPerRow, bpp);
916
917 os.write(filterType);
918 os.write(filteredRows[filterType], bpp, bytesPerRow);
919
920 // Swap current and previous rows
921 byte[] swap = currRow;
922 currRow = prevRow;
923 prevRow = swap;
924
925 pixelsDone += hpixels;
926 processImageProgress(100.0F*pixelsDone/totalPixels);
927
928 // If write has been aborted, just return;
929 // processWriteAborted will be called later
930 if (abortRequested()) {
931 return;
932 }
933 }
934 }
935
936 // Use sourceXOffset, etc.
937 private void write_IDAT(RenderedImage image) throws IOException {
938 IDATOutputStream ios = new IDATOutputStream(stream, 32768);
939 try {
940 if (metadata.IHDR_interlaceMethod == 1) {
941 for (int i = 0; i < 7; i++) {
942 encodePass(ios, image,
943 PNGImageReader.adam7XOffset[i],
944 PNGImageReader.adam7YOffset[i],
945 PNGImageReader.adam7XSubsampling[i],
946 PNGImageReader.adam7YSubsampling[i]);
947 if (abortRequested()) {
948 break;
949 }
950 }
951 } else {
952 encodePass(ios, image, 0, 0, 1, 1);
953 }
954 } finally {
955 ios.finish();
956 }
957 }
958
959 private void writeIEND() throws IOException {
960 ChunkStream cs = new ChunkStream(PNGImageReader.IEND_TYPE, stream);
961 cs.finish();
962 }
963
964 // Check two int arrays for value equality, always returns false
965 // if either array is null
966 private boolean equals(int[] s0, int[] s1) {
967 if (s0 == null || s1 == null) {
968 return false;
969 }
970 if (s0.length != s1.length) {
971 return false;
972 }
973 for (int i = 0; i < s0.length; i++) {
974 if (s0[i] != s1[i]) {
975 return false;
976 }
977 }
978 return true;
979 }
980
981 // Initialize the scale/scale0 or scaleh/scalel arrays to
982 // hold the results of scaling an input value to the desired
983 // output bit depth
984 private void initializeScaleTables(int[] sampleSize) {
985 int bitDepth = metadata.IHDR_bitDepth;
986
987 // If the existing tables are still valid, just return
988 if (bitDepth == scalingBitDepth &&
989 equals(sampleSize, this.sampleSize)) {
990 return;
991 }
992
993 // Compute new tables
994 this.sampleSize = sampleSize;
995 this.scalingBitDepth = bitDepth;
996 int maxOutSample = (1 << bitDepth) - 1;
997 if (bitDepth <= 8) {
998 scale = new byte[numBands][];
999 for (int b = 0; b < numBands; b++) {
1000 int maxInSample = (1 << sampleSize[b]) - 1;
1001 int halfMaxInSample = maxInSample/2;
1002 scale[b] = new byte[maxInSample + 1];
1003 for (int s = 0; s <= maxInSample; s++) {
1004 scale[b][s] =
1005 (byte)((s*maxOutSample + halfMaxInSample)/maxInSample);
1006 }
1007 }
1008 scale0 = scale[0];
1009 scaleh = scalel = null;
1010 } else { // bitDepth == 16
1011 // Divide scaling table into high and low bytes
1012 scaleh = new byte[numBands][];
1013 scalel = new byte[numBands][];
1014
1015 for (int b = 0; b < numBands; b++) {
1016 int maxInSample = (1 << sampleSize[b]) - 1;
1017 int halfMaxInSample = maxInSample/2;
1018 scaleh[b] = new byte[maxInSample + 1];
1019 scalel[b] = new byte[maxInSample + 1];
1020 for (int s = 0; s <= maxInSample; s++) {
1021 int val = (s*maxOutSample + halfMaxInSample)/maxInSample;
1022 scaleh[b][s] = (byte)(val >> 8);
1023 scalel[b][s] = (byte)(val & 0xff);
1024 }
1025 }
1026 scale = null;
1027 scale0 = null;
1028 }
1029 }
1030
1031 public void write(IIOMetadata streamMetadata,
1032 IIOImage image,
1033 ImageWriteParam param) throws IIOException {
1034 if (stream == null) {
1035 throw new IllegalStateException("output == null!");
1036 }
1037 if (image == null) {
1038 throw new IllegalArgumentException("image == null!");
1039 }
1040 if (image.hasRaster()) {
1041 throw new UnsupportedOperationException("image has a Raster!");
1042 }
1043
1044 RenderedImage im = image.getRenderedImage();
1045 SampleModel sampleModel = im.getSampleModel();
1046 this.numBands = sampleModel.getNumBands();
1047
1048 // Set source region and subsampling to default values
1049 this.sourceXOffset = im.getMinX();
1050 this.sourceYOffset = im.getMinY();
1051 this.sourceWidth = im.getWidth();
1052 this.sourceHeight = im.getHeight();
1053 this.sourceBands = null;
1054 this.periodX = 1;
1055 this.periodY = 1;
1056
1057 if (param != null) {
1058 // Get source region and subsampling factors
1059 Rectangle sourceRegion = param.getSourceRegion();
1060 if (sourceRegion != null) {
1061 Rectangle imageBounds = new Rectangle(im.getMinX(),
1062 im.getMinY(),
1063 im.getWidth(),
1064 im.getHeight());
1065 // Clip to actual image bounds
1066 sourceRegion = sourceRegion.intersection(imageBounds);
1067 sourceXOffset = sourceRegion.x;
1068 sourceYOffset = sourceRegion.y;
1069 sourceWidth = sourceRegion.width;
1070 sourceHeight = sourceRegion.height;
1071 }
1072
1073 // Adjust for subsampling offsets
1074 int gridX = param.getSubsamplingXOffset();
1075 int gridY = param.getSubsamplingYOffset();
1076 sourceXOffset += gridX;
1077 sourceYOffset += gridY;
1078 sourceWidth -= gridX;
1079 sourceHeight -= gridY;
1080
1081 // Get subsampling factors
1082 periodX = param.getSourceXSubsampling();
1083 periodY = param.getSourceYSubsampling();
1084
1085 int[] sBands = param.getSourceBands();
1086 if (sBands != null) {
1087 sourceBands = sBands;
1088 numBands = sourceBands.length;
1089 }
1090 }
1091
1092 // Compute output dimensions
1093 int destWidth = (sourceWidth + periodX - 1)/periodX;
1094 int destHeight = (sourceHeight + periodY - 1)/periodY;
1095 if (destWidth <= 0 || destHeight <= 0) {
1096 throw new IllegalArgumentException("Empty source region!");
1097 }
1098
1099 // Compute total number of pixels for progress notification
1100 this.totalPixels = destWidth*destHeight;
1101 this.pixelsDone = 0;
1102
1103 // Create metadata
1104 IIOMetadata imd = image.getMetadata();
1105 if (imd != null) {
1106 metadata = (PNGMetadata)convertImageMetadata(imd,
1107 ImageTypeSpecifier.createFromRenderedImage(im),
1108 null);
1109 } else {
1110 metadata = new PNGMetadata();
1111 }
1112
1113 if (param != null) {
1114 // Use Adam7 interlacing if set in write param
1115 switch (param.getProgressiveMode()) {
1116 case ImageWriteParam.MODE_DEFAULT:
1117 metadata.IHDR_interlaceMethod = 1;
1118 break;
1119 case ImageWriteParam.MODE_DISABLED:
1120 metadata.IHDR_interlaceMethod = 0;
1121 break;
1122 // MODE_COPY_FROM_METADATA should alreay be taken care of
1123 // MODE_EXPLICIT is not allowed
1124 }
1125 }
1126
1127 // Initialize bitDepth and colorType
1128 metadata.initialize(new ImageTypeSpecifier(im), numBands);
1129
1130 // Overwrite IHDR width and height values with values from image
1131 metadata.IHDR_width = destWidth;
1132 metadata.IHDR_height = destHeight;
1133
1134 this.bpp = numBands*((metadata.IHDR_bitDepth == 16) ? 2 : 1);
1135
1136 // Initialize scaling tables for this image
1137 initializeScaleTables(sampleModel.getSampleSize());
1138
1139 clearAbortRequest();
1140
1141 processImageStarted(0);
1142
1143 try {
1144 write_magic();
1145 write_IHDR();
1146
1147 write_cHRM();
1148 write_gAMA();
1149 write_iCCP();
1150 write_sBIT();
1151 write_sRGB();
1152
1153 write_PLTE();
1154
1155 write_hIST();
1156 write_tRNS();
1157 write_bKGD();
1158
1159 write_pHYs();
1160 write_sPLT();
1161 write_tIME();
1162 write_tEXt();
1163 write_iTXt();
1164 write_zTXt();
1165
1166 writeUnknownChunks();
1167
1168 write_IDAT(im);
1169
1170 if (abortRequested()) {
1171 processWriteAborted();
1172 } else {
1173 // Finish up and inform the listeners we are done
1174 writeIEND();
1175 processImageComplete();
1176 }
1177 } catch (IOException e) {
1178 throw new IIOException("I/O error writing PNG file!", e);
1179 }
1180 }
1181 }