1/*
2 * Copyright (c) 2005, 2011, 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
28#include <png.h>
29
30#include <setjmp.h>
31
32#define SIG_BYTES 8
33
34void PNGAPI
35my_png_read_stream(png_structp png_ptr, png_bytep data, png_size_t length)
36{
37    png_uint_32 check;
38
39    SplashStream * stream = (SplashStream*)png_get_io_ptr(png_ptr);
40    check = stream->read(stream, data, length);
41    if (check != length)
42        png_error(png_ptr, "Read Error");
43}
44
45int
46SplashDecodePng(Splash * splash, png_rw_ptr read_func, void *io_ptr)
47{
48    int stride;
49    ImageFormat srcFormat;
50    png_uint_32 i, rowbytes;
51    volatile png_bytepp row_pointers = NULL;
52    volatile png_bytep image_data = NULL;
53    int success = 0;
54    double gamma;
55
56    png_structp png_ptr = NULL;
57    png_infop info_ptr = NULL;
58
59    png_uint_32 width, height;
60    int bit_depth, color_type;
61
62    ImageRect srcRect, dstRect;
63
64    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
65    if (!png_ptr) {
66        goto done;
67    }
68
69    info_ptr = png_create_info_struct(png_ptr);
70    if (!info_ptr) {
71        goto done;
72    }
73
74#ifdef __APPLE__
75    /* use setjmp/longjmp versions that do not save/restore the signal mask */
76    if (_setjmp(png_set_longjmp_fn(png_ptr, _longjmp, sizeof(jmp_buf)))) {
77#else
78    if (setjmp(png_jmpbuf(png_ptr))) {
79#endif
80        goto done;
81    }
82
83    png_set_read_fn(png_ptr, io_ptr, read_func);
84
85    png_set_sig_bytes(png_ptr, SIG_BYTES);      /* we already read the 8 signature bytes */
86
87    png_read_info(png_ptr, info_ptr);   /* read all PNG info up to image data */
88
89    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
90        NULL, NULL, NULL);
91
92    /* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
93     * transparency chunks to full alpha channel; strip 16-bit-per-sample
94     * images to 8 bits per sample; and convert grayscale to RGB[A]
95     * this may be sub-optimal but this simplifies implementation */
96
97    png_set_expand(png_ptr);
98    png_set_tRNS_to_alpha(png_ptr);
99    png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
100    png_set_strip_16(png_ptr);
101    png_set_gray_to_rgb(png_ptr);
102
103    if (png_get_gAMA(png_ptr, info_ptr, &gamma))
104        png_set_gamma(png_ptr, 2.2, gamma);
105
106    png_set_interlace_handling(png_ptr);
107    png_read_update_info(png_ptr, info_ptr);
108
109    rowbytes = png_get_rowbytes(png_ptr, info_ptr);
110
111    if (!SAFE_TO_ALLOC(rowbytes, height)) {
112        goto done;
113    }
114
115    if ((image_data = (unsigned char *) malloc(rowbytes * height)) == NULL) {
116        goto done;
117    }
118
119    if (!SAFE_TO_ALLOC(height, sizeof(png_bytep))) {
120        goto done;
121    }
122    if ((row_pointers = (png_bytepp) malloc(height * sizeof(png_bytep)))
123            == NULL) {
124        goto done;
125    }
126
127    for (i = 0; i < height; ++i)
128        row_pointers[i] = image_data + i * rowbytes;
129
130    png_read_image(png_ptr, row_pointers);
131
132    SplashCleanup(splash);
133
134    splash->width = width;
135    splash->height = height;
136
137    if (!SAFE_TO_ALLOC(splash->width, splash->imageFormat.depthBytes)) {
138        goto done;
139    }
140    stride = splash->width * splash->imageFormat.depthBytes;
141
142    if (!SAFE_TO_ALLOC(splash->height, stride)) {
143        goto done;
144    }
145    splash->frameCount = 1;
146    splash->frames = (SplashImage *)
147        malloc(sizeof(SplashImage) * splash->frameCount);
148
149    if (splash->frames == NULL) {
150        goto done;
151    }
152
153    splash->loopCount = 1;
154    splash->frames[0].bitmapBits = malloc(stride * splash->height);
155    if (splash->frames[0].bitmapBits == NULL) {
156        free(splash->frames);
157        goto done;
158    }
159    splash->frames[0].delay = 0;
160
161    /* FIXME: sort out the real format */
162    initFormat(&srcFormat, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
163    srcFormat.byteOrder = BYTE_ORDER_MSBFIRST;
164
165    initRect(&srcRect, 0, 0, width, height, 1, rowbytes,
166        image_data, &srcFormat);
167    initRect(&dstRect, 0, 0, width, height, 1, stride,
168        splash->frames[0].bitmapBits, &splash->imageFormat);
169    convertRect(&srcRect, &dstRect, CVT_COPY);
170
171    SplashInitFrameShape(splash, 0);
172
173    png_read_end(png_ptr, NULL);
174    success = 1;
175
176  done:
177    free(row_pointers);
178    free(image_data);
179    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
180    return success;
181}
182
183int
184SplashDecodePngStream(Splash * splash, SplashStream * stream)
185{
186    unsigned char sig[SIG_BYTES];
187    int success = 0;
188
189    stream->read(stream, sig, SIG_BYTES);
190    if (png_sig_cmp(sig, 0, SIG_BYTES)) {
191        goto done;
192    }
193    success = SplashDecodePng(splash, my_png_read_stream, stream);
194
195  done:
196    return success;
197}
198