Merge branch 'subtree'
[fanfix.git] / src / be / nikiroo / utils / Image.java
... / ...
CommitLineData
1package be.nikiroo.utils;
2
3import java.io.ByteArrayInputStream;
4import java.io.Closeable;
5import java.io.File;
6import java.io.IOException;
7import java.io.InputStream;
8import java.io.ObjectInputStream;
9import java.io.ObjectOutputStream;
10import java.io.OutputStream;
11import java.io.Serializable;
12
13import be.nikiroo.utils.streams.Base64InputStream;
14import be.nikiroo.utils.streams.MarkableFileInputStream;
15
16/**
17 * This class represents an image data.
18 *
19 * @author niki
20 */
21public class Image implements Closeable, Serializable {
22 static private final long serialVersionUID = 1L;
23
24 static private File tempRoot;
25 static private TempFiles tmpRepository;
26 static private long count = 0;
27 static private Object lock = new Object();
28
29 private Object instanceLock = new Object();
30 private File data;
31 private long size;
32
33 /**
34 * Do not use -- for serialisation purposes only.
35 */
36 @SuppressWarnings("unused")
37 private Image() {
38 }
39
40 /**
41 * Create a new {@link Image} with the given data.
42 *
43 * @param data
44 * the data
45 */
46 public Image(byte[] data) {
47 ByteArrayInputStream in = new ByteArrayInputStream(data);
48 try {
49 this.data = getTemporaryFile();
50 size = IOUtils.write(in, this.data);
51 } catch (IOException e) {
52 throw new RuntimeException(e);
53 } finally {
54 try {
55 in.close();
56 } catch (IOException e) {
57 throw new RuntimeException(e);
58 }
59 }
60 }
61
62 /**
63 * Create an image from Base64 encoded data.
64 *
65 * <p>
66 * Please use {@link Image#Image(InputStream)} when possible instead, with a
67 * {@link Base64InputStream}; it can be much more efficient.
68 *
69 * @param base64EncodedData
70 * the Base64 encoded data as a String
71 *
72 * @throws IOException
73 * in case of I/O error or badly formated Base64
74 */
75 public Image(String base64EncodedData) throws IOException {
76 this(new Base64InputStream(new ByteArrayInputStream(
77 StringUtils.getBytes(base64EncodedData)), false));
78 }
79
80 /**
81 * Create a new {@link Image} from a stream.
82 *
83 * @param in
84 * the stream
85 *
86 * @throws IOException
87 * in case of I/O error
88 */
89 public Image(InputStream in) throws IOException {
90 data = getTemporaryFile();
91 size = IOUtils.write(in, data);
92 }
93
94 /**
95 * The size of the enclosed image in bytes.
96 *
97 * @return the size
98 */
99 public long getSize() {
100 return size;
101 }
102
103 /**
104 * Generate an {@link InputStream} that you can {@link InputStream#reset()}
105 * for this {@link Image}.
106 * <p>
107 * This {@link InputStream} will (always) be a new one, and <b>you</b> are
108 * responsible for it.
109 * <p>
110 * Note: take care that the {@link InputStream} <b>must not</b> live past
111 * the {@link Image} life time!
112 *
113 * @return the stream
114 *
115 * @throws IOException
116 * in case of I/O error
117 */
118 public InputStream newInputStream() throws IOException {
119 return new MarkableFileInputStream(data);
120 }
121
122 /**
123 * <b>Read</b> the actual image data, as a byte array.
124 *
125 * @deprecated if possible, prefer the {@link Image#newInputStream()}
126 * method, as it can be more efficient
127 *
128 * @return the image data
129 */
130 @Deprecated
131 public byte[] getData() {
132 try {
133 InputStream in = newInputStream();
134 try {
135 return IOUtils.toByteArray(in);
136 } finally {
137 in.close();
138 }
139 } catch (IOException e) {
140 throw new RuntimeException(e);
141 }
142 }
143
144 /**
145 * Convert the given {@link Image} object into a Base64 representation of
146 * the same {@link Image} object.
147 *
148 * @deprecated Please use {@link Image#newInputStream()} instead, it is more
149 * efficient
150 *
151 * @return the Base64 representation
152 */
153 @Deprecated
154 public String toBase64() {
155 try {
156 Base64InputStream stream = new Base64InputStream(newInputStream(),
157 true);
158 try {
159 return IOUtils.readSmallStream(stream);
160 } finally {
161 stream.close();
162 }
163 } catch (IOException e) {
164 return null;
165 }
166 }
167
168 /**
169 * Closing the {@link Image} will delete the associated temporary file on
170 * disk.
171 * <p>
172 * Note that even if you don't, the program will still <b>try</b> to delete
173 * all the temporary files at JVM termination.
174 */
175 @Override
176 public void close() throws IOException {
177 synchronized (instanceLock) {
178 if (size >= 0) {
179 size = -1;
180 data.delete();
181 data = null;
182
183 synchronized (lock) {
184 count--;
185 if (count <= 0) {
186 count = 0;
187 tmpRepository.close();
188 tmpRepository = null;
189 }
190 }
191 }
192 }
193 }
194
195 @Override
196 protected void finalize() throws Throwable {
197 try {
198 close();
199 } finally {
200 super.finalize();
201 }
202 }
203
204 /**
205 * Return a newly created temporary file to work on.
206 *
207 * @return the file
208 *
209 * @throws IOException
210 * in case of I/O error
211 */
212 private File getTemporaryFile() throws IOException {
213 synchronized (lock) {
214 if (tmpRepository == null) {
215 tmpRepository = new TempFiles(tempRoot, "images");
216 count = 0;
217 }
218
219 count++;
220
221 return tmpRepository.createTempFile("image");
222 }
223 }
224
225 /**
226 * Write this {@link Image} for serialization purposes; that is, write the
227 * content of the backing temporary file.
228 *
229 * @param out
230 * the {@link OutputStream} to write to
231 *
232 * @throws IOException
233 * in case of I/O error
234 */
235 private void writeObject(ObjectOutputStream out) throws IOException {
236 InputStream in = newInputStream();
237 try {
238 IOUtils.write(in, out);
239 } finally {
240 in.close();
241 }
242 }
243
244 /**
245 * Read an {@link Image} written by
246 * {@link Image#writeObject(java.io.ObjectOutputStream)}; that is, create a
247 * new temporary file with the saved content.
248 *
249 * @param in
250 * the {@link InputStream} to read from
251 * @throws IOException
252 * in case of I/O error
253 * @throws ClassNotFoundException
254 * will not be thrown by this method
255 */
256 @SuppressWarnings("unused")
257 private void readObject(ObjectInputStream in) throws IOException,
258 ClassNotFoundException {
259 data = getTemporaryFile();
260 IOUtils.write(in, data);
261 }
262
263 /**
264 * Change the temporary root directory used by the program.
265 * <p>
266 * Caution: the directory will be <b>owned</b> by the system, all its files
267 * now belong to us (and will most probably be deleted).
268 * <p>
269 * Note: it may take some time until the new temporary root is used, we
270 * first need to make sure the previous one is not used anymore (i.e., we
271 * must reach a point where no unclosed {@link Image} remains in memory) to
272 * switch the temporary root.
273 *
274 * @param root
275 * the new temporary root, which will be <b>owned</b> by the
276 * system
277 */
278 public static void setTemporaryFilesRoot(File root) {
279 tempRoot = root;
280 }
281}