net.sourceforge.openutils.mgnlmedia.media.utils.ImageUtils Maven / Gradle / Ivy
/**
*
* SimpleMedia Module for Magnolia CMS (http://www.openmindlab.com/lab/products/media.html)
* Copyright(C) 2008-2012, Openmind S.r.l. http://www.openmindonline.it
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see writers;
ImageOutputStream imageOutputStream;
ImageWriteParam params;
ImageWriter imageWriter;
String outputextension = extension;
if (StringUtils.equals(extension, "ico") || StringUtils.equals(extension, "gif"))
{
// gif and ico are remapped to png
outputextension = "png";
}
// don't use "ico" as output format
writers = ImageIO.getImageWritersBySuffix(outputextension);
if (writers != null && writers.hasNext())
{
// Fetch the first writer in the list
imageWriter = writers.next();
// Specify the parameters according to those the output file will be written
// Get Default parameters
params = imageWriter.getDefaultWriteParam();
try
{
String[] compressionTypes = params.getCompressionTypes();
if (compressionTypes != null && compressionTypes.length > 0)
{
// Define compression mode
params.setCompressionMode(javax.imageio.ImageWriteParam.MODE_EXPLICIT);
params.setCompressionType(compressionTypes[0]);
// Define compression quality
params.setCompressionQuality(quality);
}
else
{
params.setCompressionMode(javax.imageio.ImageWriteParam.MODE_COPY_FROM_METADATA);
}
// Define progressive mode
if (forceProgressive)
{
params.setProgressiveMode(javax.imageio.ImageWriteParam.MODE_DEFAULT);
}
else
{
params.setProgressiveMode(javax.imageio.ImageWriteParam.MODE_DISABLED);
}
}
catch (UnsupportedOperationException e)
{
// go on
}
// Define destination type - used the ColorModel and SampleModel of the Input Image
params.setDestinationType(new ImageTypeSpecifier(image.getColorModel(), image.getSampleModel()));
imageOutputStream = ImageIO.createImageOutputStream(out);
imageWriter.setOutput(imageOutputStream);
IIOImage iioimage = new IIOImage(image, null, null);
try
{
// Write the changed Image
imageWriter.write(null, iioimage, params);
}
catch (NullPointerException e)
{
// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6287936
// GIF writer is buggy for totally transparent gifs
// workaround: draw a point!
image.createGraphics().drawRect(0, 0, 1, 1);
imageWriter.write(null, iioimage, params);
}
finally
{
// Close the streams
imageOutputStream.close();
imageWriter.dispose();
}
}
else
{
ImageIO.write(image, outputextension, out);
}
}
}
catch (IOException ex)
{
log.error("Error writing image to buffer", ex);
throw ex;
}
return out.count;
}
/**
* Check if the resolution for a media is already present. Otherwise create it
* @param media media to check the resolutoin on
* @param resolutionTarget target resolution
* @return false if resolution doesn't exist and there is a problem in generate it; true otherwise
*/
public static boolean checkOrCreateResolution(final Content media, final String resolutionTarget)
{
return checkOrCreateResolution(media, resolutionTarget, BaseTypeHandler.ORGINAL_NODEDATA_NAME);
}
/**
* Check if the resolution for a media is already present. Otherwise create it
* @param media media to check the resolution on
* @param resolutionTarget target resolution
* @param nodeDataName nodedata where the image to resize is stored
* @return false if resolution doesn't exist and there is a problem in generate it; true otherwise
*/
public static boolean checkOrCreateResolution(final Content media, final String resolutionTarget,
String nodeDataName)
{
return checkOrCreateResolution(media, resolutionTarget, nodeDataName, false);
}
public static boolean checkOrCreateResolution(final Content media, final String resolutionTarget,
String nodeDataName, final boolean lazy)
{
Content resolutions = getResolutionsNode(media);
String resolution = resolutionTarget;
if (!RESOLUTION_THUMBNAIL.equals(resolutionTarget) && !RESOLUTION_PREVIEW.equals(resolutionTarget))
{
resolution = "res-" + resolutionTarget;
}
try
{
if (resolutions != null && resolutions.hasNodeData(getResolutionPath(resolution)))
{
if (lazy)
{
return true;
}
else if (!StringUtils.isEmpty(resolutions.getNodeData(getResolutionPath(resolution)).getAttribute(
"resolutionNotYetCreated")))
{
// continue: replace the fake image with the actual one
}
else
{
return true;
}
}
}
catch (RepositoryException e1)
{
// go on with res calculation
}
String type = media.getNodeData("type").getString();
if (StringUtils.equals(type, "other"))
{
return false;
}
if (nodeDataName == null)
{
MediaTypeConfiguration mtc = MediaConfigurationManager.getInstance().getMediaTypeConfigurationFromMedia(
media);
if (mtc == null)
{
nodeDataName = BaseTypeHandler.ORGINAL_NODEDATA_NAME;
}
else
{
nodeDataName = mtc.getHandler().getPreviewImageNodeDataName();
}
}
try
{
if (!media.hasNodeData(nodeDataName))
{
return false;
}
}
catch (RepositoryException e2)
{
log.warn(e2.getMessage(), e2);
}
final String originalNodeDataName = nodeDataName;
try
{
ImageUtils.doInSystemContext(new MgnlContext.SystemContextOperation()
{
/**
* {@inheritDoc}
*/
public void exec()
{
long timestart = System.currentTimeMillis();
HierarchyManager hm = MgnlContext.getHierarchyManager(MediaModule.REPO);
String resolutionstring = resolutionTarget;
if (RESOLUTION_THUMBNAIL.equals(resolutionstring))
{
resolutionstring = RESOLUTION_THUMBNAIL_SIZE;
}
if (RESOLUTION_PREVIEW.equals(resolutionstring))
{
resolutionstring = RESOLUTION_PREVIEW_SIZE;
}
String resolutioNodeName = "res-" + resolutionstring;
if (RESOLUTION_THUMBNAIL.equals(resolutionTarget) || RESOLUTION_PREVIEW.equals(resolutionTarget))
{
resolutioNodeName = resolutionTarget;
}
Content node;
try
{
node = hm.getContent(media.getHandle());
}
catch (RepositoryException e)
{
throw new RuntimeException(e);
}
NodeData image = node.getNodeData(originalNodeDataName);
if (image.getContentLength() == 0)
{
throw new ZeroSizeImageException(image.getHandle());
}
String outputextension = image.getAttribute(FileProperties.PROPERTY_EXTENSION);
if (!Arrays.asList(extensions).contains(outputextension))
{
outputextension = "jpg";
}
BufferedImage original = null;
BufferedImage img = null;
Map params = parseParameters(resolutionstring);
if (lazy)
{
params.put("skipRendering", "true");
}
synchronized (MediaEl.module().getLocks().nextLock())
{
currentWorkingThreads++;
if (log.isDebugEnabled())
{
log.debug("Current working resizing thread: {}", currentWorkingThreads);
}
original = createBufferedImage(image);
try
{
img = ImageUtils.getImageForResolution(original, resolutionstring, params);
}
catch (IllegalArgumentException e)
{
throw new RuntimeException(e);
}
finally
{
currentWorkingThreads--;
}
}
try
{
float quality = 0.8F;
if (StringUtils.isNotEmpty(params.get("quality")))
{
try
{
quality = NumberUtils.toFloat(params.get("quality"));
if (quality > 1.0F)
{
quality = 1.0F;
}
}
catch (NumberFormatException ex)
{
log.error("quality parameter must be a float number but was {}", params.get("quality"));
}
}
boolean forceProgressive = false;
if (StringUtils.isNotEmpty(params.get("progressive")))
{
forceProgressive = true;
}
NodeData nd = ImageUtils.saveResolution(
img,
node,
resolutioNodeName,
outputextension,
quality,
forceProgressive);
if (lazy)
{
nd.setAttribute(
"resolutionNotYetCreated",
StringUtils.removeStart(resolutioNodeName, "res-"));
nd.getParent().save();
}
}
catch (RepositoryException e)
{
throw new RuntimeException(e);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
try
{
hm.save();
}
catch (RepositoryException e)
{
throw new RuntimeException(e);
}
log.info("Generated {} for {} in {} milliseconds", new Object[]{
resolutioNodeName,
node.getHandle(),
System.currentTimeMillis() - timestart });
}
});
}
catch (BadImageFormatException e)
{
if (e.getCause() != null)
{
log.warn(e.getMessage(), e.getCause());
}
else
{
log.warn("Unable to extract a valid image from " + media.getHandle() + " (no message)");
}
try
{
media.setNodeData("bad_image_marker", media.getNodeData("bad_image_marker").getLong() + 1);
media.save();
}
catch (RepositoryException e1)
{
// ignore
}
return false;
}
catch (ZeroSizeImageException ex)
{
log.error(ex.getMessage());
return false;
}
catch (RuntimeException ex)
{
log.error(ClassUtils.getShortClassName(ex.getClass())
+ " checking resolution for "
+ media.getHandle()
+ ": "
+ ex.getMessage(), ex);
return false;
}
return true;
}
/**
* Returns the "resolutions" node, checking for existence
* @param media
* @return
*/
protected static Content getResolutionsNode(final Content media)
{
Content resolutions = null;
try
{
if (media.hasContent("resolutions"))
{
resolutions = media.getContent("resolutions");
}
}
catch (RepositoryException e)
{
// ignore, try to create it
}
return resolutions;
}
private static Map parseParameters(String resolution)
{
Map params = new HashMap();
if (StringUtils.contains(resolution, ";"))
{
String parameters = StringUtils.substringAfter(resolution, ";");
resolution = StringUtils.substringBefore(resolution, ";");
String tokens[] = StringUtils.split(parameters, ',');
for (String token : tokens)
{
if (token.indexOf("=") > 0)
{
String[] keyvalue = StringUtils.split(token, '=');
params.put(keyvalue[0], keyvalue[1]);
}
else
{
params.put(token, "true");
}
}
}
return params;
}
/**
* Get image for a resolution
* @param original original image
* @param resolution resolution
* @param params parameters
* @return new image
*/
public static BufferedImage getImageForResolution(BufferedImage original, String resolution,
Map params)
{
if (original == null)
{
throw new IllegalArgumentException("input image is null");
}
if (resolution == null || resolution.length() < 1)
{
throw new IllegalArgumentException("Invalid resolution: " + resolution);
}
BufferedImage img = null;
resolution = StringUtils.lowerCase(resolution);
char controlChar = resolution.charAt(0);
Point size = parseForSize(resolution);
if (ImageProcessorsManager.getInstance().isValidControlChar(controlChar))
{
img = ImageProcessorsManager
.getInstance()
.getImageResolutionProcessor(controlChar)
.getImageForResolution(original, size.x, size.y, params);
}
else if (controlChar < '0' || controlChar > '9')
{
throw new IllegalArgumentException("Invalid control char: " + controlChar);
}
else
{
img = ImageProcessorsManager
.getInstance()
.getDefaultImageResolutionProcessor()
.getImageForResolution(original, size.x, size.y, params);
}
for (ImagePostProcessor ipp : ImageProcessorsManager.getInstance().getImagePostProcessorsList())
{
img = ipp.processImage(img, size.x, size.y, params);
}
return img;
}
/**
* Get file extension for a resolution stored in a media node
* @param media media
* @param resolution resolution
* @return file extension for a resolution stored in a media node
*/
public static String getExtension(Content media, String resolution)
{
try
{
Content resolutions = media.getContent("resolutions");
NodeData res = resolutions.getNodeData(resolution);
return res.getAttribute(FileProperties.PROPERTY_EXTENSION);
}
catch (RepositoryException ex)
{
return "jpg";
}
}
/**
* Create a buffered image from the binary data stored in nodedata
* @param image nodedata
* @return buffered image from the binary data stored in nodedata
*/
public static BufferedImage createBufferedImage(NodeData image)
{
InputStream is = image.getStream();
String ext = image.getAttribute(FileProperties.EXTENSION);
log.debug("processing {}, extension {}", image.getHandle(), ext);
try
{
if (StringUtils.equalsIgnoreCase(ext, "ico") || StringUtils.equalsIgnoreCase(ext, "bmp"))
{
BufferedImage buffered = IcoUtils.createBufferedImage(image);
if (buffered != null)
{
return buffered;
}
}
BufferedImage result = ImageIO.read(is);
// yes, ImageIO can return null without throwing any exception
if (result == null)
{
throw new BadImageFormatException("Unable to handle " + image.getHandle() + " (no message)");
}
return result;
}
catch (IOException e)
{
// CMYK jpeg can't be read be ImageIO
// Caused by: javax.imageio.IIOException: Unsupported Image Type
BufferedImage result = JpegUtils.processNonStandardImage(image);
if (result == null)
{
// throw the original exception back
throw new BadImageFormatException("Unable to handle " + image.getHandle(), e);
}
return result;
}
catch (CMMException e)
{
// CMMException is thrown for non-standard jpegs?
// Invalid image format
// java.awt.color.CMMException: Invalid image format
// at sun.awt.color.CMM.checkStatus(CMM.java:131)
// at sun.awt.color.ICC_Transform.(ICC_Transform.java:89)
// at java.awt.image.ColorConvertOp.filter(ColorConvertOp.java:516)
// at com.sun.imageio.plugins.jpeg.JPEGImageReader.acceptPixels(JPEGImageReader.java:1169)
BufferedImage result = JpegUtils.processNonStandardImage(image);
if (result == null)
{
// throw the original exception back
throw new BadImageFormatException("Unable to handle " + image.getHandle(), e);
}
return result;
}
catch (IllegalArgumentException e)
{
// java.lang.IllegalArgumentException: Numbers of source Raster bands and source color space components do
// not match
// at java.awt.image.ColorConvertOp.filter(ColorConvertOp.java:460)
// at com.sun.imageio.plugins.jpeg.JPEGImageReader.acceptPixels(JPEGImageReader.java:1169)
// at com.sun.imageio.plugins.jpeg.JPEGImageReader.readImage(Native Method)
// at com.sun.imageio.plugins.jpeg.JPEGImageReader.readInternal(JPEGImageReader.java:1137)
// at com.sun.imageio.plugins.jpeg.JPEGImageReader.read(JPEGImageReader.java:948)
BufferedImage result = JpegUtils.processNonStandardImage(image);
if (result == null)
{
// throw the original exception back
throw new BadImageFormatException("Unable to handle " + image.getHandle(), e);
}
return result;
}
finally
{
IOUtils.closeQuietly(is);
}
}
private static String normalizeResolutionString(String res)
{
String resolution = StringUtils.lowerCase(res);
if (RESOLUTION_THUMBNAIL.equals(resolution))
{
return RESOLUTION_THUMBNAIL_SIZE;
}
if (RESOLUTION_PREVIEW.equals(resolution))
{
return RESOLUTION_PREVIEW_SIZE;
}
return resolution;
}
/**
* Parse resolution string for required sizesuper.read(b);
* @param res resolution string
* @return required size parsed from given resolution string
*/
public static java.awt.Point parseForSize(String res)
{
Point size = new Point();
String resolution = normalizeResolutionString(res);
if (StringUtils.contains(resolution, ";"))
{
resolution = StringUtils.substringBefore(resolution, ";");
}
if (ImageProcessorsManager.getInstance().isValidControlChar(resolution.charAt(0))
|| resolution.charAt(0) < '0'
|| resolution.charAt(0) > '9')
{
resolution = resolution.substring(1);
}
String[] resXY = StringUtils.split(resolution, "x");
size.x = NumberUtils.toInt(resXY[0]);
size.y = NumberUtils.toInt(resXY[1]);
return size;
}
private static void doInSystemContext(SystemContextOperation op)
{
final Context originalCtx = MgnlContext.hasInstance() ? MgnlContext.getInstance() : null;
try
{
MgnlContext.setInstance(MgnlContext.getSystemContext());
op.exec();
}
finally
{
MgnlContext.setInstance(originalCtx);
}
}
static class CountBytesBufferedOutputStream extends BufferedOutputStream
{
private int count = 0;
/**
* @param in
* @param size
*/
public CountBytesBufferedOutputStream(OutputStream out, int size)
{
super(out, size);
count = 0;
}
/**
* @param in
*/
public CountBytesBufferedOutputStream(OutputStream in)
{
super(in);
count = 0;
}
/**
* Returns the count.
* @return the count
*/
public int getCount()
{
return count;
}
/**
* {@inheritDoc}
*/
@Override
public synchronized void write(byte[] b, int off, int len) throws IOException
{
count += len;
super.write(b, off, len);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy