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