Merge branch 'subtree'

[nikiroo-utils.git] / src / be / nikiroo / utils / Image.java

diff --git a/src/be/nikiroo/utils/Image.java b/src/be/nikiroo/utils/Image.java
index 2e9c9f83a39bfd4fcdeef8d351071d8284e9af61..9b28835e0fd61585023edf83db5ba19dea0030db 100644 (file)
--- a/src/be/nikiroo/utils/Image.java
+++ b/src/be/nikiroo/utils/Image.java
@@ -5,9 +5,12 @@ import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.io.OutputStream;
 import java.io.Serializable;
 
+import be.nikiroo.utils.streams.Base64InputStream;
 import be.nikiroo.utils.streams.MarkableFileInputStream;
 
 /**
@@ -23,7 +26,9 @@ public class Image implements Closeable, Serializable {
        static private long count = 0;
        static private Object lock = new Object();
 
+       private Object instanceLock = new Object();
        private File data;
+       private long size;
 
        /**
         * Do not use -- for serialisation purposes only.
@@ -42,7 +47,7 @@ public class Image implements Closeable, Serializable {
                ByteArrayInputStream in = new ByteArrayInputStream(data);
                try {
                        this.data = getTemporaryFile();
-                       IOUtils.write(in, this.data);
+                       size = IOUtils.write(in, this.data);
                } catch (IOException e) {
                        throw new RuntimeException(e);
                } finally {
@@ -54,6 +59,24 @@ public class Image implements Closeable, Serializable {
                }
        }
 
+       /**
+        * Create an image from Base64 encoded data.
+        * 
+        * <p>
+        * Please use {@link Image#Image(InputStream)} when possible instead, with a
+        * {@link Base64InputStream}; it can be much more efficient.
+        * 
+        * @param base64EncodedData
+        *            the Base64 encoded data as a String
+        * 
+        * @throws IOException
+        *             in case of I/O error or badly formated Base64
+        */
+       public Image(String base64EncodedData) throws IOException {
+               this(new Base64InputStream(new ByteArrayInputStream(
+                               StringUtils.getBytes(base64EncodedData)), false));
+       }
+
        /**
         * Create a new {@link Image} from a stream.
         * 
@@ -65,7 +88,16 @@ public class Image implements Closeable, Serializable {
         */
        public Image(InputStream in) throws IOException {
                data = getTemporaryFile();
-               IOUtils.write(in, data);
+               size = IOUtils.write(in, data);
+       }
+
+       /**
+        * The size of the enclosed image in bytes.
+        * 
+        * @return the size
+        */
+       public long getSize() {
+               return size;
        }
 
        /**
@@ -84,17 +116,24 @@ public class Image implements Closeable, Serializable {
         *             in case of I/O error
         */
        public InputStream newInputStream() throws IOException {
-               return new MarkableFileInputStream(data);
+               synchronized (instanceLock) {
+                       if (data == null) {
+                               throw new IOException("Image was close()d");
+                       }
+                       
+                       return new MarkableFileInputStream(data);       
+               }
        }
 
        /**
         * <b>Read</b> the actual image data, as a byte array.
-        * <p>
-        * Note: if possible, prefer the {@link Image#newInputStream()} method, as
-        * it can be more efficient.
+        * 
+        * @deprecated if possible, prefer the {@link Image#newInputStream()}
+        *             method, as it can be more efficient
         * 
         * @return the image data
         */
+       @Deprecated
        public byte[] getData() {
                try {
                        InputStream in = newInputStream();
@@ -108,6 +147,30 @@ public class Image implements Closeable, Serializable {
                }
        }
 
+       /**
+        * Convert the given {@link Image} object into a Base64 representation of
+        * the same {@link Image} object.
+        * 
+        * @deprecated Please use {@link Image#newInputStream()} instead, it is more
+        *             efficient
+        * 
+        * @return the Base64 representation
+        */
+       @Deprecated
+       public String toBase64() {
+               try {
+                       Base64InputStream stream = new Base64InputStream(newInputStream(),
+                                       true);
+                       try {
+                               return IOUtils.readSmallStream(stream);
+                       } finally {
+                               stream.close();
+                       }
+               } catch (IOException e) {
+                       return null;
+               }
+       }
+
        /**
         * Closing the {@link Image} will delete the associated temporary file on
         * disk.
@@ -117,13 +180,21 @@ public class Image implements Closeable, Serializable {
         */
        @Override
        public void close() throws IOException {
-               data.delete();
-               synchronized (lock) {
-                       count--;
-                       if (count <= 0) {
-                               count = 0;
-                               tmpRepository.close();
-                               tmpRepository = null;
+               synchronized (instanceLock) {
+                       new Exception().printStackTrace();
+                       if (size >= 0) {
+                               size = -1;
+                               data.delete();
+                               data = null;
+
+                               synchronized (lock) {
+                                       count--;
+                                       if (count <= 0) {
+                                               count = 0;
+                                               tmpRepository.close();
+                                               tmpRepository = null;
+                                       }
+                               }
                        }
                }
        }
@@ -168,7 +239,7 @@ public class Image implements Closeable, Serializable {
         * @throws IOException
         *             in case of I/O error
         */
-       private void writeObject(java.io.ObjectOutputStream out) throws IOException {
+       private void writeObject(ObjectOutputStream out) throws IOException {
                InputStream in = newInputStream();
                try {
                        IOUtils.write(in, out);
@@ -190,7 +261,7 @@ public class Image implements Closeable, Serializable {
         *             will not be thrown by this method
         */
        @SuppressWarnings("unused")
-       private void readObject(java.io.ObjectInputStream in) throws IOException,
+       private void readObject(ObjectInputStream in) throws IOException,
                        ClassNotFoundException {
                data = getTemporaryFile();
                IOUtils.write(in, data);