1 /*
2 * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include "splashscreen_impl.h"
27 #include "splashscreen_gfx_impl.h"
28
29 int splashIsVisible = 0;
30
31 Splash *
32 SplashGetInstance()
33 {
34 static Splash splash;
35 static int preInitialized = 0;
36 if (!preInitialized) {
37 memset(&splash, 0, sizeof(Splash));
38 splash.currentFrame = -1;
39 preInitialized = 1;
40 }
41 return &splash;
42 }
43
44 SPLASHEXPORT void
45 SplashSetFileJarName(const char* fileName, const char* jarName) {
46 Splash *splash = SplashGetInstance();
47
48 free(splash->fileName);
49 splash->fileName = SplashConvertStringAlloc(fileName, &splash->fileNameLen);
50
51 free(splash->jarName);
52 splash->jarName = SplashConvertStringAlloc(jarName, &splash->jarNameLen);
53 }
54
55 SPLASHEXPORT void
56 SplashInit()
57 {
58 Splash *splash = SplashGetInstance();
59
60 memset(splash, 0, sizeof(Splash));
61 splash->currentFrame = -1;
62 splash->scaleFactor = 1;
63 initFormat(&splash->imageFormat, QUAD_RED_MASK, QUAD_GREEN_MASK,
64 QUAD_BLUE_MASK, QUAD_ALPHA_MASK);
65 SplashInitPlatform(splash);
66 }
67
68 SPLASHEXPORT void
69 SplashClose()
70 {
71 Splash *splash = SplashGetInstance();
72
73 if (splash->isVisible > 0) {
74 SplashLock(splash);
75 splash->isVisible = -1;
76 SplashClosePlatform(splash);
77 SplashUnlock(splash);
78 }
79 }
80
81 void
82 SplashCleanup(Splash * splash)
83 {
84 int i;
85
86 splash->currentFrame = -1;
87 SplashCleanupPlatform(splash);
88 if (splash->frames) {
89 for (i = 0; i < splash->frameCount; i++) {
90 if (splash->frames[i].bitmapBits) {
91 free(splash->frames[i].bitmapBits);
92 splash->frames[i].bitmapBits = NULL;
93 }
94 }
95 free(splash->frames);
96 splash->frames = NULL;
97 }
98 if (splash->overlayData) {
99 free(splash->overlayData);
100 splash->overlayData = NULL;
101 }
102 SplashSetFileJarName(NULL, NULL);
103 }
104
105 SPLASHEXPORT void
106 SplashSetScaleFactor(float scaleFactor)
107 {
108 Splash *splash = SplashGetInstance();
109 splash->scaleFactor = scaleFactor;
110 }
111
112 void
113 SplashDone(Splash * splash)
114 {
115 SplashCleanup(splash);
116 SplashDonePlatform(splash);
117 }
118
119 int
120 SplashIsStillLooping(Splash * splash)
121 {
122 if (splash->currentFrame < 0) {
123 return 0;
124 }
125 return splash->loopCount != 1 ||
126 splash->currentFrame + 1 < splash->frameCount;
127 }
128
129 void
130 SplashUpdateScreenData(Splash * splash)
131 {
132 ImageRect srcRect, dstRect;
133 if (splash->currentFrame < 0) {
134 return;
135 }
136
137 initRect(&srcRect, 0, 0, splash->width, splash->height, 1,
138 splash->width * sizeof(rgbquad_t),
139 splash->frames[splash->currentFrame].bitmapBits, &splash->imageFormat);
140 if (splash->screenData) {
141 free(splash->screenData);
142 }
143 splash->screenStride = splash->width * splash->screenFormat.depthBytes;
144 if (splash->byteAlignment > 1) {
145 splash->screenStride =
146 (splash->screenStride + splash->byteAlignment - 1) &
147 ~(splash->byteAlignment - 1);
148 }
149 splash->screenData = malloc(splash->height * splash->screenStride);
150 initRect(&dstRect, 0, 0, splash->width, splash->height, 1,
151 splash->screenStride, splash->screenData, &splash->screenFormat);
152 if (splash->overlayData) {
153 convertRect2(&srcRect, &dstRect, CVT_BLEND, &splash->overlayRect);
154 }
155 else {
156 convertRect(&srcRect, &dstRect, CVT_COPY);
157 }
158 }
159
160 void
161 SplashNextFrame(Splash * splash)
162 {
163 if (splash->currentFrame < 0) {
164 return;
165 }
166 do {
167 if (!SplashIsStillLooping(splash)) {
168 return;
169 }
170 splash->time += splash->frames[splash->currentFrame].delay;
171 if (++splash->currentFrame >= splash->frameCount) {
172 splash->currentFrame = 0;
173 if (splash->loopCount > 0) {
174 splash->loopCount--;
175 }
176 }
177 } while (splash->time + splash->frames[splash->currentFrame].delay -
178 SplashTime() <= 0);
179 }
180
181 int
182 BitmapToYXBandedRectangles(ImageRect * pSrcRect, RECT_T * out)
183 {
184 RECT_T *pPrevLine = NULL, *pFirst = out, *pThis = pFirst;
185 int i, j, i0;
186 int length;
187
188 for (j = 0; j < pSrcRect->numLines; j++) {
189
190 /* generate data for a scanline */
191
192 byte_t *pSrc = (byte_t *) pSrcRect->pBits + j * pSrcRect->stride;
193 RECT_T *pLine = pThis;
194
195 i = 0;
196
197 do {
198 while (i < pSrcRect->numSamples &&
199 getRGBA(pSrc, pSrcRect->format) < ALPHA_THRESHOLD) {
200 pSrc += pSrcRect->depthBytes;
201 ++i;
202 }
203 if (i >= pSrcRect->numSamples) {
204 break;
205 }
206 i0 = i;
207 while (i < pSrcRect->numSamples &&
208 getRGBA(pSrc, pSrcRect->format) >= ALPHA_THRESHOLD) {
209 pSrc += pSrcRect->depthBytes;
210 ++i;
211 }
212 RECT_SET(*pThis, i0, j, i - i0, 1);
213 ++pThis;
214 } while (i < pSrcRect->numSamples);
215
216 /* check if the previous scanline is exactly the same, merge if so
217 (this is the only optimization we can use for YXBanded rectangles, and win32 supports
218 YXBanded only */
219
220 length = pThis - pLine;
221 if (pPrevLine && pLine - pPrevLine == length) {
222 for (i = 0; i < length && RECT_EQ_X(pPrevLine[i], pLine[i]); ++i) {
223 }
224 if (i == pLine - pPrevLine) {
225 // do merge
226 for (i = 0; i < length; i++) {
227 RECT_INC_HEIGHT(pPrevLine[i]);
228 }
229 pThis = pLine;
230 continue;
231 }
232 }
233 /* or else use the generated scanline */
234
235 pPrevLine = pLine;
236 }
237 return pThis - pFirst;
238 }
239
240 typedef struct FILEFORMAT
241 {
242 int sign;
243 int (*decodeStream) (Splash * splash, SplashStream * stream);
244 } FILEFORMAT;
245
246 static const FILEFORMAT formats[] = {
247 {0x47, SplashDecodeGifStream},
248 {0x89, SplashDecodePngStream},
249 {0xFF, SplashDecodeJpegStream}
250 };
251
252 static int
253 SplashLoadStream(SplashStream * stream)
254 {
255 int success = 0;
256 int c;
257 size_t i;
258
259 Splash *splash = SplashGetInstance();
260 if (splash->isVisible < 0) {
261 return 0;
262 }
263
264 SplashLock(splash);
265
266 /* the formats we support can be easily distinguished by the first byte */
267 c = stream->peek(stream);
268 if (c != -1) {
269 for (i = 0; i < sizeof(formats) / sizeof(FILEFORMAT); i++) {
270 if (c == formats[i].sign) {
271 success = formats[i].decodeStream(splash, stream);
272 break;
273 }
274 }
275 }
276 stream->close(stream);
277
278 if (!success) { // failed to decode
279 if (splash->isVisible == 0) {
280 SplashCleanup(splash);
281 }
282 SplashUnlock(splash); // SplashClose locks
283 if (splash->isVisible == 0) {
284 SplashClose();
285 }
286 }
287 else {
288 splash->currentFrame = 0;
289 if (splash->isVisible == 0) {
290 SplashStart(splash);
291 } else {
292 SplashReconfigure(splash);
293 splash->time = SplashTime();
294 }
295 SplashUnlock(splash);
296 }
297 return success;
298 }
299
300 SPLASHEXPORT int
301 SplashLoadFile(const char *filename)
302 {
303 SplashStream stream;
304 return SplashStreamInitFile(&stream, filename) &&
305 SplashLoadStream(&stream);
306 }
307
308 SPLASHEXPORT int
309 SplashLoadMemory(void *data, int size)
310 {
311 SplashStream stream;
312 return SplashStreamInitMemory(&stream, data, size) &&
313 SplashLoadStream(&stream);
314 }
315
316 /* SplashStart MUST be called from under the lock */
317
318 void
319 SplashStart(Splash * splash)
320 {
321 if (splash->isVisible == 0) {
322 SplashCreateThread(splash);
323 splash->isVisible = 1;
324 }
325 }
326
327 /* SplashStream functions */
328
329 static int readFile(void* pStream, void* pData, int nBytes) {
330 FILE* f = ((SplashStream*)pStream)->arg.stdio.f;
331 return fread(pData, 1, nBytes, f);
332 }
333 static int peekFile(void* pStream) {
334 FILE* f = ((SplashStream*)pStream)->arg.stdio.f;
335 int c = fgetc(f);
336 if (c != EOF) {
337 ungetc(c, f);
338 return c;
339 } else {
340 return -1;
341 }
342 }
343
344 static void closeFile(void* pStream) {
345 FILE* f = ((SplashStream*)pStream)->arg.stdio.f;
346 fclose(f);
347 }
348
349 static int readMem(void* pStream, void* pData, int nBytes) {
350 unsigned char* pSrc = (unsigned char*)(((SplashStream*)pStream)->arg.mem.pData);
351 unsigned char* pSrcEnd = (unsigned char*)(((SplashStream*)pStream)->arg.mem.pDataEnd);
352 if (nBytes > pSrcEnd - pSrc) {
353 nBytes = pSrcEnd - pSrc;
354 }
355 if (nBytes>0) {
356 memcpy(pData, pSrc, nBytes);
357 pSrc += nBytes;
358 ((SplashStream*)pStream)->arg.mem.pData = (void*)pSrc;
359 }
360 return nBytes;
361 }
362
363 static int peekMem(void* pStream) {
364 unsigned char* pSrc = (unsigned char*)(((SplashStream*)pStream)->arg.mem.pData);
365 unsigned char* pSrcEnd = (unsigned char*)(((SplashStream*)pStream)->arg.mem.pDataEnd);
366 if (pSrc >= pSrcEnd) {
367 return -1;
368 } else {
369 return (int)*pSrc;
370 }
371 }
372
373 static void closeMem(void* pStream) {
374 }
375
376 int SplashStreamInitFile(SplashStream * pStream, const char* filename) {
377 pStream->arg.stdio.f = fopen(filename, "rb");
378 pStream->read = readFile;
379 pStream->peek = peekFile;
380 pStream->close = closeFile;
381 return pStream->arg.stdio.f != 0;
382 }
383
384 int SplashStreamInitMemory(SplashStream * pStream, void* pData, int size) {
385 pStream->arg.mem.pData = (unsigned char*)pData;
386 pStream->arg.mem.pDataEnd = (unsigned char*)pData + size;
387 pStream->read = readMem;
388 pStream->peek = peekMem;
389 pStream->close = closeMem;
390 return 1;
391 }