Cleanup: Get this rid of "this->" in fpdfsdk/
[pdfium.git] / samples / fx_lpng / lpng_v163 / fx_pngread.c
1 /* pngread.c - read a PNG file\r
2  *\r
3  * Last changed in libpng 1.6.1 [March 28, 2013]\r
4  * Copyright (c) 1998-2013 Glenn Randers-Pehrson\r
5  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
6  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
7  *\r
8  * This code is released under the libpng license.\r
9  * For conditions of distribution and use, see the disclaimer\r
10  * and license in png.h\r
11  *\r
12  * This file contains routines that an application calls directly to\r
13  * read a PNG file or stream.\r
14  */\r
15 \r
16 #include "pngpriv.h"\r
17 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)\r
18 #  include <errno.h>\r
19 #endif\r
20 \r
21 #ifdef PNG_READ_SUPPORTED\r
22 \r
23 /* Create a PNG structure for reading, and allocate any memory needed. */\r
24 PNG_FUNCTION(png_structp,PNGAPI\r
25 png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,\r
26     png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)\r
27 {\r
28 #ifndef PNG_USER_MEM_SUPPORTED\r
29    png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,\r
30       error_fn, warn_fn, NULL, NULL, NULL);\r
31 #else\r
32    return png_create_read_struct_2(user_png_ver, error_ptr, error_fn,\r
33        warn_fn, NULL, NULL, NULL);\r
34 }\r
35 \r
36 /* Alternate create PNG structure for reading, and allocate any memory\r
37  * needed.\r
38  */\r
39 PNG_FUNCTION(png_structp,PNGAPI\r
40 png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,\r
41     png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,\r
42     png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)\r
43 {\r
44    png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,\r
45       error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);\r
46 #endif /* PNG_USER_MEM_SUPPORTED */\r
47 \r
48    if (png_ptr != NULL)\r
49    {\r
50       png_ptr->mode = PNG_IS_READ_STRUCT;\r
51 \r
52       /* Added in libpng-1.6.0; this can be used to detect a read structure if\r
53        * required (it will be zero in a write structure.)\r
54        */\r
55 #     ifdef PNG_SEQUENTIAL_READ_SUPPORTED\r
56          png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE;\r
57 #     endif\r
58 \r
59 #     ifdef PNG_BENIGN_READ_ERRORS_SUPPORTED\r
60          png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;\r
61 \r
62          /* In stable builds only warn if an application error can be completely\r
63           * handled.\r
64           */\r
65 #        if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC\r
66             png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;\r
67 #        endif\r
68 #     endif\r
69 \r
70       /* TODO: delay this, it can be done in png_init_io (if the app doesn't\r
71        * do it itself) avoiding setting the default function if it is not\r
72        * required.\r
73        */\r
74       png_set_read_fn(png_ptr, NULL, NULL);\r
75    }\r
76 \r
77    return png_ptr;\r
78 }\r
79 \r
80 \r
81 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED\r
82 /* Read the information before the actual image data.  This has been\r
83  * changed in v0.90 to allow reading a file that already has the magic\r
84  * bytes read from the stream.  You can tell libpng how many bytes have\r
85  * been read from the beginning of the stream (up to the maximum of 8)\r
86  * via png_set_sig_bytes(), and we will only check the remaining bytes\r
87  * here.  The application can then have access to the signature bytes we\r
88  * read if it is determined that this isn't a valid PNG file.\r
89  */\r
90 void PNGAPI\r
91 png_read_info(png_structrp png_ptr, png_inforp info_ptr)\r
92 {\r
93 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
94    int keep;\r
95 #endif\r
96 \r
97    png_debug(1, "in png_read_info");\r
98 \r
99    if (png_ptr == NULL || info_ptr == NULL)\r
100       return;\r
101 \r
102    /* Read and check the PNG file signature. */\r
103    png_read_sig(png_ptr, info_ptr);\r
104 \r
105    for (;;)\r
106    {\r
107       png_uint_32 length = png_read_chunk_header(png_ptr);\r
108       png_uint_32 chunk_name = png_ptr->chunk_name;\r
109 \r
110       /* IDAT logic needs to happen here to simplify getting the two flags\r
111        * right.\r
112        */\r
113       if (chunk_name == png_IDAT)\r
114       {\r
115          if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
116             png_chunk_error(png_ptr, "Missing IHDR before IDAT");\r
117 \r
118          else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&\r
119              !(png_ptr->mode & PNG_HAVE_PLTE))\r
120             png_chunk_error(png_ptr, "Missing PLTE before IDAT");\r
121 \r
122          else if (png_ptr->mode & PNG_AFTER_IDAT)\r
123             png_chunk_benign_error(png_ptr, "Too many IDATs found");\r
124 \r
125          png_ptr->mode |= PNG_HAVE_IDAT;\r
126       }\r
127 \r
128       else if (png_ptr->mode & PNG_HAVE_IDAT)\r
129          png_ptr->mode |= PNG_AFTER_IDAT;\r
130 \r
131       /* This should be a binary subdivision search or a hash for\r
132        * matching the chunk name rather than a linear search.\r
133        */\r
134       if (chunk_name == png_IHDR)\r
135          png_handle_IHDR(png_ptr, info_ptr, length);\r
136 \r
137       else if (chunk_name == png_IEND)\r
138          png_handle_IEND(png_ptr, info_ptr, length);\r
139 \r
140 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
141       else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)\r
142       {\r
143          png_handle_unknown(png_ptr, info_ptr, length, keep);\r
144 \r
145          if (chunk_name == png_PLTE)\r
146             png_ptr->mode |= PNG_HAVE_PLTE;\r
147 \r
148          else if (chunk_name == png_IDAT)\r
149          {\r
150             png_ptr->idat_size = 0; /* It has been consumed */\r
151             break;\r
152          }\r
153       }\r
154 #endif\r
155       else if (chunk_name == png_PLTE)\r
156          png_handle_PLTE(png_ptr, info_ptr, length);\r
157 \r
158       else if (chunk_name == png_IDAT)\r
159       {\r
160          png_ptr->idat_size = length;\r
161          break;\r
162       }\r
163 \r
164 #ifdef PNG_READ_bKGD_SUPPORTED\r
165       else if (chunk_name == png_bKGD)\r
166          png_handle_bKGD(png_ptr, info_ptr, length);\r
167 #endif\r
168 \r
169 #ifdef PNG_READ_cHRM_SUPPORTED\r
170       else if (chunk_name == png_cHRM)\r
171          png_handle_cHRM(png_ptr, info_ptr, length);\r
172 #endif\r
173 \r
174 #ifdef PNG_READ_gAMA_SUPPORTED\r
175       else if (chunk_name == png_gAMA)\r
176          png_handle_gAMA(png_ptr, info_ptr, length);\r
177 #endif\r
178 \r
179 #ifdef PNG_READ_hIST_SUPPORTED\r
180       else if (chunk_name == png_hIST)\r
181          png_handle_hIST(png_ptr, info_ptr, length);\r
182 #endif\r
183 \r
184 #ifdef PNG_READ_oFFs_SUPPORTED\r
185       else if (chunk_name == png_oFFs)\r
186          png_handle_oFFs(png_ptr, info_ptr, length);\r
187 #endif\r
188 \r
189 #ifdef PNG_READ_pCAL_SUPPORTED\r
190       else if (chunk_name == png_pCAL)\r
191          png_handle_pCAL(png_ptr, info_ptr, length);\r
192 #endif\r
193 \r
194 #ifdef PNG_READ_sCAL_SUPPORTED\r
195       else if (chunk_name == png_sCAL)\r
196          png_handle_sCAL(png_ptr, info_ptr, length);\r
197 #endif\r
198 \r
199 #ifdef PNG_READ_pHYs_SUPPORTED\r
200       else if (chunk_name == png_pHYs)\r
201          png_handle_pHYs(png_ptr, info_ptr, length);\r
202 #endif\r
203 \r
204 #ifdef PNG_READ_sBIT_SUPPORTED\r
205       else if (chunk_name == png_sBIT)\r
206          png_handle_sBIT(png_ptr, info_ptr, length);\r
207 #endif\r
208 \r
209 #ifdef PNG_READ_sRGB_SUPPORTED\r
210       else if (chunk_name == png_sRGB)\r
211          png_handle_sRGB(png_ptr, info_ptr, length);\r
212 #endif\r
213 \r
214 #ifdef PNG_READ_iCCP_SUPPORTED\r
215       else if (chunk_name == png_iCCP)\r
216          png_handle_iCCP(png_ptr, info_ptr, length);\r
217 #endif\r
218 \r
219 #ifdef PNG_READ_sPLT_SUPPORTED\r
220       else if (chunk_name == png_sPLT)\r
221          png_handle_sPLT(png_ptr, info_ptr, length);\r
222 #endif\r
223 \r
224 #ifdef PNG_READ_tEXt_SUPPORTED\r
225       else if (chunk_name == png_tEXt)\r
226          png_handle_tEXt(png_ptr, info_ptr, length);\r
227 #endif\r
228 \r
229 #ifdef PNG_READ_tIME_SUPPORTED\r
230       else if (chunk_name == png_tIME)\r
231          png_handle_tIME(png_ptr, info_ptr, length);\r
232 #endif\r
233 \r
234 #ifdef PNG_READ_tRNS_SUPPORTED\r
235       else if (chunk_name == png_tRNS)\r
236          png_handle_tRNS(png_ptr, info_ptr, length);\r
237 #endif\r
238 \r
239 #ifdef PNG_READ_zTXt_SUPPORTED\r
240       else if (chunk_name == png_zTXt)\r
241          png_handle_zTXt(png_ptr, info_ptr, length);\r
242 #endif\r
243 \r
244 #ifdef PNG_READ_iTXt_SUPPORTED\r
245       else if (chunk_name == png_iTXt)\r
246          png_handle_iTXt(png_ptr, info_ptr, length);\r
247 #endif\r
248 \r
249       else\r
250          png_handle_unknown(png_ptr, info_ptr, length,\r
251             PNG_HANDLE_CHUNK_AS_DEFAULT);\r
252    }\r
253 }\r
254 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */\r
255 \r
256 /* Optional call to update the users info_ptr structure */\r
257 void PNGAPI\r
258 png_read_update_info(png_structrp png_ptr, png_inforp info_ptr)\r
259 {\r
260    png_debug(1, "in png_read_update_info");\r
261 \r
262    if (png_ptr != NULL)\r
263    {\r
264       if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)\r
265       {\r
266          png_read_start_row(png_ptr);\r
267 \r
268 #        ifdef PNG_READ_TRANSFORMS_SUPPORTED\r
269             png_read_transform_info(png_ptr, info_ptr);\r
270 #        else\r
271             PNG_UNUSED(info_ptr)\r
272 #        endif\r
273       }\r
274 \r
275       /* New in 1.6.0 this avoids the bug of doing the initializations twice */\r
276       else\r
277          png_app_error(png_ptr,\r
278             "png_read_update_info/png_start_read_image: duplicate call");\r
279    }\r
280 }\r
281 \r
282 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED\r
283 /* Initialize palette, background, etc, after transformations\r
284  * are set, but before any reading takes place.  This allows\r
285  * the user to obtain a gamma-corrected palette, for example.\r
286  * If the user doesn't call this, we will do it ourselves.\r
287  */\r
288 void PNGAPI\r
289 png_start_read_image(png_structrp png_ptr)\r
290 {\r
291    png_debug(1, "in png_start_read_image");\r
292 \r
293    if (png_ptr != NULL)\r
294    {\r
295       if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)\r
296          png_read_start_row(png_ptr);\r
297 \r
298       /* New in 1.6.0 this avoids the bug of doing the initializations twice */\r
299       else\r
300          png_app_error(png_ptr,\r
301             "png_start_read_image/png_read_update_info: duplicate call");\r
302    }\r
303 }\r
304 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */\r
305 \r
306 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED\r
307 void PNGAPI\r
308 png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)\r
309 {\r
310    png_row_info row_info;\r
311 \r
312    if (png_ptr == NULL)\r
313       return;\r
314 \r
315    png_debug2(1, "in png_read_row (row %lu, pass %d)",\r
316        (unsigned long)png_ptr->row_number, png_ptr->pass);\r
317 \r
318    /* png_read_start_row sets the information (in particular iwidth) for this\r
319     * interlace pass.\r
320     */\r
321    if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))\r
322       png_read_start_row(png_ptr);\r
323 \r
324    /* 1.5.6: row_info moved out of png_struct to a local here. */\r
325    row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */\r
326    row_info.color_type = png_ptr->color_type;\r
327    row_info.bit_depth = png_ptr->bit_depth;\r
328    row_info.channels = png_ptr->channels;\r
329    row_info.pixel_depth = png_ptr->pixel_depth;\r
330    row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);\r
331 \r
332    if (png_ptr->row_number == 0 && png_ptr->pass == 0)\r
333    {\r
334    /* Check for transforms that have been set but were defined out */\r
335 #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)\r
336    if (png_ptr->transformations & PNG_INVERT_MONO)\r
337       png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");\r
338 #endif\r
339 \r
340 #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)\r
341    if (png_ptr->transformations & PNG_FILLER)\r
342       png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");\r
343 #endif\r
344 \r
345 #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \\r
346     !defined(PNG_READ_PACKSWAP_SUPPORTED)\r
347    if (png_ptr->transformations & PNG_PACKSWAP)\r
348       png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");\r
349 #endif\r
350 \r
351 #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)\r
352    if (png_ptr->transformations & PNG_PACK)\r
353       png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");\r
354 #endif\r
355 \r
356 #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)\r
357    if (png_ptr->transformations & PNG_SHIFT)\r
358       png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");\r
359 #endif\r
360 \r
361 #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)\r
362    if (png_ptr->transformations & PNG_BGR)\r
363       png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");\r
364 #endif\r
365 \r
366 #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)\r
367    if (png_ptr->transformations & PNG_SWAP_BYTES)\r
368       png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");\r
369 #endif\r
370    }\r
371 \r
372 #ifdef PNG_READ_INTERLACING_SUPPORTED\r
373    /* If interlaced and we do not need a new row, combine row and return.\r
374     * Notice that the pixels we have from previous rows have been transformed\r
375     * already; we can only combine like with like (transformed or\r
376     * untransformed) and, because of the libpng API for interlaced images, this\r
377     * means we must transform before de-interlacing.\r
378     */\r
379    if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))\r
380    {\r
381       switch (png_ptr->pass)\r
382       {\r
383          case 0:\r
384             if (png_ptr->row_number & 0x07)\r
385             {\r
386                if (dsp_row != NULL)\r
387                   png_combine_row(png_ptr, dsp_row, 1/*display*/);\r
388                png_read_finish_row(png_ptr);\r
389                return;\r
390             }\r
391             break;\r
392 \r
393          case 1:\r
394             if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)\r
395             {\r
396                if (dsp_row != NULL)\r
397                   png_combine_row(png_ptr, dsp_row, 1/*display*/);\r
398 \r
399                png_read_finish_row(png_ptr);\r
400                return;\r
401             }\r
402             break;\r
403 \r
404          case 2:\r
405             if ((png_ptr->row_number & 0x07) != 4)\r
406             {\r
407                if (dsp_row != NULL && (png_ptr->row_number & 4))\r
408                   png_combine_row(png_ptr, dsp_row, 1/*display*/);\r
409 \r
410                png_read_finish_row(png_ptr);\r
411                return;\r
412             }\r
413             break;\r
414 \r
415          case 3:\r
416             if ((png_ptr->row_number & 3) || png_ptr->width < 3)\r
417             {\r
418                if (dsp_row != NULL)\r
419                   png_combine_row(png_ptr, dsp_row, 1/*display*/);\r
420 \r
421                png_read_finish_row(png_ptr);\r
422                return;\r
423             }\r
424             break;\r
425 \r
426          case 4:\r
427             if ((png_ptr->row_number & 3) != 2)\r
428             {\r
429                if (dsp_row != NULL && (png_ptr->row_number & 2))\r
430                   png_combine_row(png_ptr, dsp_row, 1/*display*/);\r
431 \r
432                png_read_finish_row(png_ptr);\r
433                return;\r
434             }\r
435             break;\r
436 \r
437          case 5:\r
438             if ((png_ptr->row_number & 1) || png_ptr->width < 2)\r
439             {\r
440                if (dsp_row != NULL)\r
441                   png_combine_row(png_ptr, dsp_row, 1/*display*/);\r
442 \r
443                png_read_finish_row(png_ptr);\r
444                return;\r
445             }\r
446             break;\r
447 \r
448          default:\r
449          case 6:\r
450             if (!(png_ptr->row_number & 1))\r
451             {\r
452                png_read_finish_row(png_ptr);\r
453                return;\r
454             }\r
455             break;\r
456       }\r
457    }\r
458 #endif\r
459 \r
460    if (!(png_ptr->mode & PNG_HAVE_IDAT))\r
461       png_error(png_ptr, "Invalid attempt to read row data");\r
462 \r
463    /* Fill the row with IDAT data: */\r
464    png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1);\r
465 \r
466    if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)\r
467    {\r
468       if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)\r
469          png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,\r
470             png_ptr->prev_row + 1, png_ptr->row_buf[0]);\r
471       else\r
472          png_error(png_ptr, "bad adaptive filter value");\r
473    }\r
474 \r
475    /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before\r
476     * 1.5.6, while the buffer really is this big in current versions of libpng\r
477     * it may not be in the future, so this was changed just to copy the\r
478     * interlaced count:\r
479     */\r
480    memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);\r
481 \r
482 #ifdef PNG_MNG_FEATURES_SUPPORTED\r
483    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&\r
484        (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))\r
485    {\r
486       /* Intrapixel differencing */\r
487       png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);\r
488    }\r
489 #endif\r
490 \r
491 \r
492 #ifdef PNG_READ_TRANSFORMS_SUPPORTED\r
493    if (png_ptr->transformations)\r
494       png_do_read_transformations(png_ptr, &row_info);\r
495 #endif\r
496 \r
497    /* The transformed pixel depth should match the depth now in row_info. */\r
498    if (png_ptr->transformed_pixel_depth == 0)\r
499    {\r
500       png_ptr->transformed_pixel_depth = row_info.pixel_depth;\r
501       if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)\r
502          png_error(png_ptr, "sequential row overflow");\r
503    }\r
504 \r
505    else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)\r
506       png_error(png_ptr, "internal sequential row size calculation error");\r
507 \r
508 #ifdef PNG_READ_INTERLACING_SUPPORTED\r
509    /* Blow up interlaced rows to full size */\r
510    if (png_ptr->interlaced &&\r
511       (png_ptr->transformations & PNG_INTERLACE))\r
512    {\r
513       if (png_ptr->pass < 6)\r
514          png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,\r
515             png_ptr->transformations);\r
516 \r
517       if (dsp_row != NULL)\r
518          png_combine_row(png_ptr, dsp_row, 1/*display*/);\r
519 \r
520       if (row != NULL)\r
521          png_combine_row(png_ptr, row, 0/*row*/);\r
522    }\r
523 \r
524    else\r
525 #endif\r
526    {\r
527       if (row != NULL)\r
528          png_combine_row(png_ptr, row, -1/*ignored*/);\r
529 \r
530       if (dsp_row != NULL)\r
531          png_combine_row(png_ptr, dsp_row, -1/*ignored*/);\r
532    }\r
533    png_read_finish_row(png_ptr);\r
534 \r
535    if (png_ptr->read_row_fn != NULL)\r
536       (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);\r
537 \r
538 }\r
539 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */\r
540 \r
541 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED\r
542 /* Read one or more rows of image data.  If the image is interlaced,\r
543  * and png_set_interlace_handling() has been called, the rows need to\r
544  * contain the contents of the rows from the previous pass.  If the\r
545  * image has alpha or transparency, and png_handle_alpha()[*] has been\r
546  * called, the rows contents must be initialized to the contents of the\r
547  * screen.\r
548  *\r
549  * "row" holds the actual image, and pixels are placed in it\r
550  * as they arrive.  If the image is displayed after each pass, it will\r
551  * appear to "sparkle" in.  "display_row" can be used to display a\r
552  * "chunky" progressive image, with finer detail added as it becomes\r
553  * available.  If you do not want this "chunky" display, you may pass\r
554  * NULL for display_row.  If you do not want the sparkle display, and\r
555  * you have not called png_handle_alpha(), you may pass NULL for rows.\r
556  * If you have called png_handle_alpha(), and the image has either an\r
557  * alpha channel or a transparency chunk, you must provide a buffer for\r
558  * rows.  In this case, you do not have to provide a display_row buffer\r
559  * also, but you may.  If the image is not interlaced, or if you have\r
560  * not called png_set_interlace_handling(), the display_row buffer will\r
561  * be ignored, so pass NULL to it.\r
562  *\r
563  * [*] png_handle_alpha() does not exist yet, as of this version of libpng\r
564  */\r
565 \r
566 void PNGAPI\r
567 png_read_rows(png_structrp png_ptr, png_bytepp row,\r
568     png_bytepp display_row, png_uint_32 num_rows)\r
569 {\r
570    png_uint_32 i;\r
571    png_bytepp rp;\r
572    png_bytepp dp;\r
573 \r
574    png_debug(1, "in png_read_rows");\r
575 \r
576    if (png_ptr == NULL)\r
577       return;\r
578 \r
579    rp = row;\r
580    dp = display_row;\r
581    if (rp != NULL && dp != NULL)\r
582       for (i = 0; i < num_rows; i++)\r
583       {\r
584          png_bytep rptr = *rp++;\r
585          png_bytep dptr = *dp++;\r
586 \r
587          png_read_row(png_ptr, rptr, dptr);\r
588       }\r
589 \r
590    else if (rp != NULL)\r
591       for (i = 0; i < num_rows; i++)\r
592       {\r
593          png_bytep rptr = *rp;\r
594          png_read_row(png_ptr, rptr, NULL);\r
595          rp++;\r
596       }\r
597 \r
598    else if (dp != NULL)\r
599       for (i = 0; i < num_rows; i++)\r
600       {\r
601          png_bytep dptr = *dp;\r
602          png_read_row(png_ptr, NULL, dptr);\r
603          dp++;\r
604       }\r
605 }\r
606 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */\r
607 \r
608 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED\r
609 /* Read the entire image.  If the image has an alpha channel or a tRNS\r
610  * chunk, and you have called png_handle_alpha()[*], you will need to\r
611  * initialize the image to the current image that PNG will be overlaying.\r
612  * We set the num_rows again here, in case it was incorrectly set in\r
613  * png_read_start_row() by a call to png_read_update_info() or\r
614  * png_start_read_image() if png_set_interlace_handling() wasn't called\r
615  * prior to either of these functions like it should have been.  You can\r
616  * only call this function once.  If you desire to have an image for\r
617  * each pass of a interlaced image, use png_read_rows() instead.\r
618  *\r
619  * [*] png_handle_alpha() does not exist yet, as of this version of libpng\r
620  */\r
621 void PNGAPI\r
622 png_read_image(png_structrp png_ptr, png_bytepp image)\r
623 {\r
624    png_uint_32 i, image_height;\r
625    int pass, j;\r
626    png_bytepp rp;\r
627 \r
628    png_debug(1, "in png_read_image");\r
629 \r
630    if (png_ptr == NULL)\r
631       return;\r
632 \r
633 #ifdef PNG_READ_INTERLACING_SUPPORTED\r
634    if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))\r
635    {\r
636       pass = png_set_interlace_handling(png_ptr);\r
637       /* And make sure transforms are initialized. */\r
638       png_start_read_image(png_ptr);\r
639    }\r
640    else\r
641    {\r
642       if (png_ptr->interlaced && !(png_ptr->transformations & PNG_INTERLACE))\r
643       {\r
644          /* Caller called png_start_read_image or png_read_update_info without\r
645           * first turning on the PNG_INTERLACE transform.  We can fix this here,\r
646           * but the caller should do it!\r
647           */\r
648          png_warning(png_ptr, "Interlace handling should be turned on when "\r
649             "using png_read_image");\r
650          /* Make sure this is set correctly */\r
651          png_ptr->num_rows = png_ptr->height;\r
652       }\r
653 \r
654       /* Obtain the pass number, which also turns on the PNG_INTERLACE flag in\r
655        * the above error case.\r
656        */\r
657       pass = png_set_interlace_handling(png_ptr);\r
658    }\r
659 #else\r
660    if (png_ptr->interlaced)\r
661       png_error(png_ptr,\r
662           "Cannot read interlaced image -- interlace handler disabled");\r
663 \r
664    pass = 1;\r
665 #endif\r
666 \r
667    image_height=png_ptr->height;\r
668 \r
669    for (j = 0; j < pass; j++)\r
670    {\r
671       rp = image;\r
672       for (i = 0; i < image_height; i++)\r
673       {\r
674          png_read_row(png_ptr, *rp, NULL);\r
675          rp++;\r
676       }\r
677    }\r
678 }\r
679 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */\r
680 \r
681 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED\r
682 /* Read the end of the PNG file.  Will not read past the end of the\r
683  * file, will verify the end is accurate, and will read any comments\r
684  * or time information at the end of the file, if info is not NULL.\r
685  */\r
686 void PNGAPI\r
687 png_read_end(png_structrp png_ptr, png_inforp info_ptr)\r
688 {\r
689 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
690    int keep;\r
691 #endif\r
692 \r
693    png_debug(1, "in png_read_end");\r
694 \r
695    if (png_ptr == NULL)\r
696       return;\r
697 \r
698    /* If png_read_end is called in the middle of reading the rows there may\r
699     * still be pending IDAT data and an owned zstream.  Deal with this here.\r
700     */\r
701 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
702    if (!png_chunk_unknown_handling(png_ptr, png_IDAT))\r
703 #endif\r
704       png_read_finish_IDAT(png_ptr);\r
705 \r
706 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED\r
707    /* Report invalid palette index; added at libng-1.5.10 */\r
708    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&\r
709       png_ptr->num_palette_max > png_ptr->num_palette)\r
710      png_benign_error(png_ptr, "Read palette index exceeding num_palette");\r
711 #endif\r
712 \r
713    do\r
714    {\r
715       png_uint_32 length = png_read_chunk_header(png_ptr);\r
716       png_uint_32 chunk_name = png_ptr->chunk_name;\r
717 \r
718       if (chunk_name == png_IHDR)\r
719          png_handle_IHDR(png_ptr, info_ptr, length);\r
720 \r
721       else if (chunk_name == png_IEND)\r
722          png_handle_IEND(png_ptr, info_ptr, length);\r
723 \r
724 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
725       else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)\r
726       {\r
727          if (chunk_name == png_IDAT)\r
728          {\r
729             if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))\r
730                png_benign_error(png_ptr, "Too many IDATs found");\r
731          }\r
732          png_handle_unknown(png_ptr, info_ptr, length, keep);\r
733          if (chunk_name == png_PLTE)\r
734             png_ptr->mode |= PNG_HAVE_PLTE;\r
735       }\r
736 #endif\r
737 \r
738       else if (chunk_name == png_IDAT)\r
739       {\r
740          /* Zero length IDATs are legal after the last IDAT has been\r
741           * read, but not after other chunks have been read.\r
742           */\r
743          if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))\r
744             png_benign_error(png_ptr, "Too many IDATs found");\r
745 \r
746          png_crc_finish(png_ptr, length);\r
747       }\r
748       else if (chunk_name == png_PLTE)\r
749          png_handle_PLTE(png_ptr, info_ptr, length);\r
750 \r
751 #ifdef PNG_READ_bKGD_SUPPORTED\r
752       else if (chunk_name == png_bKGD)\r
753          png_handle_bKGD(png_ptr, info_ptr, length);\r
754 #endif\r
755 \r
756 #ifdef PNG_READ_cHRM_SUPPORTED\r
757       else if (chunk_name == png_cHRM)\r
758          png_handle_cHRM(png_ptr, info_ptr, length);\r
759 #endif\r
760 \r
761 #ifdef PNG_READ_gAMA_SUPPORTED\r
762       else if (chunk_name == png_gAMA)\r
763          png_handle_gAMA(png_ptr, info_ptr, length);\r
764 #endif\r
765 \r
766 #ifdef PNG_READ_hIST_SUPPORTED\r
767       else if (chunk_name == png_hIST)\r
768          png_handle_hIST(png_ptr, info_ptr, length);\r
769 #endif\r
770 \r
771 #ifdef PNG_READ_oFFs_SUPPORTED\r
772       else if (chunk_name == png_oFFs)\r
773          png_handle_oFFs(png_ptr, info_ptr, length);\r
774 #endif\r
775 \r
776 #ifdef PNG_READ_pCAL_SUPPORTED\r
777       else if (chunk_name == png_pCAL)\r
778          png_handle_pCAL(png_ptr, info_ptr, length);\r
779 #endif\r
780 \r
781 #ifdef PNG_READ_sCAL_SUPPORTED\r
782       else if (chunk_name == png_sCAL)\r
783          png_handle_sCAL(png_ptr, info_ptr, length);\r
784 #endif\r
785 \r
786 #ifdef PNG_READ_pHYs_SUPPORTED\r
787       else if (chunk_name == png_pHYs)\r
788          png_handle_pHYs(png_ptr, info_ptr, length);\r
789 #endif\r
790 \r
791 #ifdef PNG_READ_sBIT_SUPPORTED\r
792       else if (chunk_name == png_sBIT)\r
793          png_handle_sBIT(png_ptr, info_ptr, length);\r
794 #endif\r
795 \r
796 #ifdef PNG_READ_sRGB_SUPPORTED\r
797       else if (chunk_name == png_sRGB)\r
798          png_handle_sRGB(png_ptr, info_ptr, length);\r
799 #endif\r
800 \r
801 #ifdef PNG_READ_iCCP_SUPPORTED\r
802       else if (chunk_name == png_iCCP)\r
803          png_handle_iCCP(png_ptr, info_ptr, length);\r
804 #endif\r
805 \r
806 #ifdef PNG_READ_sPLT_SUPPORTED\r
807       else if (chunk_name == png_sPLT)\r
808          png_handle_sPLT(png_ptr, info_ptr, length);\r
809 #endif\r
810 \r
811 #ifdef PNG_READ_tEXt_SUPPORTED\r
812       else if (chunk_name == png_tEXt)\r
813          png_handle_tEXt(png_ptr, info_ptr, length);\r
814 #endif\r
815 \r
816 #ifdef PNG_READ_tIME_SUPPORTED\r
817       else if (chunk_name == png_tIME)\r
818          png_handle_tIME(png_ptr, info_ptr, length);\r
819 #endif\r
820 \r
821 #ifdef PNG_READ_tRNS_SUPPORTED\r
822       else if (chunk_name == png_tRNS)\r
823          png_handle_tRNS(png_ptr, info_ptr, length);\r
824 #endif\r
825 \r
826 #ifdef PNG_READ_zTXt_SUPPORTED\r
827       else if (chunk_name == png_zTXt)\r
828          png_handle_zTXt(png_ptr, info_ptr, length);\r
829 #endif\r
830 \r
831 #ifdef PNG_READ_iTXt_SUPPORTED\r
832       else if (chunk_name == png_iTXt)\r
833          png_handle_iTXt(png_ptr, info_ptr, length);\r
834 #endif\r
835 \r
836       else\r
837          png_handle_unknown(png_ptr, info_ptr, length,\r
838             PNG_HANDLE_CHUNK_AS_DEFAULT);\r
839    } while (!(png_ptr->mode & PNG_HAVE_IEND));\r
840 }\r
841 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */\r
842 \r
843 /* Free all memory used in the read struct */\r
844 static void\r
845 png_read_destroy(png_structrp png_ptr)\r
846 {\r
847    png_debug(1, "in png_read_destroy");\r
848 \r
849 #ifdef PNG_READ_GAMMA_SUPPORTED\r
850    png_destroy_gamma_table(png_ptr);\r
851 #endif\r
852 \r
853    png_free(png_ptr, png_ptr->big_row_buf);\r
854    png_free(png_ptr, png_ptr->big_prev_row);\r
855    png_free(png_ptr, png_ptr->read_buffer);\r
856 \r
857 #ifdef PNG_READ_QUANTIZE_SUPPORTED\r
858    png_free(png_ptr, png_ptr->palette_lookup);\r
859    png_free(png_ptr, png_ptr->quantize_index);\r
860 #endif\r
861 \r
862    if (png_ptr->free_me & PNG_FREE_PLTE)\r
863       png_zfree(png_ptr, png_ptr->palette);\r
864    png_ptr->free_me &= ~PNG_FREE_PLTE;\r
865 \r
866 #if defined(PNG_tRNS_SUPPORTED) || \\r
867     defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
868    if (png_ptr->free_me & PNG_FREE_TRNS)\r
869       png_free(png_ptr, png_ptr->trans_alpha);\r
870    png_ptr->free_me &= ~PNG_FREE_TRNS;\r
871 #endif\r
872 \r
873    inflateEnd(&png_ptr->zstream);\r
874 \r
875 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
876    png_free(png_ptr, png_ptr->save_buffer);\r
877 #endif\r
878 \r
879 #if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) &&\\r
880    defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)\r
881    png_free(png_ptr, png_ptr->unknown_chunk.data);\r
882 #endif\r
883 \r
884 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED\r
885    png_free(png_ptr, png_ptr->chunk_list);\r
886 #endif\r
887 \r
888    /* NOTE: the 'setjmp' buffer may still be allocated and the memory and error\r
889     * callbacks are still set at this point.  They are required to complete the\r
890     * destruction of the png_struct itself.\r
891     */\r
892 }\r
893 \r
894 /* Free all memory used by the read */\r
895 void PNGAPI\r
896 png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,\r
897     png_infopp end_info_ptr_ptr)\r
898 {\r
899    png_structrp png_ptr = NULL;\r
900 \r
901    png_debug(1, "in png_destroy_read_struct");\r
902 \r
903    if (png_ptr_ptr != NULL)\r
904       png_ptr = *png_ptr_ptr;\r
905 \r
906    if (png_ptr == NULL)\r
907       return;\r
908 \r
909    /* libpng 1.6.0: use the API to destroy info structs to ensure consistent\r
910     * behavior.  Prior to 1.6.0 libpng did extra 'info' destruction in this API.\r
911     * The extra was, apparently, unnecessary yet this hides memory leak bugs.\r
912     */\r
913    png_destroy_info_struct(png_ptr, end_info_ptr_ptr);\r
914    png_destroy_info_struct(png_ptr, info_ptr_ptr);\r
915 \r
916    *png_ptr_ptr = NULL;\r
917    png_read_destroy(png_ptr);\r
918    png_destroy_png_struct(png_ptr);\r
919 }\r
920 \r
921 void PNGAPI\r
922 png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn)\r
923 {\r
924    if (png_ptr == NULL)\r
925       return;\r
926 \r
927    png_ptr->read_row_fn = read_row_fn;\r
928 }\r
929 \r
930 \r
931 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED\r
932 #ifdef PNG_INFO_IMAGE_SUPPORTED\r
933 void PNGAPI\r
934 png_read_png(png_structrp png_ptr, png_inforp info_ptr,\r
935                            int transforms,\r
936                            voidp params)\r
937 {\r
938    int row;\r
939 \r
940    if (png_ptr == NULL || info_ptr == NULL)\r
941       return;\r
942 \r
943    /* png_read_info() gives us all of the information from the\r
944     * PNG file before the first IDAT (image data chunk).\r
945     */\r
946    png_read_info(png_ptr, info_ptr);\r
947    if (info_ptr->height > PNG_UINT_32_MAX/(sizeof (png_bytep)))\r
948       png_error(png_ptr, "Image is too high to process with png_read_png()");\r
949 \r
950    /* -------------- image transformations start here ------------------- */\r
951 \r
952 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED\r
953    /* Tell libpng to strip 16-bit/color files down to 8 bits per color.\r
954     */\r
955    if (transforms & PNG_TRANSFORM_SCALE_16)\r
956    {\r
957      /* Added at libpng-1.5.4. "strip_16" produces the same result that it\r
958       * did in earlier versions, while "scale_16" is now more accurate.\r
959       */\r
960       png_set_scale_16(png_ptr);\r
961    }\r
962 #endif\r
963 \r
964 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED\r
965    /* If both SCALE and STRIP are required pngrtran will effectively cancel the\r
966     * latter by doing SCALE first.  This is ok and allows apps not to check for\r
967     * which is supported to get the right answer.\r
968     */\r
969    if (transforms & PNG_TRANSFORM_STRIP_16)\r
970       png_set_strip_16(png_ptr);\r
971 #endif\r
972 \r
973 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED\r
974    /* Strip alpha bytes from the input data without combining with\r
975     * the background (not recommended).\r
976     */\r
977    if (transforms & PNG_TRANSFORM_STRIP_ALPHA)\r
978       png_set_strip_alpha(png_ptr);\r
979 #endif\r
980 \r
981 #if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)\r
982    /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single\r
983     * byte into separate bytes (useful for paletted and grayscale images).\r
984     */\r
985    if (transforms & PNG_TRANSFORM_PACKING)\r
986       png_set_packing(png_ptr);\r
987 #endif\r
988 \r
989 #ifdef PNG_READ_PACKSWAP_SUPPORTED\r
990    /* Change the order of packed pixels to least significant bit first\r
991     * (not useful if you are using png_set_packing).\r
992     */\r
993    if (transforms & PNG_TRANSFORM_PACKSWAP)\r
994       png_set_packswap(png_ptr);\r
995 #endif\r
996 \r
997 #ifdef PNG_READ_EXPAND_SUPPORTED\r
998    /* Expand paletted colors into true RGB triplets\r
999     * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel\r
1000     * Expand paletted or RGB images with transparency to full alpha\r
1001     * channels so the data will be available as RGBA quartets.\r
1002     */\r
1003    if (transforms & PNG_TRANSFORM_EXPAND)\r
1004       if ((png_ptr->bit_depth < 8) ||\r
1005           (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||\r
1006           (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))\r
1007          png_set_expand(png_ptr);\r
1008 #endif\r
1009 \r
1010    /* We don't handle background color or gamma transformation or quantizing.\r
1011     */\r
1012 \r
1013 #ifdef PNG_READ_INVERT_SUPPORTED\r
1014    /* Invert monochrome files to have 0 as white and 1 as black\r
1015     */\r
1016    if (transforms & PNG_TRANSFORM_INVERT_MONO)\r
1017       png_set_invert_mono(png_ptr);\r
1018 #endif\r
1019 \r
1020 #ifdef PNG_READ_SHIFT_SUPPORTED\r
1021    /* If you want to shift the pixel values from the range [0,255] or\r
1022     * [0,65535] to the original [0,7] or [0,31], or whatever range the\r
1023     * colors were originally in:\r
1024     */\r
1025    if ((transforms & PNG_TRANSFORM_SHIFT)\r
1026        && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))\r
1027    {\r
1028       png_color_8p sig_bit;\r
1029 \r
1030       png_get_sBIT(png_ptr, info_ptr, &sig_bit);\r
1031       png_set_shift(png_ptr, sig_bit);\r
1032    }\r
1033 #endif\r
1034 \r
1035 #ifdef PNG_READ_BGR_SUPPORTED\r
1036    /* Flip the RGB pixels to BGR (or RGBA to BGRA) */\r
1037    if (transforms & PNG_TRANSFORM_BGR)\r
1038       png_set_bgr(png_ptr);\r
1039 #endif\r
1040 \r
1041 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED\r
1042    /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */\r
1043    if (transforms & PNG_TRANSFORM_SWAP_ALPHA)\r
1044       png_set_swap_alpha(png_ptr);\r
1045 #endif\r
1046 \r
1047 #ifdef PNG_READ_SWAP_SUPPORTED\r
1048    /* Swap bytes of 16-bit files to least significant byte first */\r
1049    if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)\r
1050       png_set_swap(png_ptr);\r
1051 #endif\r
1052 \r
1053 /* Added at libpng-1.2.41 */\r
1054 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED\r
1055    /* Invert the alpha channel from opacity to transparency */\r
1056    if (transforms & PNG_TRANSFORM_INVERT_ALPHA)\r
1057       png_set_invert_alpha(png_ptr);\r
1058 #endif\r
1059 \r
1060 /* Added at libpng-1.2.41 */\r
1061 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED\r
1062    /* Expand grayscale image to RGB */\r
1063    if (transforms & PNG_TRANSFORM_GRAY_TO_RGB)\r
1064       png_set_gray_to_rgb(png_ptr);\r
1065 #endif\r
1066 \r
1067 /* Added at libpng-1.5.4 */\r
1068 #ifdef PNG_READ_EXPAND_16_SUPPORTED\r
1069    if (transforms & PNG_TRANSFORM_EXPAND_16)\r
1070       png_set_expand_16(png_ptr);\r
1071 #endif\r
1072 \r
1073    /* We don't handle adding filler bytes */\r
1074 \r
1075    /* We use png_read_image and rely on that for interlace handling, but we also\r
1076     * call png_read_update_info therefore must turn on interlace handling now:\r
1077     */\r
1078    (void)png_set_interlace_handling(png_ptr);\r
1079 \r
1080    /* Optional call to gamma correct and add the background to the palette\r
1081     * and update info structure.  REQUIRED if you are expecting libpng to\r
1082     * update the palette for you (i.e., you selected such a transform above).\r
1083     */\r
1084    png_read_update_info(png_ptr, info_ptr);\r
1085 \r
1086    /* -------------- image transformations end here ------------------- */\r
1087 \r
1088    png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);\r
1089    if (info_ptr->row_pointers == NULL)\r
1090    {\r
1091       png_uint_32 iptr;\r
1092 \r
1093       info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,\r
1094           info_ptr->height * (sizeof (png_bytep)));\r
1095       for (iptr=0; iptr<info_ptr->height; iptr++)\r
1096          info_ptr->row_pointers[iptr] = NULL;\r
1097 \r
1098       info_ptr->free_me |= PNG_FREE_ROWS;\r
1099 \r
1100       for (row = 0; row < (int)info_ptr->height; row++)\r
1101          info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,\r
1102             png_get_rowbytes(png_ptr, info_ptr));\r
1103    }\r
1104 \r
1105    png_read_image(png_ptr, info_ptr->row_pointers);\r
1106    info_ptr->valid |= PNG_INFO_IDAT;\r
1107 \r
1108    /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */\r
1109    png_read_end(png_ptr, info_ptr);\r
1110 \r
1111    PNG_UNUSED(transforms)   /* Quiet compiler warnings */\r
1112    PNG_UNUSED(params)\r
1113 \r
1114 }\r
1115 #endif /* PNG_INFO_IMAGE_SUPPORTED */\r
1116 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */\r
1117 \r
1118 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED\r
1119 /* SIMPLIFIED READ\r
1120  *\r
1121  * This code currently relies on the sequential reader, though it could easily\r
1122  * be made to work with the progressive one.\r
1123  */\r
1124 /* Arguments to png_image_finish_read: */\r
1125 \r
1126 /* Encoding of PNG data (used by the color-map code) */\r
1127 /* TODO: change these, dang, ANSI-C reserves the 'E' namespace. */\r
1128 #  define E_NOTSET  0 /* File encoding not yet known */\r
1129 #  define E_sRGB    1 /* 8-bit encoded to sRGB gamma */\r
1130 #  define E_LINEAR  2 /* 16-bit linear: not encoded, NOT pre-multiplied! */\r
1131 #  define E_FILE    3 /* 8-bit encoded to file gamma, not sRGB or linear */\r
1132 #  define E_LINEAR8 4 /* 8-bit linear: only from a file value */\r
1133 \r
1134 /* Color-map processing: after libpng has run on the PNG image further\r
1135  * processing may be needed to conver the data to color-map indicies.\r
1136  */\r
1137 #define PNG_CMAP_NONE      0\r
1138 #define PNG_CMAP_GA        1 /* Process GA data to a color-map with alpha */\r
1139 #define PNG_CMAP_TRANS     2 /* Process GA data to a background index */\r
1140 #define PNG_CMAP_RGB       3 /* Process RGB data */\r
1141 #define PNG_CMAP_RGB_ALPHA 4 /* Process RGBA data */\r
1142 \r
1143 /* The following document where the background is for each processing case. */\r
1144 #define PNG_CMAP_NONE_BACKGROUND      256\r
1145 #define PNG_CMAP_GA_BACKGROUND        231\r
1146 #define PNG_CMAP_TRANS_BACKGROUND     254\r
1147 #define PNG_CMAP_RGB_BACKGROUND       256\r
1148 #define PNG_CMAP_RGB_ALPHA_BACKGROUND 216\r
1149 \r
1150 typedef struct\r
1151 {\r
1152    /* Arguments: */\r
1153    png_imagep image;\r
1154    png_voidp  buffer;\r
1155    png_int_32 row_stride;\r
1156    png_voidp  colormap;\r
1157    png_const_colorp background;\r
1158    /* Local variables: */\r
1159    png_voidp       local_row;\r
1160    png_voidp       first_row;\r
1161    ptrdiff_t       row_bytes;           /* step between rows */\r
1162    int             file_encoding;       /* E_ values above */\r
1163    png_fixed_point gamma_to_linear;     /* For E_FILE, reciprocal of gamma */\r
1164    int             colormap_processing; /* PNG_CMAP_ values above */\r
1165 } png_image_read_control;\r
1166 \r
1167 /* Do all the *safe* initialization - 'safe' means that png_error won't be\r
1168  * called, so setting up the jmp_buf is not required.  This means that anything\r
1169  * called from here must *not* call png_malloc - it has to call png_malloc_warn\r
1170  * instead so that control is returned safely back to this routine.\r
1171  */\r
1172 static int\r
1173 png_image_read_init(png_imagep image)\r
1174 {\r
1175    if (image->opaque == NULL)\r
1176    {\r
1177       png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, image,\r
1178           png_safe_error, png_safe_warning);\r
1179 \r
1180       /* And set the rest of the structure to NULL to ensure that the various\r
1181        * fields are consistent.\r
1182        */\r
1183       memset(image, 0, (sizeof *image));\r
1184       image->version = PNG_IMAGE_VERSION;\r
1185 \r
1186       if (png_ptr != NULL)\r
1187       {\r
1188          png_infop info_ptr = png_create_info_struct(png_ptr);\r
1189 \r
1190          if (info_ptr != NULL)\r
1191          {\r
1192             png_controlp control = png_voidcast(png_controlp,\r
1193                png_malloc_warn(png_ptr, (sizeof *control)));\r
1194 \r
1195             if (control != NULL)\r
1196             {\r
1197                memset(control, 0, (sizeof *control));\r
1198 \r
1199                control->png_ptr = png_ptr;\r
1200                control->info_ptr = info_ptr;\r
1201                control->for_write = 0;\r
1202 \r
1203                image->opaque = control;\r
1204                return 1;\r
1205             }\r
1206 \r
1207             /* Error clean up */\r
1208             png_destroy_info_struct(png_ptr, &info_ptr);\r
1209          }\r
1210 \r
1211          png_destroy_read_struct(&png_ptr, NULL, NULL);\r
1212       }\r
1213 \r
1214       return png_image_error(image, "png_image_read: out of memory");\r
1215    }\r
1216 \r
1217    return png_image_error(image, "png_image_read: opaque pointer not NULL");\r
1218 }\r
1219 \r
1220 /* Utility to find the base format of a PNG file from a png_struct. */\r
1221 static png_uint_32\r
1222 png_image_format(png_structrp png_ptr)\r
1223 {\r
1224    png_uint_32 format = 0;\r
1225 \r
1226    if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)\r
1227       format |= PNG_FORMAT_FLAG_COLOR;\r
1228 \r
1229    if (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)\r
1230       format |= PNG_FORMAT_FLAG_ALPHA;\r
1231 \r
1232    /* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS\r
1233     * sets the png_struct fields; that's all we are interested in here.  The\r
1234     * precise interaction with an app call to png_set_tRNS and PNG file reading\r
1235     * is unclear.\r
1236     */\r
1237    else if (png_ptr->num_trans > 0)\r
1238       format |= PNG_FORMAT_FLAG_ALPHA;\r
1239 \r
1240    if (png_ptr->bit_depth == 16)\r
1241       format |= PNG_FORMAT_FLAG_LINEAR;\r
1242 \r
1243    if (png_ptr->color_type & PNG_COLOR_MASK_PALETTE)\r
1244       format |= PNG_FORMAT_FLAG_COLORMAP;\r
1245 \r
1246    return format;\r
1247 }\r
1248 \r
1249 /* Is the given gamma significantly different from sRGB?  The test is the same\r
1250  * one used in pngrtran.c when deciding whether to do gamma correction.  The\r
1251  * arithmetic optimizes the division by using the fact that the inverse of the\r
1252  * file sRGB gamma is 2.2\r
1253  */\r
1254 static int\r
1255 png_gamma_not_sRGB(png_fixed_point g)\r
1256 {\r
1257    if (g < PNG_FP_1)\r
1258    {\r
1259       /* An uninitialized gamma is assumed to be sRGB for the simplified API. */\r
1260       if (g == 0)\r
1261          return 0;\r
1262 \r
1263       return png_gamma_significant((g * 11 + 2)/5 /* i.e. *2.2, rounded */);\r
1264    }\r
1265 \r
1266    return 1;\r
1267 }\r
1268 \r
1269 /* Do the main body of a 'png_image_begin_read' function; read the PNG file\r
1270  * header and fill in all the information.  This is executed in a safe context,\r
1271  * unlike the init routine above.\r
1272  */\r
1273 static int\r
1274 png_image_read_header(png_voidp argument)\r
1275 {\r
1276    png_imagep image = png_voidcast(png_imagep, argument);\r
1277    png_structrp png_ptr = image->opaque->png_ptr;\r
1278    png_inforp info_ptr = image->opaque->info_ptr;\r
1279 \r
1280    png_set_benign_errors(png_ptr, 1/*warn*/);\r
1281    png_read_info(png_ptr, info_ptr);\r
1282 \r
1283    /* Do this the fast way; just read directly out of png_struct. */\r
1284    image->width = png_ptr->width;\r
1285    image->height = png_ptr->height;\r
1286 \r
1287    {\r
1288       png_uint_32 format = png_image_format(png_ptr);\r
1289 \r
1290       image->format = format;\r
1291 \r
1292 #ifdef PNG_COLORSPACE_SUPPORTED\r
1293       /* Does the colorspace match sRGB?  If there is no color endpoint\r
1294        * (colorant) information assume yes, otherwise require the\r
1295        * 'ENDPOINTS_MATCHE_sRGB' colorspace flag to have been set.  If the\r
1296        * colorspace has been determined to be invalid ignore it.\r
1297        */\r
1298       if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags\r
1299          & (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB|\r
1300             PNG_COLORSPACE_INVALID)) == PNG_COLORSPACE_HAVE_ENDPOINTS))\r
1301          image->flags |= PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB;\r
1302 #endif\r
1303    }\r
1304 \r
1305    /* We need the maximum number of entries regardless of the format the\r
1306     * application sets here.\r
1307     */\r
1308    {\r
1309       png_uint_32 cmap_entries;\r
1310 \r
1311       switch (png_ptr->color_type)\r
1312       {\r
1313          case PNG_COLOR_TYPE_GRAY:\r
1314             cmap_entries = 1U << png_ptr->bit_depth;\r
1315             break;\r
1316 \r
1317          case PNG_COLOR_TYPE_PALETTE:\r
1318             cmap_entries = png_ptr->num_palette;\r
1319             break;\r
1320 \r
1321          default:\r
1322             cmap_entries = 256;\r
1323             break;\r
1324       }\r
1325 \r
1326       if (cmap_entries > 256)\r
1327          cmap_entries = 256;\r
1328 \r
1329       image->colormap_entries = cmap_entries;\r
1330    }\r
1331 \r
1332    return 1;\r
1333 }\r
1334 \r
1335 #ifdef PNG_STDIO_SUPPORTED\r
1336 int PNGAPI\r
1337 png_image_begin_read_from_stdio(png_imagep image, FILE* file)\r
1338 {\r
1339    if (image != NULL && image->version == PNG_IMAGE_VERSION)\r
1340    {\r
1341       if (file != NULL)\r
1342       {\r
1343          if (png_image_read_init(image))\r
1344          {\r
1345             /* This is slightly evil, but png_init_io doesn't do anything other\r
1346              * than this and we haven't changed the standard IO functions so\r
1347              * this saves a 'safe' function.\r
1348              */\r
1349             image->opaque->png_ptr->io_ptr = file;\r
1350             return png_safe_execute(image, png_image_read_header, image);\r
1351          }\r
1352       }\r
1353 \r
1354       else\r
1355          return png_image_error(image,\r
1356             "png_image_begin_read_from_stdio: invalid argument");\r
1357    }\r
1358 \r
1359    else if (image != NULL)\r
1360       return png_image_error(image,\r
1361          "png_image_begin_read_from_stdio: incorrect PNG_IMAGE_VERSION");\r
1362 \r
1363    return 0;\r
1364 }\r
1365 \r
1366 int PNGAPI\r
1367 png_image_begin_read_from_file(png_imagep image, const char *file_name)\r
1368 {\r
1369    if (image != NULL && image->version == PNG_IMAGE_VERSION)\r
1370    {\r
1371       if (file_name != NULL)\r
1372       {\r
1373          FILE *fp = fopen(file_name, "rb");\r
1374 \r
1375          if (fp != NULL)\r
1376          {\r
1377             if (png_image_read_init(image))\r
1378             {\r
1379                image->opaque->png_ptr->io_ptr = fp;\r
1380                image->opaque->owned_file = 1;\r
1381                return png_safe_execute(image, png_image_read_header, image);\r
1382             }\r
1383 \r
1384             /* Clean up: just the opened file. */\r
1385             (void)fclose(fp);\r
1386          }\r
1387 \r
1388          else\r
1389             return png_image_error(image, strerror(errno));\r
1390       }\r
1391 \r
1392       else\r
1393          return png_image_error(image,\r
1394             "png_image_begin_read_from_file: invalid argument");\r
1395    }\r
1396 \r
1397    else if (image != NULL)\r
1398       return png_image_error(image,\r
1399          "png_image_begin_read_from_file: incorrect PNG_IMAGE_VERSION");\r
1400 \r
1401    return 0;\r
1402 }\r
1403 #endif /* PNG_STDIO_SUPPORTED */\r
1404 \r
1405 static void PNGCBAPI\r
1406 png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need)\r
1407 {\r
1408    if (png_ptr != NULL)\r
1409    {\r
1410       png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr);\r
1411       if (image != NULL)\r
1412       {\r
1413          png_controlp cp = image->opaque;\r
1414          if (cp != NULL)\r
1415          {\r
1416             png_const_bytep memory = cp->memory;\r
1417             png_size_t size = cp->size;\r
1418 \r
1419             if (memory != NULL && size >= need)\r
1420             {\r
1421                memcpy(out, memory, need);\r
1422                cp->memory = memory + need;\r
1423                cp->size = size - need;\r
1424                return;\r
1425             }\r
1426 \r
1427             png_error(png_ptr, "read beyond end of data");\r
1428          }\r
1429       }\r
1430 \r
1431       png_error(png_ptr, "invalid memory read");\r
1432    }\r
1433 }\r
1434 \r
1435 int PNGAPI png_image_begin_read_from_memory(png_imagep image,\r
1436    png_const_voidp memory, png_size_t size)\r
1437 {\r
1438    if (image != NULL && image->version == PNG_IMAGE_VERSION)\r
1439    {\r
1440       if (memory != NULL && size > 0)\r
1441       {\r
1442          if (png_image_read_init(image))\r
1443          {\r
1444             /* Now set the IO functions to read from the memory buffer and\r
1445              * store it into io_ptr.  Again do this in-place to avoid calling a\r
1446              * libpng function that requires error handling.\r
1447              */\r
1448             image->opaque->memory = png_voidcast(png_const_bytep, memory);\r
1449             image->opaque->size = size;\r
1450             image->opaque->png_ptr->io_ptr = image;\r
1451             image->opaque->png_ptr->read_data_fn = png_image_memory_read;\r
1452 \r
1453             return png_safe_execute(image, png_image_read_header, image);\r
1454          }\r
1455       }\r
1456 \r
1457       else\r
1458          return png_image_error(image,\r
1459             "png_image_begin_read_from_memory: invalid argument");\r
1460    }\r
1461 \r
1462    else if (image != NULL)\r
1463       return png_image_error(image,\r
1464          "png_image_begin_read_from_memory: incorrect PNG_IMAGE_VERSION");\r
1465 \r
1466    return 0;\r
1467 }\r
1468 \r
1469 /* Utility function to skip chunks that are not used by the simplified image\r
1470  * read functions and an appropriate macro to call it.\r
1471  */\r
1472 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
1473 static void\r
1474 png_image_skip_unused_chunks(png_structrp png_ptr)\r
1475 {\r
1476    /* Prepare the reader to ignore all recognized chunks whose data will not\r
1477     * be used, i.e., all chunks recognized by libpng except for those\r
1478     * involved in basic image reading:\r
1479     *\r
1480     *    IHDR, PLTE, IDAT, IEND\r
1481     *\r
1482     * Or image data handling:\r
1483     *\r
1484     *    tRNS, bKGD, gAMA, cHRM, sRGB, iCCP and sBIT.\r
1485     *\r
1486     * This provides a small performance improvement and eliminates any\r
1487     * potential vulnerability to security problems in the unused chunks.\r
1488     */\r
1489    {\r
1490          static PNG_CONST png_byte chunks_to_process[] = {\r
1491             98,  75,  71,  68, '\0',  /* bKGD */\r
1492             99,  72,  82,  77, '\0',  /* cHRM */\r
1493            103,  65,  77,  65, '\0',  /* gAMA */\r
1494            105,  67,  67,  80, '\0',  /* iCCP */\r
1495            115,  66,  73,  84, '\0',  /* sBIT */\r
1496            115,  82,  71,  66, '\0',  /* sRGB */\r
1497            };\r
1498 \r
1499        /* Ignore unknown chunks and all other chunks except for the\r
1500         * IHDR, PLTE, tRNS, IDAT, and IEND chunks.\r
1501         */\r
1502        png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER,\r
1503          NULL, -1);\r
1504 \r
1505        /* But do not ignore image data handling chunks */\r
1506        png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT,\r
1507          chunks_to_process, (sizeof chunks_to_process)/5);\r
1508     }\r
1509 }\r
1510 \r
1511 #  define PNG_SKIP_CHUNKS(p) png_image_skip_unused_chunks(p)\r
1512 #else\r
1513 #  define PNG_SKIP_CHUNKS(p) ((void)0)\r
1514 #endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */\r
1515 \r
1516 /* The following macro gives the exact rounded answer for all values in the\r
1517  * range 0..255 (it actually divides by 51.2, but the rounding still generates\r
1518  * the correct numbers 0..5\r
1519  */\r
1520 #define PNG_DIV51(v8) (((v8) * 5 + 130) >> 8)\r
1521 \r
1522 /* Utility functions to make particular color-maps */\r
1523 static void\r
1524 set_file_encoding(png_image_read_control *display)\r
1525 {\r
1526    png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma;\r
1527    if (png_gamma_significant(g))\r
1528    {\r
1529       if (png_gamma_not_sRGB(g))\r
1530       {\r
1531          display->file_encoding = E_FILE;\r
1532          display->gamma_to_linear = png_reciprocal(g);\r
1533       }\r
1534 \r
1535       else\r
1536          display->file_encoding = E_sRGB;\r
1537    }\r
1538 \r
1539    else\r
1540       display->file_encoding = E_LINEAR8;\r
1541 }\r
1542 \r
1543 static unsigned int\r
1544 decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding)\r
1545 {\r
1546    if (encoding == E_FILE) /* double check */\r
1547       encoding = display->file_encoding;\r
1548 \r
1549    if (encoding == E_NOTSET) /* must be the file encoding */\r
1550    {\r
1551       set_file_encoding(display);\r
1552       encoding = display->file_encoding;\r
1553    }\r
1554 \r
1555    switch (encoding)\r
1556    {\r
1557       case E_FILE:\r
1558          value = png_gamma_16bit_correct(value*257, display->gamma_to_linear);\r
1559          break;\r
1560 \r
1561       case E_sRGB:\r
1562          value = png_sRGB_table[value];\r
1563          break;\r
1564 \r
1565       case E_LINEAR:\r
1566          break;\r
1567 \r
1568       case E_LINEAR8:\r
1569          value *= 257;\r
1570          break;\r
1571 \r
1572       default:\r
1573          png_error(display->image->opaque->png_ptr,\r
1574             "unexpected encoding (internal error)");\r
1575          break;\r
1576    }\r
1577 \r
1578    return value;\r
1579 }\r
1580 \r
1581 static png_uint_32\r
1582 png_colormap_compose(png_image_read_control *display,\r
1583    png_uint_32 foreground, int foreground_encoding, png_uint_32 alpha,\r
1584    png_uint_32 background, int encoding)\r
1585 {\r
1586    /* The file value is composed on the background, the background has the given\r
1587     * encoding and so does the result, the file is encoded with E_FILE and the\r
1588     * file and alpha are 8-bit values.  The (output) encoding will always be\r
1589     * E_LINEAR or E_sRGB.\r
1590     */\r
1591    png_uint_32 f = decode_gamma(display, foreground, foreground_encoding);\r
1592    png_uint_32 b = decode_gamma(display, background, encoding);\r
1593 \r
1594    /* The alpha is always an 8-bit value (it comes from the palette), the value\r
1595     * scaled by 255 is what PNG_sRGB_FROM_LINEAR requires.\r
1596     */\r
1597    f = f * alpha + b * (255-alpha);\r
1598 \r
1599    if (encoding == E_LINEAR)\r
1600    {\r
1601       /* Scale to 65535; divide by 255, approximately (in fact this is extremely\r
1602        * accurate, it divides by 255.00000005937181414556, with no overflow.)\r
1603        */\r
1604       f *= 257; /* Now scaled by 65535 */\r
1605       f += f >> 16;\r
1606       f = (f+32768) >> 16;\r
1607    }\r
1608 \r
1609    else /* E_sRGB */\r
1610       f = PNG_sRGB_FROM_LINEAR(f);\r
1611 \r
1612    return f;\r
1613 }\r
1614 \r
1615 /* NOTE: E_LINEAR values to this routine must be 16-bit, but E_FILE values must\r
1616  * be 8-bit.\r
1617  */\r
1618 static void\r
1619 png_create_colormap_entry(png_image_read_control *display,\r
1620    png_uint_32 ip, png_uint_32 red, png_uint_32 green, png_uint_32 blue,\r
1621    png_uint_32 alpha, int encoding)\r
1622 {\r
1623    png_imagep image = display->image;\r
1624    const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) ?\r
1625       E_LINEAR : E_sRGB;\r
1626    const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 &&\r
1627       (red != green || green != blue);\r
1628 \r
1629    if (ip > 255)\r
1630       png_error(image->opaque->png_ptr, "color-map index out of range");\r
1631 \r
1632    /* Update the cache with whether the file gamma is significantly different\r
1633     * from sRGB.\r
1634     */\r
1635    if (encoding == E_FILE)\r
1636    {\r
1637       if (display->file_encoding == E_NOTSET)\r
1638          set_file_encoding(display);\r
1639 \r
1640       /* Note that the cached value may be E_FILE too, but if it is then the\r
1641        * gamma_to_linear member has been set.\r
1642        */\r
1643       encoding = display->file_encoding;\r
1644    }\r
1645 \r
1646    if (encoding == E_FILE)\r
1647    {\r
1648       png_fixed_point g = display->gamma_to_linear;\r
1649 \r
1650       red = png_gamma_16bit_correct(red*257, g);\r
1651       green = png_gamma_16bit_correct(green*257, g);\r
1652       blue = png_gamma_16bit_correct(blue*257, g);\r
1653 \r
1654       if (convert_to_Y || output_encoding == E_LINEAR)\r
1655       {\r
1656          alpha *= 257;\r
1657          encoding = E_LINEAR;\r
1658       }\r
1659 \r
1660       else\r
1661       {\r
1662          red = PNG_sRGB_FROM_LINEAR(red * 255);\r
1663          green = PNG_sRGB_FROM_LINEAR(green * 255);\r
1664          blue = PNG_sRGB_FROM_LINEAR(blue * 255);\r
1665          encoding = E_sRGB;\r
1666       }\r
1667    }\r
1668 \r
1669    else if (encoding == E_LINEAR8)\r
1670    {\r
1671       /* This encoding occurs quite frequently in test cases because PngSuite\r
1672        * includes a gAMA 1.0 chunk with most images.\r
1673        */\r
1674       red *= 257;\r
1675       green *= 257;\r
1676       blue *= 257;\r
1677       alpha *= 257;\r
1678       encoding = E_LINEAR;\r
1679    }\r
1680 \r
1681    else if (encoding == E_sRGB && (convert_to_Y || output_encoding == E_LINEAR))\r
1682    {\r
1683       /* The values are 8-bit sRGB values, but must be converted to 16-bit\r
1684        * linear.\r
1685        */\r
1686       red = png_sRGB_table[red];\r
1687       green = png_sRGB_table[green];\r
1688       blue = png_sRGB_table[blue];\r
1689       alpha *= 257;\r
1690       encoding = E_LINEAR;\r
1691    }\r
1692 \r
1693    /* This is set if the color isn't gray but the output is. */\r
1694    if (encoding == E_LINEAR)\r
1695    {\r
1696       if (convert_to_Y)\r
1697       {\r
1698          /* NOTE: these values are copied from png_do_rgb_to_gray */\r
1699          png_uint_32 y = (png_uint_32)6968 * red  + (png_uint_32)23434 * green +\r
1700             (png_uint_32)2366 * blue;\r
1701 \r
1702          if (output_encoding == E_LINEAR)\r
1703             y = (y + 16384) >> 15;\r
1704 \r
1705          else\r
1706          {\r
1707             /* y is scaled by 32768, we need it scaled by 255: */\r
1708             y = (y + 128) >> 8;\r
1709             y *= 255;\r
1710             y = PNG_sRGB_FROM_LINEAR((y + 64) >> 7);\r
1711             encoding = E_sRGB;\r
1712          }\r
1713 \r
1714          blue = red = green = y;\r
1715       }\r
1716 \r
1717       else if (output_encoding == E_sRGB)\r
1718       {\r
1719          red = PNG_sRGB_FROM_LINEAR(red * 255);\r
1720          green = PNG_sRGB_FROM_LINEAR(green * 255);\r
1721          blue = PNG_sRGB_FROM_LINEAR(blue * 255);\r
1722          alpha = PNG_DIV257(alpha);\r
1723          encoding = E_sRGB;\r
1724       }\r
1725    }\r
1726 \r
1727    if (encoding != output_encoding)\r
1728       png_error(image->opaque->png_ptr, "bad encoding (internal error)");\r
1729 \r
1730    /* Store the value. */\r
1731    {\r
1732 #     ifdef PNG_FORMAT_BGR_SUPPORTED\r
1733          const int afirst = (image->format & PNG_FORMAT_FLAG_AFIRST) != 0 &&\r
1734             (image->format & PNG_FORMAT_FLAG_ALPHA) != 0;\r
1735 #     else\r
1736 #        define afirst 0\r
1737 #     endif\r
1738 #     ifdef PNG_FORMAT_BGR_SUPPORTED\r
1739          const int bgr = (image->format & PNG_FORMAT_FLAG_BGR) ? 2 : 0;\r
1740 #     else\r
1741 #        define bgr 0\r
1742 #     endif\r
1743 \r
1744       if (output_encoding == E_LINEAR)\r
1745       {\r
1746          png_uint_16p entry = png_voidcast(png_uint_16p, display->colormap);\r
1747 \r
1748          entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format);\r
1749 \r
1750          /* The linear 16-bit values must be pre-multiplied by the alpha channel\r
1751           * value, if less than 65535 (this is, effectively, composite on black\r
1752           * if the alpha channel is removed.)\r
1753           */\r
1754          switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format))\r
1755          {\r
1756             case 4:\r
1757                entry[afirst ? 0 : 3] = (png_uint_16)alpha;\r
1758                /* FALL THROUGH */\r
1759 \r
1760             case 3:\r
1761                if (alpha < 65535)\r
1762                {\r
1763                   if (alpha > 0)\r
1764                   {\r
1765                      blue = (blue * alpha + 32767U)/65535U;\r
1766                      green = (green * alpha + 32767U)/65535U;\r
1767                      red = (red * alpha + 32767U)/65535U;\r
1768                   }\r
1769 \r
1770                   else\r
1771                      red = green = blue = 0;\r
1772                }\r
1773                entry[afirst + (2 ^ bgr)] = (png_uint_16)blue;\r
1774                entry[afirst + 1] = (png_uint_16)green;\r
1775                entry[afirst + bgr] = (png_uint_16)red;\r
1776                break;\r
1777 \r
1778             case 2:\r
1779                entry[1 ^ afirst] = (png_uint_16)alpha;\r
1780                /* FALL THROUGH */\r
1781 \r
1782             case 1:\r
1783                if (alpha < 65535)\r
1784                {\r
1785                   if (alpha > 0)\r
1786                      green = (green * alpha + 32767U)/65535U;\r
1787 \r
1788                   else\r
1789                      green = 0;\r
1790                }\r
1791                entry[afirst] = (png_uint_16)green;\r
1792                break;\r
1793 \r
1794             default:\r
1795                break;\r
1796          }\r
1797       }\r
1798 \r
1799       else /* output encoding is E_sRGB */\r
1800       {\r
1801          png_bytep entry = png_voidcast(png_bytep, display->colormap);\r
1802 \r
1803          entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format);\r
1804 \r
1805          switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format))\r
1806          {\r
1807             case 4:\r
1808                entry[afirst ? 0 : 3] = (png_byte)alpha;\r
1809             case 3:\r
1810                entry[afirst + (2 ^ bgr)] = (png_byte)blue;\r
1811                entry[afirst + 1] = (png_byte)green;\r
1812                entry[afirst + bgr] = (png_byte)red;\r
1813                break;\r
1814 \r
1815             case 2:\r
1816                entry[1 ^ afirst] = (png_byte)alpha;\r
1817             case 1:\r
1818                entry[afirst] = (png_byte)green;\r
1819                break;\r
1820 \r
1821             default:\r
1822                break;\r
1823          }\r
1824       }\r
1825 \r
1826 #     ifdef afirst\r
1827 #        undef afirst\r
1828 #     endif\r
1829 #     ifdef bgr\r
1830 #        undef bgr\r
1831 #     endif\r
1832    }\r
1833 }\r
1834 \r
1835 static int\r
1836 make_gray_file_colormap(png_image_read_control *display)\r
1837 {\r
1838    unsigned int i;\r
1839 \r
1840    for (i=0; i<256; ++i)\r
1841       png_create_colormap_entry(display, i, i, i, i, 255, E_FILE);\r
1842 \r
1843    return i;\r
1844 }\r
1845 \r
1846 static int\r
1847 make_gray_colormap(png_image_read_control *display)\r
1848 {\r
1849    unsigned int i;\r
1850 \r
1851    for (i=0; i<256; ++i)\r
1852       png_create_colormap_entry(display, i, i, i, i, 255, E_sRGB);\r
1853 \r
1854    return i;\r
1855 }\r
1856 #define PNG_GRAY_COLORMAP_ENTRIES 256\r
1857 \r
1858 static int\r
1859 make_ga_colormap(png_image_read_control *display)\r
1860 {\r
1861    unsigned int i, a;\r
1862 \r
1863    /* Alpha is retained, the output will be a color-map with entries\r
1864     * selected by six levels of alpha.  One transparent entry, 6 gray\r
1865     * levels for all the intermediate alpha values, leaving 230 entries\r
1866     * for the opaque grays.  The color-map entries are the six values\r
1867     * [0..5]*51, the GA processing uses PNG_DIV51(value) to find the\r
1868     * relevant entry.\r
1869     *\r
1870     * if (alpha > 229) // opaque\r
1871     * {\r
1872     *    // The 231 entries are selected to make the math below work:\r
1873     *    base = 0;\r
1874     *    entry = (231 * gray + 128) >> 8;\r
1875     * }\r
1876     * else if (alpha < 26) // transparent\r
1877     * {\r
1878     *    base = 231;\r
1879     *    entry = 0;\r
1880     * }\r
1881     * else // partially opaque\r
1882     * {\r
1883     *    base = 226 + 6 * PNG_DIV51(alpha);\r
1884     *    entry = PNG_DIV51(gray);\r
1885     * }\r
1886     */\r
1887    i = 0;\r
1888    while (i < 231)\r
1889    {\r
1890       unsigned int gray = (i * 256 + 115) / 231;\r
1891       png_create_colormap_entry(display, i++, gray, gray, gray, 255, E_sRGB);\r
1892    }\r
1893 \r
1894    /* 255 is used here for the component values for consistency with the code\r
1895     * that undoes premultiplication in pngwrite.c.\r
1896     */\r
1897    png_create_colormap_entry(display, i++, 255, 255, 255, 0, E_sRGB);\r
1898 \r
1899    for (a=1; a<5; ++a)\r
1900    {\r
1901       unsigned int g;\r
1902 \r
1903       for (g=0; g<6; ++g)\r
1904          png_create_colormap_entry(display, i++, g*51, g*51, g*51, a*51,\r
1905             E_sRGB);\r
1906    }\r
1907 \r
1908    return i;\r
1909 }\r
1910 \r
1911 #define PNG_GA_COLORMAP_ENTRIES 256\r
1912 \r
1913 static int\r
1914 make_rgb_colormap(png_image_read_control *display)\r
1915 {\r
1916    unsigned int i, r;\r
1917 \r
1918    /* Build a 6x6x6 opaque RGB cube */\r
1919    for (i=r=0; r<6; ++r)\r
1920    {\r
1921       unsigned int g;\r
1922 \r
1923       for (g=0; g<6; ++g)\r
1924       {\r
1925          unsigned int b;\r
1926 \r
1927          for (b=0; b<6; ++b)\r
1928             png_create_colormap_entry(display, i++, r*51, g*51, b*51, 255,\r
1929                E_sRGB);\r
1930       }\r
1931    }\r
1932 \r
1933    return i;\r
1934 }\r
1935 \r
1936 #define PNG_RGB_COLORMAP_ENTRIES 216\r
1937 \r
1938 /* Return a palette index to the above palette given three 8-bit sRGB values. */\r
1939 #define PNG_RGB_INDEX(r,g,b) \\r
1940    ((png_byte)(6 * (6 * PNG_DIV51(r) + PNG_DIV51(g)) + PNG_DIV51(b)))\r
1941 \r
1942 static int\r
1943 png_image_read_colormap(png_voidp argument)\r
1944 {\r
1945    png_image_read_control *display =\r
1946       png_voidcast(png_image_read_control*, argument);\r
1947    const png_imagep image = display->image;\r
1948 \r
1949    const png_structrp png_ptr = image->opaque->png_ptr;\r
1950    const png_uint_32 output_format = image->format;\r
1951    const int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) ?\r
1952       E_LINEAR : E_sRGB;\r
1953 \r
1954    unsigned int cmap_entries;\r
1955    unsigned int output_processing;        /* Output processing option */\r
1956    unsigned int data_encoding = E_NOTSET; /* Encoding libpng must produce */\r
1957 \r
1958    /* Background information; the background color and the index of this color\r
1959     * in the color-map if it exists (else 256).\r
1960     */\r
1961    unsigned int background_index = 256;\r
1962    png_uint_32 back_r, back_g, back_b;\r
1963 \r
1964    /* Flags to accumulate things that need to be done to the input. */\r
1965    int expand_tRNS = 0;\r
1966 \r
1967    /* Exclude the NYI feature of compositing onto a color-mapped buffer; it is\r
1968     * very difficult to do, the results look awful, and it is difficult to see\r
1969     * what possible use it is because the application can't control the\r
1970     * color-map.\r
1971     */\r
1972    if (((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0 ||\r
1973          png_ptr->num_trans > 0) /* alpha in input */ &&\r
1974       ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0) /* no alpha in output */)\r
1975    {\r
1976       if (output_encoding == E_LINEAR) /* compose on black */\r
1977          back_b = back_g = back_r = 0;\r
1978 \r
1979       else if (display->background == NULL /* no way to remove it */)\r
1980          png_error(png_ptr,\r
1981             "a background color must be supplied to remove alpha/transparency");\r
1982 \r
1983       /* Get a copy of the background color (this avoids repeating the checks\r
1984        * below.)  The encoding is 8-bit sRGB or 16-bit linear, depending on the\r
1985        * output format.\r
1986        */\r
1987       else\r
1988       {\r
1989          back_g = display->background->green;\r
1990          if (output_format & PNG_FORMAT_FLAG_COLOR)\r
1991          {\r
1992             back_r = display->background->red;\r
1993             back_b = display->background->blue;\r
1994          }\r
1995          else\r
1996             back_b = back_r = back_g;\r
1997       }\r
1998    }\r
1999 \r
2000    else if (output_encoding == E_LINEAR)\r
2001       back_b = back_r = back_g = 65535;\r
2002 \r
2003    else\r
2004       back_b = back_r = back_g = 255;\r
2005 \r
2006    /* Default the input file gamma if required - this is necessary because\r
2007     * libpng assumes that if no gamma information is present the data is in the\r
2008     * output format, but the simplified API deduces the gamma from the input\r
2009     * format.\r
2010     */\r
2011    if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) == 0)\r
2012    {\r
2013       /* Do this directly, not using the png_colorspace functions, to ensure\r
2014        * that it happens even if the colorspace is invalid (though probably if\r
2015        * it is the setting will be ignored)  Note that the same thing can be\r
2016        * achieved at the application interface with png_set_gAMA.\r
2017        */\r
2018       if (png_ptr->bit_depth == 16 &&\r
2019          (image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0)\r
2020          png_ptr->colorspace.gamma = PNG_GAMMA_LINEAR;\r
2021 \r
2022       else\r
2023          png_ptr->colorspace.gamma = PNG_GAMMA_sRGB_INVERSE;\r
2024 \r
2025       png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;\r
2026    }\r
2027 \r
2028    /* Decide what to do based on the PNG color type of the input data.  The\r
2029     * utility function png_create_colormap_entry deals with most aspects of the\r
2030     * output transformations; this code works out how to produce bytes of\r
2031     * color-map entries from the original format.\r
2032     */\r
2033    switch (png_ptr->color_type)\r
2034    {\r
2035       case PNG_COLOR_TYPE_GRAY:\r
2036          if (png_ptr->bit_depth <= 8)\r
2037          {\r
2038             /* There at most 256 colors in the output, regardless of\r
2039              * transparency.\r
2040              */\r
2041             unsigned int step, i, val, trans = 256/*ignore*/, back_alpha = 0;\r
2042 \r
2043             cmap_entries = 1U << png_ptr->bit_depth;\r
2044             if (cmap_entries > image->colormap_entries)\r
2045                png_error(png_ptr, "gray[8] color-map: too few entries");\r
2046 \r
2047             step = 255 / (cmap_entries - 1);\r
2048             output_processing = PNG_CMAP_NONE;\r
2049 \r
2050             /* If there is a tRNS chunk then this either selects a transparent\r
2051              * value or, if the output has no alpha, the background color.\r
2052              */\r
2053             if (png_ptr->num_trans > 0)\r
2054             {\r
2055                trans = png_ptr->trans_color.gray;\r
2056 \r
2057                if ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0)\r
2058                   back_alpha = output_encoding == E_LINEAR ? 65535 : 255;\r
2059             }\r
2060 \r
2061             /* png_create_colormap_entry just takes an RGBA and writes the\r
2062              * corresponding color-map entry using the format from 'image',\r
2063              * including the required conversion to sRGB or linear as\r
2064              * appropriate.  The input values are always either sRGB (if the\r
2065              * gamma correction flag is 0) or 0..255 scaled file encoded values\r
2066              * (if the function must gamma correct them).\r
2067              */\r
2068             for (i=val=0; i<cmap_entries; ++i, val += step)\r
2069             {\r
2070                /* 'i' is a file value.  While this will result in duplicated\r
2071                 * entries for 8-bit non-sRGB encoded files it is necessary to\r
2072                 * have non-gamma corrected values to do tRNS handling.\r
2073                 */\r
2074                if (i != trans)\r
2075                   png_create_colormap_entry(display, i, val, val, val, 255,\r
2076                      E_FILE/*8-bit with file gamma*/);\r
2077 \r
2078                /* Else this entry is transparent.  The colors don't matter if\r
2079                 * there is an alpha channel (back_alpha == 0), but it does no\r
2080                 * harm to pass them in; the values are not set above so this\r
2081                 * passes in white.\r
2082                 *\r
2083                 * NOTE: this preserves the full precision of the application\r
2084                 * supplied background color when it is used.\r
2085                 */\r
2086                else\r
2087                   png_create_colormap_entry(display, i, back_r, back_g, back_b,\r
2088                      back_alpha, output_encoding);\r
2089             }\r
2090 \r
2091             /* We need libpng to preserve the original encoding. */\r
2092             data_encoding = E_FILE;\r
2093 \r
2094             /* The rows from libpng, while technically gray values, are now also\r
2095              * color-map indicies; however, they may need to be expanded to 1\r
2096              * byte per pixel.  This is what png_set_packing does (i.e., it\r
2097              * unpacks the bit values into bytes.)\r
2098              */\r
2099             if (png_ptr->bit_depth < 8)\r
2100                png_set_packing(png_ptr);\r
2101          }\r
2102 \r
2103          else /* bit depth is 16 */\r
2104          {\r
2105             /* The 16-bit input values can be converted directly to 8-bit gamma\r
2106              * encoded values; however, if a tRNS chunk is present 257 color-map\r
2107              * entries are required.  This means that the extra entry requires\r
2108              * special processing; add an alpha channel, sacrifice gray level\r
2109              * 254 and convert transparent (alpha==0) entries to that.\r
2110              *\r
2111              * Use libpng to chop the data to 8 bits.  Convert it to sRGB at the\r
2112              * same time to minimize quality loss.  If a tRNS chunk is present\r
2113              * this means libpng must handle it too; otherwise it is impossible\r
2114              * to do the exact match on the 16-bit value.\r
2115              *\r
2116              * If the output has no alpha channel *and* the background color is\r
2117              * gray then it is possible to let libpng handle the substitution by\r
2118              * ensuring that the corresponding gray level matches the background\r
2119              * color exactly.\r
2120              */\r
2121             data_encoding = E_sRGB;\r
2122 \r
2123             if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries)\r
2124                png_error(png_ptr, "gray[16] color-map: too few entries");\r
2125 \r
2126             cmap_entries = make_gray_colormap(display);\r
2127 \r
2128             if (png_ptr->num_trans > 0)\r
2129             {\r
2130                unsigned int back_alpha;\r
2131 \r
2132                if (output_format & PNG_FORMAT_FLAG_ALPHA)\r
2133                   back_alpha = 0;\r
2134 \r
2135                else\r
2136                {\r
2137                   if (back_r == back_g && back_g == back_b)\r
2138                   {\r
2139                      /* Background is gray; no special processing will be\r
2140                       * required.\r
2141                       */\r
2142                      png_color_16 c;\r
2143                      png_uint_32 gray = back_g;\r
2144 \r
2145                      if (output_encoding == E_LINEAR)\r
2146                      {\r
2147                         gray = PNG_sRGB_FROM_LINEAR(gray * 255);\r
2148 \r
2149                         /* And make sure the corresponding palette entry\r
2150                          * matches.\r
2151                          */\r
2152                         png_create_colormap_entry(display, gray, back_g, back_g,\r
2153                            back_g, 65535, E_LINEAR);\r
2154                      }\r
2155 \r
2156                      /* The background passed to libpng, however, must be the\r
2157                       * sRGB value.\r
2158                       */\r
2159                      c.index = 0; /*unused*/\r
2160                      c.gray = c.red = c.green = c.blue = (png_uint_16)gray;\r
2161 \r
2162                      /* NOTE: does this work without expanding tRNS to alpha?\r
2163                       * It should be the color->gray case below apparently\r
2164                       * doesn't.\r
2165                       */\r
2166                      png_set_background_fixed(png_ptr, &c,\r
2167                         PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,\r
2168                         0/*gamma: not used*/);\r
2169 \r
2170                      output_processing = PNG_CMAP_NONE;\r
2171                      break;\r
2172                   }\r
2173 \r
2174                   back_alpha = output_encoding == E_LINEAR ? 65535 : 255;\r
2175                }\r
2176 \r
2177                /* output_processing means that the libpng-processed row will be\r
2178                 * 8-bit GA and it has to be processing to single byte color-map\r
2179                 * values.  Entry 254 is replaced by either a completely\r
2180                 * transparent entry or by the background color at full\r
2181                 * precision (and the background color is not a simple gray leve\r
2182                 * in this case.)\r
2183                 */\r
2184                expand_tRNS = 1;\r
2185                output_processing = PNG_CMAP_TRANS;\r
2186                background_index = 254;\r
2187 \r
2188                /* And set (overwrite) color-map entry 254 to the actual\r
2189                 * background color at full precision.\r
2190                 */\r
2191                png_create_colormap_entry(display, 254, back_r, back_g, back_b,\r
2192                   back_alpha, output_encoding);\r
2193             }\r
2194 \r
2195             else\r
2196                output_processing = PNG_CMAP_NONE;\r
2197          }\r
2198          break;\r
2199 \r
2200       case PNG_COLOR_TYPE_GRAY_ALPHA:\r
2201          /* 8-bit or 16-bit PNG with two channels - gray and alpha.  A minimum\r
2202           * of 65536 combinations.  If, however, the alpha channel is to be\r
2203           * removed there are only 256 possibilities if the background is gray.\r
2204           * (Otherwise there is a subset of the 65536 possibilities defined by\r
2205           * the triangle between black, white and the background color.)\r
2206           *\r
2207           * Reduce 16-bit files to 8-bit and sRGB encode the result.  No need to\r
2208           * worry about tRNS matching - tRNS is ignored if there is an alpha\r
2209           * channel.\r
2210           */\r
2211          data_encoding = E_sRGB;\r
2212 \r
2213          if (output_format & PNG_FORMAT_FLAG_ALPHA)\r
2214          {\r
2215             if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)\r
2216                png_error(png_ptr, "gray+alpha color-map: too few entries");\r
2217 \r
2218             cmap_entries = make_ga_colormap(display);\r
2219 \r
2220             background_index = PNG_CMAP_GA_BACKGROUND;\r
2221             output_processing = PNG_CMAP_GA;\r
2222          }\r
2223 \r
2224          else /* alpha is removed */\r
2225          {\r
2226             /* Alpha must be removed as the PNG data is processed when the\r
2227              * background is a color because the G and A channels are\r
2228              * independent and the vector addition (non-parallel vectors) is a\r
2229              * 2-D problem.\r
2230              *\r
2231              * This can be reduced to the same algorithm as above by making a\r
2232              * colormap containing gray levels (for the opaque grays), a\r
2233              * background entry (for a transparent pixel) and a set of four six\r
2234              * level color values, one set for each intermediate alpha value.\r
2235              * See the comments in make_ga_colormap for how this works in the\r
2236              * per-pixel processing.\r
2237              *\r
2238              * If the background is gray, however, we only need a 256 entry gray\r
2239              * level color map.  It is sufficient to make the entry generated\r
2240              * for the background color be exactly the color specified.\r
2241              */\r
2242             if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0 ||\r
2243                (back_r == back_g && back_g == back_b))\r
2244             {\r
2245                /* Background is gray; no special processing will be required. */\r
2246                png_color_16 c;\r
2247                png_uint_32 gray = back_g;\r
2248 \r
2249                if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries)\r
2250                   png_error(png_ptr, "gray-alpha color-map: too few entries");\r
2251 \r
2252                cmap_entries = make_gray_colormap(display);\r
2253 \r
2254                if (output_encoding == E_LINEAR)\r
2255                {\r
2256                   gray = PNG_sRGB_FROM_LINEAR(gray * 255);\r
2257 \r
2258                   /* And make sure the corresponding palette entry matches. */\r
2259                   png_create_colormap_entry(display, gray, back_g, back_g,\r
2260                      back_g, 65535, E_LINEAR);\r
2261                }\r
2262 \r
2263                /* The background passed to libpng, however, must be the sRGB\r
2264                 * value.\r
2265                 */\r
2266                c.index = 0; /*unused*/\r
2267                c.gray = c.red = c.green = c.blue = (png_uint_16)gray;\r
2268 \r
2269                png_set_background_fixed(png_ptr, &c,\r
2270                   PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,\r
2271                   0/*gamma: not used*/);\r
2272 \r
2273                output_processing = PNG_CMAP_NONE;\r
2274             }\r
2275 \r
2276             else\r
2277             {\r
2278                png_uint_32 i, a;\r
2279 \r
2280                /* This is the same as png_make_ga_colormap, above, except that\r
2281                 * the entries are all opaque.\r
2282                 */\r
2283                if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)\r
2284                   png_error(png_ptr, "ga-alpha color-map: too few entries");\r
2285 \r
2286                i = 0;\r
2287                while (i < 231)\r
2288                {\r
2289                   png_uint_32 gray = (i * 256 + 115) / 231;\r
2290                   png_create_colormap_entry(display, i++, gray, gray, gray,\r
2291                      255, E_sRGB);\r
2292                }\r
2293 \r
2294                /* NOTE: this preserves the full precision of the application\r
2295                 * background color.\r
2296                 */\r
2297                background_index = i;\r
2298                png_create_colormap_entry(display, i++, back_r, back_g, back_b,\r
2299                   output_encoding == E_LINEAR ? 65535U : 255U, output_encoding);\r
2300 \r
2301                /* For non-opaque input composite on the sRGB background - this\r
2302                 * requires inverting the encoding for each component.  The input\r
2303                 * is still converted to the sRGB encoding because this is a\r
2304                 * reasonable approximate to the logarithmic curve of human\r
2305                 * visual sensitivity, at least over the narrow range which PNG\r
2306                 * represents.  Consequently 'G' is always sRGB encoded, while\r
2307                 * 'A' is linear.  We need the linear background colors.\r
2308                 */\r
2309                if (output_encoding == E_sRGB) /* else already linear */\r
2310                {\r
2311                   /* This may produce a value not exactly matching the\r
2312                    * background, but that's ok because these numbers are only\r
2313                    * used when alpha != 0\r
2314                    */\r
2315                   back_r = png_sRGB_table[back_r];\r
2316                   back_g = png_sRGB_table[back_g];\r
2317                   back_b = png_sRGB_table[back_b];\r
2318                }\r
2319 \r
2320                for (a=1; a<5; ++a)\r
2321                {\r
2322                   unsigned int g;\r
2323 \r
2324                   /* PNG_sRGB_FROM_LINEAR expects a 16-bit linear value scaled\r
2325                    * by an 8-bit alpha value (0..255).\r
2326                    */\r
2327                   png_uint_32 alpha = 51 * a;\r
2328                   png_uint_32 back_rx = (255-alpha) * back_r;\r
2329                   png_uint_32 back_gx = (255-alpha) * back_g;\r
2330                   png_uint_32 back_bx = (255-alpha) * back_b;\r
2331 \r
2332                   for (g=0; g<6; ++g)\r
2333                   {\r
2334                      png_uint_32 gray = png_sRGB_table[g*51] * alpha;\r
2335 \r
2336                      png_create_colormap_entry(display, i++,\r
2337                         PNG_sRGB_FROM_LINEAR(gray + back_rx),\r
2338                         PNG_sRGB_FROM_LINEAR(gray + back_gx),\r
2339                         PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, E_sRGB);\r
2340                   }\r
2341                }\r
2342 \r
2343                cmap_entries = i;\r
2344                output_processing = PNG_CMAP_GA;\r
2345             }\r
2346          }\r
2347          break;\r
2348 \r
2349       case PNG_COLOR_TYPE_RGB:\r
2350       case PNG_COLOR_TYPE_RGB_ALPHA:\r
2351          /* Exclude the case where the output is gray; we can always handle this\r
2352           * with the cases above.\r
2353           */\r
2354          if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0)\r
2355          {\r
2356             /* The color-map will be grayscale, so we may as well convert the\r
2357              * input RGB values to a simple grayscale and use the grayscale\r
2358              * code above.\r
2359              *\r
2360              * NOTE: calling this apparently damages the recognition of the\r
2361              * transparent color in background color handling; call\r
2362              * png_set_tRNS_to_alpha before png_set_background_fixed.\r
2363              */\r
2364             png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1,\r
2365                -1);\r
2366             data_encoding = E_sRGB;\r
2367 \r
2368             /* The output will now be one or two 8-bit gray or gray+alpha\r
2369              * channels.  The more complex case arises when the input has alpha.\r
2370              */\r
2371             if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||\r
2372                png_ptr->num_trans > 0) &&\r
2373                (output_format & PNG_FORMAT_FLAG_ALPHA) != 0)\r
2374             {\r
2375                /* Both input and output have an alpha channel, so no background\r
2376                 * processing is required; just map the GA bytes to the right\r
2377                 * color-map entry.\r
2378                 */\r
2379                expand_tRNS = 1;\r
2380 \r
2381                if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)\r
2382                   png_error(png_ptr, "rgb[ga] color-map: too few entries");\r
2383 \r
2384                cmap_entries = make_ga_colormap(display);\r
2385                background_index = PNG_CMAP_GA_BACKGROUND;\r
2386                output_processing = PNG_CMAP_GA;\r
2387             }\r
2388 \r
2389             else\r
2390             {\r
2391                /* Either the input or the output has no alpha channel, so there\r
2392                 * will be no non-opaque pixels in the color-map; it will just be\r
2393                 * grayscale.\r
2394                 */\r
2395                if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries)\r
2396                   png_error(png_ptr, "rgb[gray] color-map: too few entries");\r
2397 \r
2398                /* Ideally this code would use libpng to do the gamma correction,\r
2399                 * but if an input alpha channel is to be removed we will hit the\r
2400                 * libpng bug in gamma+compose+rgb-to-gray (the double gamma\r
2401                 * correction bug).  Fix this by dropping the gamma correction in\r
2402                 * this case and doing it in the palette; this will result in\r
2403                 * duplicate palette entries, but that's better than the\r
2404                 * alternative of double gamma correction.\r
2405                 */\r
2406                if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||\r
2407                   png_ptr->num_trans > 0) &&\r
2408                   png_gamma_not_sRGB(png_ptr->colorspace.gamma))\r
2409                {\r
2410                   cmap_entries = make_gray_file_colormap(display);\r
2411                   data_encoding = E_FILE;\r
2412                }\r
2413 \r
2414                else\r
2415                   cmap_entries = make_gray_colormap(display);\r
2416 \r
2417                /* But if the input has alpha or transparency it must be removed\r
2418                 */\r
2419                if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||\r
2420                   png_ptr->num_trans > 0)\r
2421                {\r
2422                   png_color_16 c;\r
2423                   png_uint_32 gray = back_g;\r
2424 \r
2425                   /* We need to ensure that the application background exists in\r
2426                    * the colormap and that completely transparent pixels map to\r
2427                    * it.  Achieve this simply by ensuring that the entry\r
2428                    * selected for the background really is the background color.\r
2429                    */\r
2430                   if (data_encoding == E_FILE) /* from the fixup above */\r
2431                   {\r
2432                      /* The app supplied a gray which is in output_encoding, we\r
2433                       * need to convert it to a value of the input (E_FILE)\r
2434                       * encoding then set this palette entry to the required\r
2435                       * output encoding.\r
2436                       */\r
2437                      if (output_encoding == E_sRGB)\r
2438                         gray = png_sRGB_table[gray]; /* now E_LINEAR */\r
2439 \r
2440                      gray = PNG_DIV257(png_gamma_16bit_correct(gray,\r
2441                         png_ptr->colorspace.gamma)); /* now E_FILE */\r
2442 \r
2443                      /* And make sure the corresponding palette entry contains\r
2444                       * exactly the required sRGB value.\r
2445                       */\r
2446                      png_create_colormap_entry(display, gray, back_g, back_g,\r
2447                         back_g, 0/*unused*/, output_encoding);\r
2448                   }\r
2449 \r
2450                   else if (output_encoding == E_LINEAR)\r
2451                   {\r
2452                      gray = PNG_sRGB_FROM_LINEAR(gray * 255);\r
2453 \r
2454                      /* And make sure the corresponding palette entry matches.\r
2455                       */\r
2456                      png_create_colormap_entry(display, gray, back_g, back_g,\r
2457                         back_g, 0/*unused*/, E_LINEAR);\r
2458                   }\r
2459 \r
2460                   /* The background passed to libpng, however, must be the\r
2461                    * output (normally sRGB) value.\r
2462                    */\r
2463                   c.index = 0; /*unused*/\r
2464                   c.gray = c.red = c.green = c.blue = (png_uint_16)gray;\r
2465 \r
2466                   /* NOTE: the following is apparently a bug in libpng. Without\r
2467                    * it the transparent color recognition in\r
2468                    * png_set_background_fixed seems to go wrong.\r
2469                    */\r
2470                   expand_tRNS = 1;\r
2471                   png_set_background_fixed(png_ptr, &c,\r
2472                      PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,\r
2473                      0/*gamma: not used*/);\r
2474                }\r
2475 \r
2476                output_processing = PNG_CMAP_NONE;\r
2477             }\r
2478          }\r
2479 \r
2480          else /* output is color */\r
2481          {\r
2482             /* We could use png_quantize here so long as there is no transparent\r
2483              * color or alpha; png_quantize ignores alpha.  Easier overall just\r
2484              * to do it once and using PNG_DIV51 on the 6x6x6 reduced RGB cube.\r
2485              * Consequently we always want libpng to produce sRGB data.\r
2486              */\r
2487             data_encoding = E_sRGB;\r
2488 \r
2489             /* Is there any transparency or alpha? */\r
2490             if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||\r
2491                png_ptr->num_trans > 0)\r
2492             {\r
2493                /* Is there alpha in the output too?  If so all four channels are\r
2494                 * processed into a special RGB cube with alpha support.\r
2495                 */\r
2496                if (output_format & PNG_FORMAT_FLAG_ALPHA)\r
2497                {\r
2498                   png_uint_32 r;\r
2499 \r
2500                   if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries)\r
2501                      png_error(png_ptr, "rgb+alpha color-map: too few entries");\r
2502 \r
2503                   cmap_entries = make_rgb_colormap(display);\r
2504 \r
2505                   /* Add a transparent entry. */\r
2506                   png_create_colormap_entry(display, cmap_entries, 255, 255,\r
2507                      255, 0, E_sRGB);\r
2508 \r
2509                   /* This is stored as the background index for the processing\r
2510                    * algorithm.\r
2511                    */\r
2512                   background_index = cmap_entries++;\r
2513 \r
2514                   /* Add 27 r,g,b entries each with alpha 0.5. */\r
2515                   for (r=0; r<256; r = (r << 1) | 0x7f)\r
2516                   {\r
2517                      png_uint_32 g;\r
2518 \r
2519                      for (g=0; g<256; g = (g << 1) | 0x7f)\r
2520                      {\r
2521                         png_uint_32 b;\r
2522 \r
2523                         /* This generates components with the values 0, 127 and\r
2524                          * 255\r
2525                          */\r
2526                         for (b=0; b<256; b = (b << 1) | 0x7f)\r
2527                            png_create_colormap_entry(display, cmap_entries++,\r
2528                               r, g, b, 128, E_sRGB);\r
2529                      }\r
2530                   }\r
2531 \r
2532                   expand_tRNS = 1;\r
2533                   output_processing = PNG_CMAP_RGB_ALPHA;\r
2534                }\r
2535 \r
2536                else\r
2537                {\r
2538                   /* Alpha/transparency must be removed.  The background must\r
2539                    * exist in the color map (achieved by setting adding it after\r
2540                    * the 666 color-map).  If the standard processing code will\r
2541                    * pick up this entry automatically that's all that is\r
2542                    * required; libpng can be called to do the background\r
2543                    * processing.\r
2544                    */\r
2545                   unsigned int sample_size =\r
2546                      PNG_IMAGE_SAMPLE_SIZE(output_format);\r
2547                   png_uint_32 r, g, b; /* sRGB background */\r
2548 \r
2549                   if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries)\r
2550                      png_error(png_ptr, "rgb-alpha color-map: too few entries");\r
2551 \r
2552                   cmap_entries = make_rgb_colormap(display);\r
2553 \r
2554                   png_create_colormap_entry(display, cmap_entries, back_r,\r
2555                         back_g, back_b, 0/*unused*/, output_encoding);\r
2556 \r
2557                   if (output_encoding == E_LINEAR)\r
2558                   {\r
2559                      r = PNG_sRGB_FROM_LINEAR(back_r * 255);\r
2560                      g = PNG_sRGB_FROM_LINEAR(back_g * 255);\r
2561                      b = PNG_sRGB_FROM_LINEAR(back_b * 255);\r
2562                   }\r
2563 \r
2564                   else\r
2565                   {\r
2566                      r = back_r;\r
2567                      g = back_g;\r
2568                      b = back_g;\r
2569                   }\r
2570 \r
2571                   /* Compare the newly-created color-map entry with the one the\r
2572                    * PNG_CMAP_RGB algorithm will use.  If the two entries don't\r
2573                    * match, add the new one and set this as the background\r
2574                    * index.\r
2575                    */\r
2576                   if (memcmp((png_const_bytep)display->colormap +\r
2577                         sample_size * cmap_entries,\r
2578                      (png_const_bytep)display->colormap +\r
2579                         sample_size * PNG_RGB_INDEX(r,g,b),\r
2580                      sample_size) != 0)\r
2581                   {\r
2582                      /* The background color must be added. */\r
2583                      background_index = cmap_entries++;\r
2584 \r
2585                      /* Add 27 r,g,b entries each with created by composing with\r
2586                       * the background at alpha 0.5.\r
2587                       */\r
2588                      for (r=0; r<256; r = (r << 1) | 0x7f)\r
2589                      {\r
2590                         for (g=0; g<256; g = (g << 1) | 0x7f)\r
2591                         {\r
2592                            /* This generates components with the values 0, 127\r
2593                             * and 255\r
2594                             */\r
2595                            for (b=0; b<256; b = (b << 1) | 0x7f)\r
2596                               png_create_colormap_entry(display, cmap_entries++,\r
2597                                  png_colormap_compose(display, r, E_sRGB, 128,\r
2598                                     back_r, output_encoding),\r
2599                                  png_colormap_compose(display, g, E_sRGB, 128,\r
2600                                     back_g, output_encoding),\r
2601                                  png_colormap_compose(display, b, E_sRGB, 128,\r
2602                                     back_b, output_encoding),\r
2603                                  0/*unused*/, output_encoding);\r
2604                         }\r
2605                      }\r
2606 \r
2607                      expand_tRNS = 1;\r
2608                      output_processing = PNG_CMAP_RGB_ALPHA;\r
2609                   }\r
2610 \r
2611                   else /* background color is in the standard color-map */\r
2612                   {\r
2613                      png_color_16 c;\r
2614 \r
2615                      c.index = 0; /*unused*/\r
2616                      c.red = (png_uint_16)back_r;\r
2617                      c.gray = c.green = (png_uint_16)back_g;\r
2618                      c.blue = (png_uint_16)back_b;\r
2619 \r
2620                      png_set_background_fixed(png_ptr, &c,\r
2621                         PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,\r
2622                         0/*gamma: not used*/);\r
2623 \r
2624                      output_processing = PNG_CMAP_RGB;\r
2625                   }\r
2626                }\r
2627             }\r
2628 \r
2629             else /* no alpha or transparency in the input */\r
2630             {\r
2631                /* Alpha in the output is irrelevant, simply map the opaque input\r
2632                 * pixels to the 6x6x6 color-map.\r
2633                 */\r
2634                if (PNG_RGB_COLORMAP_ENTRIES > image->colormap_entries)\r
2635                   png_error(png_ptr, "rgb color-map: too few entries");\r
2636 \r
2637                cmap_entries = make_rgb_colormap(display);\r
2638                output_processing = PNG_CMAP_RGB;\r
2639             }\r
2640          }\r
2641          break;\r
2642 \r
2643       case PNG_COLOR_TYPE_PALETTE:\r
2644          /* It's already got a color-map.  It may be necessary to eliminate the\r
2645           * tRNS entries though.\r
2646           */\r
2647          {\r
2648             unsigned int num_trans = png_ptr->num_trans;\r
2649             png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL;\r
2650             png_const_colorp colormap = png_ptr->palette;\r
2651             const int do_background = trans != NULL &&\r
2652                (output_format & PNG_FORMAT_FLAG_ALPHA) == 0;\r
2653             unsigned int i;\r
2654 \r
2655             /* Just in case: */\r
2656             if (trans == NULL)\r
2657                num_trans = 0;\r
2658 \r
2659             output_processing = PNG_CMAP_NONE;\r
2660             data_encoding = E_FILE; /* Don't change from color-map indicies */\r
2661             cmap_entries = png_ptr->num_palette;\r
2662             if (cmap_entries > 256)\r
2663                cmap_entries = 256;\r
2664 \r
2665             if (cmap_entries > image->colormap_entries)\r
2666                png_error(png_ptr, "palette color-map: too few entries");\r
2667 \r
2668             for (i=0; i < cmap_entries; ++i)\r
2669             {\r
2670                if (do_background && i < num_trans && trans[i] < 255)\r
2671                {\r
2672                   if (trans[i] == 0)\r
2673                      png_create_colormap_entry(display, i, back_r, back_g,\r
2674                         back_b, 0, output_encoding);\r
2675 \r
2676                   else\r
2677                   {\r
2678                      /* Must compose the PNG file color in the color-map entry\r
2679                       * on the sRGB color in 'back'.\r
2680                       */\r
2681                      png_create_colormap_entry(display, i,\r
2682                         png_colormap_compose(display, colormap[i].red, E_FILE,\r
2683                            trans[i], back_r, output_encoding),\r
2684                         png_colormap_compose(display, colormap[i].green, E_FILE,\r
2685                            trans[i], back_g, output_encoding),\r
2686                         png_colormap_compose(display, colormap[i].blue, E_FILE,\r
2687                            trans[i], back_b, output_encoding),\r
2688                         output_encoding == E_LINEAR ? trans[i] * 257U :\r
2689                            trans[i],\r
2690                         output_encoding);\r
2691                   }\r
2692                }\r
2693 \r
2694                else\r
2695                   png_create_colormap_entry(display, i, colormap[i].red,\r
2696                      colormap[i].green, colormap[i].blue,\r
2697                      i < num_trans ? trans[i] : 255U, E_FILE/*8-bit*/);\r
2698             }\r
2699 \r
2700             /* The PNG data may have indicies packed in fewer than 8 bits, it\r
2701              * must be expanded if so.\r
2702              */\r
2703             if (png_ptr->bit_depth < 8)\r
2704                png_set_packing(png_ptr);\r
2705          }\r
2706          break;\r
2707 \r
2708       default:\r
2709          png_error(png_ptr, "invalid PNG color type");\r
2710          /*NOT REACHED*/\r
2711          break;\r
2712    }\r
2713 \r
2714    /* Now deal with the output processing */\r
2715    if (expand_tRNS && png_ptr->num_trans > 0 &&\r
2716       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0)\r
2717       png_set_tRNS_to_alpha(png_ptr);\r
2718 \r
2719    switch (data_encoding)\r
2720    {\r
2721       default:\r
2722          png_error(png_ptr, "bad data option (internal error)");\r
2723          break;\r
2724 \r
2725       case E_sRGB:\r
2726          /* Change to 8-bit sRGB */\r
2727          png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB);\r
2728          /* FALL THROUGH */\r
2729 \r
2730       case E_FILE:\r
2731          if (png_ptr->bit_depth > 8)\r
2732             png_set_scale_16(png_ptr);\r
2733          break;\r
2734    }\r
2735 \r
2736    if (cmap_entries > 256 || cmap_entries > image->colormap_entries)\r
2737       png_error(png_ptr, "color map overflow (BAD internal error)");\r
2738 \r
2739    image->colormap_entries = cmap_entries;\r
2740 \r
2741    /* Double check using the recorded background index */\r
2742    switch (output_processing)\r
2743    {\r
2744       case PNG_CMAP_NONE:\r
2745          if (background_index != PNG_CMAP_NONE_BACKGROUND)\r
2746             goto bad_background;\r
2747          break;\r
2748 \r
2749       case PNG_CMAP_GA:\r
2750          if (background_index != PNG_CMAP_GA_BACKGROUND)\r
2751             goto bad_background;\r
2752          break;\r
2753 \r
2754       case PNG_CMAP_TRANS:\r
2755          if (background_index >= cmap_entries ||\r
2756             background_index != PNG_CMAP_TRANS_BACKGROUND)\r
2757             goto bad_background;\r
2758          break;\r
2759 \r
2760       case PNG_CMAP_RGB:\r
2761          if (background_index != PNG_CMAP_RGB_BACKGROUND)\r
2762             goto bad_background;\r
2763          break;\r
2764 \r
2765       case PNG_CMAP_RGB_ALPHA:\r
2766          if (background_index != PNG_CMAP_RGB_ALPHA_BACKGROUND)\r
2767             goto bad_background;\r
2768          break;\r
2769 \r
2770       default:\r
2771          png_error(png_ptr, "bad processing option (internal error)");\r
2772 \r
2773       bad_background:\r
2774          png_error(png_ptr, "bad background index (internal error)");\r
2775    }\r
2776 \r
2777    display->colormap_processing = output_processing;\r
2778 \r
2779    return 1/*ok*/;\r
2780 }\r
2781 \r
2782 /* The final part of the color-map read called from png_image_finish_read. */\r
2783 static int\r
2784 png_image_read_and_map(png_voidp argument)\r
2785 {\r
2786    png_image_read_control *display = png_voidcast(png_image_read_control*,\r
2787       argument);\r
2788    png_imagep image = display->image;\r
2789    png_structrp png_ptr = image->opaque->png_ptr;\r
2790    int passes;\r
2791 \r
2792    /* Called when the libpng data must be transformed into the color-mapped\r
2793     * form.  There is a local row buffer in display->local and this routine must\r
2794     * do the interlace handling.\r
2795     */\r
2796    switch (png_ptr->interlaced)\r
2797    {\r
2798       case PNG_INTERLACE_NONE:\r
2799          passes = 1;\r
2800          break;\r
2801 \r
2802       case PNG_INTERLACE_ADAM7:\r
2803          passes = PNG_INTERLACE_ADAM7_PASSES;\r
2804          break;\r
2805 \r
2806       default:\r
2807          passes = 0;\r
2808          png_error(png_ptr, "unknown interlace type");\r
2809    }\r
2810 \r
2811    {\r
2812       png_uint_32  height = image->height;\r
2813       png_uint_32  width = image->width;\r
2814       int          proc = display->colormap_processing;\r
2815       png_bytep    first_row = png_voidcast(png_bytep, display->first_row);\r
2816       ptrdiff_t    step_row = display->row_bytes;\r
2817       int pass;\r
2818 \r
2819       for (pass = 0; pass < passes; ++pass)\r
2820       {\r
2821          unsigned int     startx, stepx, stepy;\r
2822          png_uint_32      y;\r
2823 \r
2824          if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)\r
2825          {\r
2826             /* The row may be empty for a short image: */\r
2827             if (PNG_PASS_COLS(width, pass) == 0)\r
2828                continue;\r
2829 \r
2830             startx = PNG_PASS_START_COL(pass);\r
2831             stepx = PNG_PASS_COL_OFFSET(pass);\r
2832             y = PNG_PASS_START_ROW(pass);\r
2833             stepy = PNG_PASS_ROW_OFFSET(pass);\r
2834          }\r
2835 \r
2836          else\r
2837          {\r
2838             y = 0;\r
2839             startx = 0;\r
2840             stepx = stepy = 1;\r
2841          }\r
2842 \r
2843          for (; y<height; y += stepy)\r
2844          {\r
2845             png_bytep inrow = png_voidcast(png_bytep, display->local_row);\r
2846             png_bytep outrow = first_row + y * step_row;\r
2847             png_const_bytep end_row = outrow + width;\r
2848 \r
2849             /* Read read the libpng data into the temporary buffer. */\r
2850             png_read_row(png_ptr, inrow, NULL);\r
2851 \r
2852             /* Now process the row according to the processing option, note\r
2853              * that the caller verifies that the format of the libpng output\r
2854              * data is as required.\r
2855              */\r
2856             outrow += startx;\r
2857             switch (proc)\r
2858             {\r
2859                case PNG_CMAP_GA:\r
2860                   for (; outrow < end_row; outrow += stepx)\r
2861                   {\r
2862                      /* The data is always in the PNG order */\r
2863                      unsigned int gray = *inrow++;\r
2864                      unsigned int alpha = *inrow++;\r
2865                      unsigned int entry;\r
2866 \r
2867                      /* NOTE: this code is copied as a comment in\r
2868                       * make_ga_colormap above.  Please update the\r
2869                       * comment if you change this code!\r
2870                       */\r
2871                      if (alpha > 229) /* opaque */\r
2872                      {\r
2873                         entry = (231 * gray + 128) >> 8;\r
2874                      }\r
2875                      else if (alpha < 26) /* transparent */\r
2876                      {\r
2877                         entry = 231;\r
2878                      }\r
2879                      else /* partially opaque */\r
2880                      {\r
2881                         entry = 226 + 6 * PNG_DIV51(alpha) + PNG_DIV51(gray);\r
2882                      }\r
2883 \r
2884                      *outrow = (png_byte)entry;\r
2885                   }\r
2886                   break;\r
2887 \r
2888                case PNG_CMAP_TRANS:\r
2889                   for (; outrow < end_row; outrow += stepx)\r
2890                   {\r
2891                      png_byte gray = *inrow++;\r
2892                      png_byte alpha = *inrow++;\r
2893 \r
2894                      if (alpha == 0)\r
2895                         *outrow = PNG_CMAP_TRANS_BACKGROUND;\r
2896 \r
2897                      else if (gray != PNG_CMAP_TRANS_BACKGROUND)\r
2898                         *outrow = gray;\r
2899 \r
2900                      else\r
2901                         *outrow = (png_byte)(PNG_CMAP_TRANS_BACKGROUND+1);\r
2902                   }\r
2903                   break;\r
2904 \r
2905                case PNG_CMAP_RGB:\r
2906                   for (; outrow < end_row; outrow += stepx)\r
2907                   {\r
2908                      *outrow = PNG_RGB_INDEX(inrow[0], inrow[1], inrow[2]);\r
2909                      inrow += 3;\r
2910                   }\r
2911                   break;\r
2912 \r
2913                case PNG_CMAP_RGB_ALPHA:\r
2914                   for (; outrow < end_row; outrow += stepx)\r
2915                   {\r
2916                      unsigned int alpha = inrow[3];\r
2917 \r
2918                      /* Because the alpha entries only hold alpha==0.5 values\r
2919                       * split the processing at alpha==0.25 (64) and 0.75\r
2920                       * (196).\r
2921                       */\r
2922 \r
2923                      if (alpha >= 196)\r
2924                         *outrow = PNG_RGB_INDEX(inrow[0], inrow[1],\r
2925                            inrow[2]);\r
2926 \r
2927                      else if (alpha < 64)\r
2928                         *outrow = PNG_CMAP_RGB_ALPHA_BACKGROUND;\r
2929 \r
2930                      else\r
2931                      {\r
2932                         /* Likewise there are three entries for each of r, g\r
2933                          * and b.  We could select the entry by popcount on\r
2934                          * the top two bits on those architectures that\r
2935                          * support it, this is what the code below does,\r
2936                          * crudely.\r
2937                          */\r
2938                         unsigned int back_i = PNG_CMAP_RGB_ALPHA_BACKGROUND+1;\r
2939 \r
2940                         /* Here are how the values map:\r
2941                          *\r
2942                          * 0x00 .. 0x3f -> 0\r
2943                          * 0x40 .. 0xbf -> 1\r
2944                          * 0xc0 .. 0xff -> 2\r
2945                          *\r
2946                          * So, as above with the explicit alpha checks, the\r
2947                          * breakpoints are at 64 and 196.\r
2948                          */\r
2949                         if (inrow[0] & 0x80) back_i += 9; /* red */\r
2950                         if (inrow[0] & 0x40) back_i += 9;\r
2951                         if (inrow[0] & 0x80) back_i += 3; /* green */\r
2952                         if (inrow[0] & 0x40) back_i += 3;\r
2953                         if (inrow[0] & 0x80) back_i += 1; /* blue */\r
2954                         if (inrow[0] & 0x40) back_i += 1;\r
2955 \r
2956                         *outrow = (png_byte)back_i;\r
2957                      }\r
2958 \r
2959                      inrow += 4;\r
2960                   }\r
2961                   break;\r
2962 \r
2963                default:\r
2964                   break;\r
2965             }\r
2966          }\r
2967       }\r
2968    }\r
2969 \r
2970    return 1;\r
2971 }\r
2972 \r
2973 static int\r
2974 png_image_read_colormapped(png_voidp argument)\r
2975 {\r
2976    png_image_read_control *display = png_voidcast(png_image_read_control*,\r
2977       argument);\r
2978    png_imagep image = display->image;\r
2979    png_controlp control = image->opaque;\r
2980    png_structrp png_ptr = control->png_ptr;\r
2981    png_inforp info_ptr = control->info_ptr;\r
2982 \r
2983    int passes = 0; /* As a flag */\r
2984 \r
2985    PNG_SKIP_CHUNKS(png_ptr);\r
2986 \r
2987    /* Update the 'info' structure and make sure the result is as required; first\r
2988     * make sure to turn on the interlace handling if it will be required\r
2989     * (because it can't be turned on *after* the call to png_read_update_info!)\r
2990     */\r
2991    if (display->colormap_processing == PNG_CMAP_NONE)\r
2992       passes = png_set_interlace_handling(png_ptr);\r
2993 \r
2994    png_read_update_info(png_ptr, info_ptr);\r
2995 \r
2996    /* The expected output can be deduced from the colormap_processing option. */\r
2997    switch (display->colormap_processing)\r
2998    {\r
2999       case PNG_CMAP_NONE:\r
3000          /* Output must be one channel and one byte per pixel, the output\r
3001           * encoding can be anything.\r
3002           */\r
3003          if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||\r
3004             info_ptr->color_type == PNG_COLOR_TYPE_GRAY) &&\r
3005             info_ptr->bit_depth == 8)\r
3006             break;\r
3007 \r
3008          goto bad_output;\r
3009 \r
3010       case PNG_CMAP_TRANS:\r
3011       case PNG_CMAP_GA:\r
3012          /* Output must be two channels and the 'G' one must be sRGB, the latter\r
3013           * can be checked with an exact number because it should have been set\r
3014           * to this number above!\r
3015           */\r
3016          if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&\r
3017             info_ptr->bit_depth == 8 &&\r
3018             png_ptr->screen_gamma == PNG_GAMMA_sRGB &&\r
3019             image->colormap_entries == 256)\r
3020             break;\r
3021 \r
3022          goto bad_output;\r
3023 \r
3024       case PNG_CMAP_RGB:\r
3025          /* Output must be 8-bit sRGB encoded RGB */\r
3026          if (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&\r
3027             info_ptr->bit_depth == 8 &&\r
3028             png_ptr->screen_gamma == PNG_GAMMA_sRGB &&\r
3029             image->colormap_entries == 216)\r
3030             break;\r
3031 \r
3032          goto bad_output;\r
3033 \r
3034       case PNG_CMAP_RGB_ALPHA:\r
3035          /* Output must be 8-bit sRGB encoded RGBA */\r
3036          if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&\r
3037             info_ptr->bit_depth == 8 &&\r
3038             png_ptr->screen_gamma == PNG_GAMMA_sRGB &&\r
3039             image->colormap_entries == 244 /* 216 + 1 + 27 */)\r
3040             break;\r
3041 \r
3042          /* goto bad_output; */\r
3043          /* FALL THROUGH */\r
3044 \r
3045       default:\r
3046       bad_output:\r
3047          png_error(png_ptr, "bad color-map processing (internal error)");\r
3048    }\r
3049 \r
3050    /* Now read the rows.  Do this here if it is possible to read directly into\r
3051     * the output buffer, otherwise allocate a local row buffer of the maximum\r
3052     * size libpng requires and call the relevant processing routine safely.\r
3053     */\r
3054    {\r
3055       png_voidp first_row = display->buffer;\r
3056       ptrdiff_t row_bytes = display->row_stride;\r
3057 \r
3058       /* The following expression is designed to work correctly whether it gives\r
3059        * a signed or an unsigned result.\r
3060        */\r
3061       if (row_bytes < 0)\r
3062       {\r
3063          char *ptr = png_voidcast(char*, first_row);\r
3064          ptr += (image->height-1) * (-row_bytes);\r
3065          first_row = png_voidcast(png_voidp, ptr);\r
3066       }\r
3067 \r
3068       display->first_row = first_row;\r
3069       display->row_bytes = row_bytes;\r
3070    }\r
3071 \r
3072    if (passes == 0)\r