X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2FImage.java;h=4518577d640b684bee939381e02b9aa745b2d3a2;hb=8c227da67c11370980154c61861bcfb9c73881c5;hp=cfcaa74e2c1b8e2f1cd280f687afbfd7e8ad51bf;hpb=7b42695f536a88cfc5fed57e98687394e3c42fe9;p=fanfix.git

diff --git a/src/be/nikiroo/utils/Image.java b/src/be/nikiroo/utils/Image.java
index cfcaa74..4518577 100644
--- a/src/be/nikiroo/utils/Image.java
+++ b/src/be/nikiroo/utils/Image.java
@@ -3,22 +3,32 @@ package be.nikiroo.utils;
 import java.io.ByteArrayInputStream;
 import java.io.Closeable;
 import java.io.File;
-import java.io.FileInputStream;
 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;
 
 /**
  * This class represents an image data.
  * 
  * @author niki
  */
-public class Image implements Closeable {
+public class Image implements Closeable, Serializable {
+	static private final long serialVersionUID = 1L;
+
 	static private File tempRoot;
 	static private TempFiles tmpRepository;
 	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.
@@ -37,7 +47,7 @@ public class Image implements Closeable {
 		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 {
@@ -50,16 +60,21 @@ public class Image implements Closeable {
 	}
 
 	/**
-	 * Create a new {@link Image} from its Base64 representation.
+	 * 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 base64
-	 *            the {@link Image} in Base64 format
+	 * @param base64EncodedData
+	 *            the Base64 encoded data as a String
 	 * 
 	 * @throws IOException
-	 *             in case of I/O error
+	 *             in case of I/O error or badly formated Base64
 	 */
-	public Image(String base64) throws IOException {
-		this(Base64.decode(base64));
+	public Image(String base64EncodedData) throws IOException {
+		this(new Base64InputStream(new ByteArrayInputStream(
+				StringUtils.getBytes(base64EncodedData)), false));
 	}
 
 	/**
@@ -73,11 +88,21 @@ public class Image implements Closeable {
 	 */
 	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;
 	}
 
 	/**
-	 * Generate an {@link InputStream} for this {@link Image}.
+	 * Generate an {@link InputStream} that you can {@link InputStream#reset()}
+	 * for this {@link Image}.
 	 * <p>
 	 * This {@link InputStream} will (always) be a new one, and <b>you</b> are
 	 * responsible for it.
@@ -91,17 +116,18 @@ public class Image implements Closeable {
 	 *             in case of I/O error
 	 */
 	public InputStream newInputStream() throws IOException {
-		return new FileInputStream(data);
+		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();
@@ -118,17 +144,24 @@ public class Image implements Closeable {
 	/**
 	 * Convert the given {@link Image} object into a Base64 representation of
 	 * the same {@link Image} object.
-	 * <p>
-	 * Note: if possible, prefer the {@link Image#newInputStream()} method, as
-	 * it can be more efficient.
+	 * 
+	 * @deprecated Please use {@link Image#newInputStream()} instead, it is more
+	 *             efficient
 	 * 
 	 * @return the Base64 representation
 	 */
+	@Deprecated
 	public String toBase64() {
 		try {
-			return StringUtils.base64(getData(), false);
+			Base64InputStream stream = new Base64InputStream(newInputStream(),
+					true);
+			try {
+				return IOUtils.readSmallStream(stream);
+			} finally {
+				stream.close();
+			}
 		} catch (IOException e) {
-			throw new RuntimeException(e);
+			return null;
 		}
 	}
 
@@ -141,13 +174,20 @@ public class Image implements Closeable {
 	 */
 	@Override
 	public void close() throws IOException {
-		data.delete();
-		synchronized (lock) {
-			count--;
-			if (count <= 0) {
-				count = 0;
-				tmpRepository.close();
-				tmpRepository = null;
+		synchronized (instanceLock) {
+			if (size >= 0) {
+				size = -1;
+				data.delete();
+				data = null;
+
+				synchronized (lock) {
+					count--;
+					if (count <= 0) {
+						count = 0;
+						tmpRepository.close();
+						tmpRepository = null;
+					}
+				}
 			}
 		}
 	}
@@ -182,6 +222,44 @@ public class Image implements Closeable {
 		}
 	}
 
+	/**
+	 * Write this {@link Image} for serialization purposes; that is, write the
+	 * content of the backing temporary file.
+	 * 
+	 * @param out
+	 *            the {@link OutputStream} to write to
+	 * 
+	 * @throws IOException
+	 *             in case of I/O error
+	 */
+	private void writeObject(ObjectOutputStream out) throws IOException {
+		InputStream in = newInputStream();
+		try {
+			IOUtils.write(in, out);
+		} finally {
+			in.close();
+		}
+	}
+
+	/**
+	 * Read an {@link Image} written by
+	 * {@link Image#writeObject(java.io.ObjectOutputStream)}; that is, create a
+	 * new temporary file with the saved content.
+	 * 
+	 * @param in
+	 *            the {@link InputStream} to read from
+	 * @throws IOException
+	 *             in case of I/O error
+	 * @throws ClassNotFoundException
+	 *             will not be thrown by this method
+	 */
+	@SuppressWarnings("unused")
+	private void readObject(ObjectInputStream in) throws IOException,
+			ClassNotFoundException {
+		data = getTemporaryFile();
+		IOUtils.write(in, data);
+	}
+
 	/**
 	 * Change the temporary root directory used by the program.
 	 * <p>