1 /*
2 * Copyright (c) 2001, 2014, 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.jpeg;
27
28 import javax.imageio.IIOException;
29 import javax.imageio.IIOImage;
30 import javax.imageio.ImageTypeSpecifier;
31 import javax.imageio.ImageReader;
32 import javax.imageio.metadata.IIOInvalidTreeException;
33 import javax.imageio.metadata.IIOMetadataNode;
34 import javax.imageio.metadata.IIOMetadata;
35 import javax.imageio.stream.ImageInputStream;
36 import javax.imageio.stream.ImageOutputStream;
37 import javax.imageio.stream.MemoryCacheImageOutputStream;
38 import javax.imageio.event.IIOReadProgressListener;
39
40 import java.awt.Graphics;
41 import java.awt.color.ICC_Profile;
42 import java.awt.color.ICC_ColorSpace;
43 import java.awt.color.ColorSpace;
44 import java.awt.image.ColorModel;
45 import java.awt.image.SampleModel;
46 import java.awt.image.IndexColorModel;
47 import java.awt.image.ComponentColorModel;
48 import java.awt.image.BufferedImage;
49 import java.awt.image.DataBuffer;
50 import java.awt.image.DataBufferByte;
51 import java.awt.image.Raster;
52 import java.awt.image.WritableRaster;
53 import java.io.IOException;
54 import java.io.ByteArrayOutputStream;
55 import java.util.List;
56 import java.util.ArrayList;
57 import java.util.Iterator;
58
59 import org.w3c.dom.Node;
60 import org.w3c.dom.NodeList;
61 import org.w3c.dom.NamedNodeMap;
62
63 /**
64 * A JFIF (JPEG File Interchange Format) APP0 (Application-Specific)
65 * marker segment. Inner classes are included for JFXX extension
66 * marker segments, for different varieties of thumbnails, and for
67 * ICC Profile APP2 marker segments. Any of these secondary types
68 * that occur are kept as members of a single JFIFMarkerSegment object.
69 */
70 class JFIFMarkerSegment extends MarkerSegment {
71 int majorVersion;
72 int minorVersion;
73 int resUnits;
74 int Xdensity;
75 int Ydensity;
76 int thumbWidth;
77 int thumbHeight;
78 JFIFThumbRGB thumb = null; // If present
79 ArrayList<JFIFExtensionMarkerSegment> extSegments = new ArrayList<>();
80 ICCMarkerSegment iccSegment = null; // optional ICC
81 private static final int THUMB_JPEG = 0x10;
82 private static final int THUMB_PALETTE = 0x11;
83 private static final int THUMB_UNASSIGNED = 0x12;
84 private static final int THUMB_RGB = 0x13;
85 private static final int DATA_SIZE = 14;
86 private static final int ID_SIZE = 5;
87 private final int MAX_THUMB_WIDTH = 255;
88 private final int MAX_THUMB_HEIGHT = 255;
89
90 private final boolean debug = false;
91
92 /**
93 * Set to <code>true</code> when reading the chunks of an
94 * ICC profile. All chunks are consolidated to create a single
95 * "segment" containing all the chunks. This flag is a state
96 * variable identifying whether to construct a new segment or
97 * append to an old one.
98 */
99 private boolean inICC = false;
100
101 /**
102 * A placeholder for an ICC profile marker segment under
103 * construction. The segment is not added to the list
104 * until all chunks have been read.
105 */
106 private ICCMarkerSegment tempICCSegment = null;
107
108
109 /**
110 * Default constructor. Used to create a default JFIF header
111 */
112 JFIFMarkerSegment() {
113 super(JPEG.APP0);
114 majorVersion = 1;
115 minorVersion = 2;
116 resUnits = JPEG.DENSITY_UNIT_ASPECT_RATIO;
117 Xdensity = 1;
118 Ydensity = 1;
119 thumbWidth = 0;
120 thumbHeight = 0;
121 }
122
123 /**
124 * Constructs a JFIF header by reading from a stream wrapped
125 * in a JPEGBuffer.
126 */
127 JFIFMarkerSegment(JPEGBuffer buffer) throws IOException {
128 super(buffer);
129 buffer.bufPtr += ID_SIZE; // skip the id, we already checked it
130
131 majorVersion = buffer.buf[buffer.bufPtr++];
132 minorVersion = buffer.buf[buffer.bufPtr++];
133 resUnits = buffer.buf[buffer.bufPtr++];
134 Xdensity = (buffer.buf[buffer.bufPtr++] & 0xff) << 8;
135 Xdensity |= buffer.buf[buffer.bufPtr++] & 0xff;
136 Ydensity = (buffer.buf[buffer.bufPtr++] & 0xff) << 8;
137 Ydensity |= buffer.buf[buffer.bufPtr++] & 0xff;
138 thumbWidth = buffer.buf[buffer.bufPtr++] & 0xff;
139 thumbHeight = buffer.buf[buffer.bufPtr++] & 0xff;
140 buffer.bufAvail -= DATA_SIZE;
141 if (thumbWidth > 0) {
142 thumb = new JFIFThumbRGB(buffer, thumbWidth, thumbHeight);
143 }
144 }
145
146 /**
147 * Constructs a JFIF header from a DOM Node.
148 */
149 JFIFMarkerSegment(Node node) throws IIOInvalidTreeException {
150 this();
151 updateFromNativeNode(node, true);
152 }
153
154 /**
155 * Returns a deep-copy clone of this object.
156 */
157 protected Object clone() {
158 JFIFMarkerSegment newGuy = (JFIFMarkerSegment) super.clone();
159 if (!extSegments.isEmpty()) { // Clone the list with a deep copy
160 newGuy.extSegments = new ArrayList<>();
161 for (Iterator<JFIFExtensionMarkerSegment> iter =
162 extSegments.iterator(); iter.hasNext();) {
163 JFIFExtensionMarkerSegment jfxx = iter.next();
164 newGuy.extSegments.add((JFIFExtensionMarkerSegment) jfxx.clone());
165 }
166 }
167 if (iccSegment != null) {
168 newGuy.iccSegment = (ICCMarkerSegment) iccSegment.clone();
169 }
170 return newGuy;
171 }
172
173 /**
174 * Add an JFXX extension marker segment from the stream wrapped
175 * in the JPEGBuffer to the list of extension segments.
176 */
177 void addJFXX(JPEGBuffer buffer, JPEGImageReader reader)
178 throws IOException {
179 extSegments.add(new JFIFExtensionMarkerSegment(buffer, reader));
180 }
181
182 /**
183 * Adds an ICC Profile APP2 segment from the stream wrapped
184 * in the JPEGBuffer.
185 */
186 void addICC(JPEGBuffer buffer) throws IOException {
187 if (inICC == false) {
188 if (iccSegment != null) {
189 throw new IIOException
190 ("> 1 ICC APP2 Marker Segment not supported");
191 }
192 tempICCSegment = new ICCMarkerSegment(buffer);
193 if (inICC == false) { // Just one chunk
194 iccSegment = tempICCSegment;
195 tempICCSegment = null;
196 }
197 } else {
198 if (tempICCSegment.addData(buffer) == true) {
199 iccSegment = tempICCSegment;
200 tempICCSegment = null;
201 }
202 }
203 }
204
205 /**
206 * Add an ICC Profile APP2 segment by constructing it from
207 * the given ICC_ColorSpace object.
208 */
209 void addICC(ICC_ColorSpace cs) throws IOException {
210 if (iccSegment != null) {
211 throw new IIOException
212 ("> 1 ICC APP2 Marker Segment not supported");
213 }
214 iccSegment = new ICCMarkerSegment(cs);
215 }
216
217 /**
218 * Returns a tree of DOM nodes representing this object and any
219 * subordinate JFXX extension or ICC Profile segments.
220 */
221 IIOMetadataNode getNativeNode() {
222 IIOMetadataNode node = new IIOMetadataNode("app0JFIF");
223 node.setAttribute("majorVersion", Integer.toString(majorVersion));
224 node.setAttribute("minorVersion", Integer.toString(minorVersion));
225 node.setAttribute("resUnits", Integer.toString(resUnits));
226 node.setAttribute("Xdensity", Integer.toString(Xdensity));
227 node.setAttribute("Ydensity", Integer.toString(Ydensity));
228 node.setAttribute("thumbWidth", Integer.toString(thumbWidth));
229 node.setAttribute("thumbHeight", Integer.toString(thumbHeight));
230 if (!extSegments.isEmpty()) {
231 IIOMetadataNode JFXXnode = new IIOMetadataNode("JFXX");
232 node.appendChild(JFXXnode);
233 for (Iterator<JFIFExtensionMarkerSegment> iter =
234 extSegments.iterator(); iter.hasNext();) {
235 JFIFExtensionMarkerSegment seg = iter.next();
236 JFXXnode.appendChild(seg.getNativeNode());
237 }
238 }
239 if (iccSegment != null) {
240 node.appendChild(iccSegment.getNativeNode());
241 }
242
243 return node;
244 }
245
246 /**
247 * Updates the data in this object from the given DOM Node tree.
248 * If fromScratch is true, this object is being constructed.
249 * Otherwise an existing object is being modified.
250 * Throws an IIOInvalidTreeException if the tree is invalid in
251 * any way.
252 */
253 void updateFromNativeNode(Node node, boolean fromScratch)
254 throws IIOInvalidTreeException {
255 // none of the attributes are required
256 NamedNodeMap attrs = node.getAttributes();
257 if (attrs.getLength() > 0) {
258 int value = getAttributeValue(node, attrs, "majorVersion",
259 0, 255, false);
260 majorVersion = (value != -1) ? value : majorVersion;
261 value = getAttributeValue(node, attrs, "minorVersion",
262 0, 255, false);
263 minorVersion = (value != -1) ? value : minorVersion;
264 value = getAttributeValue(node, attrs, "resUnits", 0, 2, false);
265 resUnits = (value != -1) ? value : resUnits;
266 value = getAttributeValue(node, attrs, "Xdensity", 1, 65535, false);
267 Xdensity = (value != -1) ? value : Xdensity;
268 value = getAttributeValue(node, attrs, "Ydensity", 1, 65535, false);
269 Ydensity = (value != -1) ? value : Ydensity;
270 value = getAttributeValue(node, attrs, "thumbWidth", 0, 255, false);
271 thumbWidth = (value != -1) ? value : thumbWidth;
272 value = getAttributeValue(node, attrs, "thumbHeight", 0, 255, false);
273 thumbHeight = (value != -1) ? value : thumbHeight;
274 }
275 if (node.hasChildNodes()) {
276 NodeList children = node.getChildNodes();
277 int count = children.getLength();
278 if (count > 2) {
279 throw new IIOInvalidTreeException
280 ("app0JFIF node cannot have > 2 children", node);
281 }
282 for (int i = 0; i < count; i++) {
283 Node child = children.item(i);
284 String name = child.getNodeName();
285 if (name.equals("JFXX")) {
286 if ((!extSegments.isEmpty()) && fromScratch) {
287 throw new IIOInvalidTreeException
288 ("app0JFIF node cannot have > 1 JFXX node", node);
289 }
290 NodeList exts = child.getChildNodes();
291 int extCount = exts.getLength();
292 for (int j = 0; j < extCount; j++) {
293 Node ext = exts.item(j);
294 extSegments.add(new JFIFExtensionMarkerSegment(ext));
295 }
296 }
297 if (name.equals("app2ICC")) {
298 if ((iccSegment != null) && fromScratch) {
299 throw new IIOInvalidTreeException
300 ("> 1 ICC APP2 Marker Segment not supported", node);
301 }
302 iccSegment = new ICCMarkerSegment(child);
303 }
304 }
305 }
306 }
307
308 int getThumbnailWidth(int index) {
309 if (thumb != null) {
310 if (index == 0) {
311 return thumb.getWidth();
312 }
313 index--;
314 }
315 JFIFExtensionMarkerSegment jfxx = extSegments.get(index);
316 return jfxx.thumb.getWidth();
317 }
318
319 int getThumbnailHeight(int index) {
320 if (thumb != null) {
321 if (index == 0) {
322 return thumb.getHeight();
323 }
324 index--;
325 }
326 JFIFExtensionMarkerSegment jfxx = extSegments.get(index);
327 return jfxx.thumb.getHeight();
328 }
329
330 BufferedImage getThumbnail(ImageInputStream iis,
331 int index,
332 JPEGImageReader reader) throws IOException {
333 reader.thumbnailStarted(index);
334 BufferedImage ret = null;
335 if ((thumb != null) && (index == 0)) {
336 ret = thumb.getThumbnail(iis, reader);
337 } else {
338 if (thumb != null) {
339 index--;
340 }
341 JFIFExtensionMarkerSegment jfxx = extSegments.get(index);
342 ret = jfxx.thumb.getThumbnail(iis, reader);
343 }
344 reader.thumbnailComplete();
345 return ret;
346 }
347
348
349 /**
350 * Writes the data for this segment to the stream in
351 * valid JPEG format. Assumes that there will be no thumbnail.
352 */
353 void write(ImageOutputStream ios,
354 JPEGImageWriter writer) throws IOException {
355 // No thumbnail
356 write(ios, null, writer);
357 }
358
359 /**
360 * Writes the data for this segment to the stream in
361 * valid JPEG format. The length written takes the thumbnail
362 * width and height into account. If necessary, the thumbnail
363 * is clipped to 255 x 255 and a warning is sent to the writer
364 * argument. Progress updates are sent to the writer argument.
365 */
366 void write(ImageOutputStream ios,
367 BufferedImage thumb,
368 JPEGImageWriter writer) throws IOException {
369 int thumbWidth = 0;
370 int thumbHeight = 0;
371 int thumbLength = 0;
372 int [] thumbData = null;
373 if (thumb != null) {
374 // Clip if necessary and get the data in thumbData
375 thumbWidth = thumb.getWidth();
376 thumbHeight = thumb.getHeight();
377 if ((thumbWidth > MAX_THUMB_WIDTH)
378 || (thumbHeight > MAX_THUMB_HEIGHT)) {
379 writer.warningOccurred(JPEGImageWriter.WARNING_THUMB_CLIPPED);
380 }
381 thumbWidth = Math.min(thumbWidth, MAX_THUMB_WIDTH);
382 thumbHeight = Math.min(thumbHeight, MAX_THUMB_HEIGHT);
383 thumbData = thumb.getRaster().getPixels(0, 0,
384 thumbWidth, thumbHeight,
385 (int []) null);
386 thumbLength = thumbData.length;
387 }
388 length = DATA_SIZE + LENGTH_SIZE + thumbLength;
389 writeTag(ios);
390 byte [] id = {0x4A, 0x46, 0x49, 0x46, 0x00};
391 ios.write(id);
392 ios.write(majorVersion);
393 ios.write(minorVersion);
394 ios.write(resUnits);
395 write2bytes(ios, Xdensity);
396 write2bytes(ios, Ydensity);
397 ios.write(thumbWidth);
398 ios.write(thumbHeight);
399 if (thumbData != null) {
400 writer.thumbnailStarted(0);
401 writeThumbnailData(ios, thumbData, writer);
402 writer.thumbnailComplete();
403 }
404 }
405
406 /*
407 * Write out the values in the integer array as a sequence of bytes,
408 * reporting progress to the writer argument.
409 */
410 void writeThumbnailData(ImageOutputStream ios,
411 int [] thumbData,
412 JPEGImageWriter writer) throws IOException {
413 int progInterval = thumbData.length / 20; // approx. every 5%
414 if (progInterval == 0) {
415 progInterval = 1;
416 }
417 for (int i = 0; i < thumbData.length; i++) {
418 ios.write(thumbData[i]);
419 if ((i > progInterval) && (i % progInterval == 0)) {
420 writer.thumbnailProgress
421 (((float) i * 100) / ((float) thumbData.length));
422 }
423 }
424 }
425
426 /**
427 * Write out this JFIF Marker Segment, including a thumbnail or
428 * appending a series of JFXX Marker Segments, as appropriate.
429 * Warnings and progress reports are sent to the writer argument.
430 * The list of thumbnails is matched to the list of JFXX extension
431 * segments, if any, in order to determine how to encode the
432 * thumbnails. If there are more thumbnails than metadata segments,
433 * default encoding is used for the extra thumbnails.
434 */
435 void writeWithThumbs(ImageOutputStream ios,
436 List<? extends BufferedImage> thumbnails,
437 JPEGImageWriter writer) throws IOException {
438 if (thumbnails != null) {
439 JFIFExtensionMarkerSegment jfxx = null;
440 if (thumbnails.size() == 1) {
441 if (!extSegments.isEmpty()) {
442 jfxx = extSegments.get(0);
443 }
444 writeThumb(ios,
445 (BufferedImage) thumbnails.get(0),
446 jfxx,
447 0,
448 true,
449 writer);
450 } else {
451 // All others write as separate JFXX segments
452 write(ios, writer); // Just the header without any thumbnail
453 for (int i = 0; i < thumbnails.size(); i++) {
454 jfxx = null;
455 if (i < extSegments.size()) {
456 jfxx = extSegments.get(i);
457 }
458 writeThumb(ios,
459 (BufferedImage) thumbnails.get(i),
460 jfxx,
461 i,
462 false,
463 writer);
464 }
465 }
466 } else { // No thumbnails
467 write(ios, writer);
468 }
469
470 }
471
472 private void writeThumb(ImageOutputStream ios,
473 BufferedImage thumb,
474 JFIFExtensionMarkerSegment jfxx,
475 int index,
476 boolean onlyOne,
477 JPEGImageWriter writer) throws IOException {
478 ColorModel cm = thumb.getColorModel();
479 ColorSpace cs = cm.getColorSpace();
480
481 if (cm instanceof IndexColorModel) {
482 // We never write a palette image into the header
483 // So if it's the only one, we need to write the header first
484 if (onlyOne) {
485 write(ios, writer);
486 }
487 if ((jfxx == null)
488 || (jfxx.code == THUMB_PALETTE)) {
489 writeJFXXSegment(index, thumb, ios, writer); // default
490 } else {
491 // Expand to RGB
492 BufferedImage thumbRGB =
493 ((IndexColorModel) cm).convertToIntDiscrete
494 (thumb.getRaster(), false);
495 jfxx.setThumbnail(thumbRGB);
496 writer.thumbnailStarted(index);
497 jfxx.write(ios, writer); // Handles clipping if needed
498 writer.thumbnailComplete();
499 }
500 } else if (cs.getType() == ColorSpace.TYPE_RGB) {
501 if (jfxx == null) {
502 if (onlyOne) {
503 write(ios, thumb, writer); // As part of the header
504 } else {
505 writeJFXXSegment(index, thumb, ios, writer); // default
506 }
507 } else {
508 // If this is the only one, write the header first
509 if (onlyOne) {
510 write(ios, writer);
511 }
512 if (jfxx.code == THUMB_PALETTE) {
513 writeJFXXSegment(index, thumb, ios, writer); // default
514 writer.warningOccurred
515 (JPEGImageWriter.WARNING_NO_RGB_THUMB_AS_INDEXED);
516 } else {
517 jfxx.setThumbnail(thumb);
518 writer.thumbnailStarted(index);
519 jfxx.write(ios, writer); // Handles clipping if needed
520 writer.thumbnailComplete();
521 }
522 }
523 } else if (cs.getType() == ColorSpace.TYPE_GRAY) {
524 if (jfxx == null) {
525 if (onlyOne) {
526 BufferedImage thumbRGB = expandGrayThumb(thumb);
527 write(ios, thumbRGB, writer); // As part of the header
528 } else {
529 writeJFXXSegment(index, thumb, ios, writer); // default
530 }
531 } else {
532 // If this is the only one, write the header first
533 if (onlyOne) {
534 write(ios, writer);
535 }
536 if (jfxx.code == THUMB_RGB) {
537 BufferedImage thumbRGB = expandGrayThumb(thumb);
538 writeJFXXSegment(index, thumbRGB, ios, writer);
539 } else if (jfxx.code == THUMB_JPEG) {
540 jfxx.setThumbnail(thumb);
541 writer.thumbnailStarted(index);
542 jfxx.write(ios, writer); // Handles clipping if needed
543 writer.thumbnailComplete();
544 } else if (jfxx.code == THUMB_PALETTE) {
545 writeJFXXSegment(index, thumb, ios, writer); // default
546 writer.warningOccurred
547 (JPEGImageWriter.WARNING_NO_GRAY_THUMB_AS_INDEXED);
548 }
549 }
550 } else {
551 writer.warningOccurred
552 (JPEGImageWriter.WARNING_ILLEGAL_THUMBNAIL);
553 }
554 }
555
556 // Could put reason codes in here to be parsed in writeJFXXSegment
557 // in order to provide more meaningful warnings.
558 @SuppressWarnings("serial") // JDK-implementation class
559 private class IllegalThumbException extends Exception {}
560
561 /**
562 * Writes out a new JFXX extension segment, without saving it.
563 */
564 private void writeJFXXSegment(int index,
565 BufferedImage thumbnail,
566 ImageOutputStream ios,
567 JPEGImageWriter writer) throws IOException {
568 JFIFExtensionMarkerSegment jfxx = null;
569 try {
570 jfxx = new JFIFExtensionMarkerSegment(thumbnail);
571 } catch (IllegalThumbException e) {
572 writer.warningOccurred
573 (JPEGImageWriter.WARNING_ILLEGAL_THUMBNAIL);
574 return;
575 }
576 writer.thumbnailStarted(index);
577 jfxx.write(ios, writer);
578 writer.thumbnailComplete();
579 }
580
581
582 /**
583 * Return an RGB image that is the expansion of the given grayscale
584 * image.
585 */
586 private static BufferedImage expandGrayThumb(BufferedImage thumb) {
587 BufferedImage ret = new BufferedImage(thumb.getWidth(),
588 thumb.getHeight(),
589 BufferedImage.TYPE_INT_RGB);
590 Graphics g = ret.getGraphics();
591 g.drawImage(thumb, 0, 0, null);
592 return ret;
593 }
594
595 /**
596 * Writes out a default JFIF marker segment to the given
597 * output stream. If <code>thumbnails</code> is not <code>null</code>,
598 * writes out the set of thumbnail images as JFXX marker segments, or
599 * incorporated into the JFIF segment if appropriate.
600 * If <code>iccProfile</code> is not <code>null</code>,
601 * writes out the profile after the JFIF segment using as many APP2
602 * marker segments as necessary.
603 */
604 static void writeDefaultJFIF(ImageOutputStream ios,
605 List<? extends BufferedImage> thumbnails,
606 ICC_Profile iccProfile,
607 JPEGImageWriter writer)
608 throws IOException {
609
610 JFIFMarkerSegment jfif = new JFIFMarkerSegment();
611 jfif.writeWithThumbs(ios, thumbnails, writer);
612 if (iccProfile != null) {
613 writeICC(iccProfile, ios);
614 }
615 }
616
617 /**
618 * Prints out the contents of this object to System.out for debugging.
619 */
620 void print() {
621 printTag("JFIF");
622 System.out.print("Version ");
623 System.out.print(majorVersion);
624 System.out.println(".0"
625 + Integer.toString(minorVersion));
626 System.out.print("Resolution units: ");
627 System.out.println(resUnits);
628 System.out.print("X density: ");
629 System.out.println(Xdensity);
630 System.out.print("Y density: ");
631 System.out.println(Ydensity);
632 System.out.print("Thumbnail Width: ");
633 System.out.println(thumbWidth);
634 System.out.print("Thumbnail Height: ");
635 System.out.println(thumbHeight);
636 if (!extSegments.isEmpty()) {
637 for (Iterator<JFIFExtensionMarkerSegment> iter =
638 extSegments.iterator(); iter.hasNext();) {
639 JFIFExtensionMarkerSegment extSegment = iter.next();
640 extSegment.print();
641 }
642 }
643 if (iccSegment != null) {
644 iccSegment.print();
645 }
646 }
647
648 /**
649 * A JFIF extension APP0 marker segment.
650 */
651 class JFIFExtensionMarkerSegment extends MarkerSegment {
652 int code;
653 JFIFThumb thumb;
654 private static final int DATA_SIZE = 6;
655 private static final int ID_SIZE = 5;
656
657 JFIFExtensionMarkerSegment(JPEGBuffer buffer, JPEGImageReader reader)
658 throws IOException {
659
660 super(buffer);
661 buffer.bufPtr += ID_SIZE; // skip the id, we already checked it
662
663 code = buffer.buf[buffer.bufPtr++] & 0xff;
664 buffer.bufAvail -= DATA_SIZE;
665 if (code == THUMB_JPEG) {
666 thumb = new JFIFThumbJPEG(buffer, length, reader);
667 } else {
668 buffer.loadBuf(2);
669 int thumbX = buffer.buf[buffer.bufPtr++] & 0xff;
670 int thumbY = buffer.buf[buffer.bufPtr++] & 0xff;
671 buffer.bufAvail -= 2;
672 // following constructors handle bufAvail
673 if (code == THUMB_PALETTE) {
674 thumb = new JFIFThumbPalette(buffer, thumbX, thumbY);
675 } else {
676 thumb = new JFIFThumbRGB(buffer, thumbX, thumbY);
677 }
678 }
679 }
680
681 JFIFExtensionMarkerSegment(Node node) throws IIOInvalidTreeException {
682 super(JPEG.APP0);
683 NamedNodeMap attrs = node.getAttributes();
684 if (attrs.getLength() > 0) {
685 code = getAttributeValue(node,
686 attrs,
687 "extensionCode",
688 THUMB_JPEG,
689 THUMB_RGB,
690 false);
691 if (code == THUMB_UNASSIGNED) {
692 throw new IIOInvalidTreeException
693 ("invalid extensionCode attribute value", node);
694 }
695 } else {
696 code = THUMB_UNASSIGNED;
697 }
698 // Now the child
699 if (node.getChildNodes().getLength() != 1) {
700 throw new IIOInvalidTreeException
701 ("app0JFXX node must have exactly 1 child", node);
702 }
703 Node child = node.getFirstChild();
704 String name = child.getNodeName();
705 if (name.equals("JFIFthumbJPEG")) {
706 if (code == THUMB_UNASSIGNED) {
707 code = THUMB_JPEG;
708 }
709 thumb = new JFIFThumbJPEG(child);
710 } else if (name.equals("JFIFthumbPalette")) {
711 if (code == THUMB_UNASSIGNED) {
712 code = THUMB_PALETTE;
713 }
714 thumb = new JFIFThumbPalette(child);
715 } else if (name.equals("JFIFthumbRGB")) {
716 if (code == THUMB_UNASSIGNED) {
717 code = THUMB_RGB;
718 }
719 thumb = new JFIFThumbRGB(child);
720 } else {
721 throw new IIOInvalidTreeException
722 ("unrecognized app0JFXX child node", node);
723 }
724 }
725
726 JFIFExtensionMarkerSegment(BufferedImage thumbnail)
727 throws IllegalThumbException {
728
729 super(JPEG.APP0);
730 ColorModel cm = thumbnail.getColorModel();
731 int csType = cm.getColorSpace().getType();
732 if (cm.hasAlpha()) {
733 throw new IllegalThumbException();
734 }
735 if (cm instanceof IndexColorModel) {
736 code = THUMB_PALETTE;
737 thumb = new JFIFThumbPalette(thumbnail);
738 } else if (csType == ColorSpace.TYPE_RGB) {
739 code = THUMB_RGB;
740 thumb = new JFIFThumbRGB(thumbnail);
741 } else if (csType == ColorSpace.TYPE_GRAY) {
742 code = THUMB_JPEG;
743 thumb = new JFIFThumbJPEG(thumbnail);
744 } else {
745 throw new IllegalThumbException();
746 }
747 }
748
749 void setThumbnail(BufferedImage thumbnail) {
750 try {
751 switch (code) {
752 case THUMB_PALETTE:
753 thumb = new JFIFThumbPalette(thumbnail);
754 break;
755 case THUMB_RGB:
756 thumb = new JFIFThumbRGB(thumbnail);
757 break;
758 case THUMB_JPEG:
759 thumb = new JFIFThumbJPEG(thumbnail);
760 break;
761 }
762 } catch (IllegalThumbException e) {
763 // Should never happen
764 throw new InternalError("Illegal thumb in setThumbnail!", e);
765 }
766 }
767
768 protected Object clone() {
769 JFIFExtensionMarkerSegment newGuy =
770 (JFIFExtensionMarkerSegment) super.clone();
771 if (thumb != null) {
772 newGuy.thumb = (JFIFThumb) thumb.clone();
773 }
774 return newGuy;
775 }
776
777 IIOMetadataNode getNativeNode() {
778 IIOMetadataNode node = new IIOMetadataNode("app0JFXX");
779 node.setAttribute("extensionCode", Integer.toString(code));
780 node.appendChild(thumb.getNativeNode());
781 return node;
782 }
783
784 void write(ImageOutputStream ios,
785 JPEGImageWriter writer) throws IOException {
786 length = LENGTH_SIZE + DATA_SIZE + thumb.getLength();
787 writeTag(ios);
788 byte [] id = {0x4A, 0x46, 0x58, 0x58, 0x00};
789 ios.write(id);
790 ios.write(code);
791 thumb.write(ios, writer);
792 }
793
794 void print() {
795 printTag("JFXX");
796 thumb.print();
797 }
798 }
799
800 /**
801 * A superclass for the varieties of thumbnails that can
802 * be stored in a JFIF extension marker segment.
803 */
804 abstract class JFIFThumb implements Cloneable {
805 long streamPos = -1L; // Save the thumbnail pos when reading
806 abstract int getLength(); // When writing
807 abstract int getWidth();
808 abstract int getHeight();
809 abstract BufferedImage getThumbnail(ImageInputStream iis,
810 JPEGImageReader reader)
811 throws IOException;
812
813 protected JFIFThumb() {}
814
815 protected JFIFThumb(JPEGBuffer buffer) throws IOException{
816 // Save the stream position for reading the thumbnail later
817 streamPos = buffer.getStreamPosition();
818 }
819
820 abstract void print();
821
822 abstract IIOMetadataNode getNativeNode();
823
824 abstract void write(ImageOutputStream ios,
825 JPEGImageWriter writer) throws IOException;
826
827 protected Object clone() {
828 try {
829 return super.clone();
830 } catch (CloneNotSupportedException e) {} // won't happen
831 return null;
832 }
833
834 }
835
836 abstract class JFIFThumbUncompressed extends JFIFThumb {
837 BufferedImage thumbnail = null;
838 int thumbWidth;
839 int thumbHeight;
840 String name;
841
842 JFIFThumbUncompressed(JPEGBuffer buffer,
843 int width,
844 int height,
845 int skip,
846 String name)
847 throws IOException {
848 super(buffer);
849 thumbWidth = width;
850 thumbHeight = height;
851 // Now skip the thumbnail data
852 buffer.skipData(skip);
853 this.name = name;
854 }
855
856 JFIFThumbUncompressed(Node node, String name)
857 throws IIOInvalidTreeException {
858
859 thumbWidth = 0;
860 thumbHeight = 0;
861 this.name = name;
862 NamedNodeMap attrs = node.getAttributes();
863 int count = attrs.getLength();
864 if (count > 2) {
865 throw new IIOInvalidTreeException
866 (name +" node cannot have > 2 attributes", node);
867 }
868 if (count != 0) {
869 int value = getAttributeValue(node, attrs, "thumbWidth",
870 0, 255, false);
871 thumbWidth = (value != -1) ? value : thumbWidth;
872 value = getAttributeValue(node, attrs, "thumbHeight",
873 0, 255, false);
874 thumbHeight = (value != -1) ? value : thumbHeight;
875 }
876 }
877
878 JFIFThumbUncompressed(BufferedImage thumb) {
879 thumbnail = thumb;
880 thumbWidth = thumb.getWidth();
881 thumbHeight = thumb.getHeight();
882 name = null; // not used when writing
883 }
884
885 void readByteBuffer(ImageInputStream iis,
886 byte [] data,
887 JPEGImageReader reader,
888 float workPortion,
889 float workOffset) throws IOException {
890 int progInterval = Math.max((int)(data.length/20/workPortion),
891 1);
892 for (int offset = 0;
893 offset < data.length;) {
894 int len = Math.min(progInterval, data.length-offset);
895 iis.read(data, offset, len);
896 offset += progInterval;
897 float percentDone = ((float) offset* 100)
898 / data.length
899 * workPortion + workOffset;
900 if (percentDone > 100.0F) {
901 percentDone = 100.0F;
902 }
903 reader.thumbnailProgress (percentDone);
904 }
905 }
906
907
908 int getWidth() {
909 return thumbWidth;
910 }
911
912 int getHeight() {
913 return thumbHeight;
914 }
915
916 IIOMetadataNode getNativeNode() {
917 IIOMetadataNode node = new IIOMetadataNode(name);
918 node.setAttribute("thumbWidth", Integer.toString(thumbWidth));
919 node.setAttribute("thumbHeight", Integer.toString(thumbHeight));
920 return node;
921 }
922
923 void write(ImageOutputStream ios,
924 JPEGImageWriter writer) throws IOException {
925 if ((thumbWidth > MAX_THUMB_WIDTH)
926 || (thumbHeight > MAX_THUMB_HEIGHT)) {
927 writer.warningOccurred(JPEGImageWriter.WARNING_THUMB_CLIPPED);
928 }
929 thumbWidth = Math.min(thumbWidth, MAX_THUMB_WIDTH);
930 thumbHeight = Math.min(thumbHeight, MAX_THUMB_HEIGHT);
931 ios.write(thumbWidth);
932 ios.write(thumbHeight);
933 }
934
935 void writePixels(ImageOutputStream ios,
936 JPEGImageWriter writer) throws IOException {
937 if ((thumbWidth > MAX_THUMB_WIDTH)
938 || (thumbHeight > MAX_THUMB_HEIGHT)) {
939 writer.warningOccurred(JPEGImageWriter.WARNING_THUMB_CLIPPED);
940 }
941 thumbWidth = Math.min(thumbWidth, MAX_THUMB_WIDTH);
942 thumbHeight = Math.min(thumbHeight, MAX_THUMB_HEIGHT);
943 int [] data = thumbnail.getRaster().getPixels(0, 0,
944 thumbWidth,
945 thumbHeight,
946 (int []) null);
947 writeThumbnailData(ios, data, writer);
948 }
949
950 void print() {
951 System.out.print(name + " width: ");
952 System.out.println(thumbWidth);
953 System.out.print(name + " height: ");
954 System.out.println(thumbHeight);
955 }
956
957 }
958
959 /**
960 * A JFIF thumbnail stored as RGB, one byte per channel,
961 * interleaved.
962 */
963 class JFIFThumbRGB extends JFIFThumbUncompressed {
964
965 JFIFThumbRGB(JPEGBuffer buffer, int width, int height)
966 throws IOException {
967
968 super(buffer, width, height, width*height*3, "JFIFthumbRGB");
969 }
970
971 JFIFThumbRGB(Node node) throws IIOInvalidTreeException {
972 super(node, "JFIFthumbRGB");
973 }
974
975 JFIFThumbRGB(BufferedImage thumb) throws IllegalThumbException {
976 super(thumb);
977 }
978
979 int getLength() {
980 return (thumbWidth*thumbHeight*3);
981 }
982
983 BufferedImage getThumbnail(ImageInputStream iis,
984 JPEGImageReader reader)
985 throws IOException {
986 iis.mark();
987 iis.seek(streamPos);
988 DataBufferByte buffer = new DataBufferByte(getLength());
989 readByteBuffer(iis,
990 buffer.getData(),
991 reader,
992 1.0F,
993 0.0F);
994 iis.reset();
995
996 WritableRaster raster =
997 Raster.createInterleavedRaster(buffer,
998 thumbWidth,
999 thumbHeight,
1000 thumbWidth*3,
1001 3,
1002 new int [] {0, 1, 2},
1003 null);
1004 ColorModel cm = new ComponentColorModel(JPEG.JCS.sRGB,
1005 false,
1006 false,
1007 ColorModel.OPAQUE,
1008 DataBuffer.TYPE_BYTE);
1009 return new BufferedImage(cm,
1010 raster,
1011 false,
1012 null);
1013 }
1014
1015 void write(ImageOutputStream ios,
1016 JPEGImageWriter writer) throws IOException {
1017 super.write(ios, writer); // width and height
1018 writePixels(ios, writer);
1019 }
1020
1021 }
1022
1023 /**
1024 * A JFIF thumbnail stored as an indexed palette image
1025 * using an RGB palette.
1026 */
1027 class JFIFThumbPalette extends JFIFThumbUncompressed {
1028 private static final int PALETTE_SIZE = 768;
1029
1030 JFIFThumbPalette(JPEGBuffer buffer, int width, int height)
1031 throws IOException {
1032 super(buffer,
1033 width,
1034 height,
1035 PALETTE_SIZE + width * height,
1036 "JFIFThumbPalette");
1037 }
1038
1039 JFIFThumbPalette(Node node) throws IIOInvalidTreeException {
1040 super(node, "JFIFThumbPalette");
1041 }
1042
1043 JFIFThumbPalette(BufferedImage thumb) throws IllegalThumbException {
1044 super(thumb);
1045 IndexColorModel icm = (IndexColorModel) thumbnail.getColorModel();
1046 if (icm.getMapSize() > 256) {
1047 throw new IllegalThumbException();
1048 }
1049 }
1050
1051 int getLength() {
1052 return (thumbWidth*thumbHeight + PALETTE_SIZE);
1053 }
1054
1055 BufferedImage getThumbnail(ImageInputStream iis,
1056 JPEGImageReader reader)
1057 throws IOException {
1058 iis.mark();
1059 iis.seek(streamPos);
1060 // read the palette
1061 byte [] palette = new byte [PALETTE_SIZE];
1062 float palettePart = ((float) PALETTE_SIZE) / getLength();
1063 readByteBuffer(iis,
1064 palette,
1065 reader,
1066 palettePart,
1067 0.0F);
1068 DataBufferByte buffer = new DataBufferByte(thumbWidth*thumbHeight);
1069 readByteBuffer(iis,
1070 buffer.getData(),
1071 reader,
1072 1.0F-palettePart,
1073 palettePart);
1074 iis.read();
1075 iis.reset();
1076
1077 IndexColorModel cm = new IndexColorModel(8,
1078 256,
1079 palette,
1080 0,
1081 false);
1082 SampleModel sm = cm.createCompatibleSampleModel(thumbWidth,
1083 thumbHeight);
1084 WritableRaster raster =
1085 Raster.createWritableRaster(sm, buffer, null);
1086 return new BufferedImage(cm,
1087 raster,
1088 false,
1089 null);
1090 }
1091
1092 void write(ImageOutputStream ios,
1093 JPEGImageWriter writer) throws IOException {
1094 super.write(ios, writer); // width and height
1095 // Write the palette (must be 768 bytes)
1096 byte [] palette = new byte[768];
1097 IndexColorModel icm = (IndexColorModel) thumbnail.getColorModel();
1098 byte [] reds = new byte [256];
1099 byte [] greens = new byte [256];
1100 byte [] blues = new byte [256];
1101 icm.getReds(reds);
1102 icm.getGreens(greens);
1103 icm.getBlues(blues);
1104 for (int i = 0; i < 256; i++) {
1105 palette[i*3] = reds[i];
1106 palette[i*3+1] = greens[i];
1107 palette[i*3+2] = blues[i];
1108 }
1109 ios.write(palette);
1110 writePixels(ios, writer);
1111 }
1112 }
1113
1114
1115 /**
1116 * A JFIF thumbnail stored as a JPEG stream. No JFIF or
1117 * JFIF extension markers are permitted. There is no need
1118 * to clip these, but the entire image must fit into a
1119 * single JFXX marker segment.
1120 */
1121 class JFIFThumbJPEG extends JFIFThumb {
1122 JPEGMetadata thumbMetadata = null;
1123 byte [] data = null; // Compressed image data, for writing
1124 private static final int PREAMBLE_SIZE = 6;
1125
1126 JFIFThumbJPEG(JPEGBuffer buffer,
1127 int length,
1128 JPEGImageReader reader) throws IOException {
1129 super(buffer);
1130 // Compute the final stream position
1131 long finalPos = streamPos + (length - PREAMBLE_SIZE);
1132 // Set the stream back to the start of the thumbnail
1133 // and read its metadata (but don't decode the image)
1134 buffer.iis.seek(streamPos);
1135 thumbMetadata = new JPEGMetadata(false, true, buffer.iis, reader);
1136 // Set the stream to the computed final position
1137 buffer.iis.seek(finalPos);
1138 // Clear the now invalid buffer
1139 buffer.bufAvail = 0;
1140 buffer.bufPtr = 0;
1141 }
1142
1143 JFIFThumbJPEG(Node node) throws IIOInvalidTreeException {
1144 if (node.getChildNodes().getLength() > 1) {
1145 throw new IIOInvalidTreeException
1146 ("JFIFThumbJPEG node must have 0 or 1 child", node);
1147 }
1148 Node child = node.getFirstChild();
1149 if (child != null) {
1150 String name = child.getNodeName();
1151 if (!name.equals("markerSequence")) {
1152 throw new IIOInvalidTreeException
1153 ("JFIFThumbJPEG child must be a markerSequence node",
1154 node);
1155 }
1156 thumbMetadata = new JPEGMetadata(false, true);
1157 thumbMetadata.setFromMarkerSequenceNode(child);
1158 }
1159 }
1160
1161 JFIFThumbJPEG(BufferedImage thumb) throws IllegalThumbException {
1162 int INITIAL_BUFSIZE = 4096;
1163 int MAZ_BUFSIZE = 65535 - 2 - PREAMBLE_SIZE;
1164 try {
1165 ByteArrayOutputStream baos =
1166 new ByteArrayOutputStream(INITIAL_BUFSIZE);
1167 MemoryCacheImageOutputStream mos =
1168 new MemoryCacheImageOutputStream(baos);
1169
1170 JPEGImageWriter thumbWriter = new JPEGImageWriter(null);
1171
1172 thumbWriter.setOutput(mos);
1173
1174 // get default metadata for the thumb
1175 JPEGMetadata metadata =
1176 (JPEGMetadata) thumbWriter.getDefaultImageMetadata
1177 (new ImageTypeSpecifier(thumb), null);
1178
1179 // Remove the jfif segment, which should be there.
1180 MarkerSegment jfif = metadata.findMarkerSegment
1181 (JFIFMarkerSegment.class, true);
1182 if (jfif == null) {
1183 throw new IllegalThumbException();
1184 }
1185
1186 metadata.markerSequence.remove(jfif);
1187
1188 /* Use this if removing leaves a hole and causes trouble
1189
1190 // Get the tree
1191 String format = metadata.getNativeMetadataFormatName();
1192 IIOMetadataNode tree =
1193 (IIOMetadataNode) metadata.getAsTree(format);
1194
1195 // If there is no app0jfif node, the image is bad
1196 NodeList jfifs = tree.getElementsByTagName("app0JFIF");
1197 if (jfifs.getLength() == 0) {
1198 throw new IllegalThumbException();
1199 }
1200
1201 // remove the app0jfif node
1202 Node jfif = jfifs.item(0);
1203 Node parent = jfif.getParentNode();
1204 parent.removeChild(jfif);
1205
1206 metadata.setFromTree(format, tree);
1207 */
1208
1209 thumbWriter.write(new IIOImage(thumb, null, metadata));
1210
1211 thumbWriter.dispose();
1212 // Now check that the size is OK
1213 if (baos.size() > MAZ_BUFSIZE) {
1214 throw new IllegalThumbException();
1215 }
1216 data = baos.toByteArray();
1217 } catch (IOException e) {
1218 throw new IllegalThumbException();
1219 }
1220 }
1221
1222 int getWidth() {
1223 int retval = 0;
1224 SOFMarkerSegment sof =
1225 (SOFMarkerSegment) thumbMetadata.findMarkerSegment
1226 (SOFMarkerSegment.class, true);
1227 if (sof != null) {
1228 retval = sof.samplesPerLine;
1229 }
1230 return retval;
1231 }
1232
1233 int getHeight() {
1234 int retval = 0;
1235 SOFMarkerSegment sof =
1236 (SOFMarkerSegment) thumbMetadata.findMarkerSegment
1237 (SOFMarkerSegment.class, true);
1238 if (sof != null) {
1239 retval = sof.numLines;
1240 }
1241 return retval;
1242 }
1243
1244 private class ThumbnailReadListener
1245 implements IIOReadProgressListener {
1246 JPEGImageReader reader = null;
1247 ThumbnailReadListener (JPEGImageReader reader) {
1248 this.reader = reader;
1249 }
1250 public void sequenceStarted(ImageReader source, int minIndex) {}
1251 public void sequenceComplete(ImageReader source) {}
1252 public void imageStarted(ImageReader source, int imageIndex) {}
1253 public void imageProgress(ImageReader source,
1254 float percentageDone) {
1255 reader.thumbnailProgress(percentageDone);
1256 }
1257 public void imageComplete(ImageReader source) {}
1258 public void thumbnailStarted(ImageReader source,
1259 int imageIndex, int thumbnailIndex) {}
1260 public void thumbnailProgress(ImageReader source, float percentageDone) {}
1261 public void thumbnailComplete(ImageReader source) {}
1262 public void readAborted(ImageReader source) {}
1263 }
1264
1265 BufferedImage getThumbnail(ImageInputStream iis,
1266 JPEGImageReader reader)
1267 throws IOException {
1268 iis.mark();
1269 iis.seek(streamPos);
1270 JPEGImageReader thumbReader = new JPEGImageReader(null);
1271 thumbReader.setInput(iis);
1272 thumbReader.addIIOReadProgressListener
1273 (new ThumbnailReadListener(reader));
1274 BufferedImage ret = thumbReader.read(0, null);
1275 thumbReader.dispose();
1276 iis.reset();
1277 return ret;
1278 }
1279
1280 protected Object clone() {
1281 JFIFThumbJPEG newGuy = (JFIFThumbJPEG) super.clone();
1282 if (thumbMetadata != null) {
1283 newGuy.thumbMetadata = (JPEGMetadata) thumbMetadata.clone();
1284 }
1285 return newGuy;
1286 }
1287
1288 IIOMetadataNode getNativeNode() {
1289 IIOMetadataNode node = new IIOMetadataNode("JFIFthumbJPEG");
1290 if (thumbMetadata != null) {
1291 node.appendChild(thumbMetadata.getNativeTree());
1292 }
1293 return node;
1294 }
1295
1296 int getLength() {
1297 if (data == null) {
1298 return 0;
1299 } else {
1300 return data.length;
1301 }
1302 }
1303
1304 void write(ImageOutputStream ios,
1305 JPEGImageWriter writer) throws IOException {
1306 int progInterval = data.length / 20; // approx. every 5%
1307 if (progInterval == 0) {
1308 progInterval = 1;
1309 }
1310 for (int offset = 0;
1311 offset < data.length;) {
1312 int len = Math.min(progInterval, data.length-offset);
1313 ios.write(data, offset, len);
1314 offset += progInterval;
1315 float percentDone = ((float) offset * 100) / data.length;
1316 if (percentDone > 100.0F) {
1317 percentDone = 100.0F;
1318 }
1319 writer.thumbnailProgress (percentDone);
1320 }
1321 }
1322
1323 void print () {
1324 System.out.println("JFIF thumbnail stored as JPEG");
1325 }
1326 }
1327
1328 /**
1329 * Write out the given profile to the stream, embedded in
1330 * the necessary number of APP2 segments, per the ICC spec.
1331 * This is the only mechanism for writing an ICC profile
1332 * to a stream.
1333 */
1334 static void writeICC(ICC_Profile profile, ImageOutputStream ios)
1335 throws IOException {
1336 int LENGTH_LENGTH = 2;
1337 final String ID = "ICC_PROFILE";
1338 int ID_LENGTH = ID.length()+1; // spec says it's null-terminated
1339 int COUNTS_LENGTH = 2;
1340 int MAX_ICC_CHUNK_SIZE =
1341 65535 - LENGTH_LENGTH - ID_LENGTH - COUNTS_LENGTH;
1342
1343 byte [] data = profile.getData();
1344 int numChunks = data.length / MAX_ICC_CHUNK_SIZE;
1345 if ((data.length % MAX_ICC_CHUNK_SIZE) != 0) {
1346 numChunks++;
1347 }
1348 int chunkNum = 1;
1349 int offset = 0;
1350 for (int i = 0; i < numChunks; i++) {
1351 int dataLength = Math.min(data.length-offset, MAX_ICC_CHUNK_SIZE);
1352 int segLength = dataLength+COUNTS_LENGTH+ID_LENGTH+LENGTH_LENGTH;
1353 ios.write(0xff);
1354 ios.write(JPEG.APP2);
1355 MarkerSegment.write2bytes(ios, segLength);
1356 byte [] id = ID.getBytes("US-ASCII");
1357 ios.write(id);
1358 ios.write(0); // Null-terminate the string
1359 ios.write(chunkNum++);
1360 ios.write(numChunks);
1361 ios.write(data, offset, dataLength);
1362 offset += dataLength;
1363 }
1364 }
1365
1366 /**
1367 * An APP2 marker segment containing an ICC profile. In the stream
1368 * a profile larger than 64K is broken up into a series of chunks.
1369 * This inner class represents the complete profile as a single object,
1370 * combining chunks as necessary.
1371 */
1372 class ICCMarkerSegment extends MarkerSegment {
1373 ArrayList<byte[]> chunks = null;
1374 byte [] profile = null; // The complete profile when it's fully read
1375 // May remain null when writing
1376 private static final int ID_SIZE = 12;
1377 int chunksRead;
1378 int numChunks;
1379
1380 ICCMarkerSegment(ICC_ColorSpace cs) {
1381 super(JPEG.APP2);
1382 chunks = null;
1383 chunksRead = 0;
1384 numChunks = 0;
1385 profile = cs.getProfile().getData();
1386 }
1387
1388 ICCMarkerSegment(JPEGBuffer buffer) throws IOException {
1389 super(buffer); // gets whole segment or fills the buffer
1390 if (debug) {
1391 System.out.println("Creating new ICC segment");
1392 }
1393 buffer.bufPtr += ID_SIZE; // Skip the id
1394 buffer.bufAvail -= ID_SIZE;
1395 /*
1396 * Reduce the stored length by the id size. The stored
1397 * length is used to store the length of the profile
1398 * data only.
1399 */
1400 length -= ID_SIZE;
1401
1402 // get the chunk number
1403 int chunkNum = buffer.buf[buffer.bufPtr] & 0xff;
1404 // get the total number of chunks
1405 numChunks = buffer.buf[buffer.bufPtr+1] & 0xff;
1406
1407 if (chunkNum > numChunks) {
1408 throw new IIOException
1409 ("Image format Error; chunk num > num chunks");
1410 }
1411
1412 // if there are no more chunks, set up the data
1413 if (numChunks == 1) {
1414 // reduce the stored length by the two chunk numbering bytes
1415 length -= 2;
1416 profile = new byte[length];
1417 buffer.bufPtr += 2;
1418 buffer.bufAvail-=2;
1419 buffer.readData(profile);
1420 inICC = false;
1421 } else {
1422 // If we store them away, include the chunk numbering bytes
1423 byte [] profileData = new byte[length];
1424 // Now reduce the stored length by the
1425 // two chunk numbering bytes
1426 length -= 2;
1427 buffer.readData(profileData);
1428 chunks = new ArrayList<>();
1429 chunks.add(profileData);
1430 chunksRead = 1;
1431 inICC = true;
1432 }
1433 }
1434
1435 ICCMarkerSegment(Node node) throws IIOInvalidTreeException {
1436 super(JPEG.APP2);
1437 if (node instanceof IIOMetadataNode) {
1438 IIOMetadataNode ourNode = (IIOMetadataNode) node;
1439 ICC_Profile prof = (ICC_Profile) ourNode.getUserObject();
1440 if (prof != null) { // May be null
1441 profile = prof.getData();
1442 }
1443 }
1444 }
1445
1446 protected Object clone () {
1447 ICCMarkerSegment newGuy = (ICCMarkerSegment) super.clone();
1448 if (profile != null) {
1449 newGuy.profile = profile.clone();
1450 }
1451 return newGuy;
1452 }
1453
1454 boolean addData(JPEGBuffer buffer) throws IOException {
1455 if (debug) {
1456 System.out.println("Adding to ICC segment");
1457 }
1458 // skip the tag
1459 buffer.bufPtr++;
1460 buffer.bufAvail--;
1461 // Get the length, but not in length
1462 int dataLen = (buffer.buf[buffer.bufPtr++] & 0xff) << 8;
1463 dataLen |= buffer.buf[buffer.bufPtr++] & 0xff;
1464 buffer.bufAvail -= 2;
1465 // Don't include length itself
1466 dataLen -= 2;
1467 // skip the id
1468 buffer.bufPtr += ID_SIZE; // Skip the id
1469 buffer.bufAvail -= ID_SIZE;
1470 /*
1471 * Reduce the stored length by the id size. The stored
1472 * length is used to store the length of the profile
1473 * data only.
1474 */
1475 dataLen -= ID_SIZE;
1476
1477 // get the chunk number
1478 int chunkNum = buffer.buf[buffer.bufPtr] & 0xff;
1479 if (chunkNum > numChunks) {
1480 throw new IIOException
1481 ("Image format Error; chunk num > num chunks");
1482 }
1483
1484 // get the number of chunks, which should match
1485 int newNumChunks = buffer.buf[buffer.bufPtr+1] & 0xff;
1486 if (numChunks != newNumChunks) {
1487 throw new IIOException
1488 ("Image format Error; icc num chunks mismatch");
1489 }
1490 dataLen -= 2;
1491 if (debug) {
1492 System.out.println("chunkNum: " + chunkNum
1493 + ", numChunks: " + numChunks
1494 + ", dataLen: " + dataLen);
1495 }
1496 boolean retval = false;
1497 byte [] profileData = new byte[dataLen];
1498 buffer.readData(profileData);
1499 chunks.add(profileData);
1500 length += dataLen;
1501 chunksRead++;
1502 if (chunksRead < numChunks) {
1503 inICC = true;
1504 } else {
1505 if (debug) {
1506 System.out.println("Completing profile; total length is "
1507 + length);
1508 }
1509 // create an array for the whole thing
1510 profile = new byte[length];
1511 // copy the existing chunks, releasing them
1512 // Note that they may be out of order
1513
1514 int index = 0;
1515 for (int i = 1; i <= numChunks; i++) {
1516 boolean foundIt = false;
1517 for (int chunk = 0; chunk < chunks.size(); chunk++) {
1518 byte [] chunkData = chunks.get(chunk);
1519 if (chunkData[0] == i) { // Right one
1520 System.arraycopy(chunkData, 2,
1521 profile, index,
1522 chunkData.length-2);
1523 index += chunkData.length-2;
1524 foundIt = true;
1525 }
1526 }
1527 if (foundIt == false) {
1528 throw new IIOException
1529 ("Image Format Error: Missing ICC chunk num " + i);
1530 }
1531 }
1532
1533 chunks = null;
1534 chunksRead = 0;
1535 numChunks = 0;
1536 inICC = false;
1537 retval = true;
1538 }
1539 return retval;
1540 }
1541
1542 IIOMetadataNode getNativeNode() {
1543 IIOMetadataNode node = new IIOMetadataNode("app2ICC");
1544 if (profile != null) {
1545 node.setUserObject(ICC_Profile.getInstance(profile));
1546 }
1547 return node;
1548 }
1549
1550 /**
1551 * No-op. Profiles are never written from metadata.
1552 * They are written from the ColorSpace of the image.
1553 */
1554 void write(ImageOutputStream ios) throws IOException {
1555 // No-op
1556 }
1557
1558 void print () {
1559 printTag("ICC Profile APP2");
1560 }
1561 }
1562 }