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 #define BUFF_SIZE 1024
  29 #ifdef _MSC_VER
  30 # ifndef snprintf
  31 #       define snprintf _snprintf
  32 # endif
  33 #endif
  34 int splashIsVisible = 0;
  35 
  36 Splash *
  37 SplashGetInstance()
  38 {
  39     static Splash splash;
  40     static int preInitialized = 0;
  41     if (!preInitialized) {
  42         memset(&splash, 0, sizeof(Splash));
  43         splash.currentFrame = -1;
  44         preInitialized = 1;
  45     }
  46     return &splash;
  47 }
  48 
  49 SPLASHEXPORT void
  50 SplashSetFileJarName(const char* fileName, const char* jarName) {
  51     Splash *splash = SplashGetInstance();
  52 
  53     free(splash->fileName);
  54     splash->fileName = SplashConvertStringAlloc(fileName, &splash->fileNameLen);
  55 
  56     free(splash->jarName);
  57     splash->jarName = SplashConvertStringAlloc(jarName, &splash->jarNameLen);
  58 }
  59 
  60 SPLASHEXPORT void
  61 SplashInit()
  62 {
  63     Splash *splash = SplashGetInstance();
  64 
  65     memset(splash, 0, sizeof(Splash));
  66     splash->currentFrame = -1;
  67     splash->scaleFactor = 1;
  68     initFormat(&splash->imageFormat, QUAD_RED_MASK, QUAD_GREEN_MASK,
  69         QUAD_BLUE_MASK, QUAD_ALPHA_MASK);
  70     SplashInitPlatform(splash);
  71 }
  72 
  73 SPLASHEXPORT void
  74 SplashClose()
  75 {
  76     Splash *splash = SplashGetInstance();
  77 
  78     if (splash->isVisible > 0) {
  79         SplashLock(splash);
  80         splash->isVisible = -1;
  81         SplashClosePlatform(splash);
  82         SplashUnlock(splash);
  83     }
  84 }
  85 
  86 void
  87 SplashCleanup(Splash * splash)
  88 {
  89     int i;
  90 
  91     splash->currentFrame = -1;
  92     SplashCleanupPlatform(splash);
  93     if (splash->frames) {
  94         for (i = 0; i < splash->frameCount; i++) {
  95             if (splash->frames[i].bitmapBits) {
  96                 free(splash->frames[i].bitmapBits);
  97                 splash->frames[i].bitmapBits = NULL;
  98             }
  99         }
 100         free(splash->frames);
 101         splash->frames = NULL;
 102     }
 103     if (splash->overlayData) {
 104         free(splash->overlayData);
 105         splash->overlayData = NULL;
 106     }
 107     SplashSetFileJarName(NULL, NULL);
 108 }
 109 
 110 SPLASHEXPORT void
 111 SplashSetScaleFactor(float scaleFactor)
 112 {
 113     Splash *splash = SplashGetInstance();
 114     splash->scaleFactor = scaleFactor;
 115 }
 116 
 117 void
 118 SplashDone(Splash * splash)
 119 {
 120     SplashCleanup(splash);
 121     SplashDonePlatform(splash);
 122 }
 123 
 124 int
 125 SplashIsStillLooping(Splash * splash)
 126 {
 127     if (splash->currentFrame < 0) {
 128         return 0;
 129     }
 130     return splash->loopCount != 1 ||
 131         splash->currentFrame + 1 < splash->frameCount;
 132 }
 133 
 134 void
 135 SplashUpdateScreenData(Splash * splash)
 136 {
 137     ImageRect srcRect, dstRect;
 138     if (splash->currentFrame < 0) {
 139         return;
 140     }
 141 
 142     initRect(&srcRect, 0, 0, splash->width, splash->height, 1,
 143         splash->width * sizeof(rgbquad_t),
 144         splash->frames[splash->currentFrame].bitmapBits, &splash->imageFormat);
 145     if (splash->screenData) {
 146         free(splash->screenData);
 147     }
 148     splash->screenStride = splash->width * splash->screenFormat.depthBytes;
 149     if (splash->byteAlignment > 1) {
 150         splash->screenStride =
 151             (splash->screenStride + splash->byteAlignment - 1) &
 152             ~(splash->byteAlignment - 1);
 153     }
 154     splash->screenData = malloc(splash->height * splash->screenStride);
 155     initRect(&dstRect, 0, 0, splash->width, splash->height, 1,
 156         splash->screenStride, splash->screenData, &splash->screenFormat);
 157     if (splash->overlayData) {
 158         convertRect2(&srcRect, &dstRect, CVT_BLEND, &splash->overlayRect);
 159     }
 160     else {
 161         convertRect(&srcRect, &dstRect, CVT_COPY);
 162     }
 163 }
 164 
 165 void
 166 SplashNextFrame(Splash * splash)
 167 {
 168     if (splash->currentFrame < 0) {
 169         return;
 170     }
 171     do {
 172         if (!SplashIsStillLooping(splash)) {
 173             return;
 174         }
 175         splash->time += splash->frames[splash->currentFrame].delay;
 176         if (++splash->currentFrame >= splash->frameCount) {
 177             splash->currentFrame = 0;
 178             if (splash->loopCount > 0) {
 179                 splash->loopCount--;
 180             }
 181         }
 182     } while (splash->time + splash->frames[splash->currentFrame].delay -
 183         SplashTime() <= 0);
 184 }
 185 
 186 int
 187 BitmapToYXBandedRectangles(ImageRect * pSrcRect, RECT_T * out)
 188 {
 189     RECT_T *pPrevLine = NULL, *pFirst = out, *pThis = pFirst;
 190     int i, j, i0;
 191     int length;
 192 
 193     for (j = 0; j < pSrcRect->numLines; j++) {
 194 
 195         /* generate data for a scanline */
 196 
 197         byte_t *pSrc = (byte_t *) pSrcRect->pBits + j * pSrcRect->stride;
 198         RECT_T *pLine = pThis;
 199 
 200         i = 0;
 201 
 202         do {
 203             while (i < pSrcRect->numSamples &&
 204                    getRGBA(pSrc, pSrcRect->format) < ALPHA_THRESHOLD) {
 205                 pSrc += pSrcRect->depthBytes;
 206                 ++i;
 207             }
 208             if (i >= pSrcRect->numSamples) {
 209                 break;
 210             }
 211             i0 = i;
 212             while (i < pSrcRect->numSamples &&
 213                    getRGBA(pSrc, pSrcRect->format) >= ALPHA_THRESHOLD) {
 214                 pSrc += pSrcRect->depthBytes;
 215                 ++i;
 216             }
 217             RECT_SET(*pThis, i0, j, i - i0, 1);
 218             ++pThis;
 219         } while (i < pSrcRect->numSamples);
 220 
 221         /*  check if the previous scanline is exactly the same, merge if so
 222            (this is the only optimization we can use for YXBanded rectangles, and win32 supports
 223            YXBanded only */
 224 
 225         length = pThis - pLine;
 226         if (pPrevLine && pLine - pPrevLine == length) {
 227             for (i = 0; i < length && RECT_EQ_X(pPrevLine[i], pLine[i]); ++i) {
 228             }
 229             if (i == pLine - pPrevLine) {
 230                 // do merge
 231                 for (i = 0; i < length; i++) {
 232                     RECT_INC_HEIGHT(pPrevLine[i]);
 233                 }
 234                 pThis = pLine;
 235                 continue;
 236             }
 237         }
 238         /* or else use the generated scanline */
 239 
 240         pPrevLine = pLine;
 241     }
 242     return pThis - pFirst;
 243 }
 244 
 245 typedef struct FILEFORMAT
 246 {
 247     int sign;
 248     int (*decodeStream) (Splash * splash, SplashStream * stream);
 249 } FILEFORMAT;
 250 
 251 static const FILEFORMAT formats[] = {
 252     {0x47, SplashDecodeGifStream},
 253     {0x89, SplashDecodePngStream},
 254     {0xFF, SplashDecodeJpegStream}
 255 };
 256 
 257 static int
 258 SplashLoadStream(SplashStream * stream)
 259 {
 260     int success = 0;
 261     int c;
 262     size_t i;
 263 
 264     Splash *splash = SplashGetInstance();
 265     if (splash->isVisible < 0) {
 266         return 0;
 267     }
 268 
 269     SplashLock(splash);
 270 
 271     /* the formats we support can be easily distinguished by the first byte */
 272     c = stream->peek(stream);
 273     if (c != -1) {
 274         for (i = 0; i < sizeof(formats) / sizeof(FILEFORMAT); i++) {
 275             if (c == formats[i].sign) {
 276                 success = formats[i].decodeStream(splash, stream);
 277                 break;
 278             }
 279         }
 280     }
 281     stream->close(stream);
 282 
 283     if (!success) {             // failed to decode
 284         if (splash->isVisible == 0) {
 285             SplashCleanup(splash);
 286         }
 287         SplashUnlock(splash);   // SplashClose locks
 288         if (splash->isVisible == 0) {
 289             SplashClose();
 290         }
 291     }
 292     else {
 293         splash->currentFrame = 0;
 294         if (splash->isVisible == 0) {
 295             SplashStart(splash);
 296         } else {
 297             SplashReconfigure(splash);
 298             splash->time = SplashTime();
 299         }
 300         SplashUnlock(splash);
 301     }
 302     return success;
 303 }
 304 
 305 SPLASHEXPORT int
 306 SplashLoadFile(const char *filename)
 307 {
 308     SplashStream stream;
 309     return SplashStreamInitFile(&stream, filename) &&
 310                 SplashLoadStream(&stream);
 311 }
 312 
 313 SPLASHEXPORT int
 314 SplashLoadMemory(void *data, int size)
 315 {
 316     SplashStream stream;
 317     return SplashStreamInitMemory(&stream, data, size) &&
 318                 SplashLoadStream(&stream);
 319 }
 320 
 321 /* SplashStart MUST be called from under the lock */
 322 
 323 void
 324 SplashStart(Splash * splash)
 325 {
 326     if (splash->isVisible == 0) {
 327         SplashCreateThread(splash);
 328         splash->isVisible = 1;
 329     }
 330 }
 331 
 332 /* SplashStream functions */
 333 
 334 static int readFile(void* pStream, void* pData, int nBytes) {
 335     FILE* f = ((SplashStream*)pStream)->arg.stdio.f;
 336     return fread(pData, 1, nBytes, f);
 337 }
 338 static int peekFile(void* pStream) {
 339     FILE* f = ((SplashStream*)pStream)->arg.stdio.f;
 340     int c = fgetc(f);
 341     if (c != EOF) {
 342         ungetc(c, f);
 343         return c;
 344     } else {
 345         return -1;
 346     }
 347 }
 348 
 349 static void closeFile(void* pStream) {
 350     FILE* f = ((SplashStream*)pStream)->arg.stdio.f;
 351     fclose(f);
 352 }
 353 
 354 static int readMem(void* pStream, void* pData, int nBytes) {
 355     unsigned char* pSrc = (unsigned char*)(((SplashStream*)pStream)->arg.mem.pData);
 356     unsigned char* pSrcEnd = (unsigned char*)(((SplashStream*)pStream)->arg.mem.pDataEnd);
 357     if (nBytes > pSrcEnd - pSrc) {
 358         nBytes = pSrcEnd - pSrc;
 359     }
 360     if (nBytes>0) {
 361         memcpy(pData, pSrc, nBytes);
 362         pSrc += nBytes;
 363         ((SplashStream*)pStream)->arg.mem.pData = (void*)pSrc;
 364     }
 365     return nBytes;
 366 }
 367 
 368 static int peekMem(void* pStream) {
 369     unsigned char* pSrc = (unsigned char*)(((SplashStream*)pStream)->arg.mem.pData);
 370     unsigned char* pSrcEnd = (unsigned char*)(((SplashStream*)pStream)->arg.mem.pDataEnd);
 371     if (pSrc >= pSrcEnd) {
 372         return -1;
 373     } else {
 374         return (int)*pSrc;
 375     }
 376 }
 377 
 378 static void closeMem(void* pStream) {
 379 }
 380 
 381 int SplashStreamInitFile(SplashStream * pStream, const char* filename) {
 382     pStream->arg.stdio.f = fopen(filename, "rb");
 383     pStream->read = readFile;
 384     pStream->peek = peekFile;
 385     pStream->close = closeFile;
 386     return pStream->arg.stdio.f != 0;
 387 }
 388 
 389 int SplashStreamInitMemory(SplashStream * pStream, void* pData, int size) {
 390     pStream->arg.mem.pData = (unsigned char*)pData;
 391     pStream->arg.mem.pDataEnd = (unsigned char*)pData + size;
 392     pStream->read = readMem;
 393     pStream->peek = peekMem;
 394     pStream->close = closeMem;
 395     return 1;
 396 }
 397 
 398 SPLASHEXPORT int
 399 SplashGetScaledImgNameMaxPstfixLen(const char *fileName){
 400     return strlen(fileName) + strlen("@100pct") + 1;
 401 }
 402 
 403 jboolean GetScaledImageName(const char *fileName, char *scaleImageName,
 404         float *scaleFactor, const size_t scaledImageLength) {
 405     if (*scaleFactor > 1.0) {
 406         FILE *fp = NULL;
 407         char scaledImgPct[BUFF_SIZE];
 408         char scaledImgX[BUFF_SIZE];
 409         char *scaledImageXName = NULL;
 410         char *scaledImagePctName = malloc(scaledImageLength);
 411         char *dupFileName = strdup(fileName);
 412         char *fileExtension = strrchr(dupFileName, '.');
 413         size_t lengthPct = 0;
 414         size_t lengthX = 0;
 415         int retValPct = 0;
 416         int retValX = 0;
 417         jboolean isPctScaledImage = (*scaleFactor * 100) != ((int) (*scaleFactor)) *100;
 418         snprintf(scaledImgPct, BUFF_SIZE, "%s%d%s", "@", (int) (*scaleFactor * 100), "pct");
 419         if (!isPctScaledImage) {
 420             scaledImageXName = malloc(scaledImageLength);
 421             snprintf(scaledImgX, BUFF_SIZE, "%s%d%s", "@", (int) (*scaleFactor), "x");
 422         }
 423         /*File is missing extension */
 424         if (fileExtension == NULL) {
 425             lengthPct = strlen(dupFileName) +
 426                     strlen(scaledImgPct) + 1;
 427             if (!isPctScaledImage) {
 428                 lengthX = strlen(dupFileName) +
 429                     strlen(scaledImgX) + 1;
 430             }
 431             if (lengthPct > scaledImageLength || lengthX > scaledImageLength) {
 432                 cleanUp(dupFileName, scaledImageXName, scaledImagePctName, scaleFactor);
 433                 return JNI_FALSE;
 434             }
 435             retValPct = snprintf(scaledImagePctName, lengthPct, "%s%s", dupFileName,
 436                     scaledImgPct);
 437             if (!isPctScaledImage) {
 438                 retValX = snprintf(scaledImageXName, lengthX, "%s%s", dupFileName,
 439                         scaledImgX);
 440             }
 441             if ((retValPct < 0 || (retValPct > lengthPct - 1)) ||
 442                     (retValX < 0 || (retValX > lengthX - 1))) {
 443                 cleanUp(dupFileName, scaledImageXName, scaledImagePctName, scaleFactor);
 444                 return JNI_FALSE;
 445             }
 446         } else {
 447             int length_Without_Ext = fileExtension - dupFileName;
 448             lengthPct = length_Without_Ext + strlen(scaledImgPct) +
 449                     strlen(fileExtension) + 1;
 450             if (!isPctScaledImage) {
 451                 lengthX = length_Without_Ext + strlen(scaledImgX) +
 452                     strlen(fileExtension) + 1;
 453             }
 454             if (lengthPct > scaledImageLength || lengthX > scaledImageLength) {
 455                 cleanUp(dupFileName, scaledImageXName, scaledImagePctName, scaleFactor);
 456                 return JNI_FALSE;
 457             }
 458             retValPct = snprintf(scaledImagePctName, lengthPct, "%.*s%s%s",
 459                     length_Without_Ext, dupFileName, scaledImgPct, fileExtension);
 460             if(!isPctScaledImage) {
 461                 retValX = snprintf(scaledImageXName, lengthX, "%.*s%s%s",
 462                         length_Without_Ext, dupFileName, scaledImgX, fileExtension);
 463             }
 464             if ((retValPct < 0 || (retValPct > lengthPct - 1)) ||
 465                     (retValX < 0 || (retValX > lengthX - 1))) {
 466                cleanUp(dupFileName, scaledImageXName, scaledImagePctName, scaleFactor);
 467                return JNI_FALSE;
 468             }
 469         }
 470         free(dupFileName);
 471         if (!(fp = fopen(scaledImagePctName, "r"))) {
 472             if (!isPctScaledImage && (fp = fopen(scaledImageXName, "r"))) {
 473                 fclose(fp);
 474                 strcpy(scaleImageName, scaledImageXName);
 475                 free(scaledImageXName);
 476                 free(scaledImagePctName);
 477                 return JNI_TRUE;
 478             }
 479             cleanUp(NULL,scaledImageXName, scaledImagePctName, scaleFactor);
 480             return JNI_FALSE;
 481         }
 482         fclose(fp);
 483         strcpy(scaleImageName, scaledImagePctName);
 484         free(scaledImageXName);
 485         free(scaledImagePctName);
 486         return JNI_TRUE;
 487     }
 488     return JNI_FALSE;
 489 }
 490 
 491 void cleanUp(char *fName, char *xName, char *pctName, float *scaleFactor) {
 492     *scaleFactor = 1;
 493     free(fName);
 494     free(xName);
 495     free(pctName);
 496 }
 497 
--- EOF ---