Java 类javax.imageio.ImageTypeSpecifier 实例源码

public void prepareInsertEmpty(int imageIndex,
                               ImageTypeSpecifier imageType,
                               int width,
                               int height,
                               IIOMetadata imageMetadata,
                               List<? extends BufferedImage> thumbnails,
                               ImageWriteParam param) throws IOException {
    checkParamsEmpty(imageType, width, height, thumbnails);

    this.isInsertingEmpty = true;

    SampleModel emptySM = imageType.getSampleModel();
    RenderedImage emptyImage =
        new EmptyImage(0, 0, width, height,
                       0, 0, emptySM.getWidth(), emptySM.getHeight(),
                       emptySM, imageType.getColorModel());

    insert(imageIndex, new IIOImage(emptyImage, null, imageMetadata),
           param, false);
}

public boolean canEncodeImage(ImageTypeSpecifier type) {
    SampleModel sampleModel = type.getSampleModel();

    // Find the maximum bit depth across all channels
    int[] sampleSize = sampleModel.getSampleSize();
    int bitDepth = sampleSize[0];
    for (int i = 1; i < sampleSize.length; i++) {
        if (sampleSize[i] > bitDepth) {
            bitDepth = sampleSize[i];
        }
    }

    // 4450894: Ensure bitDepth is between 1 and 8
    if (bitDepth < 1 || bitDepth > 8) {
        return false;
    }

    return true;
}

public ImageTypeSpecifier getRawImageType(int imageIndex)
    throws IOException {
    setThreadLock();
    try {
        if (currentImage != imageIndex) {
            cbLock.check();

            readHeader(imageIndex, true);
        }

        // Returns null if it can't be represented
        return getImageType(colorSpaceCode).getType();
    } finally {
        clearThreadLock();
    }
}

public boolean canNodeAppear(String elementName,
                             ImageTypeSpecifier imageType) {
    // All images can have these
    if (elementName.equals(getRootName())
        || elementName.equals("JPEGvariety")
        || isInSubtree(elementName, "markerSequence")) {
        return true;
    }

    // If it is an element in the app0jfif subtree, just check
    // that the image type is JFIF compliant.
    if ((isInSubtree(elementName, "app0JFIF"))
        && JPEG.isJFIFcompliant(imageType, true)) {
        return true;
    }

    return false;
}

private void checkAdobe(AdobeMarkerSegment adobe,
                       ImageTypeSpecifier type,
                       boolean input) {
    if (adobe != null) {
        int rightTransform = JPEG.transformForType(type, input);
        if (adobe.transform != rightTransform) {
            warningOccurred(input
                            ? WARNING_IMAGE_METADATA_ADOBE_MISMATCH
                            : WARNING_DEST_METADATA_ADOBE_MISMATCH);
            if (rightTransform == JPEG.ADOBE_IMPOSSIBLE) {
                ignoreAdobe = true;
            } else {
                newAdobeTransform = rightTransform;
            }
        }
    }
}

public void testGetAsTree() {
    ImageWriteParam p = w.getDefaultWriteParam();
    IIOMetadata m =
        w.getDefaultImageMetadata(ImageTypeSpecifier.createFromBufferedImageType(type), p);

    String format = m.getNativeMetadataFormatName();
    System.out.println("native format: " + format);

    int count = 0;
    try {
        while (count < 100) {
            System.out.println(" test " + count++);
            m.getAsTree(format);
        }
    } catch (OutOfMemoryError e) {
        System.gc();
        throw new RuntimeException("Test failed. Number of performed operations: " + count, e);
    }
}

private boolean jfifOK(ImageTypeSpecifier imageType,
                       ImageWriteParam param,
                       IIOMetadata streamMetadata,
                       IIOMetadata imageMetadata) {
    // If the image type and metadata are JFIF compatible, return true
    if ((imageType != null) &&
        (!JPEG.isJFIFcompliant(imageType, true))) {
        return false;
    }
    if (imageMetadata != null) {
        JPEGMetadata metadata = null;
        if (imageMetadata instanceof JPEGMetadata) {
            metadata = (JPEGMetadata) imageMetadata;
        } else {
            metadata = (JPEGMetadata)convertImageMetadata(imageMetadata,
                                                          imageType,
                                                          param);
        }
        // metadata must have a jfif node
        if (metadata.findMarkerSegment
            (JFIFMarkerSegment.class, true) == null){
            return false;
        }
    }
    return true;
}

private void checkAdobe(AdobeMarkerSegment adobe,
                       ImageTypeSpecifier type,
                       boolean input) {
    if (adobe != null) {
        int rightTransform = JPEG.transformForType(type, input);
        if (adobe.transform != rightTransform) {
            warningOccurred(input
                            ? WARNING_IMAGE_METADATA_ADOBE_MISMATCH
                            : WARNING_DEST_METADATA_ADOBE_MISMATCH);
            if (rightTransform == JPEG.ADOBE_IMPOSSIBLE) {
                ignoreAdobe = true;
            } else {
                newAdobeTransform = rightTransform;
            }
        }
    }
}

public boolean canEncodeImage(ImageTypeSpecifier type) {
    int dataType= type.getSampleModel().getDataType();
    if (dataType < DataBuffer.TYPE_BYTE || dataType > DataBuffer.TYPE_INT)
        return false;

    SampleModel sm = type.getSampleModel();
    int numBands = sm.getNumBands();
    if (!(numBands == 1 || numBands == 3))
        return false;

    if (numBands == 1 && dataType != DataBuffer.TYPE_BYTE)
        return false;

    if (dataType > DataBuffer.TYPE_BYTE &&
          !(sm instanceof SinglePixelPackedSampleModel))
        return false;

    return true;
}

public Iterator getImageTypes(int imageIndex) throws IOException {
    if (input == null)
        throw new IllegalStateException();
    if (imageIndex >= 5 || imageIndex < 0)
        throw new IndexOutOfBoundsException();

    Vector imageTypes = new Vector();
    imageTypes.add(ImageTypeSpecifier.createFromBufferedImageType
                   (BufferedImage.TYPE_BYTE_GRAY ));
    return imageTypes.iterator();
}

public boolean canEncodeImage(ImageTypeSpecifier type) {
    if (type == null) {
        throw new IllegalArgumentException("type == null!");
    }

    SampleModel sm = type.getSampleModel();
    ColorModel cm = type.getColorModel();

    boolean canEncode = sm.getNumBands() == 1 &&
        sm.getSampleSize(0) <= 8 &&
        sm.getWidth() <= 65535 &&
        sm.getHeight() <= 65535 &&
        (cm == null || cm.getComponentSize()[0] <= 8);

    if (canEncode) {
        return true;
    } else {
        return PaletteBuilder.canCreatePalette(type);
    }
}

public IIOMetadata
    getDefaultImageMetadata(ImageTypeSpecifier imageType,
                            ImageWriteParam param) {

    List<TIFFTagSet> tagSets = new ArrayList<TIFFTagSet>(1);
    tagSets.add(BaselineTIFFTagSet.getInstance());
    TIFFImageMetadata imageMetadata = new TIFFImageMetadata(tagSets);

    if(imageType != null) {
        TIFFImageMetadata im =
            (TIFFImageMetadata)convertImageMetadata(imageMetadata,
                                                    imageType,
                                                    param);
        if(im != null) {
            imageMetadata = im;
        }
    }

    return imageMetadata;
}

public static void main(String[] args) throws Exception {

        //nomarkers.jpg has YCbCr color space
        String fileName = "nomarkers.jpg";
        String sep = System.getProperty("file.separator");
        String dir = System.getProperty("test.src", ".");
        String filePath = dir+sep+fileName;
        System.out.println("Test file: " + filePath);
        File imageFile = new File(filePath);

        ImageInputStream inputStream = ImageIO.
            createImageInputStream(imageFile);
        Iterator<ImageReader> readers = ImageIO.getImageReaders(inputStream);

        if(readers.hasNext()) {
            ImageReader reader = readers.next();
            reader.setInput(inputStream);

            ImageTypeSpecifier typeSpecifier = reader.getRawImageType(0);
            //check if ImageTypeSpecifier is null for YCbCr JPEG Image
            if (typeSpecifier == null) {
                throw new RuntimeException("ImageReader returns null raw image"
                    + " type");
            }
        }
    }

public boolean canEncodeImage(ImageTypeSpecifier type) {
    SampleModel sampleModel = type.getSampleModel();

    // Find the maximum bit depth across all channels
    int[] sampleSize = sampleModel.getSampleSize();
    int bitDepth = sampleSize[0];
    for (int i = 1; i < sampleSize.length; i++) {
        if (sampleSize[i] > bitDepth) {
            bitDepth = sampleSize[i];
        }
    }

    // 4450894: Ensure bitDepth is between 1 and 8
    if (bitDepth < 1 || bitDepth > 8) {
        return false;
    }

    return true;
}

public ImageTypeSpecifier getRawImageType(int imageIndex)
    throws IOException {
    setThreadLock();
    try {
        if (currentImage != imageIndex) {
            cbLock.check();

            readHeader(imageIndex, true);
        }

        // Returns null if it can't be represented
        return getImageType(colorSpaceCode).getType();
    } finally {
        clearThreadLock();
    }
}

private boolean jfifOK(ImageTypeSpecifier imageType,
                       ImageWriteParam param,
                       IIOMetadata streamMetadata,
                       IIOMetadata imageMetadata) {
    // If the image type and metadata are JFIF compatible, return true
    if ((imageType != null) &&
        (!JPEG.isJFIFcompliant(imageType, true))) {
        return false;
    }
    if (imageMetadata != null) {
        JPEGMetadata metadata = null;
        if (imageMetadata instanceof JPEGMetadata) {
            metadata = (JPEGMetadata) imageMetadata;
        } else {
            metadata = (JPEGMetadata)convertImageMetadata(imageMetadata,
                                                          imageType,
                                                          param);
        }
        // metadata must have a jfif node
        if (metadata.findMarkerSegment
            (JFIFMarkerSegment.class, true) == null){
            return false;
        }
    }
    return true;
}

public boolean canNodeAppear(String elementName,
                             ImageTypeSpecifier imageType) {
    // All images can have these
    if (elementName.equals(getRootName())
        || elementName.equals("JPEGvariety")
        || isInSubtree(elementName, "markerSequence")) {
        return true;
    }

    // If it is an element in the app0jfif subtree, just check
    // that the image type is JFIF compliant.
    if ((isInSubtree(elementName, "app0JFIF"))
        && JPEG.isJFIFcompliant(imageType, true)) {
        return true;
    }

    return false;
}

private boolean jfifOK(ImageTypeSpecifier imageType,
                       ImageWriteParam param,
                       IIOMetadata streamMetadata,
                       IIOMetadata imageMetadata) {
    // If the image type and metadata are JFIF compatible, return true
    if ((imageType != null) &&
        (!JPEG.isJFIFcompliant(imageType, true))) {
        return false;
    }
    if (imageMetadata != null) {
        JPEGMetadata metadata = null;
        if (imageMetadata instanceof JPEGMetadata) {
            metadata = (JPEGMetadata) imageMetadata;
        } else {
            metadata = (JPEGMetadata)convertImageMetadata(imageMetadata,
                                                          imageType,
                                                          param);
        }
        // metadata must have a jfif node
        if (metadata.findMarkerSegment
            (JFIFMarkerSegment.class, true) == null){
            return false;
        }
    }
    return true;
}

protected IIOMetadata prepareImageMetadata(int i, BufferedImage img, ImageWriteParam wparam) {
    GIFImageMetadata idata = (GIFImageMetadata)
    writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(img), wparam);

    idata.delayTime = 100;
    idata.disposalMethod = 0;
    idata.transparentColorFlag = false;

    if (i == 0) {
        ArrayList<byte[]> appIDs = new ArrayList<byte[]>();
        appIDs.add(new String("NETSCAPE").getBytes());
        ArrayList<byte[]> authCodes = new ArrayList<byte[]>();
        authCodes.add(new String("2.0").getBytes());
        ArrayList<byte[]> appData = new ArrayList<byte[]>();
        byte[] authData = {1, 0, 0};
        appData.add(authData);

        idata.applicationIDs = appIDs;
        idata.authenticationCodes = authCodes;
        idata.applicationData = appData;
    }
    return idata;
}

public boolean canEncodeImage(ImageTypeSpecifier type) {
    int dataType= type.getSampleModel().getDataType();
    if (dataType < DataBuffer.TYPE_BYTE || dataType > DataBuffer.TYPE_INT)
        return false;

    SampleModel sm = type.getSampleModel();
    int numBands = sm.getNumBands();
    if (!(numBands == 1 || numBands == 3))
        return false;

    if (numBands == 1 && dataType != DataBuffer.TYPE_BYTE)
        return false;

    if (dataType > DataBuffer.TYPE_BYTE &&
          !(sm instanceof SinglePixelPackedSampleModel))
        return false;

    return true;
}

public static void main(String[] args) throws Exception {
    String format = "javax_imageio_1.0";
    BufferedImage img =
        new BufferedImage(16, 16, BufferedImage.TYPE_INT_RGB);
    ImageWriter iw = ImageIO.getImageWritersByMIMEType("image/png").next();
    IIOMetadata meta =
        iw.getDefaultImageMetadata(new ImageTypeSpecifier(img), null);
    DOMImplementationRegistry registry;
    registry = DOMImplementationRegistry.newInstance();
    DOMImplementation impl = registry.getDOMImplementation("XML 3.0");
    Document doc = impl.createDocument(null, format, null);
    Element root, text, entry;
    root = doc.getDocumentElement();
    root.appendChild(text = doc.createElement("Text"));
    text.appendChild(entry = doc.createElement("TextEntry"));
    // keyword isn't #REQUIRED by the standard metadata format.
    // However, it is required by the PNG format, so we include it here.
    entry.setAttribute("keyword", "Comment");
    entry.setAttribute("value", "Some demo comment");
    meta.mergeTree(format, root);
}

public boolean canNodeAppear(String elementName,
                             ImageTypeSpecifier imageType) {
    // Just check if it appears in the format
    if (isInSubtree(elementName, getRootName())){
        return true;
    }
    return false;
}

private int getDestCSType(ImageTypeSpecifier destType) {
ColorModel cm = destType.getColorModel();
boolean alpha = cm.hasAlpha();
ColorSpace cs = cm.getColorSpace();
int retval = JPEG.JCS_UNKNOWN;
switch (cs.getType()) {
case ColorSpace.TYPE_GRAY:
        retval = JPEG.JCS_GRAYSCALE;
        break;
    case ColorSpace.TYPE_RGB:
        if (alpha) {
            retval = JPEG.JCS_RGBA;
        } else {
            retval = JPEG.JCS_RGB;
        }
        break;
    case ColorSpace.TYPE_YCbCr:
        if (alpha) {
            retval = JPEG.JCS_YCbCrA;
        } else {
            retval = JPEG.JCS_YCbCr;
        }
        break;
    case ColorSpace.TYPE_3CLR:
        if (cs == JPEG.JCS.getYCC()) {
            if (alpha) {
                retval = JPEG.JCS_YCCA;
            } else {
                retval = JPEG.JCS_YCC;
            }
        }
        break;
    case ColorSpace.TYPE_CMYK:
        retval = JPEG.JCS_CMYK;
        break;
    }
return retval;
}

public synchronized ImageTypeSpecifier getType() {
    if (!failed && type == null) {
        try {
            type = produce();
        } catch (Throwable e) {
            failed = true;
        }
    }
    return type;
}

/**
 * Creates a default image metadata object and merges in the
 * supplied metadata.
 */
public IIOMetadata convertImageMetadata(IIOMetadata inData,
                                        ImageTypeSpecifier imageType,
                                        ImageWriteParam param) {
    if (inData == null) {
        throw new IllegalArgumentException("inData == null!");
    }
    if (imageType == null) {
        throw new IllegalArgumentException("imageType == null!");
    }

    GIFWritableImageMetadata im =
        (GIFWritableImageMetadata)getDefaultImageMetadata(imageType,
                                                          param);

    // Save interlace flag state.

    boolean isProgressive = im.interlaceFlag;

    convertMetadata(IMAGE_METADATA_NAME, inData, im);

    // Undo change to interlace flag if not MODE_COPY_FROM_METADATA.

    if (param != null && param.canWriteProgressive() &&
        param.getProgressiveMode() != ImageWriteParam.MODE_COPY_FROM_METADATA) {
        im.interlaceFlag = isProgressive;
    }

    return im;
}

public ImageWriteParam getWriteParam() {
    ImageWriteParam p =  w.getDefaultWriteParam();
    p.setSourceBands(new int[] {0, 1, 2});
    ImageTypeSpecifier type =
        ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
    p.setDestinationType(type);

    return p;
}

private static void writeTo(File f, ITXtTest t) {
    BufferedImage src = createBufferedImage();
    try (ImageOutputStream imageOutputStream =
            ImageIO.createImageOutputStream(f)) {

        ImageTypeSpecifier imageTypeSpecifier =
            new ImageTypeSpecifier(src);
        ImageWriter imageWriter =
            ImageIO.getImageWritersByFormatName("PNG").next();

        imageWriter.setOutput(imageOutputStream);

        IIOMetadata m =
            imageWriter.getDefaultImageMetadata(imageTypeSpecifier, null);

        String format = m.getNativeMetadataFormatName();
        Node root = m.getAsTree(format);

        IIOMetadataNode iTXt = t.getNode();
        root.appendChild(iTXt);
        m.setFromTree(format, root);

        imageWriter.write(new IIOImage(src, null, m));
        System.out.println("Writing done.");
    } catch (Throwable e) {
        throw new RuntimeException("Writing test failed.", e);
    }
}

public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex)
  throws IOException {
    checkIndex(imageIndex);
    try {
        readHeader();
    } catch (IllegalArgumentException e) {
        throw new IIOException(I18N.getString("BMPImageReader6"), e);
    }
    ArrayList<ImageTypeSpecifier> list = new ArrayList<>(1);
    list.add(new ImageTypeSpecifier(originalColorModel,
                                    originalSampleModel));
    return list.iterator();
}

private static void doTest(int type) throws IOException {
    BufferedImage src = createTestImage(type);

    File f = new File("test.jpg");

    if (!ImageIO.write(src, "jpg", f)) {
        throw new RuntimeException("Failed to write test image.");
    }

    ImageInputStream iis = ImageIO.createImageInputStream(f);
    ImageReader reader = ImageIO.getImageReaders(iis).next();
    reader.setInput(iis);

    Iterator<ImageTypeSpecifier> types = reader.getImageTypes(0);
    ImageTypeSpecifier srgb = null;
    ImageTypeSpecifier gray = null;
    // look for gray and srgb types
    while ((srgb == null || gray == null) && types.hasNext()) {
        ImageTypeSpecifier t = types.next();
        if (t.getColorModel().getColorSpace().getType() == TYPE_GRAY) {
            gray = t;
        }
        if (t.getColorModel().getColorSpace() == sRGB) {
            srgb = t;
        }
    }
    if (gray == null) {
        throw new RuntimeException("No gray type available.");
    }
    if (srgb == null) {
        throw new RuntimeException("No srgb type available.");
    }

    System.out.println("Read as GRAY...");
    testType(reader, gray, src);

    System.out.println("Read as sRGB...");
    testType(reader, srgb, src);
}

private static void writeTo(File f, ITXtTest t) {
    BufferedImage src = createBufferedImage();
    try {
        ImageOutputStream imageOutputStream =
            ImageIO.createImageOutputStream(f);

        ImageTypeSpecifier imageTypeSpecifier =
            new ImageTypeSpecifier(src);
        ImageWriter imageWriter =
            ImageIO.getImageWritersByFormatName("PNG").next();

        imageWriter.setOutput(imageOutputStream);

        IIOMetadata m =
            imageWriter.getDefaultImageMetadata(imageTypeSpecifier, null);

        String format = m.getNativeMetadataFormatName();
        Node root = m.getAsTree(format);

        IIOMetadataNode iTXt = t.getNode();
        root.appendChild(iTXt);
        m.setFromTree(format, root);

        imageWriter.write(new IIOImage(src, null, m));
        imageOutputStream.close();
        System.out.println("Writing done.");
    } catch (Throwable e) {
        throw new RuntimeException("Writing test failed.", e);
    }
}

public ImageTypeSpecifier next() {
    if (theNext != null || hasNext()) {
        ImageTypeSpecifier t = theNext;
        theNext = null;
        return t;
    } else {
        throw new NoSuchElementException();
    }
}

public Iterator getImageTypes(int imageIndex)
  throws IOException {
    checkIndex(imageIndex);
    try {
        readHeader();
    } catch (IllegalArgumentException e) {
        throw new IIOException(I18N.getString("BMPImageReader6"), e);
    }
    ArrayList list = new ArrayList(1);
    list.add(new ImageTypeSpecifier(originalColorModel,
                                    originalSampleModel));
    return list.iterator();
}

public Iterator getImageTypes(int imageIndex) throws IOException {
    if (input == null)
        throw new IllegalStateException();
    if (imageIndex >= 5 || imageIndex < 0)
        throw new IndexOutOfBoundsException();

    Vector imageTypes = new Vector();
    imageTypes.add(ImageTypeSpecifier.createFromBufferedImageType
                   (BufferedImage.TYPE_BYTE_GRAY ));
    return imageTypes.iterator();
}

/** Checks that the provided <code>ImageWriter</code> can encode
 * the provided <code>ImageTypeSpecifier</code> or not.  If not, an
 * <code>IIOException</code> will be thrown.
 * @param writer The provided <code>ImageWriter</code>.
 * @param type The image to be tested.
 * @throws IIOException If the writer cannot encoded the provided image.
 */
public static final void canEncodeImage(ImageWriter writer,
                                        ImageTypeSpecifier type)
    throws IIOException {
    ImageWriterSpi spi = writer.getOriginatingProvider();

    if(type != null && spi != null && !spi.canEncodeImage(type))  {
        throw new IIOException(I18N.getString("ImageUtil2")+" "+
                               writer.getClass().getName());
    }
}

public IIOMetadata
    convertImageMetadata(IIOMetadata inData,
                         ImageTypeSpecifier imageType,
                         ImageWriteParam param) {
    setThreadLock();
    try {
        return convertImageMetadataOnThread(inData, imageType, param);
    } finally {
        clearThreadLock();
    }
}

private static void doTest(int mode) {
    String fileFormat = "bmp";
    try {
        ImageWriter iw = (ImageWriter)ImageIO.getImageWritersBySuffix(fileFormat).next();
        if(iw == null) {
            throw new RuntimeException("No available image writer for "
                                       + fileFormat
                                       + " Test failed.");
        }

        File file = new File("image." + fileFormat);
        ImageOutputStream ios = ImageIO.createImageOutputStream(file);
        iw.setOutput(ios);

        BufferedImage bimg = new BufferedImage(100,
                                               100, BufferedImage.TYPE_INT_RGB);
        Graphics g = bimg.getGraphics();
        g.setColor(Color.green);
        g.fillRect(0,0,100,100);

        ImageWriteParam param = iw.getDefaultWriteParam();

        param.setCompressionMode(mode);

        IIOMetadata meta = iw.getDefaultImageMetadata(new ImageTypeSpecifier(bimg),
                                                      param);

        IIOImage iioImg = new IIOImage(bimg, null, meta);
        iw.write(null, iioImg, param);
    } catch(Exception e) {
        e.printStackTrace();
        throw new RuntimeException("Test failed.");
    }
}

public ImageTypeSpecifier next() {
    if (theNext != null || hasNext()) {
        ImageTypeSpecifier t = theNext;
        theNext = null;
        return t;
    } else {
        throw new NoSuchElementException();
    }
}

public synchronized ImageTypeSpecifier getType() {
    if (!failed && type == null) {
        try {
            type = produce();
        } catch (Throwable e) {
            failed = true;
        }
    }
    return type;
}

public IIOMetadata
    getDefaultImageMetadata(ImageTypeSpecifier imageType,
                            ImageWriteParam param) {
    setThreadLock();
    try {
        return new JPEGMetadata(imageType, param, this);
    } finally {
        clearThreadLock();
    }
}

public IIOMetadata
    convertImageMetadata(IIOMetadata inData,
                         ImageTypeSpecifier imageType,
                         ImageWriteParam param) {
    setThreadLock();
    try {
        return convertImageMetadataOnThread(inData, imageType, param);
    } finally {
        clearThreadLock();
    }
}