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 be.nikiroo.utils.streams.MarkableFileInputStream;
+
/**
* This class represents an image data.
*
* @author niki
*/
-public class Image {
- private byte[] data;
+public class Image implements Closeable {
+ static private File tempRoot;
+ static private TempFiles tmpRepository;
+ static private long count = 0;
+ static private Object lock = new Object();
+
+ private File data;
/**
* Do not use -- for serialisation purposes only.
* the data
*/
public Image(byte[] data) {
- this.data = data;
+ ByteArrayInputStream in = new ByteArrayInputStream(data);
+ try {
+ this.data = getTemporaryFile();
+ IOUtils.write(in, this.data);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ } finally {
+ try {
+ in.close();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
}
/**
* in case of I/O error
*/
public Image(InputStream in) throws IOException {
- this.data = IOUtils.toByteArray(in);
+ data = getTemporaryFile();
+ IOUtils.write(in, data);
}
/**
- * The actual image data.
+ * Generate an {@link InputStream} for this {@link Image}.
+ * <p>
+ * This {@link InputStream} will (always) be a new one, and <b>you</b> are
+ * responsible for it.
* <p>
- * This is the actual data, not a copy, so any change made here will be
- * reflected into the {@link Image} and vice-versa.
+ * Note: take care that the {@link InputStream} <b>must not</b> live past
+ * the {@link Image} life time!
+ *
+ * @return the stream
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ public InputStream newInputStream() throws IOException {
+ return new MarkableFileInputStream(new FileInputStream(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.
*
* @return the image data
*/
public byte[] getData() {
- return data;
+ try {
+ InputStream in = newInputStream();
+ try {
+ return IOUtils.toByteArray(in);
+ } finally {
+ in.close();
+ }
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
}
/**
* 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.
*
* @return the Base64 representation
*/
public String toBase64() {
- return new String(Base64.encodeBytes(getData()));
+ try {
+ return StringUtils.base64(getData(), false);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Closing the {@link Image} will delete the associated temporary file on
+ * disk.
+ * <p>
+ * Note that even if you don't, the program will still <b>try</b> to delete
+ * all the temporary files at JVM termination.
+ */
+ @Override
+ public void close() throws IOException {
+ data.delete();
+ synchronized (lock) {
+ count--;
+ if (count <= 0) {
+ count = 0;
+ tmpRepository.close();
+ tmpRepository = null;
+ }
+ }
+ }
+
+ @Override
+ protected void finalize() throws Throwable {
+ try {
+ close();
+ } finally {
+ super.finalize();
+ }
+ }
+
+ /**
+ * Return a newly created temporary file to work on.
+ *
+ * @return the file
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ private File getTemporaryFile() throws IOException {
+ synchronized (lock) {
+ if (tmpRepository == null) {
+ tmpRepository = new TempFiles(tempRoot, "images");
+ count = 0;
+ }
+
+ count++;
+
+ return tmpRepository.createTempFile("image");
+ }
+ }
+
+ /**
+ * Change the temporary root directory used by the program.
+ * <p>
+ * Caution: the directory will be <b>owned</b> by the system, all its files
+ * now belong to us (and will most probably be deleted).
+ * <p>
+ * Note: it may take some time until the new temporary root is used, we
+ * first need to make sure the previous one is not used anymore (i.e., we
+ * must reach a point where no unclosed {@link Image} remains in memory) to
+ * switch the temporary root.
+ *
+ * @param root
+ * the new temporary root, which will be <b>owned</b> by the
+ * system
+ */
+ public static void setTemporaryFilesRoot(File root) {
+ tempRoot = root;
}
}
git://git.nikiroo.be / nikiroo-utils.git / blobdiff