import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
/**
 * Reads a Jpeg image, replaces the XMP XML and writes the result to a
 * stream.
 * 
 * @param byteSource
 *            ByteSource containing Jpeg image data.
 * @param os
 *            OutputStream to write the image to.
 * @param xmpXml
 *            String containing XMP XML.
 */
public void updateXmpXml(final ByteSource byteSource, final OutputStream os,
        final String xmpXml) throws ImageReadException, IOException,
        ImageWriteException {
    final JFIFPieces jfifPieces = analyzeJFIF(byteSource);
    List<JFIFPiece> pieces = jfifPieces.pieces;
    pieces = removeXmpSegments(pieces);

    final List<JFIFPieceSegment> newPieces = new ArrayList<JFIFPieceSegment>();
    final byte[] xmpXmlBytes = xmpXml.getBytes("utf-8");
    int index = 0;
    while (index < xmpXmlBytes.length) {
        final int segmentSize = Math.min(xmpXmlBytes.length, JpegConstants.MAX_SEGMENT_SIZE);
        final byte[] segmentData = writeXmpSegment(xmpXmlBytes, index,
                segmentSize);
        newPieces.add(new JFIFPieceSegment(JpegConstants.JPEG_APP1_MARKER, segmentData));
        index += segmentSize;
    }

    pieces = insertAfterLastAppSegments(pieces, newPieces);

    writeSegments(os, pieces);
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
private void writeChunkzTXt(final OutputStream os, final PngText.Ztxt text) 
        throws IOException, ImageWriteException {
    if (!isValidISO_8859_1(text.keyword)) {
        throw new ImageWriteException("Png zTXt chunk keyword is not ISO-8859-1: " + text.keyword);
    }
    if (!isValidISO_8859_1(text.text)) {
        throw new ImageWriteException("Png zTXt chunk text is not ISO-8859-1: " + text.text);
    }

    final ByteArrayOutputStream baos = new ByteArrayOutputStream();

    // keyword
    baos.write(text.keyword.getBytes("ISO-8859-1"));
    baos.write(0);

    // compression method
    baos.write(PngConstants.COMPRESSION_DEFLATE_INFLATE);

    // text
    baos.write(deflate(text.text.getBytes("ISO-8859-1")));

    writeChunk(os, ChunkType.zTXt, baos.toByteArray());
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
@Override
  public void write(IIOMetadata iioMetadata, IIOImage iioImage, ImageWriteParam param)
          throws IOException {

      if (ios == null) {
          throw new IllegalArgumentException(Messages.getString("imageio.7F"));
      }

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

      Map params = new HashMap();
      try {
      	
	Imaging.writeImage((BufferedImage)img,
			wrapOutput(ios),//(OutputStream)ios,
			ImageFormats.JPEG,
			params);
} catch (ImageWriteException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}
  }
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
@Override
public boolean performNextMedianCut(final List<ColorGroup> colorGroups, final boolean ignoreAlpha)
        throws ImageWriteException {
    Collections.sort(colorGroups, COMPARATOR);
    final ColorGroup colorGroup = colorGroups.get(0);

    if (colorGroup.maxDiff == 0) {
        return false;
    }
    if (!ignoreAlpha
            && colorGroup.alphaDiff > colorGroup.redDiff
            && colorGroup.alphaDiff > colorGroup.greenDiff
            && colorGroup.alphaDiff > colorGroup.blueDiff) {
        doCut(colorGroup, ColorComponent.ALPHA, colorGroups, ignoreAlpha);
    } else if (colorGroup.redDiff > colorGroup.greenDiff
            && colorGroup.redDiff > colorGroup.blueDiff) {
        doCut(colorGroup, ColorComponent.RED, colorGroups, ignoreAlpha);
    } else if (colorGroup.greenDiff > colorGroup.blueDiff) {
        doCut(colorGroup, ColorComponent.GREEN, colorGroups, ignoreAlpha);
    } else {
        doCut(colorGroup, ColorComponent.BLUE, colorGroups, ignoreAlpha);
    }
    return true;
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
public TiffOutputSet getOutputSet() throws ImageWriteException {
    final ByteOrder byteOrder = contents.header.byteOrder;
    final TiffOutputSet result = new TiffOutputSet(byteOrder);

    final List<? extends IImageMetadataItem> srcDirs = getDirectories();
    for (IImageMetadataItem srcDir1 : srcDirs) {
        final Directory srcDir = (Directory) srcDir1;

        if (null != result.findDirectory(srcDir.type)) {
            // Certain cameras right directories more than once.
            // This is a bug.
            // Ignore second directory of a given type.
            continue;
        }

        final TiffOutputDirectory outputDirectory = srcDir
                .getOutputDirectory(byteOrder);
        result.addDirectory(outputDirectory);
    }

    return result;
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
private void writeStep(final BinaryOutputStream bos,
        final List<TiffOutputItem> outputItems) throws IOException,
        ImageWriteException {
    writeImageFileHeader(bos);

    for (TiffOutputItem outputItem : outputItems) {
        outputItem.writeItem(bos);

        final int length = outputItem.getItemLength();

        final int remainder = imageDataPaddingLength(length);
        for (int j = 0; j < remainder; j++) {
            bos.write(0);
        }
    }

}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
protected void setData(final byte[] bytes) throws ImageWriteException {
    // if(tagInfo.isUnknown())
    // Debug.debug("unknown tag(0x" + Integer.toHexString(tag)
    // + ") setData", bytes);

    if (this.bytes.length != bytes.length) {
        throw new ImageWriteException("Cannot change size of value.");
    }

    // boolean wasLocalValue = isLocalValue();
    this.bytes = bytes;
    if (separateValueItem != null) {
        separateValueItem.updateValue(bytes);
    }
    // if (isLocalValue() != wasLocalValue)
    // throw new Error("Bug. Locality disrupted! "
    // + tagInfo.getDescription());
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
private void writeImage(Graphics2D graphicsTarget, Project project, File destinationFile, BufferedImage scaledImage, ImageTransformEntry validTransformEntry) {
    graphicsTarget.dispose();

    project.getLogger().info("Trying to write image-file: " + destinationFile.getAbsolutePath());
    try{
        // TODO handle incomplete Imaging-library
        // https://issues.apache.org/jira/browse/IMAGING-188
        Imaging.writeImage(scaledImage, destinationFile, validTransformEntry.format, new HashMap<>());
    } catch(IOException | ImageWriteException ex){
        project.getLogger().warn(null, ex);
    }
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
/**
 * This method will copy the Exif "orientation" information to the resulting image, if the
 * original image contains this data too.
 *
 * @param sourceImage
 *            The source image.
 * @param result
 *            The original result.
 * @return The new result containing the Exif orientation.
 */
public static byte[] copyExifOrientation(byte[] sourceImage, byte[] result) {
    try {
        ImageMetadata imageMetadata = Imaging.getMetadata(sourceImage);
        if (imageMetadata == null) {
            return result;
        }
        List<? extends ImageMetadata.ImageMetadataItem> metadataItems = imageMetadata
                .getItems();
        for (ImageMetadata.ImageMetadataItem metadataItem : metadataItems) {
            if (metadataItem instanceof TiffImageMetadata.TiffMetadataItem) {
                TiffField tiffField = ((TiffImageMetadata.TiffMetadataItem) metadataItem)
                        .getTiffField();
                if (!tiffField.getTagInfo().equals(TiffTagConstants.TIFF_TAG_ORIENTATION)) {
                    continue;
                }
                Object orientationValue = tiffField.getValue();
                if (orientationValue == null) {
                    break;
                }
                TiffOutputSet outputSet = new TiffOutputSet();
                TiffOutputDirectory outputDirectory = outputSet.getOrCreateRootDirectory();
                outputDirectory.add(TiffTagConstants.TIFF_TAG_ORIENTATION,
                        ((Number) orientationValue).shortValue());
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

                new ExifRewriter().updateExifMetadataLossy(result, outputStream, outputSet);
                return outputStream.toByteArray();
            }
        }
    } catch (IOException | ImageWriteException | ImageReadException e) {
        LOGGER.warn("Error reading image: {}", e.getMessage());
    }
    return result;
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
@Override
public int getPaletteIndex(final int rgb) throws ImageWriteException {
    final int precisionMask = (1 << precision) - 1;

    final int index = ((rgb >> (24 - 3 * precision)) & (precisionMask << (precision << 1)))
            | ((rgb >> (16 - 2 * precision)) & (precisionMask << precision))
            | ((rgb >> (8 - precision)) & (precisionMask));

    return straight[index].getIndex();
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
protected <T extends JFIFPiece, U extends JFIFPiece> List<JFIFPiece> insertAfterLastAppSegments(
        final List<T> segments, final List<U> newSegments) throws ImageWriteException {
    int lastAppIndex = -1;
    for (int i = 0; i < segments.size(); i++) {
        final JFIFPiece piece = segments.get(i);
        if (!(piece instanceof JFIFPieceSegment)) {
            continue;
        }

        final JFIFPieceSegment segment = (JFIFPieceSegment) piece;
        if (segment.isAppSegment()) {
            lastAppIndex = i;
        }
    }

    final List<JFIFPiece> result = new ArrayList<JFIFPiece>(segments);
    if (lastAppIndex == -1) {
        if (segments.size() < 1) {
            throw new ImageWriteException("JPEG file has no APP segments.");
        }
        result.addAll(1, newSegments);
    } else {
        result.addAll(lastAppIndex + 1, newSegments);
    }

    return result;
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
/**
 * Reads a Jpeg image, removes all EXIF metadata (by removing the APP1
 * segment), and writes the result to a stream.
 * <p>
 * 
 * @param byteSource
 *            ByteSource containing Jpeg image data.
 * @param os
 *            OutputStream to write the image to.
 */
public void removeExifMetadata(final ByteSource byteSource, final OutputStream os)
        throws ImageReadException, IOException, ImageWriteException {
    final JFIFPieces jfifPieces = analyzeJFIF(byteSource);
    final List<JFIFPiece> pieces = jfifPieces.pieces;

    // Debug.debug("pieces", pieces);

    // pieces.removeAll(jfifPieces.exifSegments);

    // Debug.debug("pieces", pieces);

    writeSegmentsReplacingExif(os, pieces, null);
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
public static byte[] compressT4_1D(final byte[] uncompressed, final int width,
        final int height, final boolean hasFill) throws ImageWriteException {
    final BitInputStreamFlexible inputStream = new BitInputStreamFlexible(new ByteArrayInputStream(uncompressed));
    final BitArrayOutputStream outputStream = new BitArrayOutputStream();
    if (hasFill) {
        T4_T6_Tables.EOL16.writeBits(outputStream);
    } else {
        T4_T6_Tables.EOL.writeBits(outputStream);
    }
    
    for (int y = 0; y < height; y++) {
        compress1DLine(inputStream, outputStream, null, width);
        if (hasFill) {
            int bitsAvailable = outputStream
                    .getBitsAvailableInCurrentByte();
            if (bitsAvailable < 4) {
                outputStream.flush();
                bitsAvailable = 8;
            }
            for (; bitsAvailable > 4; bitsAvailable--) {
                outputStream.writeBit(0);
            }
        }
        T4_T6_Tables.EOL.writeBits(outputStream);
        inputStream.flushCache();
    }
    
    return outputStream.toByteArray();
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
private byte[] writeExifSegment(final TiffImageWriterBase writer,
        final TiffOutputSet outputSet, final boolean includeEXIFPrefix)
        throws IOException, ImageWriteException {
    final ByteArrayOutputStream os = new ByteArrayOutputStream();

    if (includeEXIFPrefix) {
        JpegConstants.EXIF_IDENTIFIER_CODE.writeTo(os);
        os.write(0);
        os.write(0);
    }

    writer.write(os, outputSet);

    return os.toByteArray();
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
/**
 * Reads a Jpeg image, removes all IPTC data from the App13 segment but
 * leaves the other data in that segment (if present) unchanged and writes
 * the result to a stream.
 * <p>
 * 
 * @param byteSource
 *            ByteSource containing Jpeg image data.
 * @param os
 *            OutputStream to write the image to.
 */
public void removeIPTC(final ByteSource byteSource, final OutputStream os)
        throws ImageReadException, IOException, ImageWriteException {
    final JFIFPieces jfifPieces = analyzeJFIF(byteSource);
    final List<JFIFPiece> oldPieces = jfifPieces.pieces;
    final List<JFIFPiece> photoshopApp13Segments = findPhotoshopApp13Segments(oldPieces);

    if (photoshopApp13Segments.size() > 1) {
        throw new ImageReadException(
                "Image contains more than one Photoshop App13 segment.");
    }
    final List<JFIFPiece> newPieces = removePhotoshopApp13Segments(oldPieces);
    if (photoshopApp13Segments.size() == 1) {
        final JFIFPieceSegment oldSegment = (JFIFPieceSegment) photoshopApp13Segments
                .get(0);
        final Map<String, Object> params = new HashMap<String, Object>();
        final PhotoshopApp13Data oldData = new IptcParser()
                .parsePhotoshopSegment(oldSegment.segmentData, params);
        final List<IptcBlock> newBlocks = oldData.getNonIptcBlocks();
        final List<IptcRecord> newRecords = new ArrayList<IptcRecord>();
        final PhotoshopApp13Data newData = new PhotoshopApp13Data(newRecords,
                newBlocks);
        final byte[] segmentBytes = new IptcParser()
                .writePhotoshopApp13Segment(newData);
        final JFIFPieceSegment newSegment = new JFIFPieceSegment(
                oldSegment.marker, segmentBytes);
        newPieces.add(oldPieces.indexOf(oldSegment), newSegment);
    }
    writeSegments(os, newPieces);
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
/**
 * Reads a Jpeg image, replaces the IPTC data in the App13 segment but
 * leaves the other data in that segment (if present) unchanged and writes
 * the result to a stream.
 * 
 * @param byteSource
 *            ByteSource containing Jpeg image data.
 * @param os
 *            OutputStream to write the image to.
 * @param newData
 *            structure containing IPTC data.
 */
public void writeIPTC(final ByteSource byteSource, final OutputStream os,
        PhotoshopApp13Data newData) throws ImageReadException, IOException,
        ImageWriteException {
    final JFIFPieces jfifPieces = analyzeJFIF(byteSource);
    final List<JFIFPiece> oldPieces = jfifPieces.pieces;
    final List<JFIFPiece> photoshopApp13Segments = findPhotoshopApp13Segments(oldPieces);

    if (photoshopApp13Segments.size() > 1) {
        throw new ImageReadException(
                "Image contains more than one Photoshop App13 segment.");
    }
    List<JFIFPiece> newPieces = removePhotoshopApp13Segments(oldPieces);

    {
        // discard old iptc blocks.
        final List<IptcBlock> newBlocks = newData.getNonIptcBlocks();
        final byte[] newBlockBytes = new IptcParser().writeIPTCBlock(newData.getRecords());

        final int blockType = IptcConstants.IMAGE_RESOURCE_BLOCK_IPTC_DATA;
        final byte[] blockNameBytes = new byte[0];
        final IptcBlock newBlock = new IptcBlock(blockType, blockNameBytes, newBlockBytes);
        newBlocks.add(newBlock);

        newData = new PhotoshopApp13Data(newData.getRecords(), newBlocks);

        byte[] segmentBytes = new IptcParser().writePhotoshopApp13Segment(newData);
        JFIFPieceSegment newSegment = new JFIFPieceSegment(JpegConstants.JPEG_APP13_MARKER, segmentBytes);

        newPieces = insertAfterLastAppSegments(newPieces, Arrays.asList(newSegment));
    }

    writeSegments(os, newPieces);
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
@Override
public void writeImage(final BufferedImage src, final OutputStream os, final Map<String, Object> params)
        throws ImageWriteException, IOException {
    // System.out.println
    // (b1 == 0x50 && b2 == 0x36)
    os.write(0x50);
    os.write(rawbits ? 0x35 : 0x32);
    os.write(PnmConstants.PNM_SEPARATOR);

    final int width = src.getWidth();
    final int height = src.getHeight();

    os.write(Integer.toString(width).getBytes("US-ASCII"));
    os.write(PnmConstants.PNM_SEPARATOR);

    os.write(Integer.toString(height).getBytes("US-ASCII"));
    os.write(PnmConstants.PNM_SEPARATOR);

    os.write(Integer.toString(255).getBytes("US-ASCII")); // max component value
    os.write(PnmConstants.PNM_NEWLINE);

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            final int argb = src.getRGB(x, y);
            final int red = 0xff & (argb >> 16);
            final int green = 0xff & (argb >> 8);
            final int blue = 0xff & (argb >> 0);
            final int sample = (red + green + blue) / 3;

            if (rawbits) {
                os.write((byte) sample);
            } else {
                os.write(Integer.toString(sample).getBytes("US-ASCII")); // max component value
                os.write(PnmConstants.PNM_SEPARATOR);
            }
        }
    }
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
private void writeScanLine(final BinaryOutputStream bos, final byte[] scanline)
        throws IOException, ImageWriteException {
    if (encoding == PcxImageParser.PcxHeader.ENCODING_UNCOMPRESSED) {
        bos.write(scanline);
    } else {
        if (encoding == PcxImageParser.PcxHeader.ENCODING_RLE) {
            int previousByte = -1;
            int repeatCount = 0;
            for (final byte element : scanline) {
                if ((element & 0xff) == previousByte
                        && repeatCount < 63) {
                    ++repeatCount;
                } else {
                    if (repeatCount > 0) {
                        if (repeatCount == 1
                                && (previousByte & 0xc0) != 0xc0) {
                            bos.write(previousByte);
                        } else {
                            bos.write(0xc0 | repeatCount);
                            bos.write(previousByte);
                        }
                    }
                    previousByte = 0xff & element;
                    repeatCount = 1;
                }
            }
            if (repeatCount > 0) {
                if (repeatCount == 1 && (previousByte & 0xc0) != 0xc0) {
                    bos.write(previousByte);
                } else {
                    bos.write(0xc0 | repeatCount);
                    bos.write(previousByte);
                }
            }
        } else {
            throw new ImageWriteException("Invalid PCX encoding "
                    + encoding);
        }
    }
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
private void write24BppPCX(final BufferedImage src, final BinaryOutputStream bos)
        throws ImageWriteException, IOException {
    final int bytesPerLine = src.getWidth() % 2 == 0 ? src.getWidth() : src
            .getWidth() + 1;

    // PCX header
    bos.write(10); // manufacturer
    bos.write(5); // version
    bos.write(encoding); // encoding
    bos.write(8); // bits per pixel
    bos.write2Bytes(0); // xMin
    bos.write2Bytes(0); // yMin
    bos.write2Bytes(src.getWidth() - 1); // xMax
    bos.write2Bytes(src.getHeight() - 1); // yMax
    bos.write2Bytes((short) Math.round(pixelDensity
            .horizontalDensityInches())); // hDpi
    bos.write2Bytes((short) Math.round(pixelDensity.verticalDensityInches())); // vDpi
    bos.write(new byte[48]); // 16 color palette
    bos.write(0); // reserved
    bos.write(3); // planes
    bos.write2Bytes(bytesPerLine); // bytes per line
    bos.write2Bytes(1); // palette info
    bos.write2Bytes(0); // hScreenSize
    bos.write2Bytes(0); // vScreenSize
    bos.write(new byte[54]);

    final int[] rgbs = new int[src.getWidth()];
    final byte[] rgbBytes = new byte[3 * bytesPerLine];
    for (int y = 0; y < src.getHeight(); y++) {
        src.getRGB(0, y, src.getWidth(), 1, rgbs, 0, src.getWidth());
        for (int x = 0; x < rgbs.length; x++) {
            rgbBytes[x] = (byte) ((rgbs[x] >> 16) & 0xff);
            rgbBytes[bytesPerLine + x] = (byte) ((rgbs[x] >> 8) & 0xff);
            rgbBytes[2 * bytesPerLine + x] = (byte) (rgbs[x] & 0xff);
        }
        writeScanLine(bos, rgbBytes);
    }
}
 

import org.apache.commons.imaging.ImageWriteException; //导入依赖的package包/类
public ColorGroup(final List<ColorCount> colorCounts, final boolean ignoreAlpha) throws ImageWriteException {
    this.colorCounts = colorCounts;
    this.ignoreAlpha = ignoreAlpha;

    if (colorCounts.size() < 1) {
        throw new ImageWriteException("empty color_group");
    }

    int total = 0;
    for (ColorCount color : colorCounts) {
        total += color.count;

        minAlpha = Math.min(minAlpha, color.alpha);
        maxAlpha = Math.max(maxAlpha, color.alpha);
        minRed = Math.min(minRed, color.red);
        maxRed = Math.max(maxRed, color.red);
        minGreen = Math.min(minGreen, color.green);
        maxGreen = Math.max(maxGreen, color.green);
        minBlue = Math.min(minBlue, color.blue);
        maxBlue = Math.max(maxBlue, color.blue);
    }
    this.totalPoints = total;

    alphaDiff = maxAlpha - minAlpha;
    redDiff = maxRed - minRed;
    greenDiff = maxGreen - minGreen;
    blueDiff = maxBlue - minBlue;
    maxDiff = Math.max(
            ignoreAlpha ? redDiff : Math.max(alphaDiff, redDiff),
            Math.max(greenDiff, blueDiff));
    diffTotal = (ignoreAlpha ? 0 : alphaDiff) + redDiff + greenDiff + blueDiff;
}