Example usage for javax.imageio ImageIO getImageWritersByMIMEType

Introduction

In this page you can find the example usage for javax.imageio ImageIO getImageWritersByMIMEType.

Prototype

public static Iterator<ImageWriter> getImageWritersByMIMEType(String MIMEType) 

Source Link

Document

Returns an Iterator containing all currently registered ImageWriter s that claim to be able to encode files with the given MIME type.

Usage

From source file:Main.java

public static boolean canWriteMimeType(String mimeType) {
    Iterator iter = ImageIO.getImageWritersByMIMEType(mimeType);
    return iter.hasNext();
}

---

From source file:com.tomtom.speedtools.json.ImageSerializer.java

@Nonnull
private static byte[] writeAsBytes(@Nonnull final Image v) throws IOException {
    assert v != null;

    /**// w w  w  . j  av  a  2 s .c o m
     * Create a PNG output stream.
     */
    final String mimeType = "image/png";
    try (ByteArrayOutputStream stream = new ByteArrayOutputStream()) {
        final Iterator<ImageWriter> it = ImageIO.getImageWritersByMIMEType(mimeType);
        if (it.hasNext()) {
            final ImageWriter w = it.next();
            final ImageOutputStream os = ImageIO.createImageOutputStream(stream);
            w.setOutput(os);
            w.write(convertToBufferedImage(v));
            os.close();
            w.dispose();
        } else {
            LOG.info("writeAsBytes: No encoder for MIME type " + mimeType);
            throw new IOException("No encoder for MIME type " + mimeType);
        }
        return stream.toByteArray();
    }
}

---

From source file:jails.http.converter.BufferedImageHttpMessageConverter.java

/**
 * Sets the default {@code Content-Type} to be used for writing.
 * @throws IllegalArgumentException if the given content type is not supported by the Java Image I/O API
 *//*from w w  w .ja v a  2  s.  c  o m*/
public void setDefaultContentType(MediaType defaultContentType) {
    Assert.notNull(defaultContentType, "'contentType' must not be null");
    Iterator<ImageWriter> imageWriters = ImageIO.getImageWritersByMIMEType(defaultContentType.toString());
    if (!imageWriters.hasNext()) {
        throw new IllegalArgumentException(
                "ContentType [" + defaultContentType + "] is not supported by the Java Image I/O API");
    }

    this.defaultContentType = defaultContentType;
}

---

From source file:org.hippoecm.frontend.plugins.gallery.imageutil.ImageUtils.java

/**
 * Returns an image writer for a MIME type.
 *
 * @param aMimeType MIME type//www . ja  v a2  s .  c om
 * @return an image writer for the given MIME type, or <code>null</code> if no image writer could be created
 * for the given MIME type.
 */
public static ImageWriter getImageWriter(String aMimeType) {
    String mimeType = MimeTypeHelper.sanitizeMimeType(aMimeType);
    Iterator<ImageWriter> writers = ImageIO.getImageWritersByMIMEType(mimeType);
    if (writers == null || !writers.hasNext()) {
        return null;
    }
    return writers.next();
}

---

From source file:jails.http.converter.BufferedImageHttpMessageConverter.java

private boolean isWritable(MediaType mediaType) {
    if (mediaType == null) {
        return true;
    }/*from   w  w w  . j av  a 2  s  .c om*/
    Iterator<ImageWriter> imageWriters = ImageIO.getImageWritersByMIMEType(mediaType.toString());
    return imageWriters.hasNext();
}

---

From source file:org.esxx.Response.java

public static void writeObject(Object object, ContentType ct, OutputStream out) throws IOException {

    if (object == null) {
        return;//www  . j  a va  2  s  . c o  m
    }

    // Unwrap wrapped objects
    object = JS.toJavaObject(object);

    // Convert complex types to primitive types
    if (object instanceof Node) {
        ESXX esxx = ESXX.getInstance();

        if (ct.match("message/rfc822")) {
            try {
                String xml = esxx.serializeNode((Node) object);
                org.esxx.xmtp.XMTPParser xmtpp = new org.esxx.xmtp.XMTPParser();
                javax.mail.Message msg = xmtpp.convertMessage(new StringReader(xml));
                object = new ByteArrayOutputStream();
                msg.writeTo(new FilterOutputStream((OutputStream) object) {
                    @Override
                    public void write(int b) throws IOException {
                        if (b == '\r') {
                            return;
                        } else if (b == '\n') {
                            out.write('\r');
                            out.write('\n');
                        } else {
                            out.write(b);
                        }
                    }
                });
            } catch (javax.xml.stream.XMLStreamException ex) {
                throw new ESXXException("Failed to serialize Node as message/rfc822:" + ex.getMessage(), ex);
            } catch (javax.mail.MessagingException ex) {
                throw new ESXXException("Failed to serialize Node as message/rfc822:" + ex.getMessage(), ex);
            }
        } else {
            object = esxx.serializeNode((Node) object);
        }
    } else if (object instanceof Scriptable) {
        if (ct.match("application/x-www-form-urlencoded")) {
            String cs = Parsers.getParameter(ct, "charset", "UTF-8");

            object = StringUtil.encodeFormVariables(cs, (Scriptable) object);
        } else if (ct.match("text/csv")) {
            object = jsToCSV(ct, (Scriptable) object);
        } else {
            object = jsToJSON(object).toString();
        }
    } else if (object instanceof byte[]) {
        object = new ByteArrayInputStream((byte[]) object);
    } else if (object instanceof File) {
        object = new FileInputStream((File) object);
    }

    // Serialize primitive types
    if (object instanceof ByteArrayOutputStream) {
        ByteArrayOutputStream bos = (ByteArrayOutputStream) object;

        bos.writeTo(out);
    } else if (object instanceof ByteBuffer) {
        // Write result as-is to output stream
        WritableByteChannel wbc = Channels.newChannel(out);
        ByteBuffer bb = (ByteBuffer) object;

        bb.rewind();

        while (bb.hasRemaining()) {
            wbc.write(bb);
        }

        wbc.close();
    } else if (object instanceof InputStream) {
        IO.copyStream((InputStream) object, out);
    } else if (object instanceof Reader) {
        // Write stream as-is, using the specified charset (if present)
        String cs = Parsers.getParameter(ct, "charset", "UTF-8");
        Writer ow = new OutputStreamWriter(out, cs);

        IO.copyReader((Reader) object, ow);
    } else if (object instanceof String) {
        // Write string as-is, using the specified charset (if present)
        String cs = Parsers.getParameter(ct, "charset", "UTF-8");
        Writer ow = new OutputStreamWriter(out, cs);
        ow.write((String) object);
        ow.flush();
    } else if (object instanceof RenderedImage) {
        Iterator<ImageWriter> i = ImageIO.getImageWritersByMIMEType(ct.getBaseType());

        if (!i.hasNext()) {
            throw new ESXXException("No ImageWriter available for " + ct.getBaseType());
        }

        ImageWriter writer = i.next();

        writer.setOutput(ImageIO.createImageOutputStream(out));
        writer.write((RenderedImage) object);
    } else {
        throw new UnsupportedOperationException("Unsupported object class type: " + object.getClass());
    }
}

---

From source file:jails.http.converter.BufferedImageHttpMessageConverter.java

public void write(BufferedImage image, MediaType contentType, HttpOutputMessage outputMessage)
        throws IOException, HttpMessageNotWritableException {

    if (contentType == null) {
        contentType = getDefaultContentType();
    }/*  w  ww. j  av  a 2 s. c o m*/
    Assert.notNull(contentType,
            "Count not determine Content-Type, set one using the 'defaultContentType' property");
    outputMessage.getHeaders().setContentType(contentType);
    ImageOutputStream imageOutputStream = null;
    ImageWriter imageWriter = null;
    try {
        imageOutputStream = createImageOutputStream(outputMessage.getBody());
        Iterator<ImageWriter> imageWriters = ImageIO.getImageWritersByMIMEType(contentType.toString());
        if (imageWriters.hasNext()) {
            imageWriter = imageWriters.next();
            ImageWriteParam iwp = imageWriter.getDefaultWriteParam();
            process(iwp);
            imageWriter.setOutput(imageOutputStream);
            imageWriter.write(null, new IIOImage(image, null, null), iwp);
        } else {
            throw new HttpMessageNotWritableException(
                    "Could not find javax.imageio.ImageWriter for Content-Type [" + contentType + "]");
        }
    } finally {
        if (imageWriter != null) {
            imageWriter.dispose();
        }
        if (imageOutputStream != null) {
            try {
                imageOutputStream.close();
            } catch (IOException ex) {
                // ignore
            }
        }
    }
}

---

From source file:org.jahia.services.image.AbstractJava2DImageService.java

protected boolean canRead(JCRNodeWrapper node) throws RepositoryException {
    Node contentNode = node.getNode(Constants.JCR_CONTENT);
    String mimeType = contentNode.getProperty(Constants.JCR_MIMETYPE).getString();

    Iterator<ImageReader> imageReaderIterator = ImageIO.getImageReadersByMIMEType(mimeType);
    if (imageReaderIterator.hasNext()) {
        // now let's check if we can also write it.
        Iterator<ImageWriter> imageWriterIterator = ImageIO.getImageWritersByMIMEType(mimeType);
        if (imageWriterIterator.hasNext()) {
            return true;
        } else {/* w w  w.  j a  v  a2  s . com*/
            return false;
        }
    } else {
        return false;
    }
}

---

From source file:org.jahia.services.image.AbstractJava2DImageService.java

protected void saveImageToFile(BufferedImage dest, String mimeType, File destFile) throws IOException {
    Iterator<ImageWriter> suffixWriters = ImageIO.getImageWritersByMIMEType(mimeType);
    if (suffixWriters.hasNext()) {
        ImageWriter imageWriter = suffixWriters.next();
        ImageOutputStream imageOutputStream = new FileImageOutputStream(destFile);
        imageWriter.setOutput(imageOutputStream);
        imageWriter.write(dest);//  w ww .j  a  v a 2s.  com
        imageOutputStream.close();
    } else {
        logger.warn(
                "Couldn't find a writer for mime type : " + mimeType + "(" + this.getClass().getName() + ")");
    }
}

---

From source file:org.getobjects.appserver.publisher.JoDefaultRenderer.java

/**
 * Renders a java.awt.BufferedImage to the WOResponse of the given context.
 * Remember to configure:<pre>//  ww w.j  a  v a 2 s  . c  o m
 *   -Djava.awt.headless=true</pre>
 * (thats the VM arguments of the run panel in Eclipse) 
 * 
 * @param _img   - the BufferedImage object to render
 * @param _ctx - the WOContext to render the image in
 * @return null if everything went fine, an Exception otherwise
 */
public Exception renderBufferedImage(BufferedImage _img, WOContext _ctx) {
    // TBD: this method could be improved a lot, but it works well enough for
    //      simple cases

    if (_img == null)
        return new JoInternalErrorException("got no image to render");

    /* find a proper image writer */

    String usedType = null;
    Iterator<ImageWriter> writers;
    ImageWriter writer = null;
    WORequest rq = _ctx.request();
    if (rq != null) {
        // TBD: just iterate over the accepted (image/) types (considering
        //      the value quality) and check each

        if (rq.acceptsContentType("image/png", false /* direct match */)) {
            if ((writers = ImageIO.getImageWritersByMIMEType("image/png")) != null)
                writer = writers.next();
            if (writer != null)
                usedType = "image/png";
        }
        if (writer == null && rq.acceptsContentType("image/gif", false)) {
            if ((writers = ImageIO.getImageWritersByMIMEType("image/gif")) != null)
                writer = writers.next();
            if (writer != null)
                usedType = "image/gif";
        }
        if (writer == null && rq.acceptsContentType("image/jpeg", false)) {
            if ((writers = ImageIO.getImageWritersByMIMEType("image/jpeg")) != null)
                writer = writers.next();
            if (writer != null)
                usedType = "image/jpeg";
        }
    }
    if (writer == null) {
        if ((writers = ImageIO.getImageWritersByMIMEType("image/png")) != null)
            writer = writers.next();
        if (writer != null)
            usedType = "image/png";
    }
    if (writer == null)
        return new JoInternalErrorException("found no writer for image: " + _img);

    /* prepare WOResponse */

    WOResponse r = _ctx.response();
    r.setStatus(WOMessage.HTTP_STATUS_OK);
    r.setHeaderForKey("inline", "content-disposition");
    if (usedType != null)
        r.setHeaderForKey(usedType, "content-type");
    // TBD: do we know the content-length? If not, should we generate to a
    //      buffer to avoid confusing the browser (IE ...)
    r.enableStreaming();

    /* write */

    ImageOutputStream ios = null;
    try {
        ios = ImageIO.createImageOutputStream(rq.outputStream());
    } catch (IOException e) {
        log.warn("could not create image output stream: " + _img);
        return e;
    }

    writer.setOutput(ios);

    try {
        writer.write(null, new IIOImage(_img, null, null), null);
        ios.flush();
        writer.dispose();
        ios.close();
    } catch (IOException e) {
        log.warn("failed to write image to stream", e);
        return e;
    }

    return null; /* everything is awesome O */
}

---

• «
• 1
• 2
• »