reportbuilder/java/org/libreoffice/report/pentaho/output/ImageProducer.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18 package org.libreoffice.report.pentaho.output;
  19
  20 import com.sun.star.awt.Size;
  21 import org.libreoffice.report.ImageService;
  22 import org.libreoffice.report.InputRepository;
  23 import org.libreoffice.report.OutputRepository;
  24 import org.libreoffice.report.ReportExecutionException;
  25 import org.libreoffice.report.pentaho.DefaultNameGenerator;
  26
  27 import java.awt.Image;
  28
  29 import java.io.BufferedInputStream;
  30 import java.io.ByteArrayInputStream;
  31 import java.io.ByteArrayOutputStream;
  32 import java.io.IOException;
  33 import java.io.InputStream;
  34 import java.io.OutputStream;
  35
  36 import java.net.MalformedURLException;
  37 import java.net.URI;
  38 import java.net.URISyntaxException;
  39 import java.net.URL;
  40 import java.net.URLConnection;
  41
  42 import java.sql.Blob;
  43 import java.sql.SQLException;
  44
  45 import java.util.Arrays;
  46 import java.util.HashMap;
  47 import java.util.Map;
  48 import java.util.logging.Level;
  49 import java.util.logging.Logger;
  50
  51 import org.jfree.layouting.input.style.values.CSSNumericType;
  52 import org.jfree.layouting.input.style.values.CSSNumericValue;
  53
  54 import org.pentaho.reporting.libraries.base.util.IOUtils;
  55 import org.pentaho.reporting.libraries.base.util.PngEncoder;
  56 import org.pentaho.reporting.libraries.base.util.WaitingImageObserver;
  57
  58
  59 /**
  60  * This class manages the images embedded in a report.
  61  *
  62  * @since 31.03.2007
  63  */
  64 public class ImageProducer
  65 {
  66
  67     private static final Logger LOGGER = Logger.getLogger(ImageProducer.class.getName());
  68
  69     public static class OfficeImage
  70     {
  71
  72         private final CSSNumericValue width;
  73         private final CSSNumericValue height;
  74         private final String embeddableLink;
  75
  76         private OfficeImage(final String embeddableLink, final CSSNumericValue width, final CSSNumericValue height)
  77         {
  78             this.embeddableLink = embeddableLink;
  79             this.width = width;
  80             this.height = height;
  81         }
  82
  83         public CSSNumericValue getWidth()
  84         {
  85             return width;
  86         }
  87
  88         public CSSNumericValue getHeight()
  89         {
  90             return height;
  91         }
  92
  93         public String getEmbeddableLink()
  94         {
  95             return embeddableLink;
  96         }
  97     }
  98
  99     private static class ByteDataImageKey
 100     {
 101
 102         private final byte[] keyData;
 103         private Integer hashCode;
 104
 105         protected ByteDataImageKey(final byte[] keyData)
 106         {
 107             if (keyData == null)
 108             {
 109                 throw new NullPointerException();
 110             }
 111             this.keyData = keyData;
 112         }
 113
 114         @Override
 115         public boolean equals(final Object o)
 116         {
 117             if (this != o)
 118             {
 119                 if (o == null || getClass() != o.getClass())
 120                 {
 121                     return false;
 122                 }
 123
 124                 final ByteDataImageKey key = (ByteDataImageKey) o;
 125                 if (!Arrays.equals(keyData, key.keyData))
 126                 {
 127                     return false;
 128                 }
 129             }
 130
 131             return true;
 132         }
 133
 134         @Override
 135         public int hashCode()
 136         {
 137             if (hashCode != null)
 138             {
 139                 return hashCode;
 140             }
 141
 142             final int length = Math.min(keyData.length, 512);
 143             int hashValue = 0;
 144             for (int i = 0; i < length; i++)
 145             {
 146                 final byte b = keyData[i];
 147                 hashValue = b + hashValue * 23;
 148             }
 149             this.hashCode = hashValue;
 150             return hashValue;
 151         }
 152     }
 153     private final Map<Object,OfficeImage> imageCache;
 154     private final InputRepository inputRepository;
 155     private final OutputRepository outputRepository;
 156     private final ImageService imageService;
 157
 158     public ImageProducer(final InputRepository inputRepository,
 159             final OutputRepository outputRepository,
 160             final ImageService imageService)
 161     {
 162         if (inputRepository == null)
 163         {
 164             throw new NullPointerException();
 165         }
 166         if (outputRepository == null)
 167         {
 168             throw new NullPointerException();
 169         }
 170         if (imageService == null)
 171         {
 172             throw new NullPointerException();
 173         }
 174
 175         this.inputRepository = inputRepository;
 176         this.outputRepository = outputRepository;
 177         this.imageService = imageService;
 178         this.imageCache = new HashMap<Object,OfficeImage>();
 179     }
 180
 181     /**
 182      * Image-Data can be one of the following types: String, URL, URI, byte-array, blob.
 183      */
 184     public OfficeImage produceImage(final Object imageData,
 185             final boolean preserveIRI)
 186     {
 187
 188         LOGGER.config("Want to produce image " + imageData);
 189         if (imageData instanceof String)
 190         {
 191             return produceFromString((String) imageData, preserveIRI);
 192         }
 193
 194         if (imageData instanceof URL)
 195         {
 196             return produceFromURL((URL) imageData, preserveIRI);
 197         }
 198
 199         if (imageData instanceof Blob)
 200         {
 201             return produceFromBlob((Blob) imageData);
 202         }
 203
 204         if (imageData instanceof byte[])
 205         {
 206             return produceFromByteArray((byte[]) imageData);
 207         }
 208
 209         if (imageData instanceof Image)
 210         {
 211             return produceFromImage((Image) imageData);
 212         }
 213         // not usable ..
 214         return null;
 215     }
 216
 217     private OfficeImage produceFromImage(final Image image)
 218     {
 219         // quick caching ... use a weak list ...
 220         final WaitingImageObserver obs = new WaitingImageObserver(image);
 221         obs.waitImageLoaded();
 222
 223         final PngEncoder encoder = new PngEncoder(image, PngEncoder.ENCODE_ALPHA, PngEncoder.FILTER_NONE, 5);
 224         final byte[] data = encoder.pngEncode();
 225         return produceFromByteArray(data);
 226     }
 227
 228     private OfficeImage produceFromBlob(final Blob blob)
 229     {
 230         try
 231         {
 232             final InputStream inputStream = blob.getBinaryStream();
 233             final int length = (int) blob.length();
 234
 235             final ByteArrayOutputStream bout = new ByteArrayOutputStream(length);
 236             try
 237             {
 238                 IOUtils.getInstance().copyStreams(inputStream, bout);
 239             } finally
 240             {
 241                 inputStream.close();
 242             }
 243             return produceFromByteArray(bout.toByteArray());
 244         }
 245         catch (IOException e)
 246         {
 247             LOGGER.warning("Failed to produce image from Blob: " + e);
 248         }
 249         catch (SQLException e)
 250         {
 251             LOGGER.warning("Failed to produce image from Blob: " + e);
 252         }
 253         return null;
 254     }
 255
 256     private OfficeImage produceFromByteArray(final byte[] data)
 257     {
 258         final ByteDataImageKey imageKey = new ByteDataImageKey(data);
 259         final OfficeImage o = imageCache.get(imageKey);
 260         if (o != null)
 261         {
 262             return o;
 263         }
 264
 265         try
 266         {
 267             final String mimeType = imageService.getMimeType(data);
 268             final Size dims = imageService.getImageSize(data);
 269
 270             // copy the image into the local output-storage
 271             // todo: Implement data-fingerprinting so that we can detect the mime-type
 272             final OutputRepository storage = outputRepository.openOutputRepository("Pictures", null);
 273             final DefaultNameGenerator nameGenerator = new DefaultNameGenerator(storage);
 274             final String name = nameGenerator.generateName("image", mimeType);
 275             final OutputStream outputStream = storage.createOutputStream(name, mimeType);
 276             final ByteArrayInputStream bin = new ByteArrayInputStream(data);
 277
 278             try
 279             {
 280                 IOUtils.getInstance().copyStreams(bin, outputStream);
 281             } finally
 282             {
 283                 outputStream.close();
 284                 storage.closeOutputRepository();
 285             }
 286
 287             final CSSNumericValue widthVal = CSSNumericValue.createValue(CSSNumericType.MM, dims.Width / 100.0);
 288             final CSSNumericValue heightVal = CSSNumericValue.createValue(CSSNumericType.MM, dims.Height / 100.0);
 289             final OfficeImage officeImage = new OfficeImage("Pictures/" + name, widthVal, heightVal);
 290             imageCache.put(imageKey, officeImage);
 291             return officeImage;
 292         }
 293         catch (IOException e)
 294         {
 295             LOGGER.warning("Failed to load image from local input-repository: " + e);
 296         }
 297         catch (ReportExecutionException e)
 298         {
 299             LOGGER.warning("Failed to create image from local input-repository: " + e);
 300         }
 301         return null;
 302     }
 303
 304     private OfficeImage produceFromString(final String source,
 305             final boolean preserveIRI)
 306     {
 307
 308         try
 309         {
 310             final URL url = new URL(source);
 311             return produceFromURL(url, preserveIRI);
 312         }
 313         catch (MalformedURLException e)
 314         {
 315             // ignore .. but we had to try this ..
 316         }
 317
 318         final OfficeImage o = imageCache.get(source);
 319         if (o != null)
 320         {
 321             return o;
 322         }
 323
 324         // Next, check whether this is a local path.
 325         if (inputRepository.isReadable(source))
 326         {
 327             // cool, the file exists. Let's try to read it.
 328             try
 329             {
 330                 final ByteArrayOutputStream bout = new ByteArrayOutputStream(8192);
 331                 final InputStream inputStream = inputRepository.createInputStream(source);
 332                 try
 333                 {
 334                     IOUtils.getInstance().copyStreams(inputStream, bout);
 335                 } finally
 336                 {
 337                     inputStream.close();
 338                 }
 339                 final byte[] data = bout.toByteArray();
 340                 final Size dims = imageService.getImageSize(data);
 341                 final String mimeType = imageService.getMimeType(data);
 342
 343                 final CSSNumericValue widthVal = CSSNumericValue.createValue(CSSNumericType.MM, dims.Width / 100.0);
 344                 final CSSNumericValue heightVal = CSSNumericValue.createValue(CSSNumericType.MM, dims.Height / 100.0);
 345
 346                 final String filename = copyToOutputRepository(mimeType, data);
 347                 final OfficeImage officeImage = new OfficeImage(filename, widthVal, heightVal);
 348                 imageCache.put(source, officeImage);
 349                 return officeImage;
 350             }
 351             catch (IOException e)
 352             {
 353                 LOGGER.warning("Failed to load image from local input-repository: " + e);
 354             }
 355             catch (ReportExecutionException e)
 356             {
 357                 LOGGER.warning("Failed to create image from local input-repository: " + e);
 358             }
 359         }
 360         else
 361         {
 362             try
 363             {
 364                 URI rootURI = new URI(inputRepository.getRootURL());
 365                 final URI uri = rootURI.resolve(source);
 366                 return produceFromURL(uri.toURL(), preserveIRI);
 367             }
 368             catch (URISyntaxException ex)
 369             {
 370             }
 371             catch (MalformedURLException e)
 372             {
 373                 // ignore .. but we had to try this ..
 374             }
 375         }
 376
 377         // Return the image as broken image instead ..
 378         final OfficeImage officeImage = new OfficeImage(source, null, null);
 379         imageCache.put(source, officeImage);
 380         return officeImage;
 381     }
 382
 383     private OfficeImage produceFromURL(final URL url,
 384             final boolean preserveIRI)
 385     {
 386         final String urlString = url.toString();
 387         URI uri = null;
 388         try
 389         {
 390             uri = new URI(urlString);
 391         }
 392         catch (URISyntaxException ex)
 393         {
 394             Logger.getLogger(ImageProducer.class.getName()).log(Level.SEVERE, null, ex);
 395         }
 396         final OfficeImage o = imageCache.get(uri);
 397         if (o != null)
 398         {
 399             return o;
 400         }
 401
 402         try
 403         {
 404             final ByteArrayOutputStream bout = new ByteArrayOutputStream(8192);
 405             final URLConnection urlConnection = url.openConnection();
 406             final InputStream inputStream = new BufferedInputStream(urlConnection.getInputStream());
 407             try
 408             {
 409                 IOUtils.getInstance().copyStreams(inputStream, bout);
 410             } finally
 411             {
 412                 inputStream.close();
 413             }
 414             final byte[] data = bout.toByteArray();
 415
 416             final Size dims = imageService.getImageSize(data);
 417             final String mimeType = imageService.getMimeType(data);
 418             final CSSNumericValue widthVal = CSSNumericValue.createValue(CSSNumericType.MM, dims.Width / 100.0);
 419             final CSSNumericValue heightVal = CSSNumericValue.createValue(CSSNumericType.MM, dims.Height / 100.0);
 420
 421             if (preserveIRI)
 422             {
 423                 final OfficeImage retval = new OfficeImage(urlString, widthVal, heightVal);
 424                 imageCache.put(uri, retval);
 425                 return retval;
 426             }
 427
 428             final String name = copyToOutputRepository(mimeType, data);
 429             final OfficeImage officeImage = new OfficeImage(name, widthVal, heightVal);
 430             imageCache.put(uri, officeImage);
 431             return officeImage;
 432         }
 433         catch (IOException e)
 434         {
 435             LOGGER.warning("Failed to load image from local input-repository: " + e);
 436         }
 437         catch (ReportExecutionException e)
 438         {
 439             LOGGER.warning("Failed to create image from local input-repository: " + e);
 440         }
 441
 442         if (!preserveIRI)
 443         {
 444             final OfficeImage image = new OfficeImage(urlString, null, null);
 445             imageCache.put(uri, image);
 446             return image;
 447         }
 448
 449         // OK, everything failed; the image is not - repeat it - not usable.
 450         return null;
 451     }
 452
 453     private String copyToOutputRepository(final String urlMimeType, final byte[] data)
 454             throws IOException, ReportExecutionException
 455     {
 456         final String mimeType;
 457         if (urlMimeType == null)
 458         {
 459             mimeType = imageService.getMimeType(data);
 460         }
 461         else
 462         {
 463             mimeType = urlMimeType;
 464         }
 465
 466         // copy the image into the local output-storage
 467         final OutputRepository storage = outputRepository.openOutputRepository("Pictures", null);
 468         final DefaultNameGenerator nameGenerator = new DefaultNameGenerator(storage);
 469         final String name = nameGenerator.generateName("image", mimeType);
 470         final OutputStream outputStream = storage.createOutputStream(name, mimeType);
 471         final ByteArrayInputStream bin = new ByteArrayInputStream(data);
 472
 473         try
 474         {
 475             IOUtils.getInstance().copyStreams(bin, outputStream);
 476         } finally
 477         {
 478             outputStream.close();
 479             storage.closeOutputRepository();
 480         }
 481         return "Pictures/" + name;
 482     }
 483 }