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