png_ptr 36 arm/filter_neon_intrinsics.c (temp_pointer = png_ptr(type,pointer), *temp_pointer)
png_ptr 68 arm/filter_neon_intrinsics.c uint8x8x2_t *vrpt = png_ptr(uint8x8x2_t, &vtmp);
png_ptr 89 arm/filter_neon_intrinsics.c vrpt = png_ptr(uint8x8x2_t, &vtmp);
png_ptr 92 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0);
png_ptr 94 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0);
png_ptr 96 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0);
png_ptr 98 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
png_ptr 117 arm/filter_neon_intrinsics.c uint32x2x4_t vtmp = vld4_u32(png_ptr(uint32_t,rp));
png_ptr 118 arm/filter_neon_intrinsics.c uint8x8x4_t *vrpt = png_ptr(uint8x8x4_t,&vtmp);
png_ptr 126 arm/filter_neon_intrinsics.c vst4_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2x4_t,&vdest), 0);
png_ptr 147 arm/filter_neon_intrinsics.c vrpt = png_ptr(uint8x8x2_t,&vtmp);
png_ptr 160 arm/filter_neon_intrinsics.c vppt = png_ptr(uint8x8x2_t,&vtmp);
png_ptr 176 arm/filter_neon_intrinsics.c vrpt = png_ptr(uint8x8x2_t,&vtmp);
png_ptr 187 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0);
png_ptr 189 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0);
png_ptr 191 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0);
png_ptr 193 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
png_ptr 216 arm/filter_neon_intrinsics.c vtmp = vld4_u32(png_ptr(uint32_t,rp));
png_ptr 217 arm/filter_neon_intrinsics.c vrpt = png_ptr(uint8x8x4_t,&vtmp);
png_ptr 220 arm/filter_neon_intrinsics.c vppt = png_ptr(uint8x8x4_t,&vtmp);
png_ptr 232 arm/filter_neon_intrinsics.c vst4_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2x4_t,&vdest), 0);
png_ptr 279 arm/filter_neon_intrinsics.c vrpt = png_ptr(uint8x8x2_t,&vtmp);
png_ptr 290 arm/filter_neon_intrinsics.c vppt = png_ptr(uint8x8x2_t,&vtmp);
png_ptr 310 arm/filter_neon_intrinsics.c vrpt = png_ptr(uint8x8x2_t,&vtmp);
png_ptr 318 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0);
png_ptr 320 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0);
png_ptr 322 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0);
png_ptr 324 arm/filter_neon_intrinsics.c vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
png_ptr 348 arm/filter_neon_intrinsics.c vtmp = vld4_u32(png_ptr(uint32_t,rp));
png_ptr 349 arm/filter_neon_intrinsics.c vrpt = png_ptr(uint8x8x4_t,&vtmp);
png_ptr 352 arm/filter_neon_intrinsics.c vppt = png_ptr(uint8x8x4_t,&vtmp);
png_ptr 366 arm/filter_neon_intrinsics.c vst4_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2x4_t,&vdest), 0);
png_ptr 36 contrib/arm-neon/android-ndk.c PNG_UNUSED(png_ptr)
png_ptr 69 contrib/arm-neon/linux-auxv.c png_warning(png_ptr, "/proc read failed");
png_ptr 77 contrib/arm-neon/linux-auxv.c png_warning(png_ptr, "OS /proc read bug");
png_ptr 105 contrib/arm-neon/linux-auxv.c png_warning(png_ptr, "/proc/self/auxv open failed");
png_ptr 109 contrib/arm-neon/linux-auxv.c while (safe_read(png_ptr, fd, &aux, sizeof aux) == sizeof aux)
png_ptr 150 contrib/arm-neon/linux.c png_error(png_ptr, "png_have_neon: internal error (bug)");
png_ptr 156 contrib/arm-neon/linux.c png_warning(png_ptr, "/proc/cpuinfo open failed");
png_ptr 35 contrib/examples/iccfrompng.c png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
png_ptr 42 contrib/examples/iccfrompng.c if (png_ptr == NULL)
png_ptr 48 contrib/examples/iccfrompng.c if (setjmp(png_jmpbuf(png_ptr)))
png_ptr 50 contrib/examples/iccfrompng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 54 contrib/examples/iccfrompng.c png_init_io(png_ptr, fp);
png_ptr 56 contrib/examples/iccfrompng.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 58 contrib/examples/iccfrompng.c png_error(png_ptr, "OOM allocating info structure");
png_ptr 60 contrib/examples/iccfrompng.c png_read_info(png_ptr, info_ptr);
png_ptr 67 contrib/examples/iccfrompng.c if (png_get_iCCP(png_ptr, info_ptr, &name, &compression_type, &profile,
png_ptr 75 contrib/examples/iccfrompng.c png_error(png_ptr, "OOM allocating profile buffer");
png_ptr 82 contrib/examples/iccfrompng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 74 contrib/examples/pngpixel.c PNG_CONST unsigned int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
png_ptr 76 contrib/examples/pngpixel.c switch (png_get_color_type(png_ptr, info_ptr))
png_ptr 92 contrib/examples/pngpixel.c if ((png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) &
png_ptr 97 contrib/examples/pngpixel.c if ((png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans,
png_ptr 135 contrib/examples/pngpixel.c png_error(png_ptr, "pngpixel: invalid color type");
png_ptr 164 contrib/examples/pngpixel.c png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
png_ptr 167 contrib/examples/pngpixel.c if (png_ptr != NULL)
png_ptr 169 contrib/examples/pngpixel.c png_infop info_ptr = png_create_info_struct(png_ptr);
png_ptr 178 contrib/examples/pngpixel.c if (setjmp(png_jmpbuf(png_ptr)) == 0)
png_ptr 191 contrib/examples/pngpixel.c png_init_io(png_ptr, f);
png_ptr 196 contrib/examples/pngpixel.c png_read_info(png_ptr, info_ptr);
png_ptr 203 contrib/examples/pngpixel.c row = png_malloc(png_ptr, png_get_rowbytes(png_ptr,
png_ptr 215 contrib/examples/pngpixel.c if (png_get_IHDR(png_ptr, info_ptr, &width, &height,
png_ptr 237 contrib/examples/pngpixel.c png_error(png_ptr, "pngpixel: unknown interlace");
png_ptr 241 contrib/examples/pngpixel.c png_start_read_image(png_ptr);
png_ptr 294 contrib/examples/pngpixel.c png_read_row(png_ptr, row_tmp, NULL);
png_ptr 306 contrib/examples/pngpixel.c print_pixel(png_ptr, info_ptr, row_tmp, ppx);
png_ptr 319 contrib/examples/pngpixel.c png_free(png_ptr, row_tmp);
png_ptr 323 contrib/examples/pngpixel.c png_error(png_ptr, "pngpixel: png_get_IHDR failed");
png_ptr 342 contrib/examples/pngpixel.c png_free(png_ptr, row_tmp);
png_ptr 346 contrib/examples/pngpixel.c png_destroy_info_struct(png_ptr, &info_ptr);
png_ptr 352 contrib/examples/pngpixel.c png_destroy_read_struct(&png_ptr, NULL, NULL);
png_ptr 65 contrib/gregbook/readpng.c # define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
png_ptr 69 contrib/gregbook/readpng.c static png_structp png_ptr = NULL;
png_ptr 103 contrib/gregbook/readpng.c png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
png_ptr 104 contrib/gregbook/readpng.c if (!png_ptr)
png_ptr 107 contrib/gregbook/readpng.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 109 contrib/gregbook/readpng.c png_destroy_read_struct(&png_ptr, NULL, NULL);
png_ptr 122 contrib/gregbook/readpng.c if (setjmp(png_jmpbuf(png_ptr))) {
png_ptr 123 contrib/gregbook/readpng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 128 contrib/gregbook/readpng.c png_init_io(png_ptr, infile);
png_ptr 129 contrib/gregbook/readpng.c png_set_sig_bytes(png_ptr, 8); /* we already read the 8 signature bytes */
png_ptr 131 contrib/gregbook/readpng.c png_read_info(png_ptr, info_ptr); /* read all PNG info up to image data */
png_ptr 138 contrib/gregbook/readpng.c png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
png_ptr 163 contrib/gregbook/readpng.c if (setjmp(png_jmpbuf(png_ptr))) {
png_ptr 164 contrib/gregbook/readpng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 169 contrib/gregbook/readpng.c if (!png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
png_ptr 176 contrib/gregbook/readpng.c png_get_bKGD(png_ptr, info_ptr, &pBackground);
png_ptr 217 contrib/gregbook/readpng.c if (setjmp(png_jmpbuf(png_ptr))) {
png_ptr 222 contrib/gregbook/readpng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 232 contrib/gregbook/readpng.c png_set_expand(png_ptr);
png_ptr 234 contrib/gregbook/readpng.c png_set_expand(png_ptr);
png_ptr 235 contrib/gregbook/readpng.c if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
png_ptr 236 contrib/gregbook/readpng.c png_set_expand(png_ptr);
png_ptr 240 contrib/gregbook/readpng.c png_set_scale_16(png_ptr);
png_ptr 242 contrib/gregbook/readpng.c png_set_strip_16(png_ptr);
png_ptr 247 contrib/gregbook/readpng.c png_set_gray_to_rgb(png_ptr);
png_ptr 254 contrib/gregbook/readpng.c if (png_get_gAMA(png_ptr, info_ptr, &gamma))
png_ptr 255 contrib/gregbook/readpng.c png_set_gamma(png_ptr, display_exponent, gamma);
png_ptr 261 contrib/gregbook/readpng.c png_read_update_info(png_ptr, info_ptr);
png_ptr 263 contrib/gregbook/readpng.c *pRowbytes = rowbytes = png_get_rowbytes(png_ptr, info_ptr);
png_ptr 264 contrib/gregbook/readpng.c *pChannels = (int)png_get_channels(png_ptr, info_ptr);
png_ptr 267 contrib/gregbook/readpng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 271 contrib/gregbook/readpng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 289 contrib/gregbook/readpng.c png_read_image(png_ptr, row_pointers);
png_ptr 298 contrib/gregbook/readpng.c png_read_end(png_ptr, NULL);
png_ptr 311 contrib/gregbook/readpng.c if (png_ptr && info_ptr) {
png_ptr 312 contrib/gregbook/readpng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 313 contrib/gregbook/readpng.c png_ptr = NULL;
png_ptr 101 contrib/gregbook/readpng2.c png_structp png_ptr; /* note: temporary variables! */
png_ptr 107 contrib/gregbook/readpng2.c png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
png_ptr 109 contrib/gregbook/readpng2.c if (!png_ptr)
png_ptr 112 contrib/gregbook/readpng2.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 114 contrib/gregbook/readpng2.c png_destroy_read_struct(&png_ptr, NULL, NULL);
png_ptr 130 contrib/gregbook/readpng2.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 150 contrib/gregbook/readpng2.c png_set_keep_unknown_chunks(png_ptr, -1 /* PNG_HANDLE_CHUNK_NEVER */,
png_ptr 154 contrib/gregbook/readpng2.c png_set_keep_unknown_chunks(png_ptr,
png_ptr 164 contrib/gregbook/readpng2.c png_set_progressive_read_fn(png_ptr, mainprog_ptr,
png_ptr 170 contrib/gregbook/readpng2.c mainprog_ptr->png_ptr = png_ptr;
png_ptr 186 contrib/gregbook/readpng2.c png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
png_ptr 194 contrib/gregbook/readpng2.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 195 contrib/gregbook/readpng2.c mainprog_ptr->png_ptr = NULL;
png_ptr 203 contrib/gregbook/readpng2.c png_process_data(png_ptr, info_ptr, rawbuf, length);
png_ptr 236 contrib/gregbook/readpng2.c mainprog_ptr = png_get_progressive_ptr(png_ptr);
png_ptr 255 contrib/gregbook/readpng2.c png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
png_ptr 265 contrib/gregbook/readpng2.c png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
png_ptr 272 contrib/gregbook/readpng2.c png_get_bKGD(png_ptr, info_ptr, &pBackground);
png_ptr 304 contrib/gregbook/readpng2.c png_set_expand(png_ptr);
png_ptr 306 contrib/gregbook/readpng2.c png_set_expand(png_ptr);
png_ptr 307 contrib/gregbook/readpng2.c if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
png_ptr 308 contrib/gregbook/readpng2.c png_set_expand(png_ptr);
png_ptr 312 contrib/gregbook/readpng2.c png_set_scale_16(png_ptr);
png_ptr 314 contrib/gregbook/readpng2.c png_set_strip_16(png_ptr);
png_ptr 319 contrib/gregbook/readpng2.c png_set_gray_to_rgb(png_ptr);
png_ptr 338 contrib/gregbook/readpng2.c if (png_get_gAMA(png_ptr, info_ptr, &gamma))
png_ptr 339 contrib/gregbook/readpng2.c png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma);
png_ptr 341 contrib/gregbook/readpng2.c png_set_gamma(png_ptr, mainprog_ptr->display_exponent, 0.45455);
png_ptr 343 contrib/gregbook/readpng2.c if (png_get_gAMA_fixed(png_ptr, info_ptr, &gamma))
png_ptr 344 contrib/gregbook/readpng2.c png_set_gamma_fixed(png_ptr,
png_ptr 347 contrib/gregbook/readpng2.c png_set_gamma_fixed(png_ptr,
png_ptr 353 contrib/gregbook/readpng2.c mainprog_ptr->passes = png_set_interlace_handling(png_ptr);
png_ptr 359 contrib/gregbook/readpng2.c png_read_update_info(png_ptr, info_ptr);
png_ptr 361 contrib/gregbook/readpng2.c mainprog_ptr->rowbytes = (int)png_get_rowbytes(png_ptr, info_ptr);
png_ptr 362 contrib/gregbook/readpng2.c mainprog_ptr->channels = png_get_channels(png_ptr, info_ptr);
png_ptr 398 contrib/gregbook/readpng2.c mainprog_ptr = png_get_progressive_ptr(png_ptr);
png_ptr 410 contrib/gregbook/readpng2.c png_progressive_combine_row(png_ptr, mainprog_ptr->row_pointers[row_num],
png_ptr 436 contrib/gregbook/readpng2.c mainprog_ptr = png_get_progressive_ptr(png_ptr);
png_ptr 462 contrib/gregbook/readpng2.c png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
png_ptr 465 contrib/gregbook/readpng2.c if (png_ptr && info_ptr)
png_ptr 466 contrib/gregbook/readpng2.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 468 contrib/gregbook/readpng2.c mainprog_ptr->png_ptr = NULL;
png_ptr 477 contrib/gregbook/readpng2.c (void)png_ptr; /* Unused */
png_ptr 497 contrib/gregbook/readpng2.c mainprog_ptr = png_get_error_ptr(png_ptr);
png_ptr 86 contrib/gregbook/readpng2.h void *png_ptr;
png_ptr 86 contrib/gregbook/writepng.c png_structp png_ptr; /* note: temporary variables! */
png_ptr 93 contrib/gregbook/writepng.c png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
png_ptr 95 contrib/gregbook/writepng.c if (!png_ptr)
png_ptr 98 contrib/gregbook/writepng.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 100 contrib/gregbook/writepng.c png_destroy_write_struct(&png_ptr, NULL);
png_ptr 112 contrib/gregbook/writepng.c png_destroy_write_struct(&png_ptr, &info_ptr);
png_ptr 119 contrib/gregbook/writepng.c png_init_io(png_ptr, mainprog_ptr->outfile);
png_ptr 129 contrib/gregbook/writepng.c png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
png_ptr 149 contrib/gregbook/writepng.c png_destroy_write_struct(&png_ptr, &info_ptr);
png_ptr 156 contrib/gregbook/writepng.c png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,
png_ptr 161 contrib/gregbook/writepng.c png_set_gAMA(png_ptr, info_ptr, mainprog_ptr->gamma);
png_ptr 169 contrib/gregbook/writepng.c png_set_bKGD(png_ptr, info_ptr, &background);
png_ptr 176 contrib/gregbook/writepng.c png_set_tIME(png_ptr, info_ptr, &modtime);
png_ptr 219 contrib/gregbook/writepng.c png_set_text(png_ptr, info_ptr, text, num_text);
png_ptr 225 contrib/gregbook/writepng.c png_write_info(png_ptr, info_ptr);
png_ptr 238 contrib/gregbook/writepng.c png_set_packing(png_ptr);
png_ptr 244 contrib/gregbook/writepng.c mainprog_ptr->png_ptr = png_ptr;
png_ptr 261 contrib/gregbook/writepng.c png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
png_ptr 269 contrib/gregbook/writepng.c png_destroy_write_struct(&png_ptr, &info_ptr);
png_ptr 270 contrib/gregbook/writepng.c mainprog_ptr->png_ptr = NULL;
png_ptr 279 contrib/gregbook/writepng.c png_write_image(png_ptr, mainprog_ptr->row_pointers);
png_ptr 286 contrib/gregbook/writepng.c png_write_end(png_ptr, NULL);
png_ptr 299 contrib/gregbook/writepng.c png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
png_ptr 307 contrib/gregbook/writepng.c png_destroy_write_struct(&png_ptr, &info_ptr);
png_ptr 308 contrib/gregbook/writepng.c mainprog_ptr->png_ptr = NULL;
png_ptr 316 contrib/gregbook/writepng.c png_write_row(png_ptr, mainprog_ptr->image_data);
png_ptr 329 contrib/gregbook/writepng.c png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
png_ptr 337 contrib/gregbook/writepng.c png_destroy_write_struct(&png_ptr, &info_ptr);
png_ptr 338 contrib/gregbook/writepng.c mainprog_ptr->png_ptr = NULL;
png_ptr 347 contrib/gregbook/writepng.c png_write_end(png_ptr, NULL);
png_ptr 358 contrib/gregbook/writepng.c png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
png_ptr 361 contrib/gregbook/writepng.c if (png_ptr && info_ptr)
png_ptr 362 contrib/gregbook/writepng.c png_destroy_write_struct(&png_ptr, &info_ptr);
png_ptr 385 contrib/gregbook/writepng.c mainprog_ptr = png_get_error_ptr(png_ptr);
png_ptr 97 contrib/gregbook/writepng.h void *png_ptr;
png_ptr 535 contrib/libtests/makepng.c const char **ep = png_get_error_ptr(png_ptr);
png_ptr 550 contrib/libtests/makepng.c makepng_warning(png_ptr, message);
png_ptr 551 contrib/libtests/makepng.c png_longjmp(png_ptr, 1);
png_ptr 559 contrib/libtests/makepng.c png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
png_ptr 564 contrib/libtests/makepng.c if (png_ptr == NULL)
png_ptr 570 contrib/libtests/makepng.c if (setjmp(png_jmpbuf(png_ptr)))
png_ptr 572 contrib/libtests/makepng.c png_structp nv_ptr = png_ptr;
png_ptr 575 contrib/libtests/makepng.c png_ptr = NULL;
png_ptr 583 contrib/libtests/makepng.c png_set_benign_errors(png_ptr, 1/*allowed*/);
png_ptr 584 contrib/libtests/makepng.c png_init_io(png_ptr, fp);
png_ptr 586 contrib/libtests/makepng.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 588 contrib/libtests/makepng.c png_error(png_ptr, "OOM allocating info structure");
png_ptr 634 contrib/libtests/makepng.c png_set_IHDR(png_ptr, info_ptr, size, size, bit_depth, color_type,
png_ptr 645 contrib/libtests/makepng.c png_set_PLTE(png_ptr, info_ptr, palette, npalette);
png_ptr 646 contrib/libtests/makepng.c png_set_tRNS(png_ptr, info_ptr, trans, npalette-1,
png_ptr 655 contrib/libtests/makepng.c png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_ABSOLUTE);
png_ptr 659 contrib/libtests/makepng.c png_set_gAMA_fixed(png_ptr, info_ptr, real_gamma);
png_ptr 662 contrib/libtests/makepng.c png_set_cHRM_fixed(png_ptr, info_ptr,
png_ptr 674 contrib/libtests/makepng.c insert->insert(png_ptr, info_ptr, insert->nparams, insert->parameters);
png_ptr 679 contrib/libtests/makepng.c png_write_info(png_ptr, info_ptr);
png_ptr 682 contrib/libtests/makepng.c png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, filters);
png_ptr 685 contrib/libtests/makepng.c int passes = png_set_interlace_handling(png_ptr);
png_ptr 687 contrib/libtests/makepng.c png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
png_ptr 692 contrib/libtests/makepng.c png_error(png_ptr, "OOM allocating row buffer");
png_ptr 702 contrib/libtests/makepng.c png_write_row(png_ptr, row);
png_ptr 709 contrib/libtests/makepng.c png_write_end(png_ptr, info_ptr);
png_ptr 712 contrib/libtests/makepng.c png_structp nv_ptr = png_ptr;
png_ptr 715 contrib/libtests/makepng.c png_ptr = NULL;
png_ptr 965 contrib/libtests/makepng.c png_set_iCCP(png_ptr, info_ptr, params[0], PNG_COMPRESSION_TYPE_BASE,
png_ptr 1021 contrib/libtests/makepng.c png_set_text(png_ptr, info_ptr, text, 1);
png_ptr 1035 contrib/libtests/makepng.c set_text(png_ptr, info_ptr, &text, params[1]);
png_ptr 1047 contrib/libtests/makepng.c set_text(png_ptr, info_ptr, &text, params[1]);
png_ptr 1061 contrib/libtests/makepng.c set_text(png_ptr, info_ptr, &text, params[3]);
png_ptr 1089 contrib/libtests/makepng.c png_set_hIST(png_ptr, info_ptr, freq);
png_ptr 378 contrib/libtests/pngunknown.c png_structp png_ptr;
png_ptr 397 contrib/libtests/pngunknown.c d->png_ptr = NULL;
png_ptr 408 contrib/libtests/pngunknown.c png_destroy_read_struct(&d->png_ptr, &d->info_ptr, &d->end_ptr);
png_ptr 411 contrib/libtests/pngunknown.c if (d->png_ptr != NULL || d->info_ptr != NULL || d->end_ptr != NULL)
png_ptr 423 contrib/libtests/pngunknown.c if (d->png_ptr != NULL)
png_ptr 445 contrib/libtests/pngunknown.c display *d = (display*)png_get_error_ptr(png_ptr);
png_ptr 454 contrib/libtests/pngunknown.c display *d = (display*)png_get_error_ptr(png_ptr);
png_ptr 463 contrib/libtests/pngunknown.c png_uint_32 flags = png_get_valid(d->png_ptr, info_ptr, (png_uint_32)~0);
png_ptr 468 contrib/libtests/pngunknown.c png_uint_32 ntext = png_get_text(d->png_ptr, info_ptr, &text, NULL);
png_ptr 576 contrib/libtests/pngunknown.c int num_unknown = png_get_unknown_chunks(d->png_ptr, info_ptr, &unknown);
png_ptr 654 contrib/libtests/pngunknown.c d->png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, d, error,
png_ptr 656 contrib/libtests/pngunknown.c if (d->png_ptr == NULL)
png_ptr 664 contrib/libtests/pngunknown.c d->info_ptr = png_create_info_struct(d->png_ptr);
png_ptr 665 contrib/libtests/pngunknown.c d->end_ptr = png_create_info_struct(d->png_ptr);
png_ptr 674 contrib/libtests/pngunknown.c png_init_io(d->png_ptr, fp);
png_ptr 681 contrib/libtests/pngunknown.c png_set_read_user_chunk_fn(d->png_ptr, d, read_callback);
png_ptr 728 contrib/libtests/pngunknown.c png_set_keep_unknown_chunks(d->png_ptr, option, name, 1);
png_ptr 738 contrib/libtests/pngunknown.c png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
png_ptr 748 contrib/libtests/pngunknown.c png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
png_ptr 770 contrib/libtests/pngunknown.c png_read_info(d->png_ptr, d->info_ptr);
png_ptr 772 contrib/libtests/pngunknown.c switch (png_get_interlace_type(d->png_ptr, d->info_ptr))
png_ptr 794 contrib/libtests/pngunknown.c png_start_read_image(d->png_ptr);
png_ptr 795 contrib/libtests/pngunknown.c height = png_get_image_height(d->png_ptr, d->info_ptr);
png_ptr 799 contrib/libtests/pngunknown.c png_uint_32 width = png_get_image_width(d->png_ptr, d->info_ptr);
png_ptr 810 contrib/libtests/pngunknown.c png_read_row(d->png_ptr, NULL, NULL);
png_ptr 820 contrib/libtests/pngunknown.c png_read_row(d->png_ptr, NULL, NULL);
png_ptr 824 contrib/libtests/pngunknown.c png_read_end(d->png_ptr, d->end_ptr);
png_ptr 37 contrib/libtests/readpng.c png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
png_ptr 41 contrib/libtests/readpng.c if (png_ptr == NULL)
png_ptr 44 contrib/libtests/readpng.c if (setjmp(png_jmpbuf(png_ptr)))
png_ptr 46 contrib/libtests/readpng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 52 contrib/libtests/readpng.c png_init_io(png_ptr, fp);
png_ptr 54 contrib/libtests/readpng.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 56 contrib/libtests/readpng.c png_error(png_ptr, "OOM allocating info structure");
png_ptr 58 contrib/libtests/readpng.c png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_ALWAYS, NULL, 0);
png_ptr 60 contrib/libtests/readpng.c png_read_info(png_ptr, info_ptr);
png_ptr 63 contrib/libtests/readpng.c png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
png_ptr 69 contrib/libtests/readpng.c png_error(png_ptr, "OOM allocating row buffers");
png_ptr 72 contrib/libtests/readpng.c png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
png_ptr 73 contrib/libtests/readpng.c int passes = png_set_interlace_handling(png_ptr);
png_ptr 76 contrib/libtests/readpng.c png_start_read_image(png_ptr);
png_ptr 86 contrib/libtests/readpng.c png_read_row(png_ptr, row, display);
png_ptr 92 contrib/libtests/readpng.c png_read_end(png_ptr, info_ptr);
png_ptr 93 contrib/libtests/readpng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 40 contrib/libtests/timepng.c png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
png_ptr 44 contrib/libtests/timepng.c if (png_ptr == NULL)
png_ptr 47 contrib/libtests/timepng.c if (setjmp(png_jmpbuf(png_ptr)))
png_ptr 49 contrib/libtests/timepng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 55 contrib/libtests/timepng.c png_init_io(png_ptr, fp);
png_ptr 57 contrib/libtests/timepng.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 59 contrib/libtests/timepng.c png_error(png_ptr, "OOM allocating info structure");
png_ptr 61 contrib/libtests/timepng.c png_read_info(png_ptr, info_ptr);
png_ptr 64 contrib/libtests/timepng.c png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
png_ptr 70 contrib/libtests/timepng.c png_error(png_ptr, "OOM allocating row buffers");
png_ptr 73 contrib/libtests/timepng.c png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
png_ptr 74 contrib/libtests/timepng.c int passes = png_set_interlace_handling(png_ptr);
png_ptr 77 contrib/libtests/timepng.c png_start_read_image(png_ptr);
png_ptr 87 contrib/libtests/timepng.c png_read_row(png_ptr, row, display);
png_ptr 93 contrib/libtests/timepng.c png_read_end(png_ptr, info_ptr);
png_ptr 94 contrib/libtests/timepng.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 48 contrib/pngminus/png2pnm.c # define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
png_ptr 196 contrib/pngminus/png2pnm.c png_struct *png_ptr = NULL;
png_ptr 226 contrib/pngminus/png2pnm.c png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
png_ptr 228 contrib/pngminus/png2pnm.c if (!png_ptr)
png_ptr 231 contrib/pngminus/png2pnm.c info_ptr = png_create_info_struct (png_ptr);
png_ptr 234 contrib/pngminus/png2pnm.c png_destroy_read_struct (&png_ptr, NULL, NULL);
png_ptr 238 contrib/pngminus/png2pnm.c if (setjmp (png_jmpbuf(png_ptr)))
png_ptr 240 contrib/pngminus/png2pnm.c png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
png_ptr 245 contrib/pngminus/png2pnm.c png_init_io (png_ptr, png_file);
png_ptr 246 contrib/pngminus/png2pnm.c png_set_sig_bytes (png_ptr, 8); /* we already read the 8 signature bytes */
png_ptr 249 contrib/pngminus/png2pnm.c png_read_info (png_ptr, info_ptr);
png_ptr 252 contrib/pngminus/png2pnm.c png_get_IHDR (png_ptr, info_ptr,
png_ptr 260 contrib/pngminus/png2pnm.c png_set_expand (png_ptr);
png_ptr 263 contrib/pngminus/png2pnm.c png_set_expand (png_ptr);
png_ptr 265 contrib/pngminus/png2pnm.c if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
png_ptr 266 contrib/pngminus/png2pnm.c png_set_expand (png_ptr);
png_ptr 271 contrib/pngminus/png2pnm.c png_set_strip_16 (png_ptr);
png_ptr 275 contrib/pngminus/png2pnm.c png_set_gray_to_rgb (png_ptr);
png_ptr 277 contrib/pngminus/png2pnm.c if (png_get_gAMA (png_ptr, info_ptr, &file_gamma))
png_ptr 278 contrib/pngminus/png2pnm.c png_set_gamma (png_ptr, (double) 2.2, file_gamma);
png_ptr 284 contrib/pngminus/png2pnm.c png_read_update_info (png_ptr, info_ptr);
png_ptr 287 contrib/pngminus/png2pnm.c png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
png_ptr 321 contrib/pngminus/png2pnm.c row_bytes = png_get_rowbytes (png_ptr, info_ptr);
png_ptr 325 contrib/pngminus/png2pnm.c png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
png_ptr 332 contrib/pngminus/png2pnm.c png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
png_ptr 343 contrib/pngminus/png2pnm.c png_read_image (png_ptr, row_pointers);
png_ptr 346 contrib/pngminus/png2pnm.c png_read_end (png_ptr, info_ptr);
png_ptr 349 contrib/pngminus/png2pnm.c png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp) NULL);
png_ptr 46 contrib/pngminus/pnm2png.c # define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
png_ptr 192 contrib/pngminus/pnm2png.c png_struct *png_ptr = NULL;
png_ptr 428 contrib/pngminus/pnm2png.c png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
png_ptr 429 contrib/pngminus/pnm2png.c if (!png_ptr)
png_ptr 433 contrib/pngminus/pnm2png.c info_ptr = png_create_info_struct (png_ptr);
png_ptr 436 contrib/pngminus/pnm2png.c png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
png_ptr 443 contrib/pngminus/pnm2png.c png_set_packing (png_ptr);
png_ptr 444 contrib/pngminus/pnm2png.c png_set_invert_mono (png_ptr);
png_ptr 449 contrib/pngminus/pnm2png.c if (setjmp (png_jmpbuf(png_ptr)))
png_ptr 451 contrib/pngminus/pnm2png.c png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
png_ptr 456 contrib/pngminus/pnm2png.c png_init_io (png_ptr, png_file);
png_ptr 459 contrib/pngminus/pnm2png.c png_set_IHDR (png_ptr, info_ptr, width, height, bit_depth, color_type,
png_ptr 464 contrib/pngminus/pnm2png.c png_write_info (png_ptr, info_ptr);
png_ptr 472 contrib/pngminus/pnm2png.c png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
png_ptr 482 contrib/pngminus/pnm2png.c png_write_image (png_ptr, row_pointers);
png_ptr 485 contrib/pngminus/pnm2png.c png_write_end (png_ptr, info_ptr);
png_ptr 488 contrib/pngminus/pnm2png.c png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
png_ptr 3168 contrib/tools/pngfix.c stop(get_control(png_ptr), LIBPNG_ERROR_CODE, message);
png_ptr 3174 contrib/tools/pngfix.c struct file *file = get_control(png_ptr);
png_ptr 3187 contrib/tools/pngfix.c struct file *file = get_control(png_ptr);
png_ptr 3322 contrib/tools/pngfix.c read_callback(png_ptr, buffer, count);
png_ptr 3539 contrib/tools/pngfix.c png_get_error_ptr(png_ptr));
png_ptr 3578 contrib/tools/pngfix.c png_structp png_ptr;
png_ptr 3583 contrib/tools/pngfix.c png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, control,
png_ptr 3586 contrib/tools/pngfix.c if (png_ptr == NULL)
png_ptr 3597 contrib/tools/pngfix.c png_set_read_fn(png_ptr, control, read_callback);
png_ptr 3599 contrib/tools/pngfix.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 3601 contrib/tools/pngfix.c png_error(png_ptr, "OOM allocating info structure");
png_ptr 3606 contrib/tools/pngfix.c png_read_info(png_ptr, info_ptr);
png_ptr 3609 contrib/tools/pngfix.c png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
png_ptr 3615 contrib/tools/pngfix.c png_error(png_ptr, "OOM allocating row buffers");
png_ptr 3618 contrib/tools/pngfix.c png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
png_ptr 3619 contrib/tools/pngfix.c int passes = png_set_interlace_handling(png_ptr);
png_ptr 3622 contrib/tools/pngfix.c png_start_read_image(png_ptr);
png_ptr 3632 contrib/tools/pngfix.c png_read_row(png_ptr, row, display);
png_ptr 3641 contrib/tools/pngfix.c png_read_end(png_ptr, info_ptr);
png_ptr 3644 contrib/tools/pngfix.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 29 contrib/visupng/PngFile.c static png_structp png_ptr = NULL;
png_ptr 38 contrib/visupng/PngFile.c if(png_ptr)
png_ptr 139 contrib/visupng/PngFile.c png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
png_ptr 141 contrib/visupng/PngFile.c if (!png_ptr)
png_ptr 147 contrib/visupng/PngFile.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 150 contrib/visupng/PngFile.c png_destroy_read_struct(&png_ptr, NULL, NULL);
png_ptr 161 contrib/visupng/PngFile.c png_init_io(png_ptr, pfFile);
png_ptr 163 contrib/visupng/PngFile.c png_set_read_fn(png_ptr, (png_voidp)pfFile, png_read_data);
png_ptr 166 contrib/visupng/PngFile.c png_set_sig_bytes(png_ptr, 8);
png_ptr 170 contrib/visupng/PngFile.c png_read_info(png_ptr, info_ptr);
png_ptr 174 contrib/visupng/PngFile.c png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
png_ptr 183 contrib/visupng/PngFile.c png_set_scale_16(png_ptr);
png_ptr 185 contrib/visupng/PngFile.c png_set_strip_16(png_ptr);
png_ptr 189 contrib/visupng/PngFile.c png_set_expand(png_ptr);
png_ptr 191 contrib/visupng/PngFile.c png_set_expand(png_ptr);
png_ptr 192 contrib/visupng/PngFile.c if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
png_ptr 193 contrib/visupng/PngFile.c png_set_expand(png_ptr);
png_ptr 196 contrib/visupng/PngFile.c png_set_gray_to_rgb(png_ptr);
png_ptr 199 contrib/visupng/PngFile.c if (png_get_bKGD(png_ptr, info_ptr, &pBackground))
png_ptr 201 contrib/visupng/PngFile.c png_set_background(png_ptr, pBackground, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
png_ptr 212 contrib/visupng/PngFile.c if (png_get_gAMA(png_ptr, info_ptr, &dGamma))
png_ptr 213 contrib/visupng/PngFile.c png_set_gamma(png_ptr, (double) 2.2, dGamma);
png_ptr 217 contrib/visupng/PngFile.c png_read_update_info(png_ptr, info_ptr);
png_ptr 221 contrib/visupng/PngFile.c png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
png_ptr 227 contrib/visupng/PngFile.c ulRowBytes = png_get_rowbytes(png_ptr, info_ptr);
png_ptr 228 contrib/visupng/PngFile.c ulChannels = png_get_channels(png_ptr, info_ptr);
png_ptr 242 contrib/visupng/PngFile.c png_error(png_ptr, "Visual PNG: out of memory");
png_ptr 251 contrib/visupng/PngFile.c png_error(png_ptr, "Visual PNG: out of memory");
png_ptr 261 contrib/visupng/PngFile.c png_read_image(png_ptr, ppbRowPointers);
png_ptr 265 contrib/visupng/PngFile.c png_read_end(png_ptr, NULL);
png_ptr 277 contrib/visupng/PngFile.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 316 contrib/visupng/PngFile.c png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
png_ptr 318 contrib/visupng/PngFile.c if (!png_ptr)
png_ptr 324 contrib/visupng/PngFile.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 327 contrib/visupng/PngFile.c png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
png_ptr 336 contrib/visupng/PngFile.c png_init_io(png_ptr, pfFile);
png_ptr 338 contrib/visupng/PngFile.c png_set_write_fn(png_ptr, (png_voidp)pfFile, png_write_data, png_flush);
png_ptr 343 contrib/visupng/PngFile.c png_set_IHDR(png_ptr, info_ptr, iWidth, iHeight, ciBitDepth,
png_ptr 349 contrib/visupng/PngFile.c png_write_info(png_ptr, info_ptr);
png_ptr 353 contrib/visupng/PngFile.c png_set_bgr(png_ptr);
png_ptr 371 contrib/visupng/PngFile.c png_write_image (png_ptr, ppbRowPointers);
png_ptr 375 contrib/visupng/PngFile.c png_write_end(png_ptr, info_ptr);
png_ptr 384 contrib/visupng/PngFile.c png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
png_ptr 391 contrib/visupng/PngFile.c png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
png_ptr 417 contrib/visupng/PngFile.c (FILE *)png_ptr->io_ptr);
png_ptr 421 contrib/visupng/PngFile.c png_error(png_ptr, "Read Error");
png_ptr 430 contrib/visupng/PngFile.c check = fwrite(data, 1, length, (FILE *)(png_ptr->io_ptr));
png_ptr 433 contrib/visupng/PngFile.c png_error(png_ptr, "Write Error");
png_ptr 441 contrib/visupng/PngFile.c io_ptr = (FILE *)CVT_PTR((png_ptr->io_ptr));
png_ptr 221 example.c # define png_jmpbuf(png_ptr) ((png_ptr)->png_jmpbuf)
png_ptr 272 example.c png_structp png_ptr;
png_ptr 285 example.c png_structp png_ptr;
png_ptr 297 example.c png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
png_ptr 300 example.c if (png_ptr == NULL)
png_ptr 307 example.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 311 example.c png_destroy_read_struct(&png_ptr, NULL, NULL);
png_ptr 320 example.c if (setjmp(png_jmpbuf(png_ptr)))
png_ptr 323 example.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 332 example.c png_init_io(png_ptr, fp);
png_ptr 338 example.c png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);
png_ptr 343 example.c png_set_sig_bytes(png_ptr, sig_read);
png_ptr 354 example.c png_read_png(png_ptr, info_ptr, png_transforms, NULL);
png_ptr 362 example.c png_read_info(png_ptr, info_ptr);
png_ptr 364 example.c png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
png_ptr 378 example.c png_set_scale_16(png_ptr);
png_ptr 380 example.c png_set_strip_16(png_ptr);
png_ptr 386 example.c png_set_strip_alpha(png_ptr);
png_ptr 391 example.c png_set_packing(png_ptr);
png_ptr 395 example.c png_set_packswap(png_ptr);
png_ptr 399 example.c png_set_palette_to_rgb(png_ptr);
png_ptr 403 example.c png_set_expand_gray_1_2_4_to_8(png_ptr);
png_ptr 408 example.c if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
png_ptr 409 example.c png_set_tRNS_to_alpha(png_ptr);
png_ptr 420 example.c if (png_get_bKGD(png_ptr, info_ptr, &image_background))
png_ptr 421 example.c png_set_background(png_ptr, image_background,
png_ptr 424 example.c png_set_background(png_ptr, &my_background,
png_ptr 457 example.c if (png_get_sRGB(png_ptr, info_ptr, &intent))
png_ptr 458 example.c png_set_gamma(png_ptr, screen_gamma, PNG_DEFAULT_sRGB);
png_ptr 462 example.c if (png_get_gAMA(png_ptr, info_ptr, &image_gamma))
png_ptr 463 example.c png_set_gamma(png_ptr, screen_gamma, image_gamma);
png_ptr 465 example.c png_set_gamma(png_ptr, screen_gamma, 0.45455);
png_ptr 483 example.c png_set_quantize(png_ptr, std_color_cube, MAX_SCREEN_COLORS,
png_ptr 487 example.c else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette))
png_ptr 491 example.c png_get_hIST(png_ptr, info_ptr, &histogram);
png_ptr 493 example.c png_set_quantize(png_ptr, palette, num_palette,
png_ptr 500 example.c png_set_invert_mono(png_ptr);
png_ptr 506 example.c if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
png_ptr 510 example.c png_get_sBIT(png_ptr, info_ptr, &sig_bit_p);
png_ptr 511 example.c png_set_shift(png_ptr, sig_bit_p);
png_ptr 516 example.c png_set_bgr(png_ptr);
png_ptr 519 example.c png_set_swap_alpha(png_ptr);
png_ptr 522 example.c png_set_swap(png_ptr);
png_ptr 525 example.c png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
png_ptr 532 example.c number_passes = png_set_interlace_handling(png_ptr);
png_ptr 542 example.c png_read_update_info(png_ptr, info_ptr);
png_ptr 554 example.c row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr,
png_ptr 559 example.c png_read_image(png_ptr, row_pointers);
png_ptr 569 example.c png_read_rows(png_ptr, &row_pointers[y], NULL, 1);
png_ptr 576 example.c png_read_rows(png_ptr, &row_pointers[y], NULL,
png_ptr 579 example.c png_read_rows(png_ptr, NULL, &row_pointers[y],
png_ptr 590 example.c png_read_end(png_ptr, info_ptr);
png_ptr 596 example.c png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
png_ptr 608 example.c initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
png_ptr 616 example.c *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
png_ptr 619 example.c if (*png_ptr == NULL)
png_ptr 625 example.c *info_ptr = png_create_info_struct(png_ptr);
png_ptr 629 example.c png_destroy_read_struct(png_ptr, info_ptr, NULL);
png_ptr 633 example.c if (setjmp(png_jmpbuf((*png_ptr))))
png_ptr 635 example.c png_destroy_read_struct(png_ptr, info_ptr, NULL);
png_ptr 651 example.c png_set_progressive_read_fn(*png_ptr, (void *)stream_data,
png_ptr 658 example.c process_data(png_structp *png_ptr, png_infop *info_ptr,
png_ptr 661 example.c if (setjmp(png_jmpbuf((*png_ptr))))
png_ptr 664 example.c png_destroy_read_struct(png_ptr, info_ptr, NULL);
png_ptr 678 example.c png_process_data(*png_ptr, *info_ptr, buffer, length);
png_ptr 682 example.c info_callback(png_structp png_ptr, png_infop info)
png_ptr 693 example.c row_callback(png_structp png_ptr, png_bytep new_row,
png_ptr 723 example.c png_progressive_combine_row(png_ptr, old_row, new_row);
png_ptr 738 example.c png_progressive_combine_row(png_ptr, old_row, new_row);
png_ptr 750 example.c end_callback(png_structp png_ptr, png_infop info)
png_ptr 767 example.c png_structp png_ptr;
png_ptr 782 example.c png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
png_ptr 785 example.c if (png_ptr == NULL)
png_ptr 792 example.c info_ptr = png_create_info_struct(png_ptr);
png_ptr 796 example.c png_destroy_write_struct(&png_ptr, NULL);
png_ptr 803 example.c if (setjmp(png_jmpbuf(png_ptr)))
png_ptr 807 example.c png_destroy_write_struct(&png_ptr, &info_ptr);
png_ptr 815 example.c png_init_io(png_ptr, fp);
png_ptr 821 example.c png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn,
png_ptr 831 example.c png_write_png(png_ptr, info_ptr, png_transforms, NULL);
png_ptr 844 example.c png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_???,
png_ptr 848 example.c palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH
png_ptr 851 example.c png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH);
png_ptr 871 example.c png_set_sBIT(png_ptr, info_ptr, &sig_bit);
png_ptr 877 example.c png_set_gAMA(png_ptr, info_ptr, gamma);
png_ptr 921 example.c png_write_info(png_ptr, info_ptr);
png_ptr 945 example.c png_set_invert_mono(png_ptr);
png_ptr 950 example.c png_set_shift(png_ptr, &sig_bit);
png_ptr 953 example.c png_set_packing(png_ptr);
png_ptr 956 example.c png_set_swap_alpha(png_ptr);
png_ptr 961 example.c png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
png_ptr 964 example.c png_set_bgr(png_ptr);
png_ptr 967 example.c png_set_swap(png_ptr);
png_ptr 970 example.c png_set_packswap(png_ptr);
png_ptr 974 example.c number_passes = png_set_interlace_handling(png_ptr);
png_ptr 991 example.c png_error (png_ptr, "Image is too tall to process in memory");
png_ptr 1000 example.c png_write_image(png_ptr, row_pointers);
png_ptr 1012 example.c png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows);
png_ptr 1016 example.c png_write_rows(png_ptr, &row_pointers[y], 1);
png_ptr 1027 example.c png_write_end(png_ptr, info_ptr);
png_ptr 1036 example.c png_free(png_ptr, palette);
png_ptr 1043 example.c png_free(png_ptr, trans);
png_ptr 1052 example.c png_destroy_write_struct(&png_ptr, &info_ptr);
png_ptr 31 png.c if (png_ptr == NULL)
png_ptr 35 png.c png_error(png_ptr, "Too many bytes for PNG signature");
png_ptr 37 png.c png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
png_ptr 77 png.c if (png_ptr == NULL)
png_ptr 82 png.c png_warning (png_voidcast(png_structrp, png_ptr),
png_ptr 88 png.c return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes);
png_ptr 95 png.c png_free(png_voidcast(png_const_structrp,png_ptr), ptr);
png_ptr 105 png.c png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0);
png_ptr 118 png.c if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name))
png_ptr 120 png.c if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
png_ptr 127 png.c if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
png_ptr 138 png.c uLong crc = png_ptr->crc; /* Should never issue a warning */
png_ptr 158 png.c png_ptr->crc = (png_uint_32)crc;
png_ptr 175 png.c png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
png_ptr 180 png.c png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
png_ptr 182 png.c if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
png_ptr 206 png.c png_warning(png_ptr, m);
png_ptr 210 png.c png_ptr->flags = 0;
png_ptr 294 png.c png_structrp png_ptr = png_voidcast(png_structrp,
png_ptr 295 png.c png_malloc_warn(&create_struct, (sizeof *png_ptr)));
png_ptr 297 png.c if (png_ptr != NULL)
png_ptr 304 png.c create_struct.zstream.opaque = png_ptr;
png_ptr 313 png.c *png_ptr = create_struct;
png_ptr 316 png.c return png_ptr;
png_ptr 335 png.c if (png_ptr == NULL)
png_ptr 343 png.c info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,
png_ptr 367 png.c if (png_ptr == NULL)
png_ptr 383 png.c png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
png_ptr 385 png.c png_free(png_ptr, info_ptr);
png_ptr 430 png.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 440 png.c png_error(png_ptr, "Unknown freer parameter in png_data_freer");
png_ptr 449 png.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 460 png.c png_free(png_ptr, info_ptr->text[num].key);
png_ptr 469 png.c png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
png_ptr 470 png.c png_free(png_ptr, info_ptr->text);
png_ptr 481 png.c png_free(png_ptr, info_ptr->trans_alpha);
png_ptr 491 png.c png_free(png_ptr, info_ptr->scal_s_width);
png_ptr 492 png.c png_free(png_ptr, info_ptr->scal_s_height);
png_ptr 503 png.c png_free(png_ptr, info_ptr->pcal_purpose);
png_ptr 504 png.c png_free(png_ptr, info_ptr->pcal_units);
png_ptr 512 png.c png_free(png_ptr, info_ptr->pcal_params[i]);
png_ptr 515 png.c png_free(png_ptr, info_ptr->pcal_params);
png_ptr 526 png.c png_free(png_ptr, info_ptr->iccp_name);
png_ptr 527 png.c png_free(png_ptr, info_ptr->iccp_profile);
png_ptr 542 png.c png_free(png_ptr, info_ptr->splt_palettes[num].name);
png_ptr 543 png.c png_free(png_ptr, info_ptr->splt_palettes[num].entries);
png_ptr 555 png.c png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, (int)i);
png_ptr 557 png.c png_free(png_ptr, info_ptr->splt_palettes);
png_ptr 573 png.c png_free(png_ptr, info_ptr->unknown_chunks[num].data);
png_ptr 585 png.c png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, (int)i);
png_ptr 587 png.c png_free(png_ptr, info_ptr->unknown_chunks);
png_ptr 599 png.c png_free(png_ptr, info_ptr->hist);
png_ptr 608 png.c png_free(png_ptr, info_ptr->palette);
png_ptr 623 png.c png_free(png_ptr, info_ptr->row_pointers[row]);
png_ptr 626 png.c png_free(png_ptr, info_ptr->row_pointers);
png_ptr 647 png.c if (png_ptr == NULL)
png_ptr 650 png.c return (png_ptr->io_ptr);
png_ptr 666 png.c if (png_ptr == NULL)
png_ptr 669 png.c png_ptr->io_ptr = (png_voidp)fp;
png_ptr 750 png.c if (png_ptr != NULL)
png_ptr 753 png.c if (!png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime))
png_ptr 754 png.c png_warning(png_ptr, "Ignoring invalid time value");
png_ptr 757 png.c return png_ptr->time_buffer;
png_ptr 770 png.c PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
png_ptr 802 png.c return png_get_header_ver(png_ptr);
png_ptr 809 png.c PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
png_ptr 817 png.c PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
png_ptr 893 png.c if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0)
png_ptr 896 png.c p_end = png_ptr->chunk_list;
png_ptr 897 png.c p = p_end + png_ptr->num_chunk_list*5; /* beyond end */
png_ptr 928 png.c return png_handle_as_unknown(png_ptr, chunk_string);
png_ptr 938 png.c if (png_ptr == NULL)
png_ptr 942 png.c return (inflateReset(&png_ptr->zstream));
png_ptr 968 png.c if (png_ptr->zstream.msg == NULL) switch (ret)
png_ptr 972 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code");
png_ptr 977 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream");
png_ptr 984 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary");
png_ptr 989 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error");
png_ptr 994 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib");
png_ptr 998 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream");
png_ptr 1002 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory");
png_ptr 1009 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated");
png_ptr 1013 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version");
png_ptr 1022 png.c png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return");
png_ptr 1060 png.c png_chunk_report(png_ptr, "gamma value does not match sRGB",
png_ptr 1068 png.c png_chunk_report(png_ptr, "gamma value does not match libpng estimate",
png_ptr 1099 png.c else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
png_ptr 1110 png.c if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA, 1/*from gAMA*/))
png_ptr 1128 png.c png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR);
png_ptr 1142 png.c png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/);
png_ptr 1144 png.c PNG_UNUSED(png_ptr)
png_ptr 1183 png.c info_ptr->colorspace = png_ptr->colorspace;
png_ptr 1184 png.c png_colorspace_sync_info(png_ptr, info_ptr);
png_ptr 1623 png.c png_benign_error(png_ptr, "inconsistent chromaticities");
png_ptr 1664 png.c return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ,
png_ptr 1672 png.c png_benign_error(png_ptr, "invalid chromaticities");
png_ptr 1680 png.c png_error(png_ptr, "internal error checking chromaticities");
png_ptr 1697 png.c return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ,
png_ptr 1703 png.c png_benign_error(png_ptr, "invalid end points");
png_ptr 1708 png.c png_error(png_ptr, "internal error checking chromaticities");
png_ptr 1795 png.c png_chunk_report(png_ptr, message,
png_ptr 1841 png.c return png_icc_profile_error(png_ptr, colorspace, "sRGB",
png_ptr 1846 png.c return png_icc_profile_error(png_ptr, colorspace, "sRGB",
png_ptr 1851 png.c png_benign_error(png_ptr, "duplicate sRGB information ignored");
png_ptr 1861 png.c png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",
png_ptr 1867 png.c (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE,
png_ptr 1906 png.c return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
png_ptr 1926 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 1931 png.c return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
png_ptr 1937 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 1945 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 1952 png.c (void)png_icc_profile_error(png_ptr, NULL, name, temp,
png_ptr 1969 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 1980 png.c (void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/,
png_ptr 2008 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 2014 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 2019 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 2044 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 2054 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 2062 png.c (void)png_icc_profile_error(png_ptr, NULL, name, temp,
png_ptr 2072 png.c (void)png_icc_profile_error(png_ptr, NULL, name, temp,
png_ptr 2088 png.c return png_icc_profile_error(png_ptr, colorspace, name, temp,
png_ptr 2125 png.c (void)png_icc_profile_error(png_ptr, NULL, name, tag_id,
png_ptr 2133 png.c return png_icc_profile_error(png_ptr, colorspace, name, tag_id,
png_ptr 2224 png.c if (((png_ptr->options >> PNG_SKIP_sRGB_CHECK_PROFILE) & 3) ==
png_ptr 2288 png.c png_chunk_report(png_ptr, "known incorrect sRGB profile",
png_ptr 2298 png.c png_chunk_report(png_ptr, "out-of-date sRGB profile with"
png_ptr 2312 png.c png_chunk_report(png_ptr, "Not recognizing known sRGB profile that"
png_ptr 2334 png.c if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler))
png_ptr 2336 png.c (void)png_colorspace_set_sRGB(png_ptr, colorspace,
png_ptr 2349 png.c if (png_icc_check_length(png_ptr, colorspace, name, profile_length) &&
png_ptr 2350 png.c png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,
png_ptr 2352 png.c png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
png_ptr 2357 png.c png_icc_set_sRGB(png_ptr, colorspace, profile, 0);
png_ptr 2372 png.c if (!png_ptr->rgb_to_gray_coefficients_set &&
png_ptr 2373 png.c (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
png_ptr 2378 png.c png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y;
png_ptr 2379 png.c png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y;
png_ptr 2380 png.c png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y;
png_ptr 2413 png.c png_error(png_ptr,
png_ptr 2418 png.c png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r;
png_ptr 2419 png.c png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g;
png_ptr 2428 png.c png_error(png_ptr, "internal error handling cHRM->XYZ");
png_ptr 2446 png.c png_warning(png_ptr, "Image width is zero in IHDR");
png_ptr 2451 png.c png_warning(png_ptr, "Invalid image width in IHDR");
png_ptr 2457 png.c if (width > png_ptr->user_width_max)
png_ptr 2462 png.c png_warning(png_ptr, "Image width exceeds user limit in IHDR");
png_ptr 2469 png.c png_warning(png_ptr, "Image height is zero in IHDR");
png_ptr 2474 png.c png_warning(png_ptr, "Invalid image height in IHDR");
png_ptr 2480 png.c if (height > png_ptr->user_height_max)
png_ptr 2485 png.c png_warning(png_ptr, "Image height exceeds user limit in IHDR");
png_ptr 2494 png.c png_warning(png_ptr, "Invalid bit depth in IHDR");
png_ptr 2501 png.c png_warning(png_ptr, "Invalid color type in IHDR");
png_ptr 2510 png.c png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
png_ptr 2516 png.c png_warning(png_ptr, "Unknown interlace method in IHDR");
png_ptr 2522 png.c png_warning(png_ptr, "Unknown compression method in IHDR");
png_ptr 2536 png.c if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&
png_ptr 2537 png.c png_ptr->mng_features_permitted)
png_ptr 2538 png.c png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
png_ptr 2542 png.c if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
png_ptr 2544 png.c ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
png_ptr 2548 png.c png_warning(png_ptr, "Unknown filter method in IHDR");
png_ptr 2552 png.c if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)
png_ptr 2554 png.c png_warning(png_ptr, "Invalid filter method in IHDR");
png_ptr 2562 png.c png_warning(png_ptr, "Unknown filter method in IHDR");
png_ptr 2568 png.c png_error(png_ptr, "Invalid IHDR data");
png_ptr 3069 png.c png_error(png_ptr, "ASCII conversion buffer too small");
png_ptr 3143 png.c png_error(png_ptr, "ASCII conversion buffer too small");
png_ptr 3161 png.c png_fixed_error(png_ptr, text);
png_ptr 3307 png.c png_warning(png_ptr, "fixed point overflow ignored");
png_ptr 3742 png.c if (png_ptr->bit_depth == 8)
png_ptr 3774 png.c (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
png_ptr 3779 png.c (png_uint_16p)png_malloc(png_ptr, 256 * (sizeof (png_uint_16)));
png_ptr 3841 png.c (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
png_ptr 3848 png.c table[i] = (png_uint_16p)png_malloc(png_ptr,
png_ptr 3904 png.c png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
png_ptr 3919 png.c png_free(png_ptr, png_ptr->gamma_table);
png_ptr 3920 png.c png_ptr->gamma_table = NULL;
png_ptr 3923 png.c if (png_ptr->gamma_16_table != NULL)
png_ptr 3926 png.c int istop = (1 << (8 - png_ptr->gamma_shift));
png_ptr 3929 png.c png_free(png_ptr, png_ptr->gamma_16_table[i]);
png_ptr 3931 png.c png_free(png_ptr, png_ptr->gamma_16_table);
png_ptr 3932 png.c png_ptr->gamma_16_table = NULL;
png_ptr 3939 png.c png_free(png_ptr, png_ptr->gamma_from_1);
png_ptr 3940 png.c png_ptr->gamma_from_1 = NULL;
png_ptr 3941 png.c png_free(png_ptr, png_ptr->gamma_to_1);
png_ptr 3942 png.c png_ptr->gamma_to_1 = NULL;
png_ptr 3945 png.c if (png_ptr->gamma_16_from_1 != NULL)
png_ptr 3948 png.c int istop = (1 << (8 - png_ptr->gamma_shift));
png_ptr 3951 png.c png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
png_ptr 3953 png.c png_free(png_ptr, png_ptr->gamma_16_from_1);
png_ptr 3954 png.c png_ptr->gamma_16_from_1 = NULL;
png_ptr 3956 png.c if (png_ptr->gamma_16_to_1 != NULL)
png_ptr 3959 png.c int istop = (1 << (8 - png_ptr->gamma_shift));
png_ptr 3962 png.c png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
png_ptr 3964 png.c png_free(png_ptr, png_ptr->gamma_16_to_1);
png_ptr 3965 png.c png_ptr->gamma_16_to_1 = NULL;
png_ptr 3987 png.c if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
png_ptr 3989 png.c png_warning(png_ptr, "gamma table being rebuilt");
png_ptr 3990 png.c png_destroy_gamma_table(png_ptr);
png_ptr 3995 png.c png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
png_ptr 3996 png.c png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
png_ptr 3997 png.c png_ptr->screen_gamma) : PNG_FP_1);
png_ptr 4002 png.c if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))
png_ptr 4004 png.c png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
png_ptr 4005 png.c png_reciprocal(png_ptr->colorspace.gamma));
png_ptr 4007 png.c png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
png_ptr 4008 png.c png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
png_ptr 4009 png.c png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
png_ptr 4018 png.c if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
png_ptr 4020 png.c sig_bit = png_ptr->sig_bit.red;
png_ptr 4022 png.c if (png_ptr->sig_bit.green > sig_bit)
png_ptr 4023 png.c sig_bit = png_ptr->sig_bit.green;
png_ptr 4025 png.c if (png_ptr->sig_bit.blue > sig_bit)
png_ptr 4026 png.c sig_bit = png_ptr->sig_bit.blue;
png_ptr 4029 png.c sig_bit = png_ptr->sig_bit.gray;
png_ptr 4055 png.c if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8))
png_ptr 4068 png.c png_ptr->gamma_shift = shift;
png_ptr 4075 png.c if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8))
png_ptr 4076 png.c png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
png_ptr 4077 png.c png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma,
png_ptr 4078 png.c png_ptr->screen_gamma) : PNG_FP_1);
png_ptr 4081 png.c png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
png_ptr 4082 png.c png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
png_ptr 4083 png.c png_ptr->screen_gamma) : PNG_FP_1);
png_ptr 4088 png.c if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))
png_ptr 4090 png.c png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
png_ptr 4091 png.c png_reciprocal(png_ptr->colorspace.gamma));
png_ptr 4097 png.c png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
png_ptr 4098 png.c png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
png_ptr 4099 png.c png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
png_ptr 4112 png.c if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT &&
png_ptr 4117 png.c int current = png_ptr->options;
png_ptr 4119 png.c png_ptr->options = (png_byte)((current & ~mask) | setting);
png_ptr 4309 png.c if (cp->png_ptr == NULL)
png_ptr 4316 png.c FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr);
png_ptr 4322 png.c cp->png_ptr->io_ptr = NULL;
png_ptr 4335 png.c png_free(c.png_ptr, cp);
png_ptr 4341 png.c png_destroy_write_struct(&c.png_ptr, &c.info_ptr);
png_ptr 4343 png.c png_error(c.png_ptr, "simplified write not supported");
png_ptr 4349 png.c png_destroy_read_struct(&c.png_ptr, &c.info_ptr, NULL);
png_ptr 4351 png.c png_error(c.png_ptr, "simplified read not supported");
png_ptr 1038 png.h PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes));
png_ptr 1066 png.h (png_const_structrp png_ptr));
png_ptr 1068 png.h PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr,
png_ptr 1082 png.h PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr,
png_ptr 1085 png.h (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf))))
png_ptr 1095 png.h PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val),
png_ptr 1100 png.h PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED);
png_ptr 1118 png.h PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr));
png_ptr 1121 png.h PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep
png_ptr 1125 png.h PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
png_ptr 1129 png.h PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr,
png_ptr 1133 png.h PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
png_ptr 1136 png.h PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr),
png_ptr 1148 png.h (png_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 1150 png.h (png_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 1155 png.h (png_structrp png_ptr, png_inforp info_ptr));
png_ptr 1165 png.h PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr,
png_ptr 1183 png.h PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr));
png_ptr 1184 png.h PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr));
png_ptr 1185 png.h PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr));
png_ptr 1186 png.h PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr));
png_ptr 1193 png.h PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr));
png_ptr 1198 png.h PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr));
png_ptr 1203 png.h PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr));
png_ptr 1213 png.h PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr,
png_ptr 1215 png.h PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structrp png_ptr,
png_ptr 1219 png.h png_ptr));
png_ptr 1269 png.h PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structrp png_ptr, int mode,
png_ptr 1271 png.h PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr,
png_ptr 1362 png.h PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr));
png_ptr 1367 png.h PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr));
png_ptr 1372 png.h PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr));
png_ptr 1377 png.h PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler,
png_ptr 1383 png.h PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr,
png_ptr 1389 png.h PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr));
png_ptr 1394 png.h PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr));
png_ptr 1400 png.h PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr));
png_ptr 1405 png.h PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p
png_ptr 1417 png.h PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr));
png_ptr 1422 png.h PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr));
png_ptr 1431 png.h PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr,
png_ptr 1434 png.h PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structrp png_ptr,
png_ptr 1447 png.h PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr));
png_ptr 1453 png.h PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr));
png_ptr 1460 png.h PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr,
png_ptr 1482 png.h PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr,
png_ptr 1484 png.h PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structrp png_ptr,
png_ptr 1490 png.h PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows));
png_ptr 1492 png.h PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr));
png_ptr 1496 png.h PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr));
png_ptr 1499 png.h PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr,
png_ptr 1504 png.h PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row,
png_ptr 1510 png.h PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row,
png_ptr 1516 png.h PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image));
png_ptr 1520 png.h PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr,
png_ptr 1528 png.h PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row,
png_ptr 1532 png.h PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image));
png_ptr 1535 png.h PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr,
png_ptr 1540 png.h PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr));
png_ptr 1544 png.h PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr,
png_ptr 1556 png.h PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action,
png_ptr 1586 png.h PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
png_ptr 1642 png.h PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr,
png_ptr 1646 png.h (png_structrp png_ptr, int heuristic_method, int num_weights,
png_ptr 1667 png.h PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr,
png_ptr 1670 png.h PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr,
png_ptr 1673 png.h PNG_EXPORT(71, void, png_set_compression_strategy, (png_structrp png_ptr,
png_ptr 1679 png.h PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr,
png_ptr 1682 png.h PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr,
png_ptr 1688 png.h PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr,
png_ptr 1691 png.h PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr,
png_ptr 1694 png.h PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr,
png_ptr 1701 png.h (png_structrp png_ptr, int window_bits));
png_ptr 1703 png.h PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr,
png_ptr 1718 png.h PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp));
png_ptr 1729 png.h PNG_EXPORT(75, void, png_set_error_fn, (png_structrp png_ptr,
png_ptr 1733 png.h PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr));
png_ptr 1745 png.h PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr,
png_ptr 1749 png.h PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr,
png_ptr 1753 png.h PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr));
png_ptr 1755 png.h PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr,
png_ptr 1758 png.h PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr,
png_ptr 1763 png.h PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr,
png_ptr 1766 png.h PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr));
png_ptr 1770 png.h PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr,
png_ptr 1775 png.h PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr,
png_ptr 1780 png.h PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr,
png_ptr 1785 png.h (png_const_structrp png_ptr));
png_ptr 1824 png.h PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr,
png_ptr 1829 png.h PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr));
png_ptr 1836 png.h PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr,
png_ptr 1842 png.h (png_const_structrp png_ptr));
png_ptr 1845 png.h PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
png_ptr 1870 png.h PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr,
png_ptr 1874 png.h PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr,
png_ptr 1877 png.h PNG_EXPORTA(95, png_voidp, png_calloc, (png_const_structrp png_ptr,
png_ptr 1881 png.h PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr,
png_ptr 1885 png.h PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr));
png_ptr 1888 png.h PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr,
png_ptr 1898 png.h PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
png_ptr 1923 png.h PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
png_ptr 1925 png.h PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr,
png_ptr 1931 png.h PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr,
png_ptr 1935 png.h PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr,
png_ptr 1940 png.h PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN);
png_ptr 1947 png.h PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr,
png_ptr 1951 png.h PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr,
png_ptr 1961 png.h PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr,
png_ptr 1966 png.h PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr,
png_ptr 1971 png.h (png_structrp png_ptr, int allowed));
png_ptr 1995 png.h PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr,
png_ptr 1999 png.h PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr,
png_ptr 2006 png.h PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr,
png_ptr 2012 png.h PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr,
png_ptr 2017 png.h PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr,
png_ptr 2022 png.h PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr,
png_ptr 2026 png.h PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr,
png_ptr 2030 png.h PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr,
png_ptr 2034 png.h PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr,
png_ptr 2038 png.h PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr,
png_ptr 2042 png.h PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr,
png_ptr 2046 png.h PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr,
png_ptr 2051 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2053 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2055 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2059 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr))
png_ptr 2061 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr))
png_ptr 2065 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2067 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2069 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2071 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2077 png.h PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr,
png_ptr 2082 png.h PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr,
png_ptr 2087 png.h PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr,
png_ptr 2092 png.h PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structrp png_ptr,
png_ptr 2096 png.h PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_const_structrp png_ptr,
png_ptr 2101 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr,
png_ptr 2107 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr,
png_ptr 2116 png.h PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr,
png_ptr 2120 png.h PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_const_structrp png_ptr,
png_ptr 2124 png.h PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr,
png_ptr 2130 png.h PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr,
png_ptr 2139 png.h PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, (png_const_structrp png_ptr,
png_ptr 2142 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr,
png_ptr 2147 png.h PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr,
png_ptr 2149 png.h PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr,
png_ptr 2154 png.h PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr,
png_ptr 2159 png.h PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr,
png_ptr 2163 png.h PNG_EXPORT(143, png_uint_32, png_get_IHDR, (png_const_structrp png_ptr,
png_ptr 2168 png.h PNG_EXPORT(144, void, png_set_IHDR, (png_const_structrp png_ptr,
png_ptr 2174 png.h PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr,
png_ptr 2180 png.h PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr,
png_ptr 2186 png.h PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr,
png_ptr 2193 png.h PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr,
png_ptr 2199 png.h PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr,
png_ptr 2205 png.h PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr,
png_ptr 2209 png.h PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr,
png_ptr 2212 png.h PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr,
png_ptr 2216 png.h PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr,
png_ptr 2221 png.h PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr,
png_ptr 2226 png.h PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr,
png_ptr 2231 png.h PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr,
png_ptr 2233 png.h PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr,
png_ptr 2238 png.h PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr,
png_ptr 2244 png.h PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr,
png_ptr 2250 png.h PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr,
png_ptr 2255 png.h PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr,
png_ptr 2261 png.h PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr,
png_ptr 2273 png.h PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr,
png_ptr 2278 png.h PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr,
png_ptr 2283 png.h PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr,
png_ptr 2288 png.h PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr,
png_ptr 2294 png.h PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr,
png_ptr 2300 png.h PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr,
png_ptr 2310 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
png_ptr 2314 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
png_ptr 2317 png.h PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr,
png_ptr 2319 png.h PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr,
png_ptr 2322 png.h PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
png_ptr 2426 png.h PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
png_ptr 2433 png.h PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr,
png_ptr 2438 png.h PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr,
png_ptr 2451 png.h (png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location));
png_ptr 2453 png.h PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structrp png_ptr,
png_ptr 2461 png.h PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr,
png_ptr 2467 png.h PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr,
png_ptr 2471 png.h PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr,
png_ptr 2477 png.h (png_const_structrp png_ptr));
png_ptr 2479 png.h (png_const_structrp png_ptr));
png_ptr 2481 png.h (png_const_structrp png_ptr));
png_ptr 2483 png.h (png_const_structrp png_ptr));
png_ptr 2486 png.h PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr,
png_ptr 2501 png.h PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr,
png_ptr 2507 png.h PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr,
png_ptr 2510 png.h (png_const_structrp png_ptr));
png_ptr 2512 png.h (png_const_structrp png_ptr));
png_ptr 2514 png.h PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr,
png_ptr 2517 png.h (png_const_structrp png_ptr));
png_ptr 2519 png.h PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr,
png_ptr 2522 png.h (png_const_structrp png_ptr));
png_ptr 2527 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2530 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2533 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr));
png_ptr 2536 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr))
png_ptr 2539 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr))
png_ptr 2542 png.h PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structrp png_ptr,
png_ptr 2546 png.h (png_const_structrp png_ptr, png_const_inforp info_ptr))
png_ptr 2550 png.h PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr,
png_ptr 2558 png.h PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr));
png_ptr 2561 png.h PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr),
png_ptr 2565 png.h (png_const_structrp png_ptr));
png_ptr 2689 png.h PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr,
png_ptr 3209 png.h (png_structrp png_ptr, int allowed));
png_ptr 3211 png.h PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
png_ptr 3251 png.h PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option,
png_ptr 44 pngerror.c if (png_ptr != NULL)
png_ptr 46 pngerror.c if (png_ptr->flags&
png_ptr 57 pngerror.c if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
png_ptr 72 pngerror.c if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
png_ptr 82 pngerror.c if (png_ptr != NULL && png_ptr->error_fn != NULL)
png_ptr 83 pngerror.c (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr),
png_ptr 88 pngerror.c png_default_error(png_ptr, error_message);
png_ptr 99 pngerror.c if (png_ptr != NULL && png_ptr->error_fn != NULL)
png_ptr 100 pngerror.c (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr), "");
png_ptr 104 pngerror.c png_default_error(png_ptr, "");
png_ptr 219 pngerror.c if (png_ptr != NULL)
png_ptr 222 pngerror.c if (png_ptr->flags&
png_ptr 234 pngerror.c if (png_ptr != NULL && png_ptr->warning_fn != NULL)
png_ptr 235 pngerror.c (*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr),
png_ptr 238 pngerror.c png_default_warning(png_ptr, warning_message + offset);
png_ptr 356 pngerror.c png_warning(png_ptr, msg);
png_ptr 364 pngerror.c if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
png_ptr 367 pngerror.c if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
png_ptr 368 pngerror.c png_ptr->chunk_name != 0)
png_ptr 369 pngerror.c png_chunk_warning(png_ptr, error_message);
png_ptr 372 pngerror.c png_warning(png_ptr, error_message);
png_ptr 378 pngerror.c if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
png_ptr 379 pngerror.c png_ptr->chunk_name != 0)
png_ptr 380 pngerror.c png_chunk_error(png_ptr, error_message);
png_ptr 383 pngerror.c png_error(png_ptr, error_message);
png_ptr 394 pngerror.c if (png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN)
png_ptr 395 pngerror.c png_warning(png_ptr, error_message);
png_ptr 397 pngerror.c png_error(png_ptr, error_message);
png_ptr 407 pngerror.c if (png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN)
png_ptr 408 pngerror.c png_warning(png_ptr, error_message);
png_ptr 410 pngerror.c png_error(png_ptr, error_message);
png_ptr 437 pngerror.c png_uint_32 chunk_name = png_ptr->chunk_name;
png_ptr 484 pngerror.c if (png_ptr == NULL)
png_ptr 485 pngerror.c png_error(png_ptr, error_message);
png_ptr 489 pngerror.c png_format_buffer(png_ptr, msg, error_message);
png_ptr 490 pngerror.c png_error(png_ptr, msg);
png_ptr 500 pngerror.c if (png_ptr == NULL)
png_ptr 501 pngerror.c png_warning(png_ptr, warning_message);
png_ptr 505 pngerror.c png_format_buffer(png_ptr, msg, warning_message);
png_ptr 506 pngerror.c png_warning(png_ptr, msg);
png_ptr 517 pngerror.c if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
png_ptr 518 pngerror.c png_chunk_warning(png_ptr, error_message);
png_ptr 521 pngerror.c png_chunk_error(png_ptr, error_message);
png_ptr 541 pngerror.c if (png_ptr->mode & PNG_IS_READ_STRUCT)
png_ptr 547 pngerror.c png_chunk_warning(png_ptr, message);
png_ptr 550 pngerror.c png_chunk_benign_error(png_ptr, message);
png_ptr 555 pngerror.c else if (!(png_ptr->mode & PNG_IS_READ_STRUCT))
png_ptr 561 pngerror.c png_app_warning(png_ptr, message);
png_ptr 564 pngerror.c png_app_error(png_ptr, message);
png_ptr 586 pngerror.c png_error(png_ptr, msg);
png_ptr 609 pngerror.c if (png_ptr == NULL)
png_ptr 612 pngerror.c if (png_ptr->jmp_buf_ptr == NULL)
png_ptr 614 pngerror.c png_ptr->jmp_buf_size = 0; /* not allocated */
png_ptr 616 pngerror.c if (jmp_buf_size <= (sizeof png_ptr->jmp_buf_local))
png_ptr 617 pngerror.c png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local;
png_ptr 621 pngerror.c png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *,
png_ptr 622 pngerror.c png_malloc_warn(png_ptr, jmp_buf_size));
png_ptr 624 pngerror.c if (png_ptr->jmp_buf_ptr == NULL)
png_ptr 627 pngerror.c png_ptr->jmp_buf_size = jmp_buf_size;
png_ptr 633 pngerror.c size_t size = png_ptr->jmp_buf_size;
png_ptr 637 pngerror.c size = (sizeof png_ptr->jmp_buf_local);
png_ptr 638 pngerror.c if (png_ptr->jmp_buf_ptr != &png_ptr->jmp_buf_local)
png_ptr 645 pngerror.c png_error(png_ptr, "Libpng jmp_buf still allocated");
png_ptr 652 pngerror.c png_warning(png_ptr, "Application jmp_buf size changed");
png_ptr 660 pngerror.c png_ptr->longjmp_fn = longjmp_fn;
png_ptr 661 pngerror.c return png_ptr->jmp_buf_ptr;
png_ptr 667 pngerror.c if (png_ptr != NULL)
png_ptr 669 pngerror.c jmp_buf *jb = png_ptr->jmp_buf_ptr;
png_ptr 674 pngerror.c if (jb != NULL && png_ptr->jmp_buf_size > 0)
png_ptr 681 pngerror.c if (jb != &png_ptr->jmp_buf_local)
png_ptr 688 pngerror.c png_ptr->jmp_buf_ptr = &free_jmp_buf; /* come back here */
png_ptr 689 pngerror.c png_ptr->jmp_buf_size = 0; /* stack allocation */
png_ptr 690 pngerror.c png_ptr->longjmp_fn = longjmp;
png_ptr 691 pngerror.c png_free(png_ptr, jb); /* Return to setjmp on error */
png_ptr 697 pngerror.c png_ptr->jmp_buf_size = 0;
png_ptr 698 pngerror.c png_ptr->jmp_buf_ptr = NULL;
png_ptr 699 pngerror.c png_ptr->longjmp_fn = 0;
png_ptr 753 pngerror.c png_longjmp(png_ptr, 1);
png_ptr 760 pngerror.c if (png_ptr && png_ptr->longjmp_fn && png_ptr->jmp_buf_ptr)
png_ptr 761 pngerror.c png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val);
png_ptr 763 pngerror.c PNG_UNUSED(png_ptr)
png_ptr 823 pngerror.c PNG_UNUSED(png_ptr) /* Make compiler happy */
png_ptr 836 pngerror.c if (png_ptr == NULL)
png_ptr 839 pngerror.c png_ptr->error_ptr = error_ptr;
png_ptr 840 pngerror.c png_ptr->error_fn = error_fn;
png_ptr 842 pngerror.c png_ptr->warning_fn = warning_fn;
png_ptr 856 pngerror.c if (png_ptr == NULL)
png_ptr 859 pngerror.c return ((png_voidp)png_ptr->error_ptr);
png_ptr 867 pngerror.c if (png_ptr != NULL)
png_ptr 869 pngerror.c png_ptr->flags &=
png_ptr 886 pngerror.c const png_const_structrp png_ptr = png_nonconst_ptr;
png_ptr 887 pngerror.c png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
png_ptr 921 pngerror.c const png_const_structrp png_ptr = png_nonconst_ptr;
png_ptr 922 pngerror.c png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
png_ptr 23 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 32 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 42 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 54 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 63 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 72 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 81 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 90 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 99 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 108 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 119 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
png_ptr 128 pngget.c PNG_UNUSED(png_ptr)
png_ptr 140 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
png_ptr 149 pngget.c PNG_UNUSED(png_ptr)
png_ptr 160 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
png_ptr 169 pngget.c PNG_UNUSED(png_ptr)
png_ptr 182 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
png_ptr 191 pngget.c PNG_UNUSED(png_ptr)
png_ptr 205 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)
png_ptr 222 pngget.c PNG_UNUSED(png_ptr)
png_ptr 234 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
png_ptr 242 pngget.c PNG_UNUSED(png_ptr)
png_ptr 253 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
png_ptr 261 pngget.c PNG_UNUSED(png_ptr)
png_ptr 272 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
png_ptr 280 pngget.c PNG_UNUSED(png_ptr)
png_ptr 291 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
png_ptr 299 pngget.c PNG_UNUSED(png_ptr)
png_ptr 342 pngget.c return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
png_ptr 348 pngget.c return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));
png_ptr 354 pngget.c return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));
png_ptr 366 pngget.c return png_muldiv_warn(png_ptr, microns, 500, 127);
png_ptr 373 pngget.c return png_fixed_inches_from_microns(png_ptr,
png_ptr 374 pngget.c png_get_x_offset_microns(png_ptr, info_ptr));
png_ptr 383 pngget.c return png_fixed_inches_from_microns(png_ptr,
png_ptr 384 pngget.c png_get_y_offset_microns(png_ptr, info_ptr));
png_ptr 395 pngget.c return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);
png_ptr 406 pngget.c return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);
png_ptr 417 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
png_ptr 459 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 469 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 481 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
png_ptr 511 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 517 pngget.c *white_x = png_float(png_ptr,
png_ptr 520 pngget.c *white_y = png_float(png_ptr,
png_ptr 523 pngget.c *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx,
png_ptr 526 pngget.c *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy,
png_ptr 529 pngget.c *green_x = png_float(png_ptr,
png_ptr 532 pngget.c *green_y = png_float(png_ptr,
png_ptr 535 pngget.c *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex,
png_ptr 538 pngget.c *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey,
png_ptr 552 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 558 pngget.c *red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X,
png_ptr 561 pngget.c *red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y,
png_ptr 564 pngget.c *red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z,
png_ptr 567 pngget.c *green_X = png_float(png_ptr,
png_ptr 570 pngget.c *green_Y = png_float(png_ptr,
png_ptr 573 pngget.c *green_Z = png_float(png_ptr,
png_ptr 576 pngget.c *blue_X = png_float(png_ptr,
png_ptr 579 pngget.c *blue_Y = png_float(png_ptr,
png_ptr 582 pngget.c *blue_Z = png_float(png_ptr,
png_ptr 600 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 637 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 672 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 691 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 695 pngget.c *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma,
png_ptr 712 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
png_ptr 731 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
png_ptr 754 pngget.c if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
png_ptr 771 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
png_ptr 790 pngget.c if (png_ptr == NULL || info_ptr == NULL || width == NULL ||
png_ptr 813 pngget.c png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height,
png_ptr 827 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
png_ptr 848 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
png_ptr 874 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 882 pngget.c *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");
png_ptr 883 pngget.c *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),
png_ptr 897 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 913 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 935 pngget.c if (png_ptr != NULL && info_ptr != NULL &&
png_ptr 967 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
png_ptr 986 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
png_ptr 1002 pngget.c if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
png_ptr 1005 pngget.c (unsigned long)png_ptr->chunk_name);
png_ptr 1030 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
png_ptr 1047 pngget.c if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
png_ptr 1091 pngget.c if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
png_ptr 1105 pngget.c return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
png_ptr 1113 pngget.c return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
png_ptr 1120 pngget.c if (png_ptr == NULL)
png_ptr 1124 pngget.c if (png_ptr->mode & PNG_IS_READ_STRUCT)
png_ptr 1128 pngget.c return png_ptr->IDAT_read_size;
png_ptr 1136 pngget.c return png_ptr->zbuffer_size;
png_ptr 1146 pngget.c return (png_ptr ? png_ptr->user_width_max : 0);
png_ptr 1152 pngget.c return (png_ptr ? png_ptr->user_height_max : 0);
png_ptr 1159 pngget.c return (png_ptr ? png_ptr->user_chunk_cache_max : 0);
png_ptr 1166 pngget.c return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
png_ptr 1175 pngget.c return png_ptr->io_state;
png_ptr 1181 pngget.c return png_ptr->chunk_name;
png_ptr 1190 pngget.c if (png_ptr != NULL && info_ptr != NULL)
png_ptr 1191 pngget.c return png_ptr->num_palette_max;
png_ptr 27 pngmem.c if (png_ptr != NULL)
png_ptr 32 pngmem.c png_struct dummy_struct = *png_ptr;
png_ptr 33 pngmem.c memset(png_ptr, 0, (sizeof *png_ptr));
png_ptr 34 pngmem.c png_free(&dummy_struct, png_ptr);
png_ptr 54 pngmem.c ret = png_malloc(png_ptr, size);
png_ptr 77 pngmem.c PNG_UNUSED(png_ptr)
png_ptr 87 pngmem.c if (png_ptr != NULL && png_ptr->malloc_fn != NULL)
png_ptr 88 pngmem.c return png_ptr->malloc_fn(png_constcast(png_structrp,png_ptr), size);
png_ptr 112 pngmem.c return png_malloc_base(png_ptr, req * element_size);
png_ptr 123 pngmem.c png_error(png_ptr, "internal error: array alloc");
png_ptr 125 pngmem.c return png_malloc_array_checked(png_ptr, nelements, element_size);
png_ptr 135 pngmem.c png_error(png_ptr, "internal error: array realloc");
png_ptr 142 pngmem.c png_voidp new_array = png_malloc_array_checked(png_ptr,
png_ptr 173 pngmem.c if (png_ptr == NULL)
png_ptr 176 pngmem.c ret = png_malloc_base(png_ptr, size);
png_ptr 179 pngmem.c png_error(png_ptr, "Out of memory"); /* 'm' means png_malloc */
png_ptr 191 pngmem.c if (png_ptr == NULL)
png_ptr 198 pngmem.c png_error(png_ptr, "Out of Memory"); /* 'M' means png_malloc_default */
png_ptr 212 pngmem.c if (png_ptr != NULL)
png_ptr 214 pngmem.c png_voidp ret = png_malloc_base(png_ptr, size);
png_ptr 219 pngmem.c png_warning(png_ptr, "Out of memory");
png_ptr 231 pngmem.c if (png_ptr == NULL || ptr == NULL)
png_ptr 235 pngmem.c if (png_ptr->free_fn != NULL)
png_ptr 236 pngmem.c png_ptr->free_fn(png_constcast(png_structrp,png_ptr), ptr);
png_ptr 239 pngmem.c png_free_default(png_ptr, ptr);
png_ptr 245 pngmem.c if (png_ptr == NULL || ptr == NULL)
png_ptr 260 pngmem.c if (png_ptr != NULL)
png_ptr 262 pngmem.c png_ptr->mem_ptr = mem_ptr;
png_ptr 263 pngmem.c png_ptr->malloc_fn = malloc_fn;
png_ptr 264 pngmem.c png_ptr->free_fn = free_fn;
png_ptr 275 pngmem.c if (png_ptr == NULL)
png_ptr 278 pngmem.c return png_ptr->mem_ptr;
png_ptr 30 pngpread.c if (png_ptr->push_length + 4 > png_ptr->buffer_size) \
png_ptr 31 pngpread.c { png_push_save_buffer(png_ptr); return; }
png_ptr 33 pngpread.c if (png_ptr->buffer_size < N) \
png_ptr 34 pngpread.c { png_push_save_buffer(png_ptr); return; }
png_ptr 40 pngpread.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 43 pngpread.c png_push_restore_buffer(png_ptr, buffer, buffer_size);
png_ptr 45 pngpread.c while (png_ptr->buffer_size)
png_ptr 47 pngpread.c png_process_some_data(png_ptr, info_ptr);
png_ptr 54 pngpread.c if (png_ptr != NULL)
png_ptr 60 pngpread.c png_push_save_buffer(png_ptr);
png_ptr 64 pngpread.c png_size_t remaining = png_ptr->buffer_size;
png_ptr 65 pngpread.c png_ptr->buffer_size = 0;
png_ptr 70 pngpread.c if (png_ptr->save_buffer_size < remaining)
png_ptr 71 pngpread.c return remaining - png_ptr->save_buffer_size;
png_ptr 83 pngpread.c if (png_ptr != NULL && png_ptr->process_mode == PNG_SKIP_MODE &&
png_ptr 84 pngpread.c png_ptr->skip_length > 0)
png_ptr 89 pngpread.c if (png_ptr->buffer_size != 0)
png_ptr 90 pngpread.c png_error(png_ptr,
png_ptr 98 pngpread.c if (png_ptr->save_buffer_size != 0)
png_ptr 99 pngpread.c png_error(png_ptr, "png_process_data_skip called with saved data");
png_ptr 101 pngpread.c remaining = png_ptr->skip_length;
png_ptr 102 pngpread.c png_ptr->skip_length = 0;
png_ptr 103 pngpread.c png_ptr->process_mode = PNG_READ_CHUNK_MODE;
png_ptr 115 pngpread.c if (png_ptr == NULL)
png_ptr 118 pngpread.c switch (png_ptr->process_mode)
png_ptr 122 pngpread.c png_push_read_sig(png_ptr, info_ptr);
png_ptr 128 pngpread.c png_push_read_chunk(png_ptr, info_ptr);
png_ptr 134 pngpread.c png_push_read_IDAT(png_ptr);
png_ptr 140 pngpread.c png_push_crc_finish(png_ptr);
png_ptr 146 pngpread.c png_ptr->buffer_size = 0;
png_ptr 161 pngpread.c png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */
png_ptr 164 pngpread.c if (png_ptr->buffer_size < num_to_check)
png_ptr 166 pngpread.c num_to_check = png_ptr->buffer_size;
png_ptr 169 pngpread.c png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
png_ptr 171 pngpread.c png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
png_ptr 177 pngpread.c png_error(png_ptr, "Not a PNG file");
png_ptr 180 pngpread.c png_error(png_ptr, "PNG file corrupted by ASCII conversion");
png_ptr 184 pngpread.c if (png_ptr->sig_bytes >= 8)
png_ptr 186 pngpread.c png_ptr->process_mode = PNG_READ_CHUNK_MODE;
png_ptr 205 pngpread.c if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
png_ptr 211 pngpread.c png_push_fill_buffer(png_ptr, chunk_length, 4);
png_ptr 212 pngpread.c png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
png_ptr 213 pngpread.c png_reset_crc(png_ptr);
png_ptr 214 pngpread.c png_crc_read(png_ptr, chunk_tag, 4);
png_ptr 215 pngpread.c png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);
png_ptr 216 pngpread.c png_check_chunk_name(png_ptr, png_ptr->chunk_name);
png_ptr 217 pngpread.c png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
png_ptr 220 pngpread.c chunk_name = png_ptr->chunk_name;
png_ptr 224 pngpread.c if (png_ptr->mode & PNG_AFTER_IDAT)
png_ptr 225 pngpread.c png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
png_ptr 231 pngpread.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 232 pngpread.c png_error(png_ptr, "Missing IHDR before IDAT");
png_ptr 234 pngpread.c else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
png_ptr 235 pngpread.c !(png_ptr->mode & PNG_HAVE_PLTE))
png_ptr 236 pngpread.c png_error(png_ptr, "Missing PLTE before IDAT");
png_ptr 238 pngpread.c png_ptr->mode |= PNG_HAVE_IDAT;
png_ptr 239 pngpread.c png_ptr->process_mode = PNG_READ_IDAT_MODE;
png_ptr 241 pngpread.c if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
png_ptr 242 pngpread.c if (png_ptr->push_length == 0)
png_ptr 245 pngpread.c if (png_ptr->mode & PNG_AFTER_IDAT)
png_ptr 246 pngpread.c png_benign_error(png_ptr, "Too many IDATs found");
png_ptr 251 pngpread.c if (png_ptr->push_length != 13)
png_ptr 252 pngpread.c png_error(png_ptr, "Invalid IHDR length");
png_ptr 255 pngpread.c png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 261 pngpread.c png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 263 pngpread.c png_ptr->process_mode = PNG_READ_DONE_MODE;
png_ptr 264 pngpread.c png_push_have_end(png_ptr, info_ptr);
png_ptr 268 pngpread.c else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
png_ptr 271 pngpread.c png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, keep);
png_ptr 274 pngpread.c png_ptr->mode |= PNG_HAVE_PLTE;
png_ptr 281 pngpread.c png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 286 pngpread.c png_ptr->idat_size = png_ptr->push_length;
png_ptr 287 pngpread.c png_ptr->process_mode = PNG_READ_IDAT_MODE;
png_ptr 288 pngpread.c png_push_have_info(png_ptr, info_ptr);
png_ptr 289 pngpread.c png_ptr->zstream.avail_out =
png_ptr 290 pngpread.c (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,
png_ptr 291 pngpread.c png_ptr->iwidth) + 1;
png_ptr 292 pngpread.c png_ptr->zstream.next_out = png_ptr->row_buf;
png_ptr 297 pngpread.c else if (png_ptr->chunk_name == png_gAMA)
png_ptr 300 pngpread.c png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 305 pngpread.c else if (png_ptr->chunk_name == png_sBIT)
png_ptr 308 pngpread.c png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 313 pngpread.c else if (png_ptr->chunk_name == png_cHRM)
png_ptr 316 pngpread.c png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 324 pngpread.c png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 329 pngpread.c else if (png_ptr->chunk_name == png_iCCP)
png_ptr 332 pngpread.c png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 340 pngpread.c png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 348 pngpread.c png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 356 pngpread.c png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 364 pngpread.c png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 372 pngpread.c png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 380 pngpread.c png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 388 pngpread.c png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 396 pngpread.c png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 404 pngpread.c png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 412 pngpread.c png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 420 pngpread.c png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 428 pngpread.c png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
png_ptr 435 pngpread.c png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length,
png_ptr 439 pngpread.c png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
png_ptr 445 pngpread.c png_ptr->process_mode = PNG_SKIP_MODE;
png_ptr 446 pngpread.c png_ptr->skip_length = skip;
png_ptr 452 pngpread.c if (png_ptr->skip_length && png_ptr->save_buffer_size)
png_ptr 454 pngpread.c png_size_t save_size = png_ptr->save_buffer_size;
png_ptr 455 pngpread.c png_uint_32 skip_length = png_ptr->skip_length;
png_ptr 469 pngpread.c png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
png_ptr 471 pngpread.c png_ptr->skip_length -= skip_length;
png_ptr 472 pngpread.c png_ptr->buffer_size -= save_size;
png_ptr 473 pngpread.c png_ptr->save_buffer_size -= save_size;
png_ptr 474 pngpread.c png_ptr->save_buffer_ptr += save_size;
png_ptr 476 pngpread.c if (png_ptr->skip_length && png_ptr->current_buffer_size)
png_ptr 478 pngpread.c png_size_t save_size = png_ptr->current_buffer_size;
png_ptr 479 pngpread.c png_uint_32 skip_length = png_ptr->skip_length;
png_ptr 490 pngpread.c png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
png_ptr 492 pngpread.c png_ptr->skip_length -= skip_length;
png_ptr 493 pngpread.c png_ptr->buffer_size -= save_size;
png_ptr 494 pngpread.c png_ptr->current_buffer_size -= save_size;
png_ptr 495 pngpread.c png_ptr->current_buffer_ptr += save_size;
png_ptr 497 pngpread.c if (!png_ptr->skip_length)
png_ptr 500 pngpread.c png_crc_finish(png_ptr, 0);
png_ptr 501 pngpread.c png_ptr->process_mode = PNG_READ_CHUNK_MODE;
png_ptr 510 pngpread.c if (png_ptr == NULL)
png_ptr 514 pngpread.c if (png_ptr->save_buffer_size)
png_ptr 518 pngpread.c if (length < png_ptr->save_buffer_size)
png_ptr 522 pngpread.c save_size = png_ptr->save_buffer_size;
png_ptr 524 pngpread.c memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
png_ptr 527 pngpread.c png_ptr->buffer_size -= save_size;
png_ptr 528 pngpread.c png_ptr->save_buffer_size -= save_size;
png_ptr 529 pngpread.c png_ptr->save_buffer_ptr += save_size;
png_ptr 531 pngpread.c if (length && png_ptr->current_buffer_size)
png_ptr 535 pngpread.c if (length < png_ptr->current_buffer_size)
png_ptr 539 pngpread.c save_size = png_ptr->current_buffer_size;
png_ptr 541 pngpread.c memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
png_ptr 542 pngpread.c png_ptr->buffer_size -= save_size;
png_ptr 543 pngpread.c png_ptr->current_buffer_size -= save_size;
png_ptr 544 pngpread.c png_ptr->current_buffer_ptr += save_size;
png_ptr 551 pngpread.c if (png_ptr->save_buffer_size)
png_ptr 553 pngpread.c if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
png_ptr 559 pngpread.c istop = png_ptr->save_buffer_size;
png_ptr 560 pngpread.c for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
png_ptr 567 pngpread.c if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
png_ptr 568 pngpread.c png_ptr->save_buffer_max)
png_ptr 573 pngpread.c if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
png_ptr 574 pngpread.c (png_ptr->current_buffer_size + 256))
png_ptr 576 pngpread.c png_error(png_ptr, "Potential overflow of save_buffer");
png_ptr 579 pngpread.c new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
png_ptr 580 pngpread.c old_buffer = png_ptr->save_buffer;
png_ptr 581 pngpread.c png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr,
png_ptr 584 pngpread.c if (png_ptr->save_buffer == NULL)
png_ptr 586 pngpread.c png_free(png_ptr, old_buffer);
png_ptr 587 pngpread.c png_error(png_ptr, "Insufficient memory for save_buffer");
png_ptr 590 pngpread.c memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
png_ptr 591 pngpread.c png_free(png_ptr, old_buffer);
png_ptr 592 pngpread.c png_ptr->save_buffer_max = new_max;
png_ptr 594 pngpread.c if (png_ptr->current_buffer_size)
png_ptr 596 pngpread.c memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
png_ptr 597 pngpread.c png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
png_ptr 598 pngpread.c png_ptr->save_buffer_size += png_ptr->current_buffer_size;
png_ptr 599 pngpread.c png_ptr->current_buffer_size = 0;
png_ptr 601 pngpread.c png_ptr->save_buffer_ptr = png_ptr->save_buffer;
png_ptr 602 pngpread.c png_ptr->buffer_size = 0;
png_ptr 609 pngpread.c png_ptr->current_buffer = buffer;
png_ptr 610 pngpread.c png_ptr->current_buffer_size = buffer_length;
png_ptr 611 pngpread.c png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
png_ptr 612 pngpread.c png_ptr->current_buffer_ptr = png_ptr->current_buffer;
png_ptr 618 pngpread.c if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
png_ptr 625 pngpread.c png_push_fill_buffer(png_ptr, chunk_length, 4);
png_ptr 626 pngpread.c png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
png_ptr 627 pngpread.c png_reset_crc(png_ptr);
png_ptr 628 pngpread.c png_crc_read(png_ptr, chunk_tag, 4);
png_ptr 629 pngpread.c png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);
png_ptr 630 pngpread.c png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
png_ptr 632 pngpread.c if (png_ptr->chunk_name != png_IDAT)
png_ptr 634 pngpread.c png_ptr->process_mode = PNG_READ_CHUNK_MODE;
png_ptr 636 pngpread.c if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
png_ptr 637 pngpread.c png_error(png_ptr, "Not enough compressed data");
png_ptr 642 pngpread.c png_ptr->idat_size = png_ptr->push_length;
png_ptr 645 pngpread.c if (png_ptr->idat_size && png_ptr->save_buffer_size)
png_ptr 647 pngpread.c png_size_t save_size = png_ptr->save_buffer_size;
png_ptr 648 pngpread.c png_uint_32 idat_size = png_ptr->idat_size;
png_ptr 662 pngpread.c png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
png_ptr 664 pngpread.c png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
png_ptr 666 pngpread.c png_ptr->idat_size -= idat_size;
png_ptr 667 pngpread.c png_ptr->buffer_size -= save_size;
png_ptr 668 pngpread.c png_ptr->save_buffer_size -= save_size;
png_ptr 669 pngpread.c png_ptr->save_buffer_ptr += save_size;
png_ptr 672 pngpread.c if (png_ptr->idat_size && png_ptr->current_buffer_size)
png_ptr 674 pngpread.c png_size_t save_size = png_ptr->current_buffer_size;
png_ptr 675 pngpread.c png_uint_32 idat_size = png_ptr->idat_size;
png_ptr 688 pngpread.c png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
png_ptr 690 pngpread.c png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
png_ptr 692 pngpread.c png_ptr->idat_size -= idat_size;
png_ptr 693 pngpread.c png_ptr->buffer_size -= save_size;
png_ptr 694 pngpread.c png_ptr->current_buffer_size -= save_size;
png_ptr 695 pngpread.c png_ptr->current_buffer_ptr += save_size;
png_ptr 697 pngpread.c if (!png_ptr->idat_size)
png_ptr 700 pngpread.c png_crc_finish(png_ptr, 0);
png_ptr 701 pngpread.c png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
png_ptr 702 pngpread.c png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr 703 pngpread.c png_ptr->zowner = 0;
png_ptr 713 pngpread.c png_error(png_ptr, "No IDAT data (internal error)");
png_ptr 719 pngpread.c png_ptr->zstream.next_in = buffer;
png_ptr 721 pngpread.c png_ptr->zstream.avail_in = (uInt)buffer_length;
png_ptr 726 pngpread.c while (png_ptr->zstream.avail_in > 0 &&
png_ptr 727 pngpread.c !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
png_ptr 736 pngpread.c if (!(png_ptr->zstream.avail_out > 0))
png_ptr 739 pngpread.c png_ptr->zstream.avail_out = (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,
png_ptr 740 pngpread.c png_ptr->iwidth) + 1);
png_ptr 742 pngpread.c png_ptr->zstream.next_out = png_ptr->row_buf;
png_ptr 752 pngpread.c ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH);
png_ptr 758 pngpread.c png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
png_ptr 759 pngpread.c png_ptr->zowner = 0;
png_ptr 764 pngpread.c if (png_ptr->row_number >= png_ptr->num_rows ||
png_ptr 765 pngpread.c png_ptr->pass > 6)
png_ptr 766 pngpread.c png_warning(png_ptr, "Truncated compressed data in IDAT");
png_ptr 769 pngpread.c png_error(png_ptr, "Decompression error in IDAT");
png_ptr 776 pngpread.c if (png_ptr->zstream.next_out != png_ptr->row_buf)
png_ptr 782 pngpread.c if (png_ptr->row_number >= png_ptr->num_rows ||
png_ptr 783 pngpread.c png_ptr->pass > 6)
png_ptr 786 pngpread.c png_warning(png_ptr, "Extra compressed data in IDAT");
png_ptr 787 pngpread.c png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
png_ptr 788 pngpread.c png_ptr->zowner = 0;
png_ptr 797 pngpread.c if (png_ptr->zstream.avail_out == 0)
png_ptr 798 pngpread.c png_push_process_row(png_ptr);
png_ptr 803 pngpread.c png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
png_ptr 810 pngpread.c if (png_ptr->zstream.avail_in > 0)
png_ptr 811 pngpread.c png_warning(png_ptr, "Extra compression data in IDAT");
png_ptr 820 pngpread.c row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
png_ptr 821 pngpread.c row_info.color_type = png_ptr->color_type;
png_ptr 822 pngpread.c row_info.bit_depth = png_ptr->bit_depth;
png_ptr 823 pngpread.c row_info.channels = png_ptr->channels;
png_ptr 824 pngpread.c row_info.pixel_depth = png_ptr->pixel_depth;
png_ptr 827 pngpread.c if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
png_ptr 829 pngpread.c if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
png_ptr 830 pngpread.c png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
png_ptr 831 pngpread.c png_ptr->prev_row + 1, png_ptr->row_buf[0]);
png_ptr 833 pngpread.c png_error(png_ptr, "bad adaptive filter value");
png_ptr 841 pngpread.c memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
png_ptr 844 pngpread.c if (png_ptr->transformations)
png_ptr 845 pngpread.c png_do_read_transformations(png_ptr, &row_info);
png_ptr 849 pngpread.c if (png_ptr->transformed_pixel_depth == 0)
png_ptr 851 pngpread.c png_ptr->transformed_pixel_depth = row_info.pixel_depth;
png_ptr 852 pngpread.c if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
png_ptr 853 pngpread.c png_error(png_ptr, "progressive row overflow");
png_ptr 856 pngpread.c else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
png_ptr 857 pngpread.c png_error(png_ptr, "internal progressive row size calculation error");
png_ptr 862 pngpread.c if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
png_ptr 864 pngpread.c if (png_ptr->pass < 6)
png_ptr 865 pngpread.c png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
png_ptr 866 pngpread.c png_ptr->transformations);
png_ptr 868 pngpread.c switch (png_ptr->pass)
png_ptr 873 pngpread.c for (i = 0; i < 8 && png_ptr->pass == 0; i++)
png_ptr 875 pngpread.c png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_ptr 876 pngpread.c png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */
png_ptr 879 pngpread.c if (png_ptr->pass == 2) /* Pass 1 might be empty */
png_ptr 881 pngpread.c for (i = 0; i < 4 && png_ptr->pass == 2; i++)
png_ptr 883 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 884 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 888 pngpread.c if (png_ptr->pass == 4 && png_ptr->height <= 4)
png_ptr 890 pngpread.c for (i = 0; i < 2 && png_ptr->pass == 4; i++)
png_ptr 892 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 893 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 897 pngpread.c if (png_ptr->pass == 6 && png_ptr->height <= 4)
png_ptr 899 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 900 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 909 pngpread.c for (i = 0; i < 8 && png_ptr->pass == 1; i++)
png_ptr 911 pngpread.c png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_ptr 912 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 915 pngpread.c if (png_ptr->pass == 2) /* Skip top 4 generated rows */
png_ptr 917 pngpread.c for (i = 0; i < 4 && png_ptr->pass == 2; i++)
png_ptr 919 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 920 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 931 pngpread.c for (i = 0; i < 4 && png_ptr->pass == 2; i++)
png_ptr 933 pngpread.c png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_ptr 934 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 937 pngpread.c for (i = 0; i < 4 && png_ptr->pass == 2; i++)
png_ptr 939 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 940 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 943 pngpread.c if (png_ptr->pass == 4) /* Pass 3 might be empty */
png_ptr 945 pngpread.c for (i = 0; i < 2 && png_ptr->pass == 4; i++)
png_ptr 947 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 948 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 959 pngpread.c for (i = 0; i < 4 && png_ptr->pass == 3; i++)
png_ptr 961 pngpread.c png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_ptr 962 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 965 pngpread.c if (png_ptr->pass == 4) /* Skip top two generated rows */
png_ptr 967 pngpread.c for (i = 0; i < 2 && png_ptr->pass == 4; i++)
png_ptr 969 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 970 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 981 pngpread.c for (i = 0; i < 2 && png_ptr->pass == 4; i++)
png_ptr 983 pngpread.c png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_ptr 984 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 987 pngpread.c for (i = 0; i < 2 && png_ptr->pass == 4; i++)
png_ptr 989 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 990 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 993 pngpread.c if (png_ptr->pass == 6) /* Pass 5 might be empty */
png_ptr 995 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 996 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 1006 pngpread.c for (i = 0; i < 2 && png_ptr->pass == 5; i++)
png_ptr 1008 pngpread.c png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_ptr 1009 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 1012 pngpread.c if (png_ptr->pass == 6) /* Skip top generated row */
png_ptr 1014 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 1015 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 1024 pngpread.c png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_ptr 1025 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 1027 pngpread.c if (png_ptr->pass != 6)
png_ptr 1030 pngpread.c png_push_have_row(png_ptr, NULL);
png_ptr 1031 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 1037 pngpread.c png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_ptr 1038 pngpread.c png_read_push_finish_row(png_ptr);
png_ptr 1065 pngpread.c png_ptr->row_number++;
png_ptr 1066 pngpread.c if (png_ptr->row_number < png_ptr->num_rows)
png_ptr 1069 pngpread.c if (png_ptr->interlaced)
png_ptr 1071 pngpread.c png_ptr->row_number = 0;
png_ptr 1072 pngpread.c memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
png_ptr 1076 pngpread.c png_ptr->pass++;
png_ptr 1077 pngpread.c if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
png_ptr 1078 pngpread.c (png_ptr->pass == 3 && png_ptr->width < 3) ||
png_ptr 1079 pngpread.c (png_ptr->pass == 5 && png_ptr->width < 2))
png_ptr 1080 pngpread.c png_ptr->pass++;
png_ptr 1082 pngpread.c if (png_ptr->pass > 7)
png_ptr 1083 pngpread.c png_ptr->pass--;
png_ptr 1085 pngpread.c if (png_ptr->pass >= 7)
png_ptr 1088 pngpread.c png_ptr->iwidth = (png_ptr->width +
png_ptr 1089 pngpread.c png_pass_inc[png_ptr->pass] - 1 -
png_ptr 1090 pngpread.c png_pass_start[png_ptr->pass]) /
png_ptr 1091 pngpread.c png_pass_inc[png_ptr->pass];
png_ptr 1093 pngpread.c if (png_ptr->transformations & PNG_INTERLACE)
png_ptr 1096 pngpread.c png_ptr->num_rows = (png_ptr->height +
png_ptr 1097 pngpread.c png_pass_yinc[png_ptr->pass] - 1 -
png_ptr 1098 pngpread.c png_pass_ystart[png_ptr->pass]) /
png_ptr 1099 pngpread.c png_pass_yinc[png_ptr->pass];
png_ptr 1101 pngpread.c } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
png_ptr 1108 pngpread.c if (png_ptr->info_fn != NULL)
png_ptr 1109 pngpread.c (*(png_ptr->info_fn))(png_ptr, info_ptr);
png_ptr 1115 pngpread.c if (png_ptr->end_fn != NULL)
png_ptr 1116 pngpread.c (*(png_ptr->end_fn))(png_ptr, info_ptr);
png_ptr 1122 pngpread.c if (png_ptr->row_fn != NULL)
png_ptr 1123 pngpread.c (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
png_ptr 1124 pngpread.c (int)png_ptr->pass);
png_ptr 1131 pngpread.c if (png_ptr == NULL)
png_ptr 1139 pngpread.c png_combine_row(png_ptr, old_row, 1/*blocky display*/);
png_ptr 1147 pngpread.c if (png_ptr == NULL)
png_ptr 1150 pngpread.c png_ptr->info_fn = info_fn;
png_ptr 1151 pngpread.c png_ptr->row_fn = row_fn;
png_ptr 1152 pngpread.c png_ptr->end_fn = end_fn;
png_ptr 1154 pngpread.c png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
png_ptr 1160 pngpread.c if (png_ptr == NULL)
png_ptr 1163 pngpread.c return png_ptr->io_ptr;
png_ptr 705 pngpriv.h ((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0))
png_ptr 874 pngpriv.h PNG_INTERNAL_FUNCTION(void, png_zstream_error,(png_structrp png_ptr, int ret),
png_ptr 881 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_free_buffer_list,(png_structrp png_ptr,
png_ptr 893 pngpriv.h PNG_INTERNAL_FUNCTION(png_fixed_point,png_fixed,(png_const_structrp png_ptr,
png_ptr 900 pngpriv.h PNG_INTERNAL_FUNCTION(int,png_user_version_check,(png_structrp png_ptr,
png_ptr 907 pngpriv.h PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_base,(png_const_structrp png_ptr,
png_ptr 915 pngpriv.h PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_array,(png_const_structrp png_ptr,
png_ptr 922 pngpriv.h PNG_INTERNAL_FUNCTION(png_voidp,png_realloc_array,(png_const_structrp png_ptr,
png_ptr 939 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_destroy_png_struct,(png_structrp png_ptr),
png_ptr 943 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_free_jmpbuf,(png_structrp png_ptr),PNG_EMPTY);
png_ptr 946 pngpriv.h PNG_INTERNAL_FUNCTION(voidpf,png_zalloc,(voidpf png_ptr, uInt items, uInt size),
png_ptr 950 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_zfree,(voidpf png_ptr, voidpf ptr),PNG_EMPTY);
png_ptr 957 pngpriv.h PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_read_data,(png_structp png_ptr,
png_ptr 961 pngpriv.h PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_push_fill_buffer,(png_structp png_ptr,
png_ptr 965 pngpriv.h PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_write_data,(png_structp png_ptr,
png_ptr 970 pngpriv.h PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_flush,(png_structp png_ptr),
png_ptr 976 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_reset_crc,(png_structrp png_ptr),PNG_EMPTY);
png_ptr 979 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_data,(png_structrp png_ptr,
png_ptr 983 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_read_sig,(png_structrp png_ptr,
png_ptr 987 pngpriv.h PNG_INTERNAL_FUNCTION(png_uint_32,png_read_chunk_header,(png_structrp png_ptr),
png_ptr 991 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_read_data,(png_structrp png_ptr, png_bytep data,
png_ptr 995 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_crc_read,(png_structrp png_ptr, png_bytep buf,
png_ptr 999 pngpriv.h PNG_INTERNAL_FUNCTION(int,png_crc_finish,(png_structrp png_ptr,
png_ptr 1003 pngpriv.h PNG_INTERNAL_FUNCTION(int,png_crc_error,(png_structrp png_ptr),PNG_EMPTY);
png_ptr 1009 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_calculate_crc,(png_structrp png_ptr,
png_ptr 1013 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_flush,(png_structrp png_ptr),PNG_EMPTY);
png_ptr 1021 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_IHDR,(png_structrp png_ptr,
png_ptr 1025 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_PLTE,(png_structrp png_ptr,
png_ptr 1028 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_compress_IDAT,(png_structrp png_ptr,
png_ptr 1032 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_IEND,(png_structrp png_ptr),PNG_EMPTY);
png_ptr 1035 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_gAMA_fixed,(png_structrp png_ptr,
png_ptr 1040 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_sBIT,(png_structrp png_ptr,
png_ptr 1045 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_cHRM_fixed,(png_structrp png_ptr,
png_ptr 1051 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_sRGB,(png_structrp png_ptr,
png_ptr 1056 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_iCCP,(png_structrp png_ptr,
png_ptr 1065 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_sPLT,(png_structrp png_ptr,
png_ptr 1070 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_tRNS,(png_structrp png_ptr,
png_ptr 1076 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_bKGD,(png_structrp png_ptr,
png_ptr 1081 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_hIST,(png_structrp png_ptr,
png_ptr 1087 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_tEXt,(png_structrp png_ptr,
png_ptr 1092 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_zTXt,(png_structrp png_ptr, png_const_charp
png_ptr 1097 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_iTXt,(png_structrp png_ptr,
png_ptr 1103 pngpriv.h PNG_INTERNAL_FUNCTION(int,png_set_text_2,(png_const_structrp png_ptr,
png_ptr 1108 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_oFFs,(png_structrp png_ptr,
png_ptr 1113 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_pCAL,(png_structrp png_ptr,
png_ptr 1119 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_pHYs,(png_structrp png_ptr,
png_ptr 1125 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_tIME,(png_structrp png_ptr,
png_ptr 1130 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_sCAL_s,(png_structrp png_ptr,
png_ptr 1135 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_finish_row,(png_structrp png_ptr),
png_ptr 1139 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_start_row,(png_structrp png_ptr),
png_ptr 1168 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_combine_row,(png_const_structrp png_ptr,
png_ptr 1212 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr,
png_ptr 1216 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_read_IDAT_data,(png_structrp png_ptr,
png_ptr 1223 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_read_finish_IDAT,(png_structrp png_ptr),
png_ptr 1229 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_read_finish_row,(png_structrp png_ptr),
png_ptr 1235 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY);
png_ptr 1239 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_read_transform_info,(png_structrp png_ptr,
png_ptr 1278 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_IHDR,(png_structrp png_ptr,
png_ptr 1280 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_PLTE,(png_structrp png_ptr,
png_ptr 1282 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_IEND,(png_structrp png_ptr,
png_ptr 1286 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_bKGD,(png_structrp png_ptr,
png_ptr 1291 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_cHRM,(png_structrp png_ptr,
png_ptr 1296 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_gAMA,(png_structrp png_ptr,
png_ptr 1301 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_hIST,(png_structrp png_ptr,
png_ptr 1306 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_iCCP,(png_structrp png_ptr,
png_ptr 1311 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_iTXt,(png_structrp png_ptr,
png_ptr 1316 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_oFFs,(png_structrp png_ptr,
png_ptr 1321 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_pCAL,(png_structrp png_ptr,
png_ptr 1326 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_pHYs,(png_structrp png_ptr,
png_ptr 1331 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_sBIT,(png_structrp png_ptr,
png_ptr 1336 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_sCAL,(png_structrp png_ptr,
png_ptr 1341 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_sPLT,(png_structrp png_ptr,
png_ptr 1346 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_sRGB,(png_structrp png_ptr,
png_ptr 1351 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_tEXt,(png_structrp png_ptr,
png_ptr 1356 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_tIME,(png_structrp png_ptr,
png_ptr 1361 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_tRNS,(png_structrp png_ptr,
png_ptr 1366 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_zTXt,(png_structrp png_ptr,
png_ptr 1370 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_check_chunk_name,(png_structrp png_ptr,
png_ptr 1373 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_handle_unknown,(png_structrp png_ptr,
png_ptr 1384 pngpriv.h (png_const_structrp png_ptr, png_uint_32 chunk_name),PNG_EMPTY);
png_ptr 1392 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_do_read_transformations,(png_structrp png_ptr,
png_ptr 1396 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_do_write_transformations,(png_structrp png_ptr,
png_ptr 1401 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_init_read_transformations,(png_structrp png_ptr),
png_ptr 1406 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_read_chunk,(png_structrp png_ptr,
png_ptr 1408 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_read_sig,(png_structrp png_ptr,
png_ptr 1410 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_check_crc,(png_structrp png_ptr),PNG_EMPTY);
png_ptr 1411 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_crc_skip,(png_structrp png_ptr,
png_ptr 1413 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_crc_finish,(png_structrp png_ptr),
png_ptr 1415 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_save_buffer,(png_structrp png_ptr),
png_ptr 1417 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_restore_buffer,(png_structrp png_ptr,
png_ptr 1419 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_read_IDAT,(png_structrp png_ptr),PNG_EMPTY);
png_ptr 1420 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_process_IDAT_data,(png_structrp png_ptr,
png_ptr 1422 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_process_row,(png_structrp png_ptr),
png_ptr 1424 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_handle_unknown,(png_structrp png_ptr,
png_ptr 1426 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_have_info,(png_structrp png_ptr,
png_ptr 1428 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_have_end,(png_structrp png_ptr,
png_ptr 1430 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_have_row,(png_structrp png_ptr,
png_ptr 1432 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_read_end,(png_structrp png_ptr,
png_ptr 1434 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_process_some_data,(png_structrp png_ptr,
png_ptr 1436 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_read_push_finish_row,(png_structrp png_ptr),
png_ptr 1439 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_handle_tEXt,(png_structrp png_ptr,
png_ptr 1441 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_read_tEXt,(png_structrp png_ptr,
png_ptr 1445 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_handle_zTXt,(png_structrp png_ptr,
png_ptr 1447 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_read_zTXt,(png_structrp png_ptr,
png_ptr 1451 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_handle_iTXt,(png_structrp png_ptr,
png_ptr 1453 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_push_read_iTXt,(png_structrp png_ptr,
png_ptr 1461 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_colorspace_set_gamma,(png_const_structrp png_ptr,
png_ptr 1468 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_colorspace_sync_info,(png_const_structrp png_ptr,
png_ptr 1472 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_colorspace_sync,(png_const_structrp png_ptr,
png_ptr 1485 pngpriv.h (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_xy *xy,
png_ptr 1489 pngpriv.h (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_XYZ *XYZ,
png_ptr 1493 pngpriv.h PNG_INTERNAL_FUNCTION(int,png_colorspace_set_sRGB,(png_const_structrp png_ptr,
png_ptr 1503 pngpriv.h PNG_INTERNAL_FUNCTION(int,png_colorspace_set_ICC,(png_const_structrp png_ptr,
png_ptr 1510 pngpriv.h PNG_INTERNAL_FUNCTION(int,png_icc_check_length,(png_const_structrp png_ptr,
png_ptr 1513 pngpriv.h PNG_INTERNAL_FUNCTION(int,png_icc_check_header,(png_const_structrp png_ptr,
png_ptr 1518 pngpriv.h PNG_INTERNAL_FUNCTION(int,png_icc_check_tag_table,(png_const_structrp png_ptr,
png_ptr 1524 pngpriv.h png_const_structrp png_ptr, png_colorspacerp colorspace,
png_ptr 1535 pngpriv.h (png_structrp png_ptr), PNG_EMPTY);
png_ptr 1541 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_check_IHDR,(png_const_structrp png_ptr,
png_ptr 1550 pngpriv.h (png_structrp png_ptr, png_row_infop row_info),PNG_EMPTY);
png_ptr 1554 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_fixed_error,(png_const_structrp png_ptr,
png_ptr 1622 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_formatted_warning,(png_const_structrp png_ptr,
png_ptr 1645 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_app_warning,(png_const_structrp png_ptr,
png_ptr 1651 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_app_error,(png_const_structrp png_ptr,
png_ptr 1661 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_chunk_report,(png_const_structrp png_ptr,
png_ptr 1688 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_ascii_from_fp,(png_const_structrp png_ptr,
png_ptr 1694 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr,
png_ptr 1815 pngpriv.h (png_const_structrp png_ptr, png_fixed_point a, png_int_32 multiplied_by,
png_ptr 1849 pngpriv.h PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_correct,(png_structrp png_ptr,
png_ptr 1855 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_destroy_gamma_table,(png_structrp png_ptr),
png_ptr 1857 pngpriv.h PNG_INTERNAL_FUNCTION(void,png_build_gamma_table,(png_structrp png_ptr,
png_ptr 1867 pngpriv.h png_structp png_ptr;
png_ptr 1891 pngpriv.h PNG_INTERNAL_CALLBACK(void,png_safe_error,(png_structp png_ptr,
png_ptr 1895 pngpriv.h PNG_INTERNAL_CALLBACK(void,png_safe_warning,(png_structp png_ptr,
png_ptr 1923 pngpriv.h PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr,
png_ptr 1932 pngpriv.h (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
png_ptr 30 pngread.c png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
png_ptr 45 pngread.c png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
png_ptr 49 pngread.c if (png_ptr != NULL)
png_ptr 51 pngread.c png_ptr->mode = PNG_IS_READ_STRUCT;
png_ptr 57 pngread.c png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE;
png_ptr 61 pngread.c png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
png_ptr 67 pngread.c png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
png_ptr 75 pngread.c png_set_read_fn(png_ptr, NULL, NULL);
png_ptr 78 pngread.c return png_ptr;
png_ptr 100 pngread.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 104 pngread.c png_read_sig(png_ptr, info_ptr);
png_ptr 108 pngread.c png_uint_32 length = png_read_chunk_header(png_ptr);
png_ptr 109 pngread.c png_uint_32 chunk_name = png_ptr->chunk_name;
png_ptr 116 pngread.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 117 pngread.c png_chunk_error(png_ptr, "Missing IHDR before IDAT");
png_ptr 119 pngread.c else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
png_ptr 120 pngread.c !(png_ptr->mode & PNG_HAVE_PLTE))
png_ptr 121 pngread.c png_chunk_error(png_ptr, "Missing PLTE before IDAT");
png_ptr 123 pngread.c else if (png_ptr->mode & PNG_AFTER_IDAT)
png_ptr 124 pngread.c png_chunk_benign_error(png_ptr, "Too many IDATs found");
png_ptr 126 pngread.c png_ptr->mode |= PNG_HAVE_IDAT;
png_ptr 129 pngread.c else if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 130 pngread.c png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr 136 pngread.c png_handle_IHDR(png_ptr, info_ptr, length);
png_ptr 139 pngread.c png_handle_IEND(png_ptr, info_ptr, length);
png_ptr 142 pngread.c else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
png_ptr 144 pngread.c png_handle_unknown(png_ptr, info_ptr, length, keep);
png_ptr 147 pngread.c png_ptr->mode |= PNG_HAVE_PLTE;
png_ptr 151 pngread.c png_ptr->idat_size = 0; /* It has been consumed */
png_ptr 157 pngread.c png_handle_PLTE(png_ptr, info_ptr, length);
png_ptr 161 pngread.c png_ptr->idat_size = length;
png_ptr 167 pngread.c png_handle_bKGD(png_ptr, info_ptr, length);
png_ptr 172 pngread.c png_handle_cHRM(png_ptr, info_ptr, length);
png_ptr 177 pngread.c png_handle_gAMA(png_ptr, info_ptr, length);
png_ptr 182 pngread.c png_handle_hIST(png_ptr, info_ptr, length);
png_ptr 187 pngread.c png_handle_oFFs(png_ptr, info_ptr, length);
png_ptr 192 pngread.c png_handle_pCAL(png_ptr, info_ptr, length);
png_ptr 197 pngread.c png_handle_sCAL(png_ptr, info_ptr, length);
png_ptr 202 pngread.c png_handle_pHYs(png_ptr, info_ptr, length);
png_ptr 207 pngread.c png_handle_sBIT(png_ptr, info_ptr, length);
png_ptr 212 pngread.c png_handle_sRGB(png_ptr, info_ptr, length);
png_ptr 217 pngread.c png_handle_iCCP(png_ptr, info_ptr, length);
png_ptr 222 pngread.c png_handle_sPLT(png_ptr, info_ptr, length);
png_ptr 227 pngread.c png_handle_tEXt(png_ptr, info_ptr, length);
png_ptr 232 pngread.c png_handle_tIME(png_ptr, info_ptr, length);
png_ptr 237 pngread.c png_handle_tRNS(png_ptr, info_ptr, length);
png_ptr 242 pngread.c png_handle_zTXt(png_ptr, info_ptr, length);
png_ptr 247 pngread.c png_handle_iTXt(png_ptr, info_ptr, length);
png_ptr 251 pngread.c png_handle_unknown(png_ptr, info_ptr, length,
png_ptr 263 pngread.c if (png_ptr != NULL)
png_ptr 265 pngread.c if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
png_ptr 267 pngread.c png_read_start_row(png_ptr);
png_ptr 270 pngread.c png_read_transform_info(png_ptr, info_ptr);
png_ptr 278 pngread.c png_app_error(png_ptr,
png_ptr 294 pngread.c if (png_ptr != NULL)
png_ptr 296 pngread.c if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
png_ptr 297 pngread.c png_read_start_row(png_ptr);
png_ptr 301 pngread.c png_app_error(png_ptr,
png_ptr 379 pngread.c if (png_ptr == NULL)
png_ptr 383 pngread.c (unsigned long)png_ptr->row_number, png_ptr->pass);
png_ptr 388 pngread.c if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_ptr 389 pngread.c png_read_start_row(png_ptr);
png_ptr 392 pngread.c row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
png_ptr 393 pngread.c row_info.color_type = png_ptr->color_type;
png_ptr 394 pngread.c row_info.bit_depth = png_ptr->bit_depth;
png_ptr 395 pngread.c row_info.channels = png_ptr->channels;
png_ptr 396 pngread.c row_info.pixel_depth = png_ptr->pixel_depth;
png_ptr 400 pngread.c if (png_ptr->row_number == 0 && png_ptr->pass == 0)
png_ptr 404 pngread.c if (png_ptr->transformations & PNG_INVERT_MONO)
png_ptr 405 pngread.c png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
png_ptr 409 pngread.c if (png_ptr->transformations & PNG_FILLER)
png_ptr 410 pngread.c png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
png_ptr 415 pngread.c if (png_ptr->transformations & PNG_PACKSWAP)
png_ptr 416 pngread.c png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
png_ptr 420 pngread.c if (png_ptr->transformations & PNG_PACK)
png_ptr 421 pngread.c png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
png_ptr 425 pngread.c if (png_ptr->transformations & PNG_SHIFT)
png_ptr 426 pngread.c png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
png_ptr 430 pngread.c if (png_ptr->transformations & PNG_BGR)
png_ptr 431 pngread.c png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
png_ptr 435 pngread.c if (png_ptr->transformations & PNG_SWAP_BYTES)
png_ptr 436 pngread.c png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
png_ptr 448 pngread.c if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
png_ptr 450 pngread.c switch (png_ptr->pass)
png_ptr 453 pngread.c if (png_ptr->row_number & 0x07)
png_ptr 456 pngread.c png_combine_row(png_ptr, dsp_row, 1/*display*/);
png_ptr 457 pngread.c png_read_finish_row(png_ptr);
png_ptr 463 pngread.c if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
png_ptr 466 pngread.c png_combine_row(png_ptr, dsp_row, 1/*display*/);
png_ptr 468 pngread.c png_read_finish_row(png_ptr);
png_ptr 474 pngread.c if ((png_ptr->row_number & 0x07) != 4)
png_ptr 476 pngread.c if (dsp_row != NULL && (png_ptr->row_number & 4))
png_ptr 477 pngread.c png_combine_row(png_ptr, dsp_row, 1/*display*/);
png_ptr 479 pngread.c png_read_finish_row(png_ptr);
png_ptr 485 pngread.c if ((png_ptr->row_number & 3) || png_ptr->width < 3)
png_ptr 488 pngread.c png_combine_row(png_ptr, dsp_row, 1/*display*/);
png_ptr 490 pngread.c png_read_finish_row(png_ptr);
png_ptr 496 pngread.c if ((png_ptr->row_number & 3) != 2)
png_ptr 498 pngread.c if (dsp_row != NULL && (png_ptr->row_number & 2))
png_ptr 499 pngread.c png_combine_row(png_ptr, dsp_row, 1/*display*/);
png_ptr 501 pngread.c png_read_finish_row(png_ptr);
png_ptr 507 pngread.c if ((png_ptr->row_number & 1) || png_ptr->width < 2)
png_ptr 510 pngread.c png_combine_row(png_ptr, dsp_row, 1/*display*/);
png_ptr 512 pngread.c png_read_finish_row(png_ptr);
png_ptr 519 pngread.c if (!(png_ptr->row_number & 1))
png_ptr 521 pngread.c png_read_finish_row(png_ptr);
png_ptr 529 pngread.c if (!(png_ptr->mode & PNG_HAVE_IDAT))
png_ptr 530 pngread.c png_error(png_ptr, "Invalid attempt to read row data");
png_ptr 533 pngread.c png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1);
png_ptr 535 pngread.c if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
png_ptr 537 pngread.c if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
png_ptr 538 pngread.c png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
png_ptr 539 pngread.c png_ptr->prev_row + 1, png_ptr->row_buf[0]);
png_ptr 541 pngread.c png_error(png_ptr, "bad adaptive filter value");
png_ptr 549 pngread.c memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
png_ptr 552 pngread.c if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
png_ptr 553 pngread.c (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
png_ptr 556 pngread.c png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
png_ptr 561 pngread.c if (png_ptr->transformations)
png_ptr 562 pngread.c png_do_read_transformations(png_ptr, &row_info);
png_ptr 566 pngread.c if (png_ptr->transformed_pixel_depth == 0)
png_ptr 568 pngread.c png_ptr->transformed_pixel_depth = row_info.pixel_depth;
png_ptr 569 pngread.c if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
png_ptr 570 pngread.c png_error(png_ptr, "sequential row overflow");
png_ptr 573 pngread.c else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
png_ptr 574 pngread.c png_error(png_ptr, "internal sequential row size calculation error");
png_ptr 578 pngread.c if (png_ptr->interlaced &&
png_ptr 579 pngread.c (png_ptr->transformations & PNG_INTERLACE))
png_ptr 581 pngread.c if (png_ptr->pass < 6)
png_ptr 582 pngread.c png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
png_ptr 583 pngread.c png_ptr->transformations);
png_ptr 586 pngread.c png_combine_row(png_ptr, dsp_row, 1/*display*/);
png_ptr 589 pngread.c png_combine_row(png_ptr, row, 0/*row*/);
png_ptr 596 pngread.c png_combine_row(png_ptr, row, -1/*ignored*/);
png_ptr 599 pngread.c png_combine_row(png_ptr, dsp_row, -1/*ignored*/);
png_ptr 601 pngread.c png_read_finish_row(png_ptr);
png_ptr 603 pngread.c if (png_ptr->read_row_fn != NULL)
png_ptr 604 pngread.c (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
png_ptr 644 pngread.c if (png_ptr == NULL)
png_ptr 655 pngread.c png_read_row(png_ptr, rptr, dptr);
png_ptr 662 pngread.c png_read_row(png_ptr, rptr, NULL);
png_ptr 670 pngread.c png_read_row(png_ptr, NULL, dptr);
png_ptr 698 pngread.c if (png_ptr == NULL)
png_ptr 702 pngread.c if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_ptr 704 pngread.c pass = png_set_interlace_handling(png_ptr);
png_ptr 706 pngread.c png_start_read_image(png_ptr);
png_ptr 710 pngread.c if (png_ptr->interlaced && !(png_ptr->transformations & PNG_INTERLACE))
png_ptr 716 pngread.c png_warning(png_ptr, "Interlace handling should be turned on when "
png_ptr 719 pngread.c png_ptr->num_rows = png_ptr->height;
png_ptr 725 pngread.c pass = png_set_interlace_handling(png_ptr);
png_ptr 728 pngread.c if (png_ptr->interlaced)
png_ptr 729 pngread.c png_error(png_ptr,
png_ptr 735 pngread.c image_height=png_ptr->height;
png_ptr 742 pngread.c png_read_row(png_ptr, *rp, NULL);
png_ptr 763 pngread.c if (png_ptr == NULL)
png_ptr 770 pngread.c if (!png_chunk_unknown_handling(png_ptr, png_IDAT))
png_ptr 772 pngread.c png_read_finish_IDAT(png_ptr);
png_ptr 776 pngread.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
png_ptr 777 pngread.c png_ptr->num_palette_max > png_ptr->num_palette)
png_ptr 778 pngread.c png_benign_error(png_ptr, "Read palette index exceeding num_palette");
png_ptr 783 pngread.c png_uint_32 length = png_read_chunk_header(png_ptr);
png_ptr 784 pngread.c png_uint_32 chunk_name = png_ptr->chunk_name;
png_ptr 787 pngread.c png_handle_IEND(png_ptr, info_ptr, length);
png_ptr 790 pngread.c png_handle_IHDR(png_ptr, info_ptr, length);
png_ptr 793 pngread.c png_crc_finish(png_ptr, length);
png_ptr 796 pngread.c else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
png_ptr 800 pngread.c if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
png_ptr 801 pngread.c png_benign_error(png_ptr, "Too many IDATs found");
png_ptr 803 pngread.c png_handle_unknown(png_ptr, info_ptr, length, keep);
png_ptr 805 pngread.c png_ptr->mode |= PNG_HAVE_PLTE;
png_ptr 814 pngread.c if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
png_ptr 815 pngread.c png_benign_error(png_ptr, "Too many IDATs found");
png_ptr 817 pngread.c png_crc_finish(png_ptr, length);
png_ptr 820 pngread.c png_handle_PLTE(png_ptr, info_ptr, length);
png_ptr 824 pngread.c png_handle_bKGD(png_ptr, info_ptr, length);
png_ptr 829 pngread.c png_handle_cHRM(png_ptr, info_ptr, length);
png_ptr 834 pngread.c png_handle_gAMA(png_ptr, info_ptr, length);
png_ptr 839 pngread.c png_handle_hIST(png_ptr, info_ptr, length);
png_ptr 844 pngread.c png_handle_oFFs(png_ptr, info_ptr, length);
png_ptr 849 pngread.c png_handle_pCAL(png_ptr, info_ptr, length);
png_ptr 854 pngread.c png_handle_sCAL(png_ptr, info_ptr, length);
png_ptr 859 pngread.c png_handle_pHYs(png_ptr, info_ptr, length);
png_ptr 864 pngread.c png_handle_sBIT(png_ptr, info_ptr, length);
png_ptr 869 pngread.c png_handle_sRGB(png_ptr, info_ptr, length);
png_ptr 874 pngread.c png_handle_iCCP(png_ptr, info_ptr, length);
png_ptr 879 pngread.c png_handle_sPLT(png_ptr, info_ptr, length);
png_ptr 884 pngread.c png_handle_tEXt(png_ptr, info_ptr, length);
png_ptr 889 pngread.c png_handle_tIME(png_ptr, info_ptr, length);
png_ptr 894 pngread.c png_handle_tRNS(png_ptr, info_ptr, length);
png_ptr 899 pngread.c png_handle_zTXt(png_ptr, info_ptr, length);
png_ptr 904 pngread.c png_handle_iTXt(png_ptr, info_ptr, length);
png_ptr 908 pngread.c png_handle_unknown(png_ptr, info_ptr, length,
png_ptr 910 pngread.c } while (!(png_ptr->mode & PNG_HAVE_IEND));
png_ptr 921 pngread.c png_destroy_gamma_table(png_ptr);
png_ptr 924 pngread.c png_free(png_ptr, png_ptr->big_row_buf);
png_ptr 925 pngread.c png_free(png_ptr, png_ptr->big_prev_row);
png_ptr 926 pngread.c png_free(png_ptr, png_ptr->read_buffer);
png_ptr 929 pngread.c png_free(png_ptr, png_ptr->palette_lookup);
png_ptr 930 pngread.c png_free(png_ptr, png_ptr->quantize_index);
png_ptr 933 pngread.c if (png_ptr->free_me & PNG_FREE_PLTE)
png_ptr 934 pngread.c png_zfree(png_ptr, png_ptr->palette);
png_ptr 935 pngread.c png_ptr->free_me &= ~PNG_FREE_PLTE;
png_ptr 939 pngread.c if (png_ptr->free_me & PNG_FREE_TRNS)
png_ptr 940 pngread.c png_free(png_ptr, png_ptr->trans_alpha);
png_ptr 941 pngread.c png_ptr->free_me &= ~PNG_FREE_TRNS;
png_ptr 944 pngread.c inflateEnd(&png_ptr->zstream);
png_ptr 947 pngread.c png_free(png_ptr, png_ptr->save_buffer);
png_ptr 952 pngread.c png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr 956 pngread.c png_free(png_ptr, png_ptr->chunk_list);
png_ptr 970 pngread.c png_structrp png_ptr = NULL;
png_ptr 975 pngread.c png_ptr = *png_ptr_ptr;
png_ptr 977 pngread.c if (png_ptr == NULL)
png_ptr 984 pngread.c png_destroy_info_struct(png_ptr, end_info_ptr_ptr);
png_ptr 985 pngread.c png_destroy_info_struct(png_ptr, info_ptr_ptr);
png_ptr 988 pngread.c png_read_destroy(png_ptr);
png_ptr 989 pngread.c png_destroy_png_struct(png_ptr);
png_ptr 995 pngread.c if (png_ptr == NULL)
png_ptr 998 pngread.c png_ptr->read_row_fn = read_row_fn;
png_ptr 1009 pngread.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 1015 pngread.c png_read_info(png_ptr, info_ptr);
png_ptr 1017 pngread.c png_error(png_ptr, "Image is too high to process with png_read_png()");
png_ptr 1033 pngread.c png_set_scale_16(png_ptr);
png_ptr 1035 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_SCALE_16 not supported");
png_ptr 1044 pngread.c png_set_strip_16(png_ptr);
png_ptr 1046 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_16 not supported");
png_ptr 1054 pngread.c png_set_strip_alpha(png_ptr);
png_ptr 1056 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_ALPHA not supported");
png_ptr 1064 pngread.c png_set_packing(png_ptr);
png_ptr 1066 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
png_ptr 1074 pngread.c png_set_packswap(png_ptr);
png_ptr 1076 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
png_ptr 1086 pngread.c png_set_expand(png_ptr);
png_ptr 1088 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND not supported");
png_ptr 1098 pngread.c png_set_invert_mono(png_ptr);
png_ptr 1100 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
png_ptr 1110 pngread.c png_set_shift(png_ptr, &info_ptr->sig_bit);
png_ptr 1112 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
png_ptr 1118 pngread.c png_set_bgr(png_ptr);
png_ptr 1120 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
png_ptr 1126 pngread.c png_set_swap_alpha(png_ptr);
png_ptr 1128 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
png_ptr 1134 pngread.c png_set_swap(png_ptr);
png_ptr 1136 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
png_ptr 1143 pngread.c png_set_invert_alpha(png_ptr);
png_ptr 1145 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
png_ptr 1152 pngread.c png_set_gray_to_rgb(png_ptr);
png_ptr 1154 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_GRAY_TO_RGB not supported");
png_ptr 1160 pngread.c png_set_expand_16(png_ptr);
png_ptr 1162 pngread.c png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND_16 not supported");
png_ptr 1170 pngread.c (void)png_set_interlace_handling(png_ptr);
png_ptr 1176 pngread.c png_read_update_info(png_ptr, info_ptr);
png_ptr 1180 pngread.c png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
png_ptr 1185 pngread.c info_ptr->row_pointers = png_voidcast(png_bytepp, png_malloc(png_ptr,
png_ptr 1195 pngread.c png_malloc(png_ptr, info_ptr->rowbytes));
png_ptr 1198 pngread.c png_read_image(png_ptr, info_ptr->row_pointers);
png_ptr 1202 pngread.c png_read_end(png_ptr, info_ptr);
png_ptr 1267 pngread.c png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, image,
png_ptr 1276 pngread.c if (png_ptr != NULL)
png_ptr 1278 pngread.c png_infop info_ptr = png_create_info_struct(png_ptr);
png_ptr 1283 pngread.c png_malloc_warn(png_ptr, (sizeof *control)));
png_ptr 1289 pngread.c control->png_ptr = png_ptr;
png_ptr 1298 pngread.c png_destroy_info_struct(png_ptr, &info_ptr);
png_ptr 1301 pngread.c png_destroy_read_struct(&png_ptr, NULL, NULL);
png_ptr 1316 pngread.c if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
png_ptr 1319 pngread.c if (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)
png_ptr 1327 pngread.c else if (png_ptr->num_trans > 0)
png_ptr 1330 pngread.c if (png_ptr->bit_depth == 16)
png_ptr 1333 pngread.c if (png_ptr->color_type & PNG_COLOR_MASK_PALETTE)
png_ptr 1367 pngread.c png_structrp png_ptr = image->opaque->png_ptr;
png_ptr 1370 pngread.c png_set_benign_errors(png_ptr, 1/*warn*/);
png_ptr 1371 pngread.c png_read_info(png_ptr, info_ptr);
png_ptr 1374 pngread.c image->width = png_ptr->width;
png_ptr 1375 pngread.c image->height = png_ptr->height;
png_ptr 1378 pngread.c png_uint_32 format = png_image_format(png_ptr);
png_ptr 1388 pngread.c if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags
png_ptr 1401 pngread.c switch (png_ptr->color_type)
png_ptr 1404 pngread.c cmap_entries = 1U << png_ptr->bit_depth;
png_ptr 1408 pngread.c cmap_entries = png_ptr->num_palette;
png_ptr 1439 pngread.c image->opaque->png_ptr->io_ptr = file;
png_ptr 1469 pngread.c image->opaque->png_ptr->io_ptr = fp;
png_ptr 1498 pngread.c if (png_ptr != NULL)
png_ptr 1500 pngread.c png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr);
png_ptr 1517 pngread.c png_error(png_ptr, "read beyond end of data");
png_ptr 1521 pngread.c png_error(png_ptr, "invalid memory read");
png_ptr 1540 pngread.c image->opaque->png_ptr->io_ptr = image;
png_ptr 1541 pngread.c image->opaque->png_ptr->read_data_fn = png_image_memory_read;
png_ptr 1599 pngread.c png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER,
png_ptr 1603 pngread.c png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT,
png_ptr 1623 pngread.c png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma;
png_ptr 1670 pngread.c png_error(display->image->opaque->png_ptr,
png_ptr 1727 pngread.c png_error(image->opaque->png_ptr, "color-map index out of range");
png_ptr 1825 pngread.c png_error(image->opaque->png_ptr, "bad encoding (internal error)");
png_ptr 2046 pngread.c const png_structrp png_ptr = image->opaque->png_ptr;
png_ptr 2069 pngread.c if (((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0 ||
png_ptr 2070 pngread.c png_ptr->num_trans > 0) /* alpha in input */ &&
png_ptr 2077 pngread.c png_error(png_ptr,
png_ptr 2108 pngread.c if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) == 0)
png_ptr 2115 pngread.c if (png_ptr->bit_depth == 16 &&
png_ptr 2117 pngread.c png_ptr->colorspace.gamma = PNG_GAMMA_LINEAR;
png_ptr 2120 pngread.c png_ptr->colorspace.gamma = PNG_GAMMA_sRGB_INVERSE;
png_ptr 2122 pngread.c png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
png_ptr 2130 pngread.c switch (png_ptr->color_type)
png_ptr 2133 pngread.c if (png_ptr->bit_depth <= 8)
png_ptr 2140 pngread.c cmap_entries = 1U << png_ptr->bit_depth;
png_ptr 2142 pngread.c png_error(png_ptr, "gray[8] color-map: too few entries");
png_ptr 2150 pngread.c if (png_ptr->num_trans > 0)
png_ptr 2152 pngread.c trans = png_ptr->trans_color.gray;
png_ptr 2196 pngread.c if (png_ptr->bit_depth < 8)
png_ptr 2197 pngread.c png_set_packing(png_ptr);
png_ptr 2221 pngread.c png_error(png_ptr, "gray[16] color-map: too few entries");
png_ptr 2225 pngread.c if (png_ptr->num_trans > 0)
png_ptr 2263 pngread.c png_set_background_fixed(png_ptr, &c,
png_ptr 2313 pngread.c png_error(png_ptr, "gray+alpha color-map: too few entries");
png_ptr 2347 pngread.c png_error(png_ptr, "gray-alpha color-map: too few entries");
png_ptr 2366 pngread.c png_set_background_fixed(png_ptr, &c,
png_ptr 2381 pngread.c png_error(png_ptr, "ga-alpha color-map: too few entries");
png_ptr 2461 pngread.c png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1,
png_ptr 2468 pngread.c if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
png_ptr 2469 pngread.c png_ptr->num_trans > 0) &&
png_ptr 2479 pngread.c png_error(png_ptr, "rgb[ga] color-map: too few entries");
png_ptr 2493 pngread.c png_error(png_ptr, "rgb[gray] color-map: too few entries");
png_ptr 2503 pngread.c if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
png_ptr 2504 pngread.c png_ptr->num_trans > 0) &&
png_ptr 2505 pngread.c png_gamma_not_sRGB(png_ptr->colorspace.gamma))
png_ptr 2516 pngread.c if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
png_ptr 2517 pngread.c png_ptr->num_trans > 0)
png_ptr 2538 pngread.c png_ptr->colorspace.gamma)); /* now P_FILE */
png_ptr 2568 pngread.c png_set_background_fixed(png_ptr, &c,
png_ptr 2587 pngread.c if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
png_ptr 2588 pngread.c png_ptr->num_trans > 0)
png_ptr 2598 pngread.c png_error(png_ptr, "rgb+alpha color-map: too few entries");
png_ptr 2647 pngread.c png_error(png_ptr, "rgb-alpha color-map: too few entries");
png_ptr 2717 pngread.c png_set_background_fixed(png_ptr, &c,
png_ptr 2732 pngread.c png_error(png_ptr, "rgb color-map: too few entries");
png_ptr 2745 pngread.c unsigned int num_trans = png_ptr->num_trans;
png_ptr 2746 pngread.c png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL;
png_ptr 2747 pngread.c png_const_colorp colormap = png_ptr->palette;
png_ptr 2758 pngread.c cmap_entries = png_ptr->num_palette;
png_ptr 2763 pngread.c png_error(png_ptr, "palette color-map: too few entries");
png_ptr 2800 pngread.c if (png_ptr->bit_depth < 8)
png_ptr 2801 pngread.c png_set_packing(png_ptr);
png_ptr 2806 pngread.c png_error(png_ptr, "invalid PNG color type");
png_ptr 2812 pngread.c if (expand_tRNS && png_ptr->num_trans > 0 &&
png_ptr 2813 pngread.c (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0)
png_ptr 2814 pngread.c png_set_tRNS_to_alpha(png_ptr);
png_ptr 2819 pngread.c png_error(png_ptr, "bad data option (internal error)");
png_ptr 2824 pngread.c png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB);
png_ptr 2828 pngread.c if (png_ptr->bit_depth > 8)
png_ptr 2829 pngread.c png_set_scale_16(png_ptr);
png_ptr 2834 pngread.c png_error(png_ptr, "color map overflow (BAD internal error)");
png_ptr 2868 pngread.c png_error(png_ptr, "bad processing option (internal error)");
png_ptr 2871 pngread.c png_error(png_ptr, "bad background index (internal error)");
png_ptr 2886 pngread.c png_structrp png_ptr = image->opaque->png_ptr;
png_ptr 2893 pngread.c switch (png_ptr->interlaced)
png_ptr 2904 pngread.c png_error(png_ptr, "unknown interlace type");
png_ptr 2920 pngread.c if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
png_ptr 2946 pngread.c png_read_row(png_ptr, inrow, NULL);
png_ptr 3076 pngread.c png_structrp png_ptr = control->png_ptr;
png_ptr 3081 pngread.c PNG_SKIP_CHUNKS(png_ptr);
png_ptr 3088 pngread.c passes = png_set_interlace_handling(png_ptr);
png_ptr 3090 pngread.c png_read_update_info(png_ptr, info_ptr);
png_ptr 3114 pngread.c png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
png_ptr 3124 pngread.c png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
png_ptr 3134 pngread.c png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
png_ptr 3143 pngread.c png_error(png_ptr, "bad color-map processing (internal error)");
png_ptr 3171 pngread.c png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
png_ptr 3176 pngread.c png_free(png_ptr, row);
png_ptr 3192 pngread.c png_read_row(png_ptr, row, NULL);
png_ptr 3208 pngread.c png_structrp png_ptr = image->opaque->png_ptr;
png_ptr 3211 pngread.c switch (png_ptr->interlaced)
png_ptr 3222 pngread.c png_error(png_ptr, "unknown interlace type");
png_ptr 3237 pngread.c if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
png_ptr 3264 pngread.c png_read_row(png_ptr, inrow, NULL);
png_ptr 3334 pngread.c png_structrp png_ptr = image->opaque->png_ptr;
png_ptr 3345 pngread.c if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
png_ptr 3346 pngread.c png_error(png_ptr, "lost rgb to gray");
png_ptr 3348 pngread.c if ((png_ptr->transformations & PNG_COMPOSE) != 0)
png_ptr 3349 pngread.c png_error(png_ptr, "unexpected compose");
png_ptr 3351 pngread.c if (png_get_channels(png_ptr, info_ptr) != 2)
png_ptr 3352 pngread.c png_error(png_ptr, "lost/gained channels");
png_ptr 3357 pngread.c png_error(png_ptr, "unexpected 8-bit transformation");
png_ptr 3359 pngread.c switch (png_ptr->interlaced)
png_ptr 3370 pngread.c png_error(png_ptr, "unknown interlace type");
png_ptr 3381 pngread.c png_error(png_ptr, "unexpected bit depth");
png_ptr 3401 pngread.c if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
png_ptr 3430 pngread.c png_read_row(png_ptr, inrow, NULL);
png_ptr 3475 pngread.c png_read_row(png_ptr, inrow, NULL);
png_ptr 3538 pngread.c if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
png_ptr 3565 pngread.c png_read_row(png_ptr, png_voidcast(png_bytep,
png_ptr 3612 pngread.c png_structrp png_ptr = image->opaque->png_ptr;
png_ptr 3625 pngread.c png_set_expand(png_ptr);
png_ptr 3629 pngread.c png_uint_32 base_format = png_image_format(png_ptr) &
png_ptr 3640 pngread.c png_set_gray_to_rgb(png_ptr);
png_ptr 3660 pngread.c png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE,
png_ptr 3681 pngread.c png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, input_gamma_default);
png_ptr 3719 pngread.c if (png_muldiv(>est, output_gamma, png_ptr->colorspace.gamma,
png_ptr 3736 pngread.c png_set_expand_16(png_ptr);
png_ptr 3739 pngread.c png_set_scale_16(png_ptr);
png_ptr 3763 pngread.c png_set_strip_alpha(png_ptr);
png_ptr 3782 pngread.c png_set_background_fixed(png_ptr, &c,
png_ptr 3826 pngread.c png_set_add_alpha(png_ptr, filler, where);
png_ptr 3837 pngread.c png_set_alpha_mode_fixed(png_ptr, mode, output_gamma);
png_ptr 3846 pngread.c png_set_bgr(png_ptr);
png_ptr 3869 pngread.c png_set_swap_alpha(png_ptr);
png_ptr 3887 pngread.c png_set_swap(png_ptr);
png_ptr 3892 pngread.c png_error(png_ptr, "png_read_image: unsupported transformation");
png_ptr 3895 pngread.c PNG_SKIP_CHUNKS(png_ptr);
png_ptr 3904 pngread.c passes = png_set_interlace_handling(png_ptr);
png_ptr 3906 pngread.c png_read_update_info(png_ptr, info_ptr);
png_ptr 3927 pngread.c png_error(png_ptr, "png_image_read: alpha channel lost");
png_ptr 3933 pngread.c if (png_ptr->transformations & PNG_BGR)
png_ptr 3944 pngread.c if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0 ||
png_ptr 3945 pngread.c ((png_ptr->transformations & PNG_ADD_ALPHA) != 0 &&
png_ptr 3946 pngread.c (png_ptr->flags & PNG_FLAG_FILLER_AFTER) == 0))
png_ptr 3949 pngread.c png_error(png_ptr, "unexpected alpha swap transformation");
png_ptr 3957 pngread.c png_error(png_ptr, "png_read_image: invalid transformations");
png_ptr 3989 pngread.c png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
png_ptr 3994 pngread.c png_free(png_ptr, row);
png_ptr 4002 pngread.c png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
png_ptr 4007 pngread.c png_free(png_ptr, row);
png_ptr 4023 pngread.c png_read_row(png_ptr, row, NULL);
png_ptr 36 pngrio.c if (png_ptr->read_data_fn != NULL)
png_ptr 37 pngrio.c (*(png_ptr->read_data_fn))(png_ptr, data, length);
png_ptr 40 pngrio.c png_error(png_ptr, "Call to NULL read function");
png_ptr 54 pngrio.c if (png_ptr == NULL)
png_ptr 60 pngrio.c check = fread(data, 1, length, png_voidcast(png_FILE_p, png_ptr->io_ptr));
png_ptr 63 pngrio.c png_error(png_ptr, "Read Error");
png_ptr 90 pngrio.c if (png_ptr == NULL)
png_ptr 93 pngrio.c png_ptr->io_ptr = io_ptr;
png_ptr 97 pngrio.c png_ptr->read_data_fn = read_data_fn;
png_ptr 100 pngrio.c png_ptr->read_data_fn = png_default_read_data;
png_ptr 102 pngrio.c png_ptr->read_data_fn = read_data_fn;
png_ptr 107 pngrio.c if (png_ptr->write_data_fn != NULL)
png_ptr 109 pngrio.c png_ptr->write_data_fn = NULL;
png_ptr 110 pngrio.c png_warning(png_ptr,
png_ptr 117 pngrio.c png_ptr->output_flush_fn = NULL;
png_ptr 29 pngrtran.c if (png_ptr == NULL)
png_ptr 39 pngrtran.c png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr 40 pngrtran.c png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
png_ptr 44 pngrtran.c png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr 45 pngrtran.c png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
png_ptr 50 pngrtran.c png_warning(png_ptr,
png_ptr 56 pngrtran.c png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr 67 pngrtran.c png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr 68 pngrtran.c png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
png_ptr 72 pngrtran.c png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr 73 pngrtran.c png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
png_ptr 78 pngrtran.c png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr 79 pngrtran.c png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
png_ptr 86 pngrtran.c png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr 99 pngrtran.c if (png_ptr != NULL)
png_ptr 101 pngrtran.c if (png_ptr->flags & PNG_FLAG_ROW_INIT)
png_ptr 102 pngrtran.c png_app_error(png_ptr,
png_ptr 105 pngrtran.c else if (need_IHDR && (png_ptr->mode & PNG_HAVE_IHDR) == 0)
png_ptr 106 pngrtran.c png_app_error(png_ptr, "invalid before the PNG header has been read");
png_ptr 111 pngrtran.c png_ptr->flags |= PNG_FLAG_DETECT_UNINITIALIZED;
png_ptr 130 pngrtran.c if (!png_rtran_ok(png_ptr, 0) || background_color == NULL)
png_ptr 135 pngrtran.c png_warning(png_ptr, "Application must supply a known background gamma");
png_ptr 139 pngrtran.c png_ptr->transformations |= PNG_COMPOSE | PNG_STRIP_ALPHA;
png_ptr 140 pngrtran.c png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
png_ptr 141 pngrtran.c png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
png_ptr 143 pngrtran.c png_ptr->background = *background_color;
png_ptr 144 pngrtran.c png_ptr->background_gamma = background_gamma;
png_ptr 145 pngrtran.c png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
png_ptr 147 pngrtran.c png_ptr->transformations |= PNG_BACKGROUND_EXPAND;
png_ptr 149 pngrtran.c png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND;
png_ptr 158 pngrtran.c png_set_background_fixed(png_ptr, background_color, background_gamma_code,
png_ptr 159 pngrtran.c need_expand, png_fixed(png_ptr, background_gamma, "png_set_background"));
png_ptr 174 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 177 pngrtran.c png_ptr->transformations |= PNG_SCALE_16_TO_8;
png_ptr 188 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 191 pngrtran.c png_ptr->transformations |= PNG_16_TO_8;
png_ptr 201 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 204 pngrtran.c png_ptr->transformations |= PNG_STRIP_ALPHA;
png_ptr 225 pngrtran.c png_ptr->flags |= PNG_FLAG_ASSUME_sRGB;
png_ptr 227 pngrtran.c PNG_UNUSED(png_ptr)
png_ptr 265 pngrtran.c png_fixed_error(png_ptr, "gamma value");
png_ptr 282 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 285 pngrtran.c output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/);
png_ptr 294 pngrtran.c png_error(png_ptr, "output gamma out of expected range");
png_ptr 321 pngrtran.c png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
png_ptr 322 pngrtran.c png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
png_ptr 327 pngrtran.c png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
png_ptr 328 pngrtran.c png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
png_ptr 335 pngrtran.c png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
png_ptr 336 pngrtran.c png_ptr->flags |= PNG_FLAG_OPTIMIZE_ALPHA;
png_ptr 342 pngrtran.c png_ptr->transformations |= PNG_ENCODE_ALPHA;
png_ptr 343 pngrtran.c png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
png_ptr 347 pngrtran.c png_error(png_ptr, "invalid alpha mode");
png_ptr 354 pngrtran.c if (png_ptr->colorspace.gamma == 0)
png_ptr 356 pngrtran.c png_ptr->colorspace.gamma = file_gamma;
png_ptr 357 pngrtran.c png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
png_ptr 361 pngrtran.c png_ptr->screen_gamma = output_gamma;
png_ptr 369 pngrtran.c memset(&png_ptr->background, 0, (sizeof png_ptr->background));
png_ptr 370 pngrtran.c png_ptr->background_gamma = png_ptr->colorspace.gamma; /* just in case */
png_ptr 371 pngrtran.c png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_FILE;
png_ptr 372 pngrtran.c png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND;
png_ptr 374 pngrtran.c if (png_ptr->transformations & PNG_COMPOSE)
png_ptr 375 pngrtran.c png_error(png_ptr,
png_ptr 378 pngrtran.c png_ptr->transformations |= PNG_COMPOSE;
png_ptr 386 pngrtran.c png_set_alpha_mode_fixed(png_ptr, mode, convert_gamma_value(png_ptr,
png_ptr 418 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 421 pngrtran.c png_ptr->transformations |= PNG_QUANTIZE;
png_ptr 427 pngrtran.c png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr,
png_ptr 430 pngrtran.c png_ptr->quantize_index[i] = (png_byte)i;
png_ptr 444 pngrtran.c png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr,
png_ptr 449 pngrtran.c png_ptr->quantize_sort[i] = (png_byte)i;
png_ptr 466 pngrtran.c if (histogram[png_ptr->quantize_sort[j]]
png_ptr 467 pngrtran.c < histogram[png_ptr->quantize_sort[j + 1]])
png_ptr 471 pngrtran.c t = png_ptr->quantize_sort[j];
png_ptr 472 pngrtran.c png_ptr->quantize_sort[j] = png_ptr->quantize_sort[j + 1];
png_ptr 473 pngrtran.c png_ptr->quantize_sort[j + 1] = t;
png_ptr 492 pngrtran.c if ((int)png_ptr->quantize_sort[i] >= maximum_colors)
png_ptr 496 pngrtran.c while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
png_ptr 512 pngrtran.c if ((int)png_ptr->quantize_sort[i] >= maximum_colors)
png_ptr 518 pngrtran.c while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
png_ptr 524 pngrtran.c png_ptr->quantize_index[j] = (png_byte)i;
png_ptr 525 pngrtran.c png_ptr->quantize_index[i] = (png_byte)j;
png_ptr 532 pngrtran.c if ((int)png_ptr->quantize_index[i] >= maximum_colors)
png_ptr 537 pngrtran.c d_index = png_ptr->quantize_index[i];
png_ptr 552 pngrtran.c png_ptr->quantize_index[i] = (png_byte)min_k;
png_ptr 556 pngrtran.c png_free(png_ptr, png_ptr->quantize_sort);
png_ptr 557 pngrtran.c png_ptr->quantize_sort = NULL;
png_ptr 578 pngrtran.c png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
png_ptr 580 pngrtran.c png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
png_ptr 586 pngrtran.c png_ptr->index_to_palette[i] = (png_byte)i;
png_ptr 587 pngrtran.c png_ptr->palette_to_index[i] = (png_byte)i;
png_ptr 590 pngrtran.c hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 *
png_ptr 620 pngrtran.c t = (png_dsortp)png_malloc_warn(png_ptr,
png_ptr 645 pngrtran.c if ((int)png_ptr->index_to_palette[p->left]
png_ptr 647 pngrtran.c (int)png_ptr->index_to_palette[p->right]
png_ptr 664 pngrtran.c palette[png_ptr->index_to_palette[j]]
png_ptr 672 pngrtran.c if (png_ptr->quantize_index[k] ==
png_ptr 673 pngrtran.c png_ptr->index_to_palette[j])
png_ptr 674 pngrtran.c png_ptr->quantize_index[k] =
png_ptr 675 pngrtran.c png_ptr->index_to_palette[next_j];
png_ptr 677 pngrtran.c if ((int)png_ptr->quantize_index[k] ==
png_ptr 679 pngrtran.c png_ptr->quantize_index[k] =
png_ptr 680 pngrtran.c png_ptr->index_to_palette[j];
png_ptr 684 pngrtran.c png_ptr->index_to_palette[png_ptr->palette_to_index
png_ptr 685 pngrtran.c [num_new_palette]] = png_ptr->index_to_palette[j];
png_ptr 687 pngrtran.c png_ptr->palette_to_index[png_ptr->index_to_palette[j]]
png_ptr 688 pngrtran.c = png_ptr->palette_to_index[num_new_palette];
png_ptr 690 pngrtran.c png_ptr->index_to_palette[j] =
png_ptr 693 pngrtran.c png_ptr->palette_to_index[num_new_palette] =
png_ptr 712 pngrtran.c png_free(png_ptr, p);
png_ptr 720 pngrtran.c png_free(png_ptr, hash);
png_ptr 721 pngrtran.c png_free(png_ptr, png_ptr->palette_to_index);
png_ptr 722 pngrtran.c png_free(png_ptr, png_ptr->index_to_palette);
png_ptr 723 pngrtran.c png_ptr->palette_to_index = NULL;
png_ptr 724 pngrtran.c png_ptr->index_to_palette = NULL;
png_ptr 728 pngrtran.c if (png_ptr->palette == NULL)
png_ptr 730 pngrtran.c png_ptr->palette = palette;
png_ptr 732 pngrtran.c png_ptr->num_palette = (png_uint_16)num_palette;
png_ptr 745 pngrtran.c png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr,
png_ptr 748 pngrtran.c distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
png_ptr 786 pngrtran.c png_ptr->palette_lookup[d_index] = (png_byte)i;
png_ptr 793 pngrtran.c png_free(png_ptr, distance);
png_ptr 805 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 809 pngrtran.c scrn_gamma = translate_gamma_flags(png_ptr, scrn_gamma, 1/*screen*/);
png_ptr 810 pngrtran.c file_gamma = translate_gamma_flags(png_ptr, file_gamma, 0/*file*/);
png_ptr 824 pngrtran.c png_error(png_ptr, "invalid file gamma in png_set_gamma");
png_ptr 827 pngrtran.c png_error(png_ptr, "invalid screen gamma in png_set_gamma");
png_ptr 833 pngrtran.c png_ptr->colorspace.gamma = file_gamma;
png_ptr 834 pngrtran.c png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
png_ptr 835 pngrtran.c png_ptr->screen_gamma = scrn_gamma;
png_ptr 842 pngrtran.c png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma),
png_ptr 843 pngrtran.c convert_gamma_value(png_ptr, file_gamma));
png_ptr 858 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 861 pngrtran.c png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
png_ptr 888 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 891 pngrtran.c png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
png_ptr 900 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 903 pngrtran.c png_ptr->transformations |= PNG_EXPAND;
png_ptr 912 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 915 pngrtran.c png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
png_ptr 928 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 931 pngrtran.c png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS);
png_ptr 941 pngrtran.c if (!png_rtran_ok(png_ptr, 0))
png_ptr 945 pngrtran.c png_set_expand_gray_1_2_4_to_8(png_ptr);
png_ptr 946 pngrtran.c png_ptr->transformations |= PNG_GRAY_TO_RGB;
png_ptr 959 pngrtran.c if (!png_rtran_ok(png_ptr, 1))
png_ptr 965 pngrtran.c png_ptr->transformations |= PNG_RGB_TO_GRAY;
png_ptr 969 pngrtran.c png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
png_ptr 973 pngrtran.c png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
png_ptr 977 pngrtran.c png_error(png_ptr, "invalid error action to rgb_to_gray");
png_ptr 981 pngrtran.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 983 pngrtran.c png_ptr->transformations |= PNG_EXPAND;
png_ptr 989 pngrtran.c png_error(png_ptr,
png_ptr 1008 pngrtran.c png_ptr->rgb_to_gray_red_coeff = red_int;
png_ptr 1009 pngrtran.c png_ptr->rgb_to_gray_green_coeff = green_int;
png_ptr 1010 pngrtran.c png_ptr->rgb_to_gray_coefficients_set = 1;
png_ptr 1016 pngrtran.c png_app_warning(png_ptr,
png_ptr 1025 pngrtran.c if (png_ptr->rgb_to_gray_red_coeff == 0 &&
png_ptr 1026 pngrtran.c png_ptr->rgb_to_gray_green_coeff == 0)
png_ptr 1028 pngrtran.c png_ptr->rgb_to_gray_red_coeff = 6968;
png_ptr 1029 pngrtran.c png_ptr->rgb_to_gray_green_coeff = 23434;
png_ptr 1045 pngrtran.c png_set_rgb_to_gray_fixed(png_ptr, error_action,
png_ptr 1046 pngrtran.c png_fixed(png_ptr, red, "rgb to gray red coefficient"),
png_ptr 1047 pngrtran.c png_fixed(png_ptr, green, "rgb to gray green coefficient"));
png_ptr 1062 pngrtran.c png_ptr->transformations |= PNG_USER_TRANSFORM;
png_ptr 1063 pngrtran.c png_ptr->read_user_transform_fn = read_user_transform_fn;
png_ptr 1113 pngrtran.c if (png_ptr->num_trans > 0)
png_ptr 1118 pngrtran.c for (i=0; i<png_ptr->num_trans; ++i)
png_ptr 1120 pngrtran.c if (png_ptr->trans_alpha[i] == 255)
png_ptr 1122 pngrtran.c else if (png_ptr->trans_alpha[i] == 0)
png_ptr 1140 pngrtran.c png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
png_ptr 1141 pngrtran.c png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
png_ptr 1144 pngrtran.c png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND);
png_ptr 1156 pngrtran.c if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
png_ptr 1157 pngrtran.c (png_ptr->transformations & PNG_EXPAND))
png_ptr 1160 pngrtran.c png_ptr->background.red =
png_ptr 1161 pngrtran.c png_ptr->palette[png_ptr->background.index].red;
png_ptr 1162 pngrtran.c png_ptr->background.green =
png_ptr 1163 pngrtran.c png_ptr->palette[png_ptr->background.index].green;
png_ptr 1164 pngrtran.c png_ptr->background.blue =
png_ptr 1165 pngrtran.c png_ptr->palette[png_ptr->background.index].blue;
png_ptr 1168 pngrtran.c if (png_ptr->transformations & PNG_INVERT_ALPHA)
png_ptr 1170 pngrtran.c if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
png_ptr 1175 pngrtran.c int i, istop = png_ptr->num_trans;
png_ptr 1178 pngrtran.c png_ptr->trans_alpha[i] = (png_byte)(255 -
png_ptr 1179 pngrtran.c png_ptr->trans_alpha[i]);
png_ptr 1195 pngrtran.c int input_has_alpha = (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0;
png_ptr 1196 pngrtran.c int input_has_transparency = png_ptr->num_trans > 0;
png_ptr 1206 pngrtran.c png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
png_ptr 1207 pngrtran.c png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
png_ptr 1211 pngrtran.c png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND);
png_ptr 1223 pngrtran.c if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
png_ptr 1224 pngrtran.c (png_ptr->transformations & PNG_EXPAND) &&
png_ptr 1225 pngrtran.c !(png_ptr->color_type & PNG_COLOR_MASK_COLOR))
png_ptr 1230 pngrtran.c int gray = png_ptr->background.gray;
png_ptr 1231 pngrtran.c int trans_gray = png_ptr->trans_color.gray;
png_ptr 1233 pngrtran.c switch (png_ptr->bit_depth)
png_ptr 1260 pngrtran.c png_ptr->background.red = png_ptr->background.green =
png_ptr 1261 pngrtran.c png_ptr->background.blue = (png_uint_16)gray;
png_ptr 1263 pngrtran.c if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
png_ptr 1265 pngrtran.c png_ptr->trans_color.red = png_ptr->trans_color.green =
png_ptr 1266 pngrtran.c png_ptr->trans_color.blue = (png_uint_16)trans_gray;
png_ptr 1299 pngrtran.c if (png_ptr->colorspace.gamma != 0) /* has been set */
png_ptr 1301 pngrtran.c if (png_ptr->screen_gamma != 0) /* screen set too */
png_ptr 1302 pngrtran.c gamma_correction = png_gamma_threshold(png_ptr->colorspace.gamma,
png_ptr 1303 pngrtran.c png_ptr->screen_gamma);
png_ptr 1309 pngrtran.c png_ptr->screen_gamma = png_reciprocal(png_ptr->colorspace.gamma);
png_ptr 1312 pngrtran.c else if (png_ptr->screen_gamma != 0)
png_ptr 1318 pngrtran.c png_ptr->colorspace.gamma = png_reciprocal(png_ptr->screen_gamma);
png_ptr 1326 pngrtran.c png_ptr->screen_gamma = png_ptr->colorspace.gamma = PNG_FP_1;
png_ptr 1329 pngrtran.c png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
png_ptr 1340 pngrtran.c png_ptr->transformations |= PNG_GAMMA;
png_ptr 1343 pngrtran.c png_ptr->transformations &= ~PNG_GAMMA;
png_ptr 1377 pngrtran.c if ((png_ptr->transformations & PNG_STRIP_ALPHA) &&
png_ptr 1378 pngrtran.c !(png_ptr->transformations & PNG_COMPOSE))
png_ptr 1385 pngrtran.c png_ptr->transformations &= ~(PNG_BACKGROUND_EXPAND | PNG_ENCODE_ALPHA |
png_ptr 1387 pngrtran.c png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
png_ptr 1396 pngrtran.c png_ptr->num_trans = 0;
png_ptr 1404 pngrtran.c if (!png_gamma_significant(png_ptr->screen_gamma))
png_ptr 1406 pngrtran.c png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
png_ptr 1407 pngrtran.c png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
png_ptr 1415 pngrtran.c if (png_ptr->transformations & PNG_RGB_TO_GRAY)
png_ptr 1416 pngrtran.c png_colorspace_set_rgb_coefficients(png_ptr);
png_ptr 1436 pngrtran.c if (png_ptr->transformations & PNG_BACKGROUND_EXPAND)
png_ptr 1441 pngrtran.c if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR))
png_ptr 1442 pngrtran.c png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
png_ptr 1445 pngrtran.c else if (png_ptr->transformations & PNG_COMPOSE)
png_ptr 1452 pngrtran.c if (png_ptr->transformations & PNG_GRAY_TO_RGB)
png_ptr 1454 pngrtran.c if (png_ptr->background.red == png_ptr->background.green &&
png_ptr 1455 pngrtran.c png_ptr->background.red == png_ptr->background.blue)
png_ptr 1457 pngrtran.c png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
png_ptr 1458 pngrtran.c png_ptr->background.gray = png_ptr->background.red;
png_ptr 1476 pngrtran.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 1477 pngrtran.c png_init_palette_transformations(png_ptr);
png_ptr 1480 pngrtran.c png_init_rgb_transformations(png_ptr);
png_ptr 1484 pngrtran.c if ((png_ptr->transformations & PNG_EXPAND_16) &&
png_ptr 1485 pngrtran.c (png_ptr->transformations & PNG_COMPOSE) &&
png_ptr 1486 pngrtran.c !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
png_ptr 1487 pngrtran.c png_ptr->bit_depth != 16)
png_ptr 1500 pngrtran.c CHOP(png_ptr->background.red);
png_ptr 1501 pngrtran.c CHOP(png_ptr->background.green);
png_ptr 1502 pngrtran.c CHOP(png_ptr->background.blue);
png_ptr 1503 pngrtran.c CHOP(png_ptr->background.gray);
png_ptr 1511 pngrtran.c if ((png_ptr->transformations & (PNG_16_TO_8|PNG_SCALE_16_TO_8)) &&
png_ptr 1512 pngrtran.c (png_ptr->transformations & PNG_COMPOSE) &&
png_ptr 1513 pngrtran.c !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
png_ptr 1514 pngrtran.c png_ptr->bit_depth == 16)
png_ptr 1522 pngrtran.c png_ptr->background.red = (png_uint_16)(png_ptr->background.red * 257);
png_ptr 1523 pngrtran.c png_ptr->background.green =
png_ptr 1524 pngrtran.c (png_uint_16)(png_ptr->background.green * 257);
png_ptr 1525 pngrtran.c png_ptr->background.blue = (png_uint_16)(png_ptr->background.blue * 257);
png_ptr 1526 pngrtran.c png_ptr->background.gray = (png_uint_16)(png_ptr->background.gray * 257);
png_ptr 1541 pngrtran.c png_ptr->background_1 = png_ptr->background;
png_ptr 1557 pngrtran.c if ((png_ptr->transformations & PNG_GAMMA)
png_ptr 1558 pngrtran.c || ((png_ptr->transformations & PNG_RGB_TO_GRAY)
png_ptr 1559 pngrtran.c && (png_gamma_significant(png_ptr->colorspace.gamma) ||
png_ptr 1560 pngrtran.c png_gamma_significant(png_ptr->screen_gamma)))
png_ptr 1561 pngrtran.c || ((png_ptr->transformations & PNG_COMPOSE)
png_ptr 1562 pngrtran.c && (png_gamma_significant(png_ptr->colorspace.gamma)
png_ptr 1563 pngrtran.c || png_gamma_significant(png_ptr->screen_gamma)
png_ptr 1565 pngrtran.c || (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE
png_ptr 1566 pngrtran.c && png_gamma_significant(png_ptr->background_gamma))
png_ptr 1568 pngrtran.c )) || ((png_ptr->transformations & PNG_ENCODE_ALPHA)
png_ptr 1569 pngrtran.c && png_gamma_significant(png_ptr->screen_gamma))
png_ptr 1572 pngrtran.c png_build_gamma_table(png_ptr, png_ptr->bit_depth);
png_ptr 1575 pngrtran.c if (png_ptr->transformations & PNG_COMPOSE)
png_ptr 1583 pngrtran.c if (png_ptr->transformations & PNG_RGB_TO_GRAY)
png_ptr 1584 pngrtran.c png_warning(png_ptr,
png_ptr 1587 pngrtran.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 1593 pngrtran.c png_colorp palette = png_ptr->palette;
png_ptr 1594 pngrtran.c int num_palette = png_ptr->num_palette;
png_ptr 1596 pngrtran.c if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
png_ptr 1599 pngrtran.c back.red = png_ptr->gamma_table[png_ptr->background.red];
png_ptr 1600 pngrtran.c back.green = png_ptr->gamma_table[png_ptr->background.green];
png_ptr 1601 pngrtran.c back.blue = png_ptr->gamma_table[png_ptr->background.blue];
png_ptr 1603 pngrtran.c back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
png_ptr 1604 pngrtran.c back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
png_ptr 1605 pngrtran.c back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
png_ptr 1611 pngrtran.c switch (png_ptr->background_gamma_type)
png_ptr 1614 pngrtran.c g = (png_ptr->screen_gamma);
png_ptr 1619 pngrtran.c g = png_reciprocal(png_ptr->colorspace.gamma);
png_ptr 1620 pngrtran.c gs = png_reciprocal2(png_ptr->colorspace.gamma,
png_ptr 1621 pngrtran.c png_ptr->screen_gamma);
png_ptr 1625 pngrtran.c g = png_reciprocal(png_ptr->background_gamma);
png_ptr 1626 pngrtran.c gs = png_reciprocal2(png_ptr->background_gamma,
png_ptr 1627 pngrtran.c png_ptr->screen_gamma);
png_ptr 1637 pngrtran.c back.red = png_gamma_8bit_correct(png_ptr->background.red,
png_ptr 1639 pngrtran.c back.green = png_gamma_8bit_correct(png_ptr->background.green,
png_ptr 1641 pngrtran.c back.blue = png_gamma_8bit_correct(png_ptr->background.blue,
png_ptr 1647 pngrtran.c back.red = (png_byte)png_ptr->background.red;
png_ptr 1648 pngrtran.c back.green = (png_byte)png_ptr->background.green;
png_ptr 1649 pngrtran.c back.blue = (png_byte)png_ptr->background.blue;
png_ptr 1654 pngrtran.c back_1.red = png_gamma_8bit_correct(png_ptr->background.red,
png_ptr 1657 pngrtran.c png_ptr->background.green, g);
png_ptr 1658 pngrtran.c back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue,
png_ptr 1664 pngrtran.c back_1.red = (png_byte)png_ptr->background.red;
png_ptr 1665 pngrtran.c back_1.green = (png_byte)png_ptr->background.green;
png_ptr 1666 pngrtran.c back_1.blue = (png_byte)png_ptr->background.blue;
png_ptr 1672 pngrtran.c if (i < (int)png_ptr->num_trans &&
png_ptr 1673 pngrtran.c png_ptr->trans_alpha[i] != 0xff)
png_ptr 1675 pngrtran.c if (png_ptr->trans_alpha[i] == 0)
png_ptr 1683 pngrtran.c v = png_ptr->gamma_to_1[palette[i].red];
png_ptr 1684 pngrtran.c png_composite(w, v, png_ptr->trans_alpha[i], back_1.red);
png_ptr 1685 pngrtran.c palette[i].red = png_ptr->gamma_from_1[w];
png_ptr 1687 pngrtran.c v = png_ptr->gamma_to_1[palette[i].green];
png_ptr 1688 pngrtran.c png_composite(w, v, png_ptr->trans_alpha[i], back_1.green);
png_ptr 1689 pngrtran.c palette[i].green = png_ptr->gamma_from_1[w];
png_ptr 1691 pngrtran.c v = png_ptr->gamma_to_1[palette[i].blue];
png_ptr 1692 pngrtran.c png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue);
png_ptr 1693 pngrtran.c palette[i].blue = png_ptr->gamma_from_1[w];
png_ptr 1698 pngrtran.c palette[i].red = png_ptr->gamma_table[palette[i].red];
png_ptr 1699 pngrtran.c palette[i].green = png_ptr->gamma_table[palette[i].green];
png_ptr 1700 pngrtran.c palette[i].blue = png_ptr->gamma_table[palette[i].blue];
png_ptr 1710 pngrtran.c png_ptr->transformations &= ~(PNG_COMPOSE | PNG_GAMMA);
png_ptr 1720 pngrtran.c switch (png_ptr->background_gamma_type)
png_ptr 1723 pngrtran.c g = png_ptr->screen_gamma;
png_ptr 1728 pngrtran.c g = png_reciprocal(png_ptr->colorspace.gamma);
png_ptr 1729 pngrtran.c gs = png_reciprocal2(png_ptr->colorspace.gamma,
png_ptr 1730 pngrtran.c png_ptr->screen_gamma);
png_ptr 1734 pngrtran.c g = png_reciprocal(png_ptr->background_gamma);
png_ptr 1735 pngrtran.c gs = png_reciprocal2(png_ptr->background_gamma,
png_ptr 1736 pngrtran.c png_ptr->screen_gamma);
png_ptr 1740 pngrtran.c png_error(png_ptr, "invalid background gamma type");
png_ptr 1747 pngrtran.c png_ptr->background_1.gray = png_gamma_correct(png_ptr,
png_ptr 1748 pngrtran.c png_ptr->background.gray, g);
png_ptr 1751 pngrtran.c png_ptr->background.gray = png_gamma_correct(png_ptr,
png_ptr 1752 pngrtran.c png_ptr->background.gray, gs);
png_ptr 1754 pngrtran.c if ((png_ptr->background.red != png_ptr->background.green) ||
png_ptr 1755 pngrtran.c (png_ptr->background.red != png_ptr->background.blue) ||
png_ptr 1756 pngrtran.c (png_ptr->background.red != png_ptr->background.gray))
png_ptr 1761 pngrtran.c png_ptr->background_1.red = png_gamma_correct(png_ptr,
png_ptr 1762 pngrtran.c png_ptr->background.red, g);
png_ptr 1764 pngrtran.c png_ptr->background_1.green = png_gamma_correct(png_ptr,
png_ptr 1765 pngrtran.c png_ptr->background.green, g);
png_ptr 1767 pngrtran.c png_ptr->background_1.blue = png_gamma_correct(png_ptr,
png_ptr 1768 pngrtran.c png_ptr->background.blue, g);
png_ptr 1773 pngrtran.c png_ptr->background.red = png_gamma_correct(png_ptr,
png_ptr 1774 pngrtran.c png_ptr->background.red, gs);
png_ptr 1776 pngrtran.c png_ptr->background.green = png_gamma_correct(png_ptr,
png_ptr 1777 pngrtran.c png_ptr->background.green, gs);
png_ptr 1779 pngrtran.c png_ptr->background.blue = png_gamma_correct(png_ptr,
png_ptr 1780 pngrtran.c png_ptr->background.blue, gs);
png_ptr 1787 pngrtran.c png_ptr->background_1.red = png_ptr->background_1.green
png_ptr 1788 pngrtran.c = png_ptr->background_1.blue = png_ptr->background_1.gray;
png_ptr 1790 pngrtran.c png_ptr->background.red = png_ptr->background.green
png_ptr 1791 pngrtran.c = png_ptr->background.blue = png_ptr->background.gray;
png_ptr 1795 pngrtran.c png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_SCREEN;
png_ptr 1802 pngrtran.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE
png_ptr 1805 pngrtran.c && ((png_ptr->transformations & PNG_EXPAND) == 0 ||
png_ptr 1806 pngrtran.c (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
png_ptr 1810 pngrtran.c png_colorp palette = png_ptr->palette;
png_ptr 1811 pngrtran.c int num_palette = png_ptr->num_palette;
png_ptr 1819 pngrtran.c palette[i].red = png_ptr->gamma_table[palette[i].red];
png_ptr 1820 pngrtran.c palette[i].green = png_ptr->gamma_table[palette[i].green];
png_ptr 1821 pngrtran.c palette[i].blue = png_ptr->gamma_table[palette[i].blue];
png_ptr 1825 pngrtran.c png_ptr->transformations &= ~PNG_GAMMA;
png_ptr 1835 pngrtran.c if ((png_ptr->transformations & PNG_COMPOSE) &&
png_ptr 1836 pngrtran.c (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
png_ptr 1839 pngrtran.c int istop = (int)png_ptr->num_trans;
png_ptr 1841 pngrtran.c png_colorp palette = png_ptr->palette;
png_ptr 1843 pngrtran.c back.red = (png_byte)png_ptr->background.red;
png_ptr 1844 pngrtran.c back.green = (png_byte)png_ptr->background.green;
png_ptr 1845 pngrtran.c back.blue = (png_byte)png_ptr->background.blue;
png_ptr 1849 pngrtran.c if (png_ptr->trans_alpha[i] == 0)
png_ptr 1854 pngrtran.c else if (png_ptr->trans_alpha[i] != 0xff)
png_ptr 1858 pngrtran.c png_ptr->trans_alpha[i], back.red);
png_ptr 1861 pngrtran.c png_ptr->trans_alpha[i], back.green);
png_ptr 1864 pngrtran.c png_ptr->trans_alpha[i], back.blue);
png_ptr 1868 pngrtran.c png_ptr->transformations &= ~PNG_COMPOSE;
png_ptr 1873 pngrtran.c if ((png_ptr->transformations & PNG_SHIFT) &&
png_ptr 1874 pngrtran.c !(png_ptr->transformations & PNG_EXPAND) &&
png_ptr 1875 pngrtran.c (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
png_ptr 1878 pngrtran.c int istop = png_ptr->num_palette;
png_ptr 1879 pngrtran.c int shift = 8 - png_ptr->sig_bit.red;
png_ptr 1881 pngrtran.c png_ptr->transformations &= ~PNG_SHIFT;
png_ptr 1890 pngrtran.c int component = png_ptr->palette[i].red;
png_ptr 1893 pngrtran.c png_ptr->palette[i].red = (png_byte)component;
png_ptr 1896 pngrtran.c shift = 8 - png_ptr->sig_bit.green;
png_ptr 1900 pngrtran.c int component = png_ptr->palette[i].green;
png_ptr 1903 pngrtran.c png_ptr->palette[i].green = (png_byte)component;
png_ptr 1906 pngrtran.c shift = 8 - png_ptr->sig_bit.blue;
png_ptr 1910 pngrtran.c int component = png_ptr->palette[i].blue;
png_ptr 1913 pngrtran.c png_ptr->palette[i].blue = (png_byte)component;
png_ptr 1929 pngrtran.c if (png_ptr->transformations & PNG_EXPAND)
png_ptr 1937 pngrtran.c if (png_ptr->num_trans > 0)
png_ptr 1946 pngrtran.c if (png_ptr->palette == NULL)
png_ptr 1947 pngrtran.c png_error (png_ptr, "Palette is NULL in indexed image");
png_ptr 1951 pngrtran.c if (png_ptr->num_trans)
png_ptr 1953 pngrtran.c if (png_ptr->transformations & PNG_EXPAND_tRNS)
png_ptr 1969 pngrtran.c if (png_ptr->transformations & PNG_COMPOSE)
png_ptr 1970 pngrtran.c info_ptr->background = png_ptr->background;
png_ptr 1983 pngrtran.c info_ptr->colorspace.gamma = png_ptr->colorspace.gamma;
png_ptr 1990 pngrtran.c if (png_ptr->transformations & PNG_SCALE_16_TO_8)
png_ptr 1995 pngrtran.c if (png_ptr->transformations & PNG_16_TO_8)
png_ptr 2009 pngrtran.c png_ptr->transformations |= PNG_16_TO_8;
png_ptr 2014 pngrtran.c png_ptr->transformations |= PNG_SCALE_16_TO_8;
png_ptr 2025 pngrtran.c if (png_ptr->transformations & PNG_GRAY_TO_RGB)
png_ptr 2031 pngrtran.c if (png_ptr->transformations & PNG_RGB_TO_GRAY)
png_ptr 2037 pngrtran.c if (png_ptr->transformations & PNG_QUANTIZE)
png_ptr 2041 pngrtran.c png_ptr->palette_lookup && info_ptr->bit_depth == 8)
png_ptr 2049 pngrtran.c if (png_ptr->transformations & PNG_EXPAND_16 && info_ptr->bit_depth == 8 &&
png_ptr 2057 pngrtran.c if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
png_ptr 2071 pngrtran.c if (png_ptr->transformations & PNG_STRIP_ALPHA)
png_ptr 2084 pngrtran.c if ((png_ptr->transformations & PNG_FILLER) &&
png_ptr 2090 pngrtran.c if (png_ptr->transformations & PNG_ADD_ALPHA)
png_ptr 2097 pngrtran.c if (png_ptr->transformations & PNG_USER_TRANSFORM)
png_ptr 2099 pngrtran.c if (info_ptr->bit_depth < png_ptr->user_transform_depth)
png_ptr 2100 pngrtran.c info_ptr->bit_depth = png_ptr->user_transform_depth;
png_ptr 2102 pngrtran.c if (info_ptr->channels < png_ptr->user_transform_channels)
png_ptr 2103 pngrtran.c info_ptr->channels = png_ptr->user_transform_channels;
png_ptr 2118 pngrtran.c png_ptr->info_rowbytes = info_ptr->rowbytes;
png_ptr 2121 pngrtran.c if (png_ptr != NULL)
png_ptr 2992 pngrtran.c PNG_CONST png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
png_ptr 2993 pngrtran.c PNG_CONST png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
png_ptr 3007 pngrtran.c if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
png_ptr 3021 pngrtran.c red = png_ptr->gamma_to_1[red];
png_ptr 3022 pngrtran.c green = png_ptr->gamma_to_1[green];
png_ptr 3023 pngrtran.c blue = png_ptr->gamma_to_1[blue];
png_ptr 3026 pngrtran.c *(dp++) = png_ptr->gamma_from_1[
png_ptr 3035 pngrtran.c if (png_ptr->gamma_table != NULL)
png_ptr 3036 pngrtran.c red = png_ptr->gamma_table[red];
png_ptr 3079 pngrtran.c if (png_ptr->gamma_16_to_1 != NULL && png_ptr->gamma_16_from_1 != NULL)
png_ptr 3095 pngrtran.c if (png_ptr->gamma_16_table != NULL)
png_ptr 3096 pngrtran.c w = png_ptr->gamma_16_table[(red&0xff)
png_ptr 3097 pngrtran.c >> png_ptr->gamma_shift][red>>8];
png_ptr 3105 pngrtran.c png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff)
png_ptr 3106 pngrtran.c >> png_ptr->gamma_shift][red>>8];
png_ptr 3108 pngrtran.c png_ptr->gamma_16_to_1[(green&0xff) >>
png_ptr 3109 pngrtran.c png_ptr->gamma_shift][green>>8];
png_ptr 3110 pngrtran.c png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff)
png_ptr 3111 pngrtran.c >> png_ptr->gamma_shift][blue>>8];
png_ptr 3114 pngrtran.c w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
png_ptr 3115 pngrtran.c png_ptr->gamma_shift][gray16 >> 8];
png_ptr 3186 pngrtran.c png_const_bytep gamma_table = png_ptr->gamma_table;
png_ptr 3187 pngrtran.c png_const_bytep gamma_from_1 = png_ptr->gamma_from_1;
png_ptr 3188 pngrtran.c png_const_bytep gamma_to_1 = png_ptr->gamma_to_1;
png_ptr 3189 pngrtran.c png_const_uint_16pp gamma_16 = png_ptr->gamma_16_table;
png_ptr 3190 pngrtran.c png_const_uint_16pp gamma_16_from_1 = png_ptr->gamma_16_from_1;
png_ptr 3191 pngrtran.c png_const_uint_16pp gamma_16_to_1 = png_ptr->gamma_16_to_1;
png_ptr 3192 pngrtran.c int gamma_shift = png_ptr->gamma_shift;
png_ptr 3193 pngrtran.c int optimize = (png_ptr->flags & PNG_FLAG_OPTIMIZE_ALPHA) != 0;
png_ptr 3217 pngrtran.c == png_ptr->trans_color.gray)
png_ptr 3220 pngrtran.c tmp |= png_ptr->background.gray << shift;
png_ptr 3246 pngrtran.c == png_ptr->trans_color.gray)
png_ptr 3249 pngrtran.c tmp |= png_ptr->background.gray << shift;
png_ptr 3282 pngrtran.c == png_ptr->trans_color.gray)
png_ptr 3285 pngrtran.c tmp |= png_ptr->background.gray << shift;
png_ptr 3312 pngrtran.c == png_ptr->trans_color.gray)
png_ptr 3315 pngrtran.c tmp |= png_ptr->background.gray << shift;
png_ptr 3348 pngrtran.c == png_ptr->trans_color.gray)
png_ptr 3351 pngrtran.c tmp |= png_ptr->background.gray << shift;
png_ptr 3376 pngrtran.c if (*sp == png_ptr->trans_color.gray)
png_ptr 3377 pngrtran.c *sp = (png_byte)png_ptr->background.gray;
png_ptr 3389 pngrtran.c if (*sp == png_ptr->trans_color.gray)
png_ptr 3390 pngrtran.c *sp = (png_byte)png_ptr->background.gray;
png_ptr 3408 pngrtran.c if (v == png_ptr->trans_color.gray)
png_ptr 3411 pngrtran.c *sp = (png_byte)((png_ptr->background.gray >> 8)
png_ptr 3413 pngrtran.c *(sp + 1) = (png_byte)(png_ptr->background.gray
png_ptr 3435 pngrtran.c if (v == png_ptr->trans_color.gray)
png_ptr 3437 pngrtran.c *sp = (png_byte)((png_ptr->background.gray >> 8)
png_ptr 3439 pngrtran.c *(sp + 1) = (png_byte)(png_ptr->background.gray
png_ptr 3463 pngrtran.c if (*sp == png_ptr->trans_color.red &&
png_ptr 3464 pngrtran.c *(sp + 1) == png_ptr->trans_color.green &&
png_ptr 3465 pngrtran.c *(sp + 2) == png_ptr->trans_color.blue)
png_ptr 3467 pngrtran.c *sp = (png_byte)png_ptr->background.red;
png_ptr 3468 pngrtran.c *(sp + 1) = (png_byte)png_ptr->background.green;
png_ptr 3469 pngrtran.c *(sp + 2) = (png_byte)png_ptr->background.blue;
png_ptr 3486 pngrtran.c if (*sp == png_ptr->trans_color.red &&
png_ptr 3487 pngrtran.c *(sp + 1) == png_ptr->trans_color.green &&
png_ptr 3488 pngrtran.c *(sp + 2) == png_ptr->trans_color.blue)
png_ptr 3490 pngrtran.c *sp = (png_byte)png_ptr->background.red;
png_ptr 3491 pngrtran.c *(sp + 1) = (png_byte)png_ptr->background.green;
png_ptr 3492 pngrtran.c *(sp + 2) = (png_byte)png_ptr->background.blue;
png_ptr 3513 pngrtran.c if (r == png_ptr->trans_color.red &&
png_ptr 3514 pngrtran.c g == png_ptr->trans_color.green &&
png_ptr 3515 pngrtran.c b == png_ptr->trans_color.blue)
png_ptr 3518 pngrtran.c *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
png_ptr 3519 pngrtran.c *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
png_ptr 3520 pngrtran.c *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
png_ptr 3522 pngrtran.c *(sp + 3) = (png_byte)(png_ptr->background.green
png_ptr 3524 pngrtran.c *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
png_ptr 3526 pngrtran.c *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
png_ptr 3560 pngrtran.c if (r == png_ptr->trans_color.red &&
png_ptr 3561 pngrtran.c g == png_ptr->trans_color.green &&
png_ptr 3562 pngrtran.c b == png_ptr->trans_color.blue)
png_ptr 3564 pngrtran.c *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
png_ptr 3565 pngrtran.c *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
png_ptr 3566 pngrtran.c *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
png_ptr 3568 pngrtran.c *(sp + 3) = (png_byte)(png_ptr->background.green
png_ptr 3570 pngrtran.c *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
png_ptr 3572 pngrtran.c *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
png_ptr 3599 pngrtran.c *sp = (png_byte)png_ptr->background.gray;
png_ptr 3607 pngrtran.c png_composite(w, v, a, png_ptr->background_1.gray);
png_ptr 3623 pngrtran.c *sp = (png_byte)png_ptr->background.gray;
png_ptr 3626 pngrtran.c png_composite(*sp, *sp, a, png_ptr->background.gray);
png_ptr 3654 pngrtran.c *sp = (png_byte)((png_ptr->background.gray >> 8)
png_ptr 3656 pngrtran.c *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
png_ptr 3664 pngrtran.c png_composite_16(v, g, a, png_ptr->background_1.gray);
png_ptr 3685 pngrtran.c *sp = (png_byte)((png_ptr->background.gray >> 8)
png_ptr 3687 pngrtran.c *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
png_ptr 3695 pngrtran.c png_composite_16(v, g, a, png_ptr->background.gray);
png_ptr 3728 pngrtran.c *sp = (png_byte)png_ptr->background.red;
png_ptr 3729 pngrtran.c *(sp + 1) = (png_byte)png_ptr->background.green;
png_ptr 3730 pngrtran.c *(sp + 2) = (png_byte)png_ptr->background.blue;
png_ptr 3738 pngrtran.c png_composite(w, v, a, png_ptr->background_1.red);
png_ptr 3743 pngrtran.c png_composite(w, v, a, png_ptr->background_1.green);
png_ptr 3748 pngrtran.c png_composite(w, v, a, png_ptr->background_1.blue);
png_ptr 3764 pngrtran.c *sp = (png_byte)png_ptr->background.red;
png_ptr 3765 pngrtran.c *(sp + 1) = (png_byte)png_ptr->background.green;
png_ptr 3766 pngrtran.c *(sp + 2) = (png_byte)png_ptr->background.blue;
png_ptr 3771 pngrtran.c png_composite(*sp, *sp, a, png_ptr->background.red);
png_ptr 3774 pngrtran.c png_ptr->background.green);
png_ptr 3777 pngrtran.c png_ptr->background.blue);
png_ptr 3814 pngrtran.c *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
png_ptr 3815 pngrtran.c *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
png_ptr 3816 pngrtran.c *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
png_ptr 3818 pngrtran.c *(sp + 3) = (png_byte)(png_ptr->background.green
png_ptr 3820 pngrtran.c *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
png_ptr 3822 pngrtran.c *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
png_ptr 3830 pngrtran.c png_composite_16(w, v, a, png_ptr->background_1.red);
png_ptr 3838 pngrtran.c png_composite_16(w, v, a, png_ptr->background_1.green);
png_ptr 3847 pngrtran.c png_composite_16(w, v, a, png_ptr->background_1.blue);
png_ptr 3869 pngrtran.c *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
png_ptr 3870 pngrtran.c *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
png_ptr 3871 pngrtran.c *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
png_ptr 3873 pngrtran.c *(sp + 3) = (png_byte)(png_ptr->background.green
png_ptr 3875 pngrtran.c *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
png_ptr 3877 pngrtran.c *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
png_ptr 3890 pngrtran.c png_composite_16(v, r, a, png_ptr->background.red);
png_ptr 3894 pngrtran.c png_composite_16(v, g, a, png_ptr->background.green);
png_ptr 3898 pngrtran.c png_composite_16(v, b, a, png_ptr->background.blue);
png_ptr 3925 pngrtran.c png_const_bytep gamma_table = png_ptr->gamma_table;
png_ptr 3926 pngrtran.c png_const_uint_16pp gamma_16_table = png_ptr->gamma_16_table;
png_ptr 3927 pngrtran.c int gamma_shift = png_ptr->gamma_shift;
png_ptr 4134 pngrtran.c PNG_CONST png_bytep table = png_ptr->gamma_from_1;
png_ptr 4153 pngrtran.c PNG_CONST png_uint_16pp table = png_ptr->gamma_16_from_1;
png_ptr 4154 pngrtran.c PNG_CONST int gamma_shift = png_ptr->gamma_shift;
png_ptr 4181 pngrtran.c png_warning(png_ptr, "png_do_encode_alpha: unexpected call");
png_ptr 4702 pngrtran.c if (png_ptr->row_buf == NULL)
png_ptr 4708 pngrtran.c png_error(png_ptr, "NULL row buffer");
png_ptr 4717 pngrtran.c if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 &&
png_ptr 4718 pngrtran.c !(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_ptr 4724 pngrtran.c png_error(png_ptr, "Uninitialized row");
png_ptr 4728 pngrtran.c if (png_ptr->transformations & PNG_EXPAND)
png_ptr 4732 pngrtran.c png_do_expand_palette(row_info, png_ptr->row_buf + 1,
png_ptr 4733 pngrtran.c png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);
png_ptr 4738 pngrtran.c if (png_ptr->num_trans &&
png_ptr 4739 pngrtran.c (png_ptr->transformations & PNG_EXPAND_tRNS))
png_ptr 4740 pngrtran.c png_do_expand(row_info, png_ptr->row_buf + 1,
png_ptr 4741 pngrtran.c &(png_ptr->trans_color));
png_ptr 4744 pngrtran.c png_do_expand(row_info, png_ptr->row_buf + 1,
png_ptr 4751 pngrtran.c if ((png_ptr->transformations & PNG_STRIP_ALPHA) &&
png_ptr 4752 pngrtran.c !(png_ptr->transformations & PNG_COMPOSE) &&
png_ptr 4755 pngrtran.c png_do_strip_channel(row_info, png_ptr->row_buf + 1,
png_ptr 4760 pngrtran.c if (png_ptr->transformations & PNG_RGB_TO_GRAY)
png_ptr 4763 pngrtran.c png_do_rgb_to_gray(png_ptr, row_info,
png_ptr 4764 pngrtran.c png_ptr->row_buf + 1);
png_ptr 4768 pngrtran.c png_ptr->rgb_to_gray_status=1;
png_ptr 4769 pngrtran.c if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
png_ptr 4771 pngrtran.c png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
png_ptr 4773 pngrtran.c if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
png_ptr 4775 pngrtran.c png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
png_ptr 4815 pngrtran.c if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
png_ptr 4816 pngrtran.c !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
png_ptr 4817 pngrtran.c png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
png_ptr 4822 pngrtran.c if (png_ptr->transformations & PNG_COMPOSE)
png_ptr 4823 pngrtran.c png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr);
png_ptr 4827 pngrtran.c if ((png_ptr->transformations & PNG_GAMMA) &&
png_ptr 4830 pngrtran.c !(png_ptr->transformations & PNG_RGB_TO_GRAY) &&
png_ptr 4837 pngrtran.c !((png_ptr->transformations & PNG_COMPOSE) &&
png_ptr 4838 pngrtran.c ((png_ptr->num_trans != 0) ||
png_ptr 4839 pngrtran.c (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
png_ptr 4844 pngrtran.c (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
png_ptr 4845 pngrtran.c png_do_gamma(row_info, png_ptr->row_buf + 1, png_ptr);
png_ptr 4849 pngrtran.c if ((png_ptr->transformations & PNG_STRIP_ALPHA) &&
png_ptr 4850 pngrtran.c (png_ptr->transformations & PNG_COMPOSE) &&
png_ptr 4853 pngrtran.c png_do_strip_channel(row_info, png_ptr->row_buf + 1,
png_ptr 4858 pngrtran.c if ((png_ptr->transformations & PNG_ENCODE_ALPHA) &&
png_ptr 4860 pngrtran.c png_do_encode_alpha(row_info, png_ptr->row_buf + 1, png_ptr);
png_ptr 4864 pngrtran.c if (png_ptr->transformations & PNG_SCALE_16_TO_8)
png_ptr 4865 pngrtran.c png_do_scale_16_to_8(row_info, png_ptr->row_buf + 1);
png_ptr 4873 pngrtran.c if (png_ptr->transformations & PNG_16_TO_8)
png_ptr 4874 pngrtran.c png_do_chop(row_info, png_ptr->row_buf + 1);
png_ptr 4878 pngrtran.c if (png_ptr->transformations & PNG_QUANTIZE)
png_ptr 4880 pngrtran.c png_do_quantize(row_info, png_ptr->row_buf + 1,
png_ptr 4881 pngrtran.c png_ptr->palette_lookup, png_ptr->quantize_index);
png_ptr 4884 pngrtran.c png_error(png_ptr, "png_do_quantize returned rowbytes=0");
png_ptr 4894 pngrtran.c if (png_ptr->transformations & PNG_EXPAND_16)
png_ptr 4895 pngrtran.c png_do_expand_16(row_info, png_ptr->row_buf + 1);
png_ptr 4900 pngrtran.c if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
png_ptr 4901 pngrtran.c (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
png_ptr 4902 pngrtran.c png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
png_ptr 4906 pngrtran.c if (png_ptr->transformations & PNG_INVERT_MONO)
png_ptr 4907 pngrtran.c png_do_invert(row_info, png_ptr->row_buf + 1);
png_ptr 4911 pngrtran.c if (png_ptr->transformations & PNG_INVERT_ALPHA)
png_ptr 4912 pngrtran.c png_do_read_invert_alpha(row_info, png_ptr->row_buf + 1);
png_ptr 4916 pngrtran.c if (png_ptr->transformations & PNG_SHIFT)
png_ptr 4917 pngrtran.c png_do_unshift(row_info, png_ptr->row_buf + 1,
png_ptr 4918 pngrtran.c &(png_ptr->shift));
png_ptr 4922 pngrtran.c if (png_ptr->transformations & PNG_PACK)
png_ptr 4923 pngrtran.c png_do_unpack(row_info, png_ptr->row_buf + 1);
png_ptr 4929 pngrtran.c png_ptr->num_palette_max >= 0)
png_ptr 4930 pngrtran.c png_do_check_palette_indexes(png_ptr, row_info);
png_ptr 4934 pngrtran.c if (png_ptr->transformations & PNG_BGR)
png_ptr 4935 pngrtran.c png_do_bgr(row_info, png_ptr->row_buf + 1);
png_ptr 4939 pngrtran.c if (png_ptr->transformations & PNG_PACKSWAP)
png_ptr 4940 pngrtran.c png_do_packswap(row_info, png_ptr->row_buf + 1);
png_ptr 4944 pngrtran.c if (png_ptr->transformations & PNG_FILLER)
png_ptr 4945 pngrtran.c png_do_read_filler(row_info, png_ptr->row_buf + 1,
png_ptr 4946 pngrtran.c (png_uint_32)png_ptr->filler, png_ptr->flags);
png_ptr 4950 pngrtran.c if (png_ptr->transformations & PNG_SWAP_ALPHA)
png_ptr 4951 pngrtran.c png_do_read_swap_alpha(row_info, png_ptr->row_buf + 1);
png_ptr 4956 pngrtran.c if (png_ptr->transformations & PNG_SWAP_BYTES)
png_ptr 4957 pngrtran.c png_do_swap(row_info, png_ptr->row_buf + 1);
png_ptr 4962 pngrtran.c if (png_ptr->transformations & PNG_USER_TRANSFORM)
png_ptr 4964 pngrtran.c if (png_ptr->read_user_transform_fn != NULL)
png_ptr 4965 pngrtran.c (*(png_ptr->read_user_transform_fn)) /* User read transform function */
png_ptr 4966 pngrtran.c (png_ptr, /* png_ptr */
png_ptr 4974 pngrtran.c png_ptr->row_buf + 1); /* start of pixel data for row */
png_ptr 4976 pngrtran.c if (png_ptr->user_transform_depth)
png_ptr 4977 pngrtran.c row_info->bit_depth = png_ptr->user_transform_depth;
png_ptr 4979 pngrtran.c if (png_ptr->user_transform_channels)
png_ptr 4980 pngrtran.c row_info->channels = png_ptr->user_transform_channels;
png_ptr 27 pngrutil.c png_error(png_ptr, "PNG unsigned integer out of range");
png_ptr 49 pngrutil.c if (png_ptr != NULL)
png_ptr 50 pngrutil.c png_warning(png_ptr, "PNG fixed point integer out of range");
png_ptr 120 pngrutil.c if (png_ptr->sig_bytes >= 8)
png_ptr 123 pngrutil.c num_checked = png_ptr->sig_bytes;
png_ptr 127 pngrutil.c png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE;
png_ptr 131 pngrutil.c png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
png_ptr 132 pngrutil.c png_ptr->sig_bytes = 8;
png_ptr 138 pngrutil.c png_error(png_ptr, "Not a PNG file");
png_ptr 140 pngrutil.c png_error(png_ptr, "PNG file corrupted by ASCII conversion");
png_ptr 143 pngrutil.c png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
png_ptr 156 pngrutil.c png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;
png_ptr 162 pngrutil.c png_read_data(png_ptr, buf, 8);
png_ptr 163 pngrutil.c length = png_get_uint_31(png_ptr, buf);
png_ptr 166 pngrutil.c png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(buf+4);
png_ptr 169 pngrutil.c (unsigned long)png_ptr->chunk_name, (unsigned long)length);
png_ptr 172 pngrutil.c png_reset_crc(png_ptr);
png_ptr 173 pngrutil.c png_calculate_crc(png_ptr, buf + 4, 4);
png_ptr 176 pngrutil.c png_check_chunk_name(png_ptr, png_ptr->chunk_name);
png_ptr 179 pngrutil.c png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA;
png_ptr 189 pngrutil.c if (png_ptr == NULL)
png_ptr 192 pngrutil.c png_read_data(png_ptr, buf, length);
png_ptr 193 pngrutil.c png_calculate_crc(png_ptr, buf, length);
png_ptr 217 pngrutil.c png_crc_read(png_ptr, tmpbuf, len);
png_ptr 220 pngrutil.c if (png_crc_error(png_ptr))
png_ptr 222 pngrutil.c if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) ?
png_ptr 223 pngrutil.c !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) :
png_ptr 224 pngrutil.c (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))
png_ptr 226 pngrutil.c png_chunk_warning(png_ptr, "CRC error");
png_ptr 230 pngrutil.c png_chunk_error(png_ptr, "CRC error");
png_ptr 248 pngrutil.c if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name))
png_ptr 250 pngrutil.c if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
png_ptr 257 pngrutil.c if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
png_ptr 262 pngrutil.c png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC;
png_ptr 266 pngrutil.c png_read_data(png_ptr, crc_bytes, 4);
png_ptr 271 pngrutil.c return ((int)(crc != png_ptr->crc));
png_ptr 291 pngrutil.c png_bytep buffer = png_ptr->read_buffer;
png_ptr 293 pngrutil.c if (buffer != NULL && new_size > png_ptr->read_buffer_size)
png_ptr 295 pngrutil.c png_ptr->read_buffer = NULL;
png_ptr 296 pngrutil.c png_ptr->read_buffer = NULL;
png_ptr 297 pngrutil.c png_ptr->read_buffer_size = 0;
png_ptr 298 pngrutil.c png_free(png_ptr, buffer);
png_ptr 304 pngrutil.c buffer = png_voidcast(png_bytep, png_malloc_base(png_ptr, new_size));
png_ptr 308 pngrutil.c png_ptr->read_buffer = buffer;
png_ptr 309 pngrutil.c png_ptr->read_buffer_size = new_size;
png_ptr 315 pngrutil.c png_chunk_warning(png_ptr, "insufficient memory to read chunk");
png_ptr 318 pngrutil.c png_chunk_error(png_ptr, "insufficient memory to read chunk");
png_ptr 334 pngrutil.c if (png_ptr->zowner != 0)
png_ptr 338 pngrutil.c PNG_STRING_FROM_CHUNK(msg, png_ptr->zowner);
png_ptr 345 pngrutil.c png_chunk_warning(png_ptr, msg);
png_ptr 346 pngrutil.c png_ptr->zowner = 0;
png_ptr 348 pngrutil.c png_chunk_error(png_ptr, msg);
png_ptr 372 pngrutil.c if (((png_ptr->options >> PNG_MAXIMUM_INFLATE_WINDOW) & 3) ==
png_ptr 386 pngrutil.c png_ptr->zstream.next_in = NULL;
png_ptr 387 pngrutil.c png_ptr->zstream.avail_in = 0;
png_ptr 388 pngrutil.c png_ptr->zstream.next_out = NULL;
png_ptr 389 pngrutil.c png_ptr->zstream.avail_out = 0;
png_ptr 391 pngrutil.c if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED)
png_ptr 394 pngrutil.c ret = inflateReset(&png_ptr->zstream);
png_ptr 396 pngrutil.c ret = inflateReset2(&png_ptr->zstream, window_bits);
png_ptr 403 pngrutil.c ret = inflateInit(&png_ptr->zstream);
png_ptr 405 pngrutil.c ret = inflateInit2(&png_ptr->zstream, window_bits);
png_ptr 409 pngrutil.c png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
png_ptr 413 pngrutil.c png_ptr->zowner = owner;
png_ptr 416 pngrutil.c png_zstream_error(png_ptr, ret);
png_ptr 443 pngrutil.c if (png_ptr->zowner == owner) /* Else not claimed */
png_ptr 458 pngrutil.c png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
png_ptr 460 pngrutil.c png_ptr->zstream.avail_in = 0;
png_ptr 461 pngrutil.c png_ptr->zstream.avail_out = 0;
png_ptr 467 pngrutil.c png_ptr->zstream.next_out = output;
png_ptr 482 pngrutil.c avail_in += png_ptr->zstream.avail_in; /* not consumed last time */
png_ptr 490 pngrutil.c png_ptr->zstream.avail_in = avail;
png_ptr 493 pngrutil.c avail_out += png_ptr->zstream.avail_out; /* not written last time */
png_ptr 502 pngrutil.c png_ptr->zstream.next_out = local_buffer;
png_ptr 510 pngrutil.c png_ptr->zstream.avail_out = avail;
png_ptr 519 pngrutil.c ret = inflate(&png_ptr->zstream, avail_out > 0 ? Z_NO_FLUSH :
png_ptr 525 pngrutil.c png_ptr->zstream.next_out = NULL;
png_ptr 528 pngrutil.c avail_in += png_ptr->zstream.avail_in;
png_ptr 529 pngrutil.c avail_out += png_ptr->zstream.avail_out;
png_ptr 541 pngrutil.c png_zstream_error(png_ptr, ret);
png_ptr 551 pngrutil.c png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed");
png_ptr 579 pngrutil.c if (png_ptr->user_chunk_malloc_max > 0 &&
png_ptr 580 pngrutil.c png_ptr->user_chunk_malloc_max < limit)
png_ptr 581 pngrutil.c limit = png_ptr->user_chunk_malloc_max;
png_ptr 597 pngrutil.c ret = png_inflate_claim(png_ptr, png_ptr->chunk_name);
png_ptr 603 pngrutil.c ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/,
png_ptr 604 pngrutil.c /* input: */ png_ptr->read_buffer + prefix_size, &lzsize,
png_ptr 616 pngrutil.c if (inflateReset(&png_ptr->zstream) == Z_OK)
png_ptr 626 pngrutil.c png_bytep text = png_voidcast(png_bytep, png_malloc_base(png_ptr,
png_ptr 631 pngrutil.c ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/,
png_ptr 632 pngrutil.c png_ptr->read_buffer + prefix_size, &lzsize,
png_ptr 643 pngrutil.c memcpy(text, png_ptr->read_buffer, prefix_size);
png_ptr 646 pngrutil.c png_bytep old_ptr = png_ptr->read_buffer;
png_ptr 648 pngrutil.c png_ptr->read_buffer = text;
png_ptr 649 pngrutil.c png_ptr->read_buffer_size = buffer_size;
png_ptr 672 pngrutil.c png_free(png_ptr, text);
png_ptr 679 pngrutil.c png_chunk_benign_error(png_ptr, "extra compressed data");
png_ptr 686 pngrutil.c png_zstream_error(png_ptr, Z_MEM_ERROR);
png_ptr 693 pngrutil.c png_zstream_error(png_ptr, ret);
png_ptr 704 pngrutil.c png_ptr->zowner = 0;
png_ptr 716 pngrutil.c png_zstream_error(png_ptr, Z_MEM_ERROR);
png_ptr 731 pngrutil.c if (png_ptr->zowner == png_ptr->chunk_name)
png_ptr 736 pngrutil.c png_ptr->zstream.next_out = next_out;
png_ptr 737 pngrutil.c png_ptr->zstream.avail_out = 0; /* set in the loop */
png_ptr 741 pngrutil.c if (png_ptr->zstream.avail_in == 0)
png_ptr 748 pngrutil.c png_crc_read(png_ptr, read_buffer, read_size);
png_ptr 750 pngrutil.c png_ptr->zstream.next_in = read_buffer;
png_ptr 751 pngrutil.c png_ptr->zstream.avail_in = read_size;
png_ptr 754 pngrutil.c if (png_ptr->zstream.avail_out == 0)
png_ptr 761 pngrutil.c png_ptr->zstream.avail_out = avail;
png_ptr 768 pngrutil.c ret = inflate(&png_ptr->zstream,
png_ptr 771 pngrutil.c while (ret == Z_OK && (*out_size > 0 || png_ptr->zstream.avail_out > 0));
png_ptr 773 pngrutil.c *out_size += png_ptr->zstream.avail_out;
png_ptr 774 pngrutil.c png_ptr->zstream.avail_out = 0; /* Should not be required, but is safe */
png_ptr 777 pngrutil.c png_zstream_error(png_ptr, ret);
png_ptr 783 pngrutil.c png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed");
png_ptr 800 pngrutil.c if (png_ptr->mode & PNG_HAVE_IHDR)
png_ptr 801 pngrutil.c png_chunk_error(png_ptr, "out of place");
png_ptr 805 pngrutil.c png_chunk_error(png_ptr, "invalid");
png_ptr 807 pngrutil.c png_ptr->mode |= PNG_HAVE_IHDR;
png_ptr 809 pngrutil.c png_crc_read(png_ptr, buf, 13);
png_ptr 810 pngrutil.c png_crc_finish(png_ptr, 0);
png_ptr 812 pngrutil.c width = png_get_uint_31(png_ptr, buf);
png_ptr 813 pngrutil.c height = png_get_uint_31(png_ptr, buf + 4);
png_ptr 821 pngrutil.c png_ptr->width = width;
png_ptr 822 pngrutil.c png_ptr->height = height;
png_ptr 823 pngrutil.c png_ptr->bit_depth = (png_byte)bit_depth;
png_ptr 824 pngrutil.c png_ptr->interlaced = (png_byte)interlace_type;
png_ptr 825 pngrutil.c png_ptr->color_type = (png_byte)color_type;
png_ptr 827 pngrutil.c png_ptr->filter_type = (png_byte)filter_type;
png_ptr 829 pngrutil.c png_ptr->compression_type = (png_byte)compression_type;
png_ptr 832 pngrutil.c switch (png_ptr->color_type)
png_ptr 837 pngrutil.c png_ptr->channels = 1;
png_ptr 841 pngrutil.c png_ptr->channels = 3;
png_ptr 845 pngrutil.c png_ptr->channels = 2;
png_ptr 849 pngrutil.c png_ptr->channels = 4;
png_ptr 854 pngrutil.c png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
png_ptr 855 pngrutil.c png_ptr->channels);
png_ptr 856 pngrutil.c png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
png_ptr 857 pngrutil.c png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
png_ptr 858 pngrutil.c png_debug1(3, "channels = %d", png_ptr->channels);
png_ptr 859 pngrutil.c png_debug1(3, "rowbytes = %lu", (unsigned long)png_ptr->rowbytes);
png_ptr 860 pngrutil.c png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
png_ptr 876 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 877 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 884 pngrutil.c else if (png_ptr->mode & PNG_HAVE_PLTE)
png_ptr 885 pngrutil.c png_chunk_error(png_ptr, "duplicate");
png_ptr 887 pngrutil.c else if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 892 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 893 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 897 pngrutil.c png_ptr->mode |= PNG_HAVE_PLTE;
png_ptr 899 pngrutil.c if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR))
png_ptr 901 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 902 pngrutil.c png_chunk_benign_error(png_ptr, "ignored in grayscale PNG");
png_ptr 907 pngrutil.c if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
png_ptr 909 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 916 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 918 pngrutil.c if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
png_ptr 919 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 922 pngrutil.c png_chunk_error(png_ptr, "invalid");
png_ptr 935 pngrutil.c png_crc_read(png_ptr, buf, 3);
png_ptr 945 pngrutil.c png_crc_read(png_ptr, buf, 3);
png_ptr 959 pngrutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 962 pngrutil.c png_crc_finish(png_ptr, 0);
png_ptr 966 pngrutil.c else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */
png_ptr 977 pngrutil.c if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
png_ptr 979 pngrutil.c if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
png_ptr 983 pngrutil.c png_chunk_error(png_ptr, "CRC error");
png_ptr 987 pngrutil.c else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
png_ptr 988 pngrutil.c png_chunk_warning(png_ptr, "CRC error");
png_ptr 1000 pngrutil.c png_set_PLTE(png_ptr, info_ptr, palette, num);
png_ptr 1012 pngrutil.c if (png_ptr->num_trans > 0 ||
png_ptr 1019 pngrutil.c png_ptr->num_trans = 0;
png_ptr 1024 pngrutil.c png_chunk_benign_error(png_ptr, "tRNS must be after");
png_ptr 1030 pngrutil.c png_chunk_benign_error(png_ptr, "hIST must be after");
png_ptr 1035 pngrutil.c png_chunk_benign_error(png_ptr, "bKGD must be after");
png_ptr 1044 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
png_ptr 1045 pngrutil.c png_chunk_error(png_ptr, "out of place");
png_ptr 1047 pngrutil.c png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
png_ptr 1049 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1052 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1066 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 1067 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 1069 pngrutil.c else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
png_ptr 1071 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1072 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1078 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1079 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1083 pngrutil.c png_crc_read(png_ptr, buf, 4);
png_ptr 1085 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 1090 pngrutil.c png_colorspace_set_gamma(png_ptr, &png_ptr->colorspace, igamma);
png_ptr 1091 pngrutil.c png_colorspace_sync(png_ptr, info_ptr);
png_ptr 1105 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 1106 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 1108 pngrutil.c else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
png_ptr 1110 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1111 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1117 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1118 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 1122 pngrutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 1130 pngrutil.c truelen = png_ptr->channels;
png_ptr 1131 pngrutil.c sample_depth = png_ptr->bit_depth;
png_ptr 1136 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1137 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1142 pngrutil.c png_crc_read(png_ptr, buf, truelen);
png_ptr 1144 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 1150 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1154 pngrutil.c if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
png_ptr 1156 pngrutil.c png_ptr->sig_bit.red = buf[0];
png_ptr 1157 pngrutil.c png_ptr->sig_bit.green = buf[1];
png_ptr 1158 pngrutil.c png_ptr->sig_bit.blue = buf[2];
png_ptr 1159 pngrutil.c png_ptr->sig_bit.alpha = buf[3];
png_ptr 1164 pngrutil.c png_ptr->sig_bit.gray = buf[0];
png_ptr 1165 pngrutil.c png_ptr->sig_bit.red = buf[0];
png_ptr 1166 pngrutil.c png_ptr->sig_bit.green = buf[0];
png_ptr 1167 pngrutil.c png_ptr->sig_bit.blue = buf[0];
png_ptr 1168 pngrutil.c png_ptr->sig_bit.alpha = buf[1];
png_ptr 1171 pngrutil.c png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
png_ptr 1184 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 1185 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 1187 pngrutil.c else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
png_ptr 1189 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1190 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1196 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1197 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1201 pngrutil.c png_crc_read(png_ptr, buf, 32);
png_ptr 1203 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 1224 pngrutil.c png_chunk_benign_error(png_ptr, "invalid values");
png_ptr 1229 pngrutil.c if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)
png_ptr 1232 pngrutil.c if (png_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM)
png_ptr 1234 pngrutil.c png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
png_ptr 1235 pngrutil.c png_colorspace_sync(png_ptr, info_ptr);
png_ptr 1236 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 1240 pngrutil.c png_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
png_ptr 1241 pngrutil.c (void)png_colorspace_set_chromaticities(png_ptr, &png_ptr->colorspace, &xy,
png_ptr 1243 pngrutil.c png_colorspace_sync(png_ptr, info_ptr);
png_ptr 1255 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 1256 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 1258 pngrutil.c else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
png_ptr 1260 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1261 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1267 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1268 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1272 pngrutil.c png_crc_read(png_ptr, &intent, 1);
png_ptr 1274 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 1278 pngrutil.c if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)
png_ptr 1284 pngrutil.c if (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT)
png_ptr 1286 pngrutil.c png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
png_ptr 1287 pngrutil.c png_colorspace_sync(png_ptr, info_ptr);
png_ptr 1288 pngrutil.c png_chunk_benign_error(png_ptr, "too many profiles");
png_ptr 1292 pngrutil.c (void)png_colorspace_set_sRGB(png_ptr, &png_ptr->colorspace, intent);
png_ptr 1293 pngrutil.c png_colorspace_sync(png_ptr, info_ptr);
png_ptr 1307 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 1308 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 1310 pngrutil.c else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE))
png_ptr 1312 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1313 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1327 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1328 pngrutil.c png_chunk_benign_error(png_ptr, "too short");
png_ptr 1333 pngrutil.c if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)
png_ptr 1335 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1342 pngrutil.c if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT) == 0)
png_ptr 1354 pngrutil.c png_crc_read(png_ptr, (png_bytep)keyword, read_length);
png_ptr 1373 pngrutil.c if (png_inflate_claim(png_ptr, png_iCCP) == Z_OK)
png_ptr 1379 pngrutil.c png_ptr->zstream.next_in = (Bytef*)keyword + (keyword_length+2);
png_ptr 1380 pngrutil.c png_ptr->zstream.avail_in = read_length;
png_ptr 1381 pngrutil.c (void)png_inflate_read(png_ptr, local_buffer,
png_ptr 1392 pngrutil.c if (png_icc_check_length(png_ptr, &png_ptr->colorspace,
png_ptr 1398 pngrutil.c if (png_icc_check_header(png_ptr, &png_ptr->colorspace,
png_ptr 1400 pngrutil.c png_ptr->color_type))
png_ptr 1409 pngrutil.c png_bytep profile = png_read_buffer(png_ptr,
png_ptr 1419 pngrutil.c (void)png_inflate_read(png_ptr, local_buffer,
png_ptr 1428 pngrutil.c if (png_icc_check_tag_table(png_ptr,
png_ptr 1429 pngrutil.c &png_ptr->colorspace, keyword, profile_length,
png_ptr 1438 pngrutil.c (void)png_inflate_read(png_ptr, local_buffer,
png_ptr 1443 pngrutil.c if (length > 0 && !(png_ptr->flags &
png_ptr 1455 pngrutil.c png_chunk_warning(png_ptr,
png_ptr 1459 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1464 pngrutil.c png_icc_set_sRGB(png_ptr,
png_ptr 1465 pngrutil.c &png_ptr->colorspace, profile,
png_ptr 1466 pngrutil.c png_ptr->zstream.adler);
png_ptr 1472 pngrutil.c png_free_data(png_ptr, info_ptr,
png_ptr 1476 pngrutil.c png_malloc_base(png_ptr,
png_ptr 1485 pngrutil.c png_ptr->read_buffer = NULL; /*steal*/
png_ptr 1492 pngrutil.c png_ptr->colorspace.flags |=
png_ptr 1504 pngrutil.c png_colorspace_sync(png_ptr, info_ptr);
png_ptr 1508 pngrutil.c png_ptr->zowner = 0;
png_ptr 1517 pngrutil.c errmsg = png_ptr->zstream.msg;
png_ptr 1524 pngrutil.c errmsg = png_ptr->zstream.msg;
png_ptr 1538 pngrutil.c errmsg = png_ptr->zstream.msg;
png_ptr 1541 pngrutil.c png_ptr->zowner = 0;
png_ptr 1545 pngrutil.c errmsg = png_ptr->zstream.msg;
png_ptr 1561 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1563 pngrutil.c png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
png_ptr 1564 pngrutil.c png_colorspace_sync(png_ptr, info_ptr);
png_ptr 1566 pngrutil.c png_chunk_benign_error(png_ptr, errmsg);
png_ptr 1587 pngrutil.c if (png_ptr->user_chunk_cache_max != 0)
png_ptr 1589 pngrutil.c if (png_ptr->user_chunk_cache_max == 1)
png_ptr 1591 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1595 pngrutil.c if (--png_ptr->user_chunk_cache_max == 1)
png_ptr 1597 pngrutil.c png_warning(png_ptr, "No space in chunk cache for sPLT");
png_ptr 1598 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1604 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 1605 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 1607 pngrutil.c else if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 1609 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1610 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1617 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1618 pngrutil.c png_chunk_benign_error(png_ptr, "too large to fit in memory");
png_ptr 1623 pngrutil.c buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
png_ptr 1626 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1627 pngrutil.c png_chunk_benign_error(png_ptr, "out of memory");
png_ptr 1636 pngrutil.c png_crc_read(png_ptr, buffer, length);
png_ptr 1638 pngrutil.c if (png_crc_finish(png_ptr, skip))
png_ptr 1651 pngrutil.c png_warning(png_ptr, "malformed sPLT chunk");
png_ptr 1665 pngrutil.c png_warning(png_ptr, "sPLT chunk has bad length");
png_ptr 1674 pngrutil.c png_warning(png_ptr, "sPLT chunk too long");
png_ptr 1681 pngrutil.c png_ptr, new_palette.nentries * (sizeof (png_sPLT_entry)));
png_ptr 1685 pngrutil.c png_warning(png_ptr, "sPLT chunk requires too much memory");
png_ptr 1741 pngrutil.c png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
png_ptr 1743 pngrutil.c png_free(png_ptr, new_palette.entries);
png_ptr 1755 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 1756 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 1758 pngrutil.c else if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 1760 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1761 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1767 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1768 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 1772 pngrutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
png_ptr 1778 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1779 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1783 pngrutil.c png_crc_read(png_ptr, buf, 2);
png_ptr 1784 pngrutil.c png_ptr->num_trans = 1;
png_ptr 1785 pngrutil.c png_ptr->trans_color.gray = png_get_uint_16(buf);
png_ptr 1788 pngrutil.c else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
png_ptr 1794 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1795 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1799 pngrutil.c png_crc_read(png_ptr, buf, length);
png_ptr 1800 pngrutil.c png_ptr->num_trans = 1;
png_ptr 1801 pngrutil.c png_ptr->trans_color.red = png_get_uint_16(buf);
png_ptr 1802 pngrutil.c png_ptr->trans_color.green = png_get_uint_16(buf + 2);
png_ptr 1803 pngrutil.c png_ptr->trans_color.blue = png_get_uint_16(buf + 4);
png_ptr 1806 pngrutil.c else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 1808 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_PLTE))
png_ptr 1811 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1812 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1816 pngrutil.c if (length > png_ptr->num_palette || length > PNG_MAX_PALETTE_LENGTH ||
png_ptr 1819 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1820 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1824 pngrutil.c png_crc_read(png_ptr, readbuf, length);
png_ptr 1825 pngrutil.c png_ptr->num_trans = (png_uint_16)length;
png_ptr 1830 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1831 pngrutil.c png_chunk_benign_error(png_ptr, "invalid with alpha channel");
png_ptr 1835 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 1837 pngrutil.c png_ptr->num_trans = 0;
png_ptr 1845 pngrutil.c png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
png_ptr 1846 pngrutil.c &(png_ptr->trans_color));
png_ptr 1860 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 1861 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 1863 pngrutil.c else if ((png_ptr->mode & PNG_HAVE_IDAT) ||
png_ptr 1864 pngrutil.c (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
png_ptr 1865 pngrutil.c !(png_ptr->mode & PNG_HAVE_PLTE)))
png_ptr 1867 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1868 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1874 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1875 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 1879 pngrutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 1882 pngrutil.c else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
png_ptr 1890 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1891 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1895 pngrutil.c png_crc_read(png_ptr, buf, truelen);
png_ptr 1897 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 1905 pngrutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 1913 pngrutil.c png_chunk_benign_error(png_ptr, "invalid index");
png_ptr 1917 pngrutil.c background.red = (png_uint_16)png_ptr->palette[buf[0]].red;
png_ptr 1918 pngrutil.c background.green = (png_uint_16)png_ptr->palette[buf[0]].green;
png_ptr 1919 pngrutil.c background.blue = (png_uint_16)png_ptr->palette[buf[0]].blue;
png_ptr 1928 pngrutil.c else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
png_ptr 1946 pngrutil.c png_set_bKGD(png_ptr, info_ptr, &background);
png_ptr 1959 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 1960 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 1962 pngrutil.c else if ((png_ptr->mode & PNG_HAVE_IDAT) || !(png_ptr->mode & PNG_HAVE_PLTE))
png_ptr 1964 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1965 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 1971 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1972 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 1978 pngrutil.c if (num != png_ptr->num_palette || num > PNG_MAX_PALETTE_LENGTH)
png_ptr 1980 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 1981 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 1989 pngrutil.c png_crc_read(png_ptr, buf, 2);
png_ptr 1993 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 1996 pngrutil.c png_set_hIST(png_ptr, info_ptr, readbuf);
png_ptr 2010 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 2011 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 2013 pngrutil.c else if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 2015 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2016 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 2022 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2023 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 2029 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2030 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 2034 pngrutil.c png_crc_read(png_ptr, buf, 9);
png_ptr 2036 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 2042 pngrutil.c png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
png_ptr 2056 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 2057 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 2059 pngrutil.c else if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 2061 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2062 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 2068 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2069 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 2075 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2076 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 2080 pngrutil.c png_crc_read(png_ptr, buf, 9);
png_ptr 2082 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 2088 pngrutil.c png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
png_ptr 2105 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 2106 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 2108 pngrutil.c else if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 2110 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2111 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 2117 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2118 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 2125 pngrutil.c buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
png_ptr 2129 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2130 pngrutil.c png_chunk_benign_error(png_ptr, "out of memory");
png_ptr 2134 pngrutil.c png_crc_read(png_ptr, buffer, length);
png_ptr 2136 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 2152 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 2172 pngrutil.c png_chunk_benign_error(png_ptr, "invalid parameter count");
png_ptr 2178 pngrutil.c png_chunk_benign_error(png_ptr, "unrecognized equation type");
png_ptr 2186 pngrutil.c params = png_voidcast(png_charpp, png_malloc_warn(png_ptr,
png_ptr 2191 pngrutil.c png_chunk_benign_error(png_ptr, "out of memory");
png_ptr 2208 pngrutil.c png_free(png_ptr, params);
png_ptr 2209 pngrutil.c png_chunk_benign_error(png_ptr, "invalid data");
png_ptr 2214 pngrutil.c png_set_pCAL(png_ptr, info_ptr, (png_charp)buffer, X0, X1, type, nparams,
png_ptr 2217 pngrutil.c png_free(png_ptr, params);
png_ptr 2232 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 2233 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 2235 pngrutil.c else if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 2237 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2238 pngrutil.c png_chunk_benign_error(png_ptr, "out of place");
png_ptr 2244 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2245 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 2252 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2253 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 2260 pngrutil.c buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
png_ptr 2264 pngrutil.c png_chunk_benign_error(png_ptr, "out of memory");
png_ptr 2265 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2269 pngrutil.c png_crc_read(png_ptr, buffer, length);
png_ptr 2272 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 2278 pngrutil.c png_chunk_benign_error(png_ptr, "invalid unit");
png_ptr 2290 pngrutil.c png_chunk_benign_error(png_ptr, "bad width format");
png_ptr 2293 pngrutil.c png_chunk_benign_error(png_ptr, "non-positive width");
png_ptr 2302 pngrutil.c png_chunk_benign_error(png_ptr, "bad height format");
png_ptr 2305 pngrutil.c png_chunk_benign_error(png_ptr, "non-positive height");
png_ptr 2309 pngrutil.c png_set_sCAL_s(png_ptr, info_ptr, buffer[0],
png_ptr 2324 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 2325 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 2329 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2330 pngrutil.c png_chunk_benign_error(png_ptr, "duplicate");
png_ptr 2334 pngrutil.c if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 2335 pngrutil.c png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr 2339 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2340 pngrutil.c png_chunk_benign_error(png_ptr, "invalid");
png_ptr 2344 pngrutil.c png_crc_read(png_ptr, buf, 7);
png_ptr 2346 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 2356 pngrutil.c png_set_tIME(png_ptr, info_ptr, &mod_time);
png_ptr 2374 pngrutil.c if (png_ptr->user_chunk_cache_max != 0)
png_ptr 2376 pngrutil.c if (png_ptr->user_chunk_cache_max == 1)
png_ptr 2378 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2382 pngrutil.c if (--png_ptr->user_chunk_cache_max == 1)
png_ptr 2384 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2385 pngrutil.c png_chunk_benign_error(png_ptr, "no space in chunk cache");
png_ptr 2391 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 2392 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 2394 pngrutil.c if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 2395 pngrutil.c png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr 2400 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2401 pngrutil.c png_chunk_benign_error(png_ptr, "too large to fit in memory");
png_ptr 2406 pngrutil.c buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/);
png_ptr 2410 pngrutil.c png_chunk_benign_error(png_ptr, "out of memory");
png_ptr 2414 pngrutil.c png_crc_read(png_ptr, buffer, length);
png_ptr 2416 pngrutil.c if (png_crc_finish(png_ptr, skip))
png_ptr 2436 pngrutil.c if (png_set_text_2(png_ptr, info_ptr, &text_info, 1))
png_ptr 2437 pngrutil.c png_warning(png_ptr, "Insufficient memory to process text chunk");
png_ptr 2453 pngrutil.c if (png_ptr->user_chunk_cache_max != 0)
png_ptr 2455 pngrutil.c if (png_ptr->user_chunk_cache_max == 1)
png_ptr 2457 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2461 pngrutil.c if (--png_ptr->user_chunk_cache_max == 1)
png_ptr 2463 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2464 pngrutil.c png_chunk_benign_error(png_ptr, "no space in chunk cache");
png_ptr 2470 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 2471 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 2473 pngrutil.c if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 2474 pngrutil.c png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr 2476 pngrutil.c buffer = png_read_buffer(png_ptr, length, 2/*silent*/);
png_ptr 2480 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2481 pngrutil.c png_chunk_benign_error(png_ptr, "out of memory");
png_ptr 2485 pngrutil.c png_crc_read(png_ptr, buffer, length);
png_ptr 2487 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 2517 pngrutil.c if (png_decompress_chunk(png_ptr, length, keyword_length+2,
png_ptr 2526 pngrutil.c buffer = png_ptr->read_buffer;
png_ptr 2537 pngrutil.c if (png_set_text_2(png_ptr, info_ptr, &text, 1))
png_ptr 2542 pngrutil.c errmsg = png_ptr->zstream.msg;
png_ptr 2546 pngrutil.c png_chunk_benign_error(png_ptr, errmsg);
png_ptr 2562 pngrutil.c if (png_ptr->user_chunk_cache_max != 0)
png_ptr 2564 pngrutil.c if (png_ptr->user_chunk_cache_max == 1)
png_ptr 2566 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2570 pngrutil.c if (--png_ptr->user_chunk_cache_max == 1)
png_ptr 2572 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2573 pngrutil.c png_chunk_benign_error(png_ptr, "no space in chunk cache");
png_ptr 2579 pngrutil.c if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_ptr 2580 pngrutil.c png_chunk_error(png_ptr, "missing IHDR");
png_ptr 2582 pngrutil.c if (png_ptr->mode & PNG_HAVE_IDAT)
png_ptr 2583 pngrutil.c png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr 2585 pngrutil.c buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/);
png_ptr 2589 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2590 pngrutil.c png_chunk_benign_error(png_ptr, "out of memory");
png_ptr 2594 pngrutil.c png_crc_read(png_ptr, buffer, length);
png_ptr 2596 pngrutil.c if (png_crc_finish(png_ptr, 0))
png_ptr 2657 pngrutil.c if (png_decompress_chunk(png_ptr, length, prefix_length,
png_ptr 2659 pngrutil.c buffer = png_ptr->read_buffer;
png_ptr 2662 pngrutil.c errmsg = png_ptr->zstream.msg;
png_ptr 2687 pngrutil.c if (png_set_text_2(png_ptr, info_ptr, &text, 1))
png_ptr 2696 pngrutil.c png_chunk_benign_error(png_ptr, errmsg);
png_ptr 2707 pngrutil.c if (png_ptr->unknown_chunk.data != NULL)
png_ptr 2709 pngrutil.c png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr 2710 pngrutil.c png_ptr->unknown_chunk.data = NULL;
png_ptr 2714 pngrutil.c if (png_ptr->user_chunk_malloc_max > 0 &&
png_ptr 2715 pngrutil.c png_ptr->user_chunk_malloc_max < limit)
png_ptr 2716 pngrutil.c limit = png_ptr->user_chunk_malloc_max;
png_ptr 2725 pngrutil.c PNG_CSTRING_FROM_CHUNK(png_ptr->unknown_chunk.name, png_ptr->chunk_name);
png_ptr 2727 pngrutil.c png_ptr->unknown_chunk.size = (png_size_t)length/*SAFE*/;
png_ptr 2729 pngrutil.c png_ptr->unknown_chunk.location = (png_byte)png_ptr->mode/*SAFE*/;
png_ptr 2732 pngrutil.c png_ptr->unknown_chunk.data = NULL;
png_ptr 2737 pngrutil.c png_ptr->unknown_chunk.data = png_voidcast(png_bytep,
png_ptr 2738 pngrutil.c png_malloc_warn(png_ptr, length));
png_ptr 2742 pngrutil.c if (png_ptr->unknown_chunk.data == NULL && length > 0)
png_ptr 2745 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2746 pngrutil.c png_chunk_benign_error(png_ptr, "unknown chunk exceeds memory limits");
png_ptr 2753 pngrutil.c png_crc_read(png_ptr, png_ptr->unknown_chunk.data, length);
png_ptr 2754 pngrutil.c png_crc_finish(png_ptr, 0);
png_ptr 2783 pngrutil.c keep = png_chunk_unknown_handling(png_ptr, png_ptr->chunk_name);
png_ptr 2795 pngrutil.c if (png_ptr->read_user_chunk_fn != NULL)
png_ptr 2797 pngrutil.c if (png_cache_unknown_chunk(png_ptr, length))
png_ptr 2800 pngrutil.c int ret = (*(png_ptr->read_user_chunk_fn))(png_ptr,
png_ptr 2801 pngrutil.c &png_ptr->unknown_chunk);
png_ptr 2813 pngrutil.c png_chunk_error(png_ptr, "error in user chunk");
png_ptr 2831 pngrutil.c if (png_ptr->unknown_default < PNG_HANDLE_CHUNK_IF_SAFE)
png_ptr 2833 pngrutil.c png_chunk_warning(png_ptr, "Saving unknown chunk:");
png_ptr 2834 pngrutil.c png_app_warning(png_ptr,
png_ptr 2868 pngrutil.c keep = png_ptr->unknown_default;
png_ptr 2872 pngrutil.c PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
png_ptr 2874 pngrutil.c if (!png_cache_unknown_chunk(png_ptr, length))
png_ptr 2879 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2894 pngrutil.c png_app_error(png_ptr, "no unknown chunk support available");
png_ptr 2896 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2906 pngrutil.c PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
png_ptr 2909 pngrutil.c switch (png_ptr->user_chunk_cache_max)
png_ptr 2912 pngrutil.c png_ptr->user_chunk_cache_max = 1;
png_ptr 2913 pngrutil.c png_chunk_benign_error(png_ptr, "no space in chunk cache");
png_ptr 2922 pngrutil.c --(png_ptr->user_chunk_cache_max);
png_ptr 2929 pngrutil.c png_set_unknown_chunks(png_ptr, info_ptr,
png_ptr 2930 pngrutil.c &png_ptr->unknown_chunk, 1);
png_ptr 2945 pngrutil.c if (png_ptr->unknown_chunk.data != NULL)
png_ptr 2946 pngrutil.c png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr 2947 pngrutil.c png_ptr->unknown_chunk.data = NULL;
png_ptr 2951 pngrutil.c png_crc_finish(png_ptr, length);
png_ptr 2957 pngrutil.c if (!handled && PNG_CHUNK_CRITICAL(png_ptr->chunk_name))
png_ptr 2958 pngrutil.c png_chunk_error(png_ptr, "unhandled critical chunk");
png_ptr 2985 pngrutil.c png_chunk_error(png_ptr, "invalid chunk type");
png_ptr 3001 pngrutil.c unsigned int pixel_depth = png_ptr->transformed_pixel_depth;
png_ptr 3002 pngrutil.c png_const_bytep sp = png_ptr->row_buf + 1;
png_ptr 3003 pngrutil.c png_uint_32 row_width = png_ptr->width;
png_ptr 3004 pngrutil.c unsigned int pass = png_ptr->pass;
png_ptr 3015 pngrutil.c png_error(png_ptr, "internal row logic error");
png_ptr 3021 pngrutil.c if (png_ptr->info_rowbytes != 0 && png_ptr->info_rowbytes !=
png_ptr 3023 pngrutil.c png_error(png_ptr, "internal row size calculation error");
png_ptr 3027 pngrutil.c png_error(png_ptr, "internal row width error");
png_ptr 3040 pngrutil.c if (png_ptr->transformations & PNG_PACKSWAP) /* little-endian byte */
png_ptr 3056 pngrutil.c if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE) &&
png_ptr 3202 pngrutil.c if (png_ptr->transformations & PNG_PACKSWAP)
png_ptr 3248 pngrutil.c png_error(png_ptr, "invalid user transform pixel depth");
png_ptr 3941 pngrutil.c png_ptr->zstream.next_out = output;
png_ptr 3942 pngrutil.c png_ptr->zstream.avail_out = 0; /* safety: set below */
png_ptr 3952 pngrutil.c if (png_ptr->zstream.avail_in == 0)
png_ptr 3957 pngrutil.c while (png_ptr->idat_size == 0)
png_ptr 3959 pngrutil.c png_crc_finish(png_ptr, 0);
png_ptr 3961 pngrutil.c png_ptr->idat_size = png_read_chunk_header(png_ptr);
png_ptr 3965 pngrutil.c if (png_ptr->chunk_name != png_IDAT)
png_ptr 3966 pngrutil.c png_error(png_ptr, "Not enough image data");
png_ptr 3969 pngrutil.c avail_in = png_ptr->IDAT_read_size;
png_ptr 3971 pngrutil.c if (avail_in > png_ptr->idat_size)
png_ptr 3972 pngrutil.c avail_in = (uInt)png_ptr->idat_size;
png_ptr 3979 pngrutil.c buffer = png_read_buffer(png_ptr, avail_in, 0/*error*/);
png_ptr 3981 pngrutil.c png_crc_read(png_ptr, buffer, avail_in);
png_ptr 3982 pngrutil.c png_ptr->idat_size -= avail_in;
png_ptr 3984 pngrutil.c png_ptr->zstream.next_in = buffer;
png_ptr 3985 pngrutil.c png_ptr->zstream.avail_in = avail_in;
png_ptr 3997 pngrutil.c png_ptr->zstream.avail_out = out;
png_ptr 4002 pngrutil.c png_ptr->zstream.next_out = tmpbuf;
png_ptr 4003 pngrutil.c png_ptr->zstream.avail_out = (sizeof tmpbuf);
png_ptr 4013 pngrutil.c ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);
png_ptr 4017 pngrutil.c avail_out += png_ptr->zstream.avail_out;
png_ptr 4020 pngrutil.c avail_out += (sizeof tmpbuf) - png_ptr->zstream.avail_out;
png_ptr 4022 pngrutil.c png_ptr->zstream.avail_out = 0;
png_ptr 4027 pngrutil.c png_ptr->zstream.next_out = NULL;
png_ptr 4029 pngrutil.c png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr 4030 pngrutil.c png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
png_ptr 4032 pngrutil.c if (png_ptr->zstream.avail_in > 0 || png_ptr->idat_size > 0)
png_ptr 4033 pngrutil.c png_chunk_benign_error(png_ptr, "Extra compressed data");
png_ptr 4039 pngrutil.c png_zstream_error(png_ptr, ret);
png_ptr 4042 pngrutil.c png_chunk_error(png_ptr, png_ptr->zstream.msg);
png_ptr 4046 pngrutil.c png_chunk_benign_error(png_ptr, png_ptr->zstream.msg);
png_ptr 4058 pngrutil.c png_error(png_ptr, "Not enough image data");
png_ptr 4061 pngrutil.c png_chunk_benign_error(png_ptr, "Too much image data");
png_ptr 4073 pngrutil.c if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
png_ptr 4079 pngrutil.c png_read_IDAT_data(png_ptr, NULL, 0);
png_ptr 4080 pngrutil.c png_ptr->zstream.next_out = NULL; /* safety */
png_ptr 4085 pngrutil.c if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
png_ptr 4087 pngrutil.c png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr 4088 pngrutil.c png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
png_ptr 4095 pngrutil.c if (png_ptr->zowner == png_IDAT)
png_ptr 4098 pngrutil.c png_ptr->zstream.next_in = NULL;
png_ptr 4099 pngrutil.c png_ptr->zstream.avail_in = 0;
png_ptr 4102 pngrutil.c png_ptr->zowner = 0;
png_ptr 4109 pngrutil.c (void)png_crc_finish(png_ptr, png_ptr->idat_size);
png_ptr 4131 pngrutil.c png_ptr->row_number++;
png_ptr 4132 pngrutil.c if (png_ptr->row_number < png_ptr->num_rows)
png_ptr 4135 pngrutil.c if (png_ptr->interlaced)
png_ptr 4137 pngrutil.c png_ptr->row_number = 0;
png_ptr 4142 pngrutil.c memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
png_ptr 4146 pngrutil.c png_ptr->pass++;
png_ptr 4148 pngrutil.c if (png_ptr->pass >= 7)
png_ptr 4151 pngrutil.c png_ptr->iwidth = (png_ptr->width +
png_ptr 4152 pngrutil.c png_pass_inc[png_ptr->pass] - 1 -
png_ptr 4153 pngrutil.c png_pass_start[png_ptr->pass]) /
png_ptr 4154 pngrutil.c png_pass_inc[png_ptr->pass];
png_ptr 4156 pngrutil.c if (!(png_ptr->transformations & PNG_INTERLACE))
png_ptr 4158 pngrutil.c png_ptr->num_rows = (png_ptr->height +
png_ptr 4159 pngrutil.c png_pass_yinc[png_ptr->pass] - 1 -
png_ptr 4160 pngrutil.c png_pass_ystart[png_ptr->pass]) /
png_ptr 4161 pngrutil.c png_pass_yinc[png_ptr->pass];
png_ptr 4167 pngrutil.c } while (png_ptr->num_rows == 0 || png_ptr->iwidth == 0);
png_ptr 4169 pngrutil.c if (png_ptr->pass < 7)
png_ptr 4174 pngrutil.c png_read_finish_IDAT(png_ptr);
png_ptr 4201 pngrutil.c png_init_read_transformations(png_ptr);
png_ptr 4203 pngrutil.c if (png_ptr->interlaced)
png_ptr 4205 pngrutil.c if (!(png_ptr->transformations & PNG_INTERLACE))
png_ptr 4206 pngrutil.c png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
png_ptr 4210 pngrutil.c png_ptr->num_rows = png_ptr->height;
png_ptr 4212 pngrutil.c png_ptr->iwidth = (png_ptr->width +
png_ptr 4213 pngrutil.c png_pass_inc[png_ptr->pass] - 1 -
png_ptr 4214 pngrutil.c png_pass_start[png_ptr->pass]) /
png_ptr 4215 pngrutil.c png_pass_inc[png_ptr->pass];
png_ptr 4220 pngrutil.c png_ptr->num_rows = png_ptr->height;
png_ptr 4221 pngrutil.c png_ptr->iwidth = png_ptr->width;
png_ptr 4224 pngrutil.c max_pixel_depth = png_ptr->pixel_depth;
png_ptr 4237 pngrutil.c if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
png_ptr 4242 pngrutil.c if (png_ptr->transformations & PNG_EXPAND)
png_ptr 4244 pngrutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 4246 pngrutil.c if (png_ptr->num_trans)
png_ptr 4253 pngrutil.c else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
png_ptr 4258 pngrutil.c if (png_ptr->num_trans)
png_ptr 4262 pngrutil.c else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
png_ptr 4264 pngrutil.c if (png_ptr->num_trans)
png_ptr 4274 pngrutil.c if (png_ptr->transformations & PNG_EXPAND_16)
png_ptr 4280 pngrutil.c if (png_ptr->transformations & PNG_EXPAND)
png_ptr 4282 pngrutil.c if (png_ptr->bit_depth < 16)
png_ptr 4287 pngrutil.c png_ptr->transformations &= ~PNG_EXPAND_16;
png_ptr 4292 pngrutil.c if (png_ptr->transformations & (PNG_FILLER))
png_ptr 4294 pngrutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
png_ptr 4303 pngrutil.c else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB ||
png_ptr 4304 pngrutil.c png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 4316 pngrutil.c if (png_ptr->transformations & PNG_GRAY_TO_RGB)
png_ptr 4320 pngrutil.c (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
png_ptr 4323 pngrutil.c (png_ptr->transformations & (PNG_FILLER)) ||
png_ptr 4325 pngrutil.c png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
png_ptr 4338 pngrutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
png_ptr 4345 pngrutil.c else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
png_ptr 4356 pngrutil.c if (png_ptr->transformations & PNG_USER_TRANSFORM)
png_ptr 4358 pngrutil.c int user_pixel_depth = png_ptr->user_transform_depth *
png_ptr 4359 pngrutil.c png_ptr->user_transform_channels;
png_ptr 4369 pngrutil.c png_ptr->maximum_pixel_depth = (png_byte)max_pixel_depth;
png_ptr 4370 pngrutil.c png_ptr->transformed_pixel_depth = 0; /* calculated on demand */
png_ptr 4375 pngrutil.c row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
png_ptr 4384 pngrutil.c png_error(png_ptr, "This image requires a row greater than 64KB");
png_ptr 4387 pngrutil.c if (row_bytes + 48 > png_ptr->old_big_row_buf_size)
png_ptr 4389 pngrutil.c png_free(png_ptr, png_ptr->big_row_buf);
png_ptr 4390 pngrutil.c png_free(png_ptr, png_ptr->big_prev_row);
png_ptr 4392 pngrutil.c if (png_ptr->interlaced)
png_ptr 4393 pngrutil.c png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
png_ptr 4397 pngrutil.c png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
png_ptr 4399 pngrutil.c png_ptr->big_prev_row = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
png_ptr 4410 pngrutil.c png_bytep temp = png_ptr->big_row_buf + 32;
png_ptr 4412 pngrutil.c png_ptr->row_buf = temp - extra - 1/*filter byte*/;
png_ptr 4414 pngrutil.c temp = png_ptr->big_prev_row + 32;
png_ptr 4416 pngrutil.c png_ptr->prev_row = temp - extra - 1/*filter byte*/;
png_ptr 4421 pngrutil.c png_ptr->row_buf = png_ptr->big_row_buf + 31;
png_ptr 4422 pngrutil.c png_ptr->prev_row = png_ptr->big_prev_row + 31;
png_ptr 4424 pngrutil.c png_ptr->old_big_row_buf_size = row_bytes + 48;
png_ptr 4428 pngrutil.c if (png_ptr->rowbytes > 65535)
png_ptr 4429 pngrutil.c png_error(png_ptr, "This image requires a row greater than 64KB");
png_ptr 4432 pngrutil.c if (png_ptr->rowbytes > (PNG_SIZE_MAX - 1))
png_ptr 4433 pngrutil.c png_error(png_ptr, "Row has too many bytes to allocate in memory");
png_ptr 4435 pngrutil.c memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
png_ptr 4437 pngrutil.c png_debug1(3, "width = %u,", png_ptr->width);
png_ptr 4438 pngrutil.c png_debug1(3, "height = %u,", png_ptr->height);
png_ptr 4439 pngrutil.c png_debug1(3, "iwidth = %u,", png_ptr->iwidth);
png_ptr 4440 pngrutil.c png_debug1(3, "num_rows = %u,", png_ptr->num_rows);
png_ptr 4441 pngrutil.c png_debug1(3, "rowbytes = %lu,", (unsigned long)png_ptr->rowbytes);
png_ptr 4443 pngrutil.c (unsigned long)PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);
png_ptr 4449 pngrutil.c if (png_ptr->read_buffer)
png_ptr 4451 pngrutil.c png_bytep buffer = png_ptr->read_buffer;
png_ptr 4453 pngrutil.c png_ptr->read_buffer_size = 0;
png_ptr 4454 pngrutil.c png_ptr->read_buffer = NULL;
png_ptr 4455 pngrutil.c png_free(png_ptr, buffer);
png_ptr 4463 pngrutil.c if (png_inflate_claim(png_ptr, png_IDAT) != Z_OK)
png_ptr 4464 pngrutil.c png_error(png_ptr, png_ptr->zstream.msg);
png_ptr 4466 pngrutil.c png_ptr->flags |= PNG_FLAG_ROW_INIT;
png_ptr 30 pngset.c if (png_ptr == NULL || info_ptr == NULL || background == NULL)
png_ptr 49 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 61 pngset.c if (png_colorspace_set_chromaticities(png_ptr, &info_ptr->colorspace, &xy,
png_ptr 65 pngset.c png_colorspace_sync_info(png_ptr, info_ptr);
png_ptr 80 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 93 pngset.c if (png_colorspace_set_endpoints(png_ptr, &info_ptr->colorspace, &XYZ, 2))
png_ptr 96 pngset.c png_colorspace_sync_info(png_ptr, info_ptr);
png_ptr 105 pngset.c png_set_cHRM_fixed(png_ptr, info_ptr,
png_ptr 106 pngset.c png_fixed(png_ptr, white_x, "cHRM White X"),
png_ptr 107 pngset.c png_fixed(png_ptr, white_y, "cHRM White Y"),
png_ptr 108 pngset.c png_fixed(png_ptr, red_x, "cHRM Red X"),
png_ptr 109 pngset.c png_fixed(png_ptr, red_y, "cHRM Red Y"),
png_ptr 110 pngset.c png_fixed(png_ptr, green_x, "cHRM Green X"),
png_ptr 111 pngset.c png_fixed(png_ptr, green_y, "cHRM Green Y"),
png_ptr 112 pngset.c png_fixed(png_ptr, blue_x, "cHRM Blue X"),
png_ptr 113 pngset.c png_fixed(png_ptr, blue_y, "cHRM Blue Y"));
png_ptr 121 pngset.c png_set_cHRM_XYZ_fixed(png_ptr, info_ptr,
png_ptr 122 pngset.c png_fixed(png_ptr, red_X, "cHRM Red X"),
png_ptr 123 pngset.c png_fixed(png_ptr, red_Y, "cHRM Red Y"),
png_ptr 124 pngset.c png_fixed(png_ptr, red_Z, "cHRM Red Z"),
png_ptr 125 pngset.c png_fixed(png_ptr, green_X, "cHRM Red X"),
png_ptr 126 pngset.c png_fixed(png_ptr, green_Y, "cHRM Red Y"),
png_ptr 127 pngset.c png_fixed(png_ptr, green_Z, "cHRM Red Z"),
png_ptr 128 pngset.c png_fixed(png_ptr, blue_X, "cHRM Red X"),
png_ptr 129 pngset.c png_fixed(png_ptr, blue_Y, "cHRM Red Y"),
png_ptr 130 pngset.c png_fixed(png_ptr, blue_Z, "cHRM Red Z"));
png_ptr 143 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 146 pngset.c png_colorspace_set_gamma(png_ptr, &info_ptr->colorspace, file_gamma);
png_ptr 147 pngset.c png_colorspace_sync_info(png_ptr, info_ptr);
png_ptr 154 pngset.c png_set_gAMA_fixed(png_ptr, info_ptr, png_fixed(png_ptr, file_gamma,
png_ptr 169 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 175 pngset.c png_warning(png_ptr,
png_ptr 181 pngset.c png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
png_ptr 186 pngset.c info_ptr->hist = png_voidcast(png_uint_16p, png_malloc_warn(png_ptr,
png_ptr 191 pngset.c png_warning(png_ptr, "Insufficient memory for hIST chunk data");
png_ptr 212 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 223 pngset.c png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
png_ptr 251 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 272 pngset.c if (png_ptr == NULL || info_ptr == NULL || purpose == NULL || units == NULL
png_ptr 284 pngset.c png_error(png_ptr, "Invalid pCAL equation type");
png_ptr 287 pngset.c png_error(png_ptr, "Invalid pCAL parameter count");
png_ptr 293 pngset.c png_error(png_ptr, "Invalid format for pCAL parameter");
png_ptr 296 pngset.c png_malloc_warn(png_ptr, length));
png_ptr 300 pngset.c png_warning(png_ptr, "Insufficient memory for pCAL purpose");
png_ptr 317 pngset.c png_malloc_warn(png_ptr, length));
png_ptr 321 pngset.c png_warning(png_ptr, "Insufficient memory for pCAL units");
png_ptr 327 pngset.c info_ptr->pcal_params = png_voidcast(png_charpp, png_malloc_warn(png_ptr,
png_ptr 332 pngset.c png_warning(png_ptr, "Insufficient memory for pCAL params");
png_ptr 344 pngset.c info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
png_ptr 348 pngset.c png_warning(png_ptr, "Insufficient memory for pCAL parameter");
png_ptr 369 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 376 pngset.c png_error(png_ptr, "Invalid sCAL unit");
png_ptr 380 pngset.c png_error(png_ptr, "Invalid sCAL width");
png_ptr 384 pngset.c png_error(png_ptr, "Invalid sCAL height");
png_ptr 393 pngset.c png_malloc_warn(png_ptr, lengthw));
png_ptr 397 pngset.c png_warning(png_ptr, "Memory allocation failed while processing sCAL");
png_ptr 408 pngset.c png_malloc_warn(png_ptr, lengthh));
png_ptr 412 pngset.c png_free (png_ptr, info_ptr->scal_s_width);
png_ptr 415 pngset.c png_warning(png_ptr, "Memory allocation failed while processing sCAL");
png_ptr 434 pngset.c png_warning(png_ptr, "Invalid sCAL width ignored");
png_ptr 437 pngset.c png_warning(png_ptr, "Invalid sCAL height ignored");
png_ptr 445 pngset.c png_ascii_from_fp(png_ptr, swidth, (sizeof swidth), width,
png_ptr 447 pngset.c png_ascii_from_fp(png_ptr, sheight, (sizeof sheight), height,
png_ptr 450 pngset.c png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight);
png_ptr 464 pngset.c png_warning(png_ptr, "Invalid sCAL width ignored");
png_ptr 467 pngset.c png_warning(png_ptr, "Invalid sCAL height ignored");
png_ptr 475 pngset.c png_ascii_from_fixed(png_ptr, swidth, (sizeof swidth), width);
png_ptr 476 pngset.c png_ascii_from_fixed(png_ptr, sheight, (sizeof sheight), height);
png_ptr 478 pngset.c png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight);
png_ptr 491 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 508 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 514 pngset.c png_error(png_ptr, "Invalid palette length");
png_ptr 518 pngset.c png_warning(png_ptr, "Invalid palette length");
png_ptr 526 pngset.c && (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0
png_ptr 530 pngset.c png_error(png_ptr, "Invalid palette");
png_ptr 541 pngset.c png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
png_ptr 547 pngset.c png_ptr->palette = png_voidcast(png_colorp, png_calloc(png_ptr,
png_ptr 551 pngset.c memcpy(png_ptr->palette, palette, num_palette * (sizeof (png_color)));
png_ptr 552 pngset.c info_ptr->palette = png_ptr->palette;
png_ptr 553 pngset.c info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
png_ptr 567 pngset.c if (png_ptr == NULL || info_ptr == NULL || sig_bit == NULL)
png_ptr 581 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 584 pngset.c (void)png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent);
png_ptr 585 pngset.c png_colorspace_sync_info(png_ptr, info_ptr);
png_ptr 594 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 597 pngset.c if (png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent))
png_ptr 604 pngset.c png_colorspace_sync_info(png_ptr, info_ptr);
png_ptr 621 pngset.c if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
png_ptr 625 pngset.c png_app_error(png_ptr, "Invalid iCCP compression method");
png_ptr 634 pngset.c int result = png_colorspace_set_ICC(png_ptr, &info_ptr->colorspace, name,
png_ptr 637 pngset.c png_colorspace_sync_info(png_ptr, info_ptr);
png_ptr 649 pngset.c new_iccp_name = png_voidcast(png_charp, png_malloc_warn(png_ptr, length));
png_ptr 653 pngset.c png_benign_error(png_ptr, "Insufficient memory to process iCCP chunk");
png_ptr 659 pngset.c png_malloc_warn(png_ptr, proflen));
png_ptr 663 pngset.c png_free(png_ptr, new_iccp_name);
png_ptr 664 pngset.c png_benign_error(png_ptr,
png_ptr 671 pngset.c png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
png_ptr 687 pngset.c ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
png_ptr 690 pngset.c png_error(png_ptr, "Insufficient memory to store text");
png_ptr 699 pngset.c png_debug1(1, "in %lx storage function", png_ptr == NULL ? "unexpected" :
png_ptr 700 pngset.c (unsigned long)png_ptr->chunk_name);
png_ptr 702 pngset.c if (png_ptr == NULL || info_ptr == NULL || num_text <= 0 || text_ptr == NULL)
png_ptr 732 pngset.c new_text = png_voidcast(png_textp,png_realloc_array(png_ptr,
png_ptr 739 pngset.c png_chunk_report(png_ptr, "too many text chunks",
png_ptr 744 pngset.c png_free(png_ptr, info_ptr->text);
png_ptr 766 pngset.c png_chunk_report(png_ptr, "text compression mode is out of range",
png_ptr 798 pngset.c png_chunk_report(png_ptr, "iTXt chunk not supported",
png_ptr 822 pngset.c textp->key = png_voidcast(png_charp,png_malloc_base(png_ptr,
png_ptr 827 pngset.c png_chunk_report(png_ptr, "text chunk: out of memory",
png_ptr 892 pngset.c if (png_ptr == NULL || info_ptr == NULL || mod_time == NULL ||
png_ptr 893 pngset.c (png_ptr->mode & PNG_WROTE_tIME))
png_ptr 901 pngset.c png_warning(png_ptr, "Ignoring invalid time value");
png_ptr 917 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 931 pngset.c png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
png_ptr 934 pngset.c png_ptr->trans_alpha = info_ptr->trans_alpha = png_voidcast(png_bytep,
png_ptr 935 pngset.c png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));
png_ptr 951 pngset.c png_warning(png_ptr,
png_ptr 985 pngset.c if (png_ptr == NULL || info_ptr == NULL || nentries <= 0 || entries == NULL)
png_ptr 991 pngset.c np = png_voidcast(png_sPLT_tp,png_realloc_array(png_ptr,
png_ptr 998 pngset.c png_chunk_report(png_ptr, "too many sPLT chunks", PNG_CHUNK_WRITE_ERROR);
png_ptr 1002 pngset.c png_free(png_ptr, info_ptr->splt_palettes);
png_ptr 1016 pngset.c png_app_error(png_ptr, "png_set_sPLT: invalid sPLT");
png_ptr 1027 pngset.c np->name = png_voidcast(png_charp, png_malloc_base(png_ptr, length));
png_ptr 1038 pngset.c np->entries = png_voidcast(png_sPLT_entryp, png_malloc_array(png_ptr,
png_ptr 1043 pngset.c png_free(png_ptr, np->name);
png_ptr 1064 pngset.c png_chunk_report(png_ptr, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR);
png_ptr 1078 pngset.c if (location == 0 && !(png_ptr->mode & PNG_IS_READ_STRUCT))
png_ptr 1081 pngset.c png_app_warning(png_ptr,
png_ptr 1084 pngset.c location = (png_byte)(png_ptr->mode &
png_ptr 1092 pngset.c png_error(png_ptr, "invalid location in png_set_unknown_chunks");
png_ptr 1112 pngset.c if (png_ptr == NULL || info_ptr == NULL || num_unknowns <= 0 ||
png_ptr 1124 pngset.c if (png_ptr->mode & PNG_IS_READ_STRUCT)
png_ptr 1126 pngset.c png_app_error(png_ptr, "no unknown chunk support on read");
png_ptr 1132 pngset.c if (!(png_ptr->mode & PNG_IS_READ_STRUCT))
png_ptr 1134 pngset.c png_app_error(png_ptr, "no unknown chunk support on write");
png_ptr 1144 pngset.c np = png_voidcast(png_unknown_chunkp, png_realloc_array(png_ptr,
png_ptr 1150 pngset.c png_chunk_report(png_ptr, "too many unknown chunks",
png_ptr 1155 pngset.c png_free(png_ptr, info_ptr->unknown_chunks);
png_ptr 1168 pngset.c np->location = check_location(png_ptr, unknowns->location);
png_ptr 1179 pngset.c png_malloc_base(png_ptr, unknowns->size));
png_ptr 1183 pngset.c png_chunk_report(png_ptr, "unknown chunk: out of memory",
png_ptr 1211 pngset.c if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 &&
png_ptr 1216 pngset.c png_app_error(png_ptr, "invalid unknown chunk location");
png_ptr 1226 pngset.c check_location(png_ptr, location);
png_ptr 1238 pngset.c if (png_ptr == NULL)
png_ptr 1241 pngset.c png_ptr->mng_features_permitted = mng_features & PNG_ALL_MNG_FEATURES;
png_ptr 1243 pngset.c return png_ptr->mng_features_permitted;
png_ptr 1279 pngset.c if (png_ptr == NULL)
png_ptr 1284 pngset.c png_app_error(png_ptr, "png_set_keep_unknown_chunks: invalid keep");
png_ptr 1290 pngset.c png_ptr->unknown_default = keep;
png_ptr 1333 pngset.c png_app_error(png_ptr, "png_set_keep_unknown_chunks: no chunk list");
png_ptr 1340 pngset.c old_num_chunks = png_ptr->num_chunk_list;
png_ptr 1341 pngset.c if (png_ptr->chunk_list == NULL)
png_ptr 1348 pngset.c png_app_error(png_ptr, "png_set_keep_unknown_chunks: too many chunks");
png_ptr 1358 pngset.c new_list = png_voidcast(png_bytep, png_malloc(png_ptr,
png_ptr 1362 pngset.c memcpy(new_list, png_ptr->chunk_list, 5*old_num_chunks);
png_ptr 1366 pngset.c new_list = png_ptr->chunk_list;
png_ptr 1400 pngset.c if (png_ptr->chunk_list != new_list)
png_ptr 1401 pngset.c png_free(png_ptr, new_list);
png_ptr 1410 pngset.c png_ptr->num_chunk_list = num_chunks;
png_ptr 1412 pngset.c if (png_ptr->chunk_list != new_list)
png_ptr 1414 pngset.c if (png_ptr->chunk_list != NULL)
png_ptr 1415 pngset.c png_free(png_ptr, png_ptr->chunk_list);
png_ptr 1417 pngset.c png_ptr->chunk_list = new_list;
png_ptr 1429 pngset.c if (png_ptr == NULL)
png_ptr 1432 pngset.c png_ptr->read_user_chunk_fn = read_user_chunk_fn;
png_ptr 1433 pngset.c png_ptr->user_chunk_ptr = user_chunk_ptr;
png_ptr 1444 pngset.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 1448 pngset.c png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
png_ptr 1460 pngset.c if (png_ptr == NULL)
png_ptr 1464 pngset.c png_error(png_ptr, "invalid compression buffer size");
png_ptr 1467 pngset.c if (png_ptr->mode & PNG_IS_READ_STRUCT)
png_ptr 1469 pngset.c png_ptr->IDAT_read_size = (png_uint_32)size; /* checked above */
png_ptr 1475 pngset.c if (!(png_ptr->mode & PNG_IS_READ_STRUCT))
png_ptr 1477 pngset.c if (png_ptr->zowner != 0)
png_ptr 1479 pngset.c png_warning(png_ptr,
png_ptr 1486 pngset.c png_warning(png_ptr,
png_ptr 1496 pngset.c png_warning(png_ptr,
png_ptr 1501 pngset.c if (png_ptr->zbuffer_size != size)
png_ptr 1503 pngset.c png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
png_ptr 1504 pngset.c png_ptr->zbuffer_size = (uInt)size;
png_ptr 1513 pngset.c if (png_ptr && info_ptr)
png_ptr 1528 pngset.c if (png_ptr == NULL)
png_ptr 1531 pngset.c png_ptr->user_width_max = user_width_max;
png_ptr 1532 pngset.c png_ptr->user_height_max = user_height_max;
png_ptr 1539 pngset.c if (png_ptr != NULL)
png_ptr 1540 pngset.c png_ptr->user_chunk_cache_max = user_chunk_cache_max;
png_ptr 1548 pngset.c if (png_ptr != NULL)
png_ptr 1549 pngset.c png_ptr->user_chunk_malloc_max = user_chunk_malloc_max;
png_ptr 1567 pngset.c png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN |
png_ptr 1571 pngset.c png_ptr->flags &= ~(PNG_FLAG_BENIGN_ERRORS_WARN |
png_ptr 1591 pngset.c png_ptr->num_palette_max = 0;
png_ptr 1594 pngset.c png_ptr->num_palette_max = -1;
png_ptr 132 pngtest.c # define png_jmpbuf(png_ptr) png_ptr->jmpbuf
png_ptr 154 pngtest.c if (png_ptr == NULL || row_number > PNG_UINT_31_MAX)
png_ptr 179 pngtest.c if (png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7)
png_ptr 196 pngtest.c if (png_ptr != NULL && row_info != NULL)
png_ptr 212 pngtest.c if (png_ptr == NULL)
png_ptr 333 pngtest.c png_uint_32 io_state = png_get_io_state(png_ptr);
png_ptr 338 pngtest.c png_error(png_ptr, "Incorrect operation in I/O state");
png_ptr 363 pngtest.c png_error(png_ptr, "Bad I/O state or buffer size");
png_ptr 376 pngtest.c io_ptr = png_get_io_ptr(png_ptr);
png_ptr 384 pngtest.c png_error(png_ptr, "Read Error");
png_ptr 388 pngtest.c pngtest_check_io_state(png_ptr, length, PNG_IO_READING);
png_ptr 397 pngtest.c PNG_UNUSED(png_ptr) /* Stifle compiler warning */
png_ptr 411 pngtest.c check = fwrite(data, 1, length, (png_FILE_p)png_get_io_ptr(png_ptr));
png_ptr 415 pngtest.c png_error(png_ptr, "Write Error");
png_ptr 419 pngtest.c pngtest_check_io_state(png_ptr, length, PNG_IO_WRITING);
png_ptr 439 pngtest.c (pngtest_error_parameters*)png_get_error_ptr(png_ptr);
png_ptr 459 pngtest.c pngtest_warning(png_ptr, message);
png_ptr 513 pngtest.c png_set_mem_fn(png_ptr, NULL, NULL, NULL);
png_ptr 514 pngtest.c pinfo = (memory_infop)png_malloc(png_ptr,
png_ptr 524 pngtest.c pinfo->pointer = png_malloc(png_ptr, size);
png_ptr 527 pngtest.c png_set_mem_fn(png_ptr,
png_ptr 534 pngtest.c png_error(png_ptr,
png_ptr 555 pngtest.c if (png_ptr == NULL)
png_ptr 655 pngtest.c else if (png_get_valid(png_ptr, data->info_ptr, PNG_INFO_PLTE))
png_ptr 674 pngtest.c (struct user_chunk_data*)png_get_user_chunk_ptr(png_ptr);
png_ptr 677 pngtest.c png_error(png_ptr, "lost user chunk pointer");
png_ptr 702 pngtest.c if (set_location(png_ptr, my_user_chunk_data, have_sTER))
png_ptr 721 pngtest.c if (!set_location(png_ptr, my_user_chunk_data, have_vpAg))
png_ptr 724 pngtest.c my_user_chunk_data->vpAg_width = png_get_uint_31(png_ptr, chunk->data);
png_ptr 725 pngtest.c my_user_chunk_data->vpAg_height = png_get_uint_31(png_ptr, chunk->data + 4);
png_ptr 819 pngtest.c png_error(png_ptr, "invalid text chunk compression field");
png_ptr 25 pngtrans.c if (png_ptr == NULL)
png_ptr 28 pngtrans.c png_ptr->transformations |= PNG_BGR;
png_ptr 39 pngtrans.c if (png_ptr == NULL)
png_ptr 42 pngtrans.c if (png_ptr->bit_depth == 16)
png_ptr 43 pngtrans.c png_ptr->transformations |= PNG_SWAP_BYTES;
png_ptr 54 pngtrans.c if (png_ptr == NULL)
png_ptr 57 pngtrans.c if (png_ptr->bit_depth < 8)
png_ptr 59 pngtrans.c png_ptr->transformations |= PNG_PACK;
png_ptr 61 pngtrans.c png_ptr->usr_bit_depth = 8;
png_ptr 74 pngtrans.c if (png_ptr == NULL)
png_ptr 77 pngtrans.c if (png_ptr->bit_depth < 8)
png_ptr 78 pngtrans.c png_ptr->transformations |= PNG_PACKSWAP;
png_ptr 88 pngtrans.c if (png_ptr == NULL)
png_ptr 91 pngtrans.c png_ptr->transformations |= PNG_SHIFT;
png_ptr 92 pngtrans.c png_ptr->shift = *true_bits;
png_ptr 103 pngtrans.c if (png_ptr && png_ptr->interlaced)
png_ptr 105 pngtrans.c png_ptr->transformations |= PNG_INTERLACE;
png_ptr 124 pngtrans.c if (png_ptr == NULL)
png_ptr 130 pngtrans.c if (png_ptr->mode & PNG_IS_READ_STRUCT)
png_ptr 141 pngtrans.c png_ptr->filler = (png_uint_16)filler;
png_ptr 143 pngtrans.c png_app_error(png_ptr, "png_set_filler not supported on read");
png_ptr 155 pngtrans.c switch (png_ptr->color_type)
png_ptr 158 pngtrans.c png_ptr->usr_channels = 4;
png_ptr 162 pngtrans.c if (png_ptr->bit_depth >= 8)
png_ptr 164 pngtrans.c png_ptr->usr_channels = 2;
png_ptr 174 pngtrans.c png_app_error(png_ptr,
png_ptr 180 pngtrans.c png_app_error(png_ptr,
png_ptr 185 pngtrans.c png_app_error(png_ptr, "png_set_filler not supported on write");
png_ptr 193 pngtrans.c png_ptr->transformations |= PNG_FILLER;
png_ptr 196 pngtrans.c png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
png_ptr 199 pngtrans.c png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
png_ptr 208 pngtrans.c if (png_ptr == NULL)
png_ptr 211 pngtrans.c png_set_filler(png_ptr, filler, filler_loc);
png_ptr 213 pngtrans.c if (png_ptr->transformations & PNG_FILLER)
png_ptr 214 pngtrans.c png_ptr->transformations |= PNG_ADD_ALPHA;
png_ptr 226 pngtrans.c if (png_ptr == NULL)
png_ptr 229 pngtrans.c png_ptr->transformations |= PNG_SWAP_ALPHA;
png_ptr 240 pngtrans.c if (png_ptr == NULL)
png_ptr 243 pngtrans.c png_ptr->transformations |= PNG_INVERT_ALPHA;
png_ptr 253 pngtrans.c if (png_ptr == NULL)
png_ptr 256 pngtrans.c png_ptr->transformations |= PNG_INVERT_MONO;
png_ptr 686 pngtrans.c if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
png_ptr 687 pngtrans.c png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
png_ptr 696 pngtrans.c png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
png_ptr 705 pngtrans.c for (; rp > png_ptr->row_buf; rp--)
png_ptr 708 pngtrans.c png_ptr->num_palette_max = 1;
png_ptr 717 pngtrans.c for (; rp > png_ptr->row_buf; rp--)
png_ptr 721 pngtrans.c if (i > png_ptr->num_palette_max)
png_ptr 722 pngtrans.c png_ptr->num_palette_max = i;
png_ptr 726 pngtrans.c if (i > png_ptr->num_palette_max)
png_ptr 727 pngtrans.c png_ptr->num_palette_max = i;
png_ptr 731 pngtrans.c if (i > png_ptr->num_palette_max)
png_ptr 732 pngtrans.c png_ptr->num_palette_max = i;
png_ptr 736 pngtrans.c if (i > png_ptr->num_palette_max)
png_ptr 737 pngtrans.c png_ptr->num_palette_max = i;
png_ptr 747 pngtrans.c for (; rp > png_ptr->row_buf; rp--)
png_ptr 751 pngtrans.c if (i > png_ptr->num_palette_max)
png_ptr 752 pngtrans.c png_ptr->num_palette_max = i;
png_ptr 756 pngtrans.c if (i > png_ptr->num_palette_max)
png_ptr 757 pngtrans.c png_ptr->num_palette_max = i;
png_ptr 767 pngtrans.c for (; rp > png_ptr->row_buf; rp--)
png_ptr 769 pngtrans.c if (*rp > png_ptr->num_palette_max)
png_ptr 770 pngtrans.c png_ptr->num_palette_max = (int) *rp;
png_ptr 792 pngtrans.c if (png_ptr == NULL)
png_ptr 796 pngtrans.c if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
png_ptr 797 pngtrans.c (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
png_ptr 799 pngtrans.c png_app_error(png_ptr,
png_ptr 805 pngtrans.c png_ptr->user_transform_ptr = user_transform_ptr;
png_ptr 806 pngtrans.c png_ptr->user_transform_depth = (png_byte)user_transform_depth;
png_ptr 807 pngtrans.c png_ptr->user_transform_channels = (png_byte)user_transform_channels;
png_ptr 820 pngtrans.c if (png_ptr == NULL)
png_ptr 823 pngtrans.c return png_ptr->user_transform_ptr;
png_ptr 834 pngtrans.c if (png_ptr != NULL)
png_ptr 835 pngtrans.c return png_ptr->row_number;
png_ptr 843 pngtrans.c if (png_ptr != NULL)
png_ptr 844 pngtrans.c return png_ptr->pass;
png_ptr 36 pngwio.c if (png_ptr->write_data_fn != NULL )
png_ptr 37 pngwio.c (*(png_ptr->write_data_fn))(png_ptr, png_constcast(png_bytep,data),
png_ptr 41 pngwio.c png_error(png_ptr, "Call to NULL write function");
png_ptr 55 pngwio.c if (png_ptr == NULL)
png_ptr 58 pngwio.c check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
png_ptr 61 pngwio.c png_error(png_ptr, "Write Error");
png_ptr 73 pngwio.c if (png_ptr->output_flush_fn != NULL)
png_ptr 74 pngwio.c (*(png_ptr->output_flush_fn))(png_ptr);
png_ptr 83 pngwio.c if (png_ptr == NULL)
png_ptr 86 pngwio.c io_ptr = png_voidcast(png_FILE_p, (png_ptr->io_ptr));
png_ptr 125 pngwio.c if (png_ptr == NULL)
png_ptr 128 pngwio.c png_ptr->io_ptr = io_ptr;
png_ptr 132 pngwio.c png_ptr->write_data_fn = write_data_fn;
png_ptr 135 pngwio.c png_ptr->write_data_fn = png_default_write_data;
png_ptr 137 pngwio.c png_ptr->write_data_fn = write_data_fn;
png_ptr 144 pngwio.c png_ptr->output_flush_fn = output_flush_fn;
png_ptr 147 pngwio.c png_ptr->output_flush_fn = png_default_flush;
png_ptr 150 pngwio.c png_ptr->output_flush_fn = output_flush_fn;
png_ptr 158 pngwio.c if (png_ptr->read_data_fn != NULL)
png_ptr 160 pngwio.c png_ptr->read_data_fn = NULL;
png_ptr 162 pngwio.c png_warning(png_ptr,
png_ptr 42 pngwrite.c int keep = png_handle_as_unknown(png_ptr, up->name);
png_ptr 60 pngwrite.c png_ptr->unknown_default == PNG_HANDLE_CHUNK_ALWAYS)))
png_ptr 65 pngwrite.c png_warning(png_ptr, "Writing zero-length unknown chunk");
png_ptr 67 pngwrite.c png_write_chunk(png_ptr, up->name, up->data, up->size);
png_ptr 88 pngwrite.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 91 pngwrite.c if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
png_ptr 94 pngwrite.c png_write_sig(png_ptr);
png_ptr 97 pngwrite.c if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) && \
png_ptr 98 pngwrite.c (png_ptr->mng_features_permitted))
png_ptr 100 pngwrite.c png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
png_ptr 101 pngwrite.c png_ptr->mng_features_permitted = 0;
png_ptr 106 pngwrite.c png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
png_ptr 135 pngwrite.c png_write_gAMA_fixed(png_ptr, info_ptr->colorspace.gamma);
png_ptr 149 pngwrite.c png_app_warning(png_ptr,
png_ptr 153 pngwrite.c png_write_iCCP(png_ptr, info_ptr->iccp_name,
png_ptr 164 pngwrite.c png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);
png_ptr 170 pngwrite.c png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
png_ptr 178 pngwrite.c png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);
png_ptr 183 pngwrite.c write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR);
png_ptr 186 pngwrite.c png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
png_ptr 199 pngwrite.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 202 pngwrite.c png_write_info_before_PLTE(png_ptr, info_ptr);
png_ptr 205 pngwrite.c png_write_PLTE(png_ptr, info_ptr->palette,
png_ptr 209 pngwrite.c png_error(png_ptr, "Valid palette required for paletted images");
png_ptr 216 pngwrite.c if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
png_ptr 225 pngwrite.c png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),
png_ptr 231 pngwrite.c png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
png_ptr 236 pngwrite.c png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
png_ptr 241 pngwrite.c png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
png_ptr 247 pngwrite.c png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
png_ptr 254 pngwrite.c png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
png_ptr 260 pngwrite.c png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
png_ptr 267 pngwrite.c png_write_tIME(png_ptr, &(info_ptr->mod_time));
png_ptr 268 pngwrite.c png_ptr->mode |= PNG_WROTE_tIME;
png_ptr 275 pngwrite.c png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
png_ptr 289 pngwrite.c png_write_iTXt(png_ptr,
png_ptr 301 pngwrite.c png_warning(png_ptr, "Unable to write international text");
png_ptr 310 pngwrite.c png_write_zTXt(png_ptr, info_ptr->text[i].key,
png_ptr 315 pngwrite.c png_warning(png_ptr, "Unable to write compressed text");
png_ptr 323 pngwrite.c png_write_tEXt(png_ptr, info_ptr->text[i].key,
png_ptr 330 pngwrite.c png_warning(png_ptr, "Unable to write uncompressed text");
png_ptr 337 pngwrite.c write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_PLTE);
png_ptr 351 pngwrite.c if (png_ptr == NULL)
png_ptr 354 pngwrite.c if (!(png_ptr->mode & PNG_HAVE_IDAT))
png_ptr 355 pngwrite.c png_error(png_ptr, "No IDATs written into file");
png_ptr 358 pngwrite.c if (png_ptr->num_palette_max > png_ptr->num_palette)
png_ptr 359 pngwrite.c png_benign_error(png_ptr, "Wrote palette index exceeding num_palette");
png_ptr 371 pngwrite.c !(png_ptr->mode & PNG_WROTE_tIME))
png_ptr 372 pngwrite.c png_write_tIME(png_ptr, &(info_ptr->mod_time));
png_ptr 386 pngwrite.c png_write_iTXt(png_ptr,
png_ptr 398 pngwrite.c png_warning(png_ptr, "Unable to write international text");
png_ptr 406 pngwrite.c png_write_zTXt(png_ptr, info_ptr->text[i].key,
png_ptr 411 pngwrite.c png_warning(png_ptr, "Unable to write compressed text");
png_ptr 419 pngwrite.c png_write_tEXt(png_ptr, info_ptr->text[i].key,
png_ptr 424 pngwrite.c png_warning(png_ptr, "Unable to write uncompressed text");
png_ptr 430 pngwrite.c write_unknown_chunks(png_ptr, info_ptr, PNG_AFTER_IDAT);
png_ptr 434 pngwrite.c png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr 437 pngwrite.c png_write_IEND(png_ptr);
png_ptr 448 pngwrite.c png_flush(png_ptr);
png_ptr 485 pngwrite.c png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
png_ptr 498 pngwrite.c png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
png_ptr 501 pngwrite.c if (png_ptr != NULL)
png_ptr 506 pngwrite.c png_ptr->zbuffer_size = PNG_ZBUF_SIZE;
png_ptr 512 pngwrite.c png_ptr->zlib_strategy = PNG_Z_DEFAULT_STRATEGY;
png_ptr 513 pngwrite.c png_ptr->zlib_level = PNG_Z_DEFAULT_COMPRESSION;
png_ptr 514 pngwrite.c png_ptr->zlib_mem_level = 8;
png_ptr 515 pngwrite.c png_ptr->zlib_window_bits = 15;
png_ptr 516 pngwrite.c png_ptr->zlib_method = 8;
png_ptr 519 pngwrite.c png_ptr->zlib_text_strategy = PNG_TEXT_Z_DEFAULT_STRATEGY;
png_ptr 520 pngwrite.c png_ptr->zlib_text_level = PNG_TEXT_Z_DEFAULT_COMPRESSION;
png_ptr 521 pngwrite.c png_ptr->zlib_text_mem_level = 8;
png_ptr 522 pngwrite.c png_ptr->zlib_text_window_bits = 15;
png_ptr 523 pngwrite.c png_ptr->zlib_text_method = 8;
png_ptr 535 pngwrite.c png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
png_ptr 542 pngwrite.c png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
png_ptr 549 pngwrite.c png_set_write_fn(png_ptr, NULL, NULL, NULL);
png_ptr 552 pngwrite.c return png_ptr;
png_ptr 570 pngwrite.c if (png_ptr == NULL)
png_ptr 576 pngwrite.c png_write_row(png_ptr, *rp);
png_ptr 590 pngwrite.c if (png_ptr == NULL)
png_ptr 599 pngwrite.c num_pass = png_set_interlace_handling(png_ptr);
png_ptr 607 pngwrite.c for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
png_ptr 609 pngwrite.c png_write_row(png_ptr, *rp);
png_ptr 686 pngwrite.c if (png_ptr == NULL)
png_ptr 690 pngwrite.c png_ptr->row_number, png_ptr->pass);
png_ptr 693 pngwrite.c if (png_ptr->row_number == 0 && png_ptr->pass == 0)
png_ptr 696 pngwrite.c if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
png_ptr 697 pngwrite.c png_error(png_ptr,
png_ptr 702 pngwrite.c if (png_ptr->transformations & PNG_INVERT_MONO)
png_ptr 703 pngwrite.c png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");
png_ptr 707 pngwrite.c if (png_ptr->transformations & PNG_FILLER)
png_ptr 708 pngwrite.c png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");
png_ptr 712 pngwrite.c if (png_ptr->transformations & PNG_PACKSWAP)
png_ptr 713 pngwrite.c png_warning(png_ptr,
png_ptr 718 pngwrite.c if (png_ptr->transformations & PNG_PACK)
png_ptr 719 pngwrite.c png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");
png_ptr 723 pngwrite.c if (png_ptr->transformations & PNG_SHIFT)
png_ptr 724 pngwrite.c png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");
png_ptr 728 pngwrite.c if (png_ptr->transformations & PNG_BGR)
png_ptr 729 pngwrite.c png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");
png_ptr 733 pngwrite.c if (png_ptr->transformations & PNG_SWAP_BYTES)
png_ptr 734 pngwrite.c png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");
png_ptr 737 pngwrite.c png_write_start_row(png_ptr);
png_ptr 742 pngwrite.c if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
png_ptr 744 pngwrite.c switch (png_ptr->pass)
png_ptr 747 pngwrite.c if (png_ptr->row_number & 0x07)
png_ptr 749 pngwrite.c png_write_finish_row(png_ptr);
png_ptr 755 pngwrite.c if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
png_ptr 757 pngwrite.c png_write_finish_row(png_ptr);
png_ptr 763 pngwrite.c if ((png_ptr->row_number & 0x07) != 4)
png_ptr 765 pngwrite.c png_write_finish_row(png_ptr);
png_ptr 771 pngwrite.c if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)
png_ptr 773 pngwrite.c png_write_finish_row(png_ptr);
png_ptr 779 pngwrite.c if ((png_ptr->row_number & 0x03) != 2)
png_ptr 781 pngwrite.c png_write_finish_row(png_ptr);
png_ptr 787 pngwrite.c if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)
png_ptr 789 pngwrite.c png_write_finish_row(png_ptr);
png_ptr 795 pngwrite.c if (!(png_ptr->row_number & 0x01))
png_ptr 797 pngwrite.c png_write_finish_row(png_ptr);
png_ptr 809 pngwrite.c row_info.color_type = png_ptr->color_type;
png_ptr 810 pngwrite.c row_info.width = png_ptr->usr_width;
png_ptr 811 pngwrite.c row_info.channels = png_ptr->usr_channels;
png_ptr 812 pngwrite.c row_info.bit_depth = png_ptr->usr_bit_depth;
png_ptr 824 pngwrite.c memcpy(png_ptr->row_buf + 1, row, row_info.rowbytes);
png_ptr 828 pngwrite.c if (png_ptr->interlaced && png_ptr->pass < 6 &&
png_ptr 829 pngwrite.c (png_ptr->transformations & PNG_INTERLACE))
png_ptr 831 pngwrite.c png_do_write_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass);
png_ptr 835 pngwrite.c png_write_finish_row(png_ptr);
png_ptr 843 pngwrite.c if (png_ptr->transformations)
png_ptr 844 pngwrite.c png_do_write_transformations(png_ptr, &row_info);
png_ptr 850 pngwrite.c if (row_info.pixel_depth != png_ptr->pixel_depth ||
png_ptr 851 pngwrite.c row_info.pixel_depth != png_ptr->transformed_pixel_depth)
png_ptr 852 pngwrite.c png_error(png_ptr, "internal write transform logic error");
png_ptr 864 pngwrite.c if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
png_ptr 865 pngwrite.c (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
png_ptr 868 pngwrite.c png_do_write_intrapixel(&row_info, png_ptr->row_buf + 1);
png_ptr 876 pngwrite.c png_ptr->num_palette_max >= 0)
png_ptr 877 pngwrite.c png_do_check_palette_indexes(png_ptr, &row_info);
png_ptr 881 pngwrite.c png_write_find_filter(png_ptr, &row_info);
png_ptr 883 pngwrite.c if (png_ptr->write_row_fn != NULL)
png_ptr 884 pngwrite.c (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
png_ptr 894 pngwrite.c if (png_ptr == NULL)
png_ptr 897 pngwrite.c png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
png_ptr 906 pngwrite.c if (png_ptr == NULL)
png_ptr 910 pngwrite.c if (png_ptr->row_number >= png_ptr->num_rows)
png_ptr 913 pngwrite.c png_compress_IDAT(png_ptr, NULL, 0, Z_SYNC_FLUSH);
png_ptr 914 pngwrite.c png_ptr->flush_rows = 0;
png_ptr 915 pngwrite.c png_flush(png_ptr);
png_ptr 930 pngwrite.c if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED)
png_ptr 931 pngwrite.c deflateEnd(&png_ptr->zstream);
png_ptr 934 pngwrite.c png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
png_ptr 935 pngwrite.c png_free(png_ptr, png_ptr->row_buf);
png_ptr 937 pngwrite.c png_free(png_ptr, png_ptr->prev_row);
png_ptr 938 pngwrite.c png_free(png_ptr, png_ptr->sub_row);
png_ptr 939 pngwrite.c png_free(png_ptr, png_ptr->up_row);
png_ptr 940 pngwrite.c png_free(png_ptr, png_ptr->avg_row);
png_ptr 941 pngwrite.c png_free(png_ptr, png_ptr->paeth_row);
png_ptr 946 pngwrite.c png_reset_filter_heuristics(png_ptr);
png_ptr 947 pngwrite.c png_free(png_ptr, png_ptr->filter_costs);
png_ptr 948 pngwrite.c png_free(png_ptr, png_ptr->inv_filter_costs);
png_ptr 952 pngwrite.c png_free(png_ptr, png_ptr->chunk_list);
png_ptr 975 pngwrite.c png_structrp png_ptr = *png_ptr_ptr;
png_ptr 977 pngwrite.c if (png_ptr != NULL) /* added in libpng 1.6.0 */
png_ptr 979 pngwrite.c png_destroy_info_struct(png_ptr, info_ptr_ptr);
png_ptr 982 pngwrite.c png_write_destroy(png_ptr);
png_ptr 983 pngwrite.c png_destroy_png_struct(png_ptr);
png_ptr 994 pngwrite.c if (png_ptr == NULL)
png_ptr 998 pngwrite.c if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
png_ptr 1010 pngwrite.c case 7: png_app_error(png_ptr, "Unknown row filter for method 0");
png_ptr 1014 pngwrite.c png_ptr->do_filter = PNG_FILTER_NONE; break;
png_ptr 1018 pngwrite.c png_ptr->do_filter = PNG_FILTER_SUB; break;
png_ptr 1021 pngwrite.c png_ptr->do_filter = PNG_FILTER_UP; break;
png_ptr 1024 pngwrite.c png_ptr->do_filter = PNG_FILTER_AVG; break;
png_ptr 1027 pngwrite.c png_ptr->do_filter = PNG_FILTER_PAETH; break;
png_ptr 1030 pngwrite.c png_ptr->do_filter = (png_byte)filters; break;
png_ptr 1033 pngwrite.c png_app_error(png_ptr, "Unknown row filter for method 0");
png_ptr 1046 pngwrite.c if (png_ptr->row_buf != NULL)
png_ptr 1049 pngwrite.c if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)
png_ptr 1051 pngwrite.c png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
png_ptr 1052 pngwrite.c (png_ptr->rowbytes + 1));
png_ptr 1053 pngwrite.c png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
png_ptr 1056 pngwrite.c if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)
png_ptr 1058 pngwrite.c if (png_ptr->prev_row == NULL)
png_ptr 1060 pngwrite.c png_warning(png_ptr, "Can't add Up filter after starting");
png_ptr 1061 pngwrite.c png_ptr->do_filter = (png_byte)(png_ptr->do_filter &
png_ptr 1067 pngwrite.c png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
png_ptr 1068 pngwrite.c (png_ptr->rowbytes + 1));
png_ptr 1069 pngwrite.c png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
png_ptr 1073 pngwrite.c if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)
png_ptr 1075 pngwrite.c if (png_ptr->prev_row == NULL)
png_ptr 1077 pngwrite.c png_warning(png_ptr, "Can't add Average filter after starting");
png_ptr 1078 pngwrite.c png_ptr->do_filter = (png_byte)(png_ptr->do_filter &
png_ptr 1084 pngwrite.c png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
png_ptr 1085 pngwrite.c (png_ptr->rowbytes + 1));
png_ptr 1086 pngwrite.c png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
png_ptr 1090 pngwrite.c if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&
png_ptr 1091 pngwrite.c png_ptr->paeth_row == NULL)
png_ptr 1093 pngwrite.c if (png_ptr->prev_row == NULL)
png_ptr 1095 pngwrite.c png_warning(png_ptr, "Can't add Paeth filter after starting");
png_ptr 1096 pngwrite.c png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);
png_ptr 1101 pngwrite.c png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
png_ptr 1102 pngwrite.c (png_ptr->rowbytes + 1));
png_ptr 1103 pngwrite.c png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
png_ptr 1107 pngwrite.c if (png_ptr->do_filter == PNG_NO_FILTERS)
png_ptr 1109 pngwrite.c png_ptr->do_filter = PNG_FILTER_NONE;
png_ptr 1113 pngwrite.c png_error(png_ptr, "Unknown custom filter method");
png_ptr 1133 pngwrite.c png_ptr->num_prev_filters = 0;
png_ptr 1134 pngwrite.c png_ptr->heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;
png_ptr 1135 pngwrite.c if (png_ptr->prev_filters != NULL)
png_ptr 1137 pngwrite.c png_bytep old = png_ptr->prev_filters;
png_ptr 1138 pngwrite.c png_ptr->prev_filters = NULL;
png_ptr 1139 pngwrite.c png_free(png_ptr, old);
png_ptr 1141 pngwrite.c if (png_ptr->filter_weights != NULL)
png_ptr 1143 pngwrite.c png_uint_16p old = png_ptr->filter_weights;
png_ptr 1144 pngwrite.c png_ptr->filter_weights = NULL;
png_ptr 1145 pngwrite.c png_free(png_ptr, old);
png_ptr 1148 pngwrite.c if (png_ptr->inv_filter_weights != NULL)
png_ptr 1150 pngwrite.c png_uint_16p old = png_ptr->inv_filter_weights;
png_ptr 1151 pngwrite.c png_ptr->inv_filter_weights = NULL;
png_ptr 1152 pngwrite.c png_free(png_ptr, old);
png_ptr 1162 pngwrite.c if (png_ptr == NULL)
png_ptr 1166 pngwrite.c png_reset_filter_heuristics(png_ptr);
png_ptr 1178 pngwrite.c png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,
png_ptr 1184 pngwrite.c png_ptr->prev_filters[i] = 255;
png_ptr 1187 pngwrite.c png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,
png_ptr 1190 pngwrite.c png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,
png_ptr 1195 pngwrite.c png_ptr->inv_filter_weights[i] =
png_ptr 1196 pngwrite.c png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
png_ptr 1200 pngwrite.c png_ptr->num_prev_filters = (png_byte)num_weights;
png_ptr 1206 pngwrite.c if (png_ptr->filter_costs == NULL)
png_ptr 1208 pngwrite.c png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,
png_ptr 1211 pngwrite.c png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,
png_ptr 1217 pngwrite.c png_ptr->inv_filter_costs[i] =
png_ptr 1218 pngwrite.c png_ptr->filter_costs[i] = PNG_COST_FACTOR;
png_ptr 1222 pngwrite.c png_ptr->heuristic_method = PNG_FILTER_HEURISTIC_WEIGHTED;
png_ptr 1234 pngwrite.c png_warning(png_ptr, "Unknown filter heuristic method");
png_ptr 1251 pngwrite.c if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights))
png_ptr 1262 pngwrite.c png_ptr->inv_filter_weights[i] =
png_ptr 1263 pngwrite.c png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
png_ptr 1268 pngwrite.c png_ptr->inv_filter_weights[i] =
png_ptr 1271 pngwrite.c png_ptr->filter_weights[i] =
png_ptr 1285 pngwrite.c png_ptr->inv_filter_costs[i] =
png_ptr 1288 pngwrite.c png_ptr->filter_costs[i] =
png_ptr 1306 pngwrite.c if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights))
png_ptr 1317 pngwrite.c png_ptr->inv_filter_weights[i] =
png_ptr 1318 pngwrite.c png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
png_ptr 1323 pngwrite.c png_ptr->inv_filter_weights[i] = (png_uint_16)
png_ptr 1326 pngwrite.c png_ptr->filter_weights[i] = (png_uint_16)((PNG_WEIGHT_FACTOR*
png_ptr 1350 pngwrite.c png_ptr->inv_filter_costs[i] = (png_uint_16)tmp;
png_ptr 1355 pngwrite.c png_ptr->filter_costs[i] = (png_uint_16)tmp;
png_ptr 1367 pngwrite.c if (png_ptr == NULL)
png_ptr 1370 pngwrite.c png_ptr->zlib_level = level;
png_ptr 1378 pngwrite.c if (png_ptr == NULL)
png_ptr 1381 pngwrite.c png_ptr->zlib_mem_level = mem_level;
png_ptr 1389 pngwrite.c if (png_ptr == NULL)
png_ptr 1394 pngwrite.c png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
png_ptr 1395 pngwrite.c png_ptr->zlib_strategy = strategy;
png_ptr 1404 pngwrite.c if (png_ptr == NULL)
png_ptr 1415 pngwrite.c png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
png_ptr 1421 pngwrite.c png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
png_ptr 1425 pngwrite.c png_ptr->zlib_window_bits = window_bits;
png_ptr 1433 pngwrite.c if (png_ptr == NULL)
png_ptr 1440 pngwrite.c png_warning(png_ptr, "Only compression method 8 is supported by PNG");
png_ptr 1442 pngwrite.c png_ptr->zlib_method = method;
png_ptr 1452 pngwrite.c if (png_ptr == NULL)
png_ptr 1455 pngwrite.c png_ptr->zlib_text_level = level;
png_ptr 1463 pngwrite.c if (png_ptr == NULL)
png_ptr 1466 pngwrite.c png_ptr->zlib_text_mem_level = mem_level;
png_ptr 1474 pngwrite.c if (png_ptr == NULL)
png_ptr 1477 pngwrite.c png_ptr->zlib_text_strategy = strategy;
png_ptr 1486 pngwrite.c if (png_ptr == NULL)
png_ptr 1491 pngwrite.c png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
png_ptr 1497 pngwrite.c png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
png_ptr 1501 pngwrite.c png_ptr->zlib_text_window_bits = window_bits;
png_ptr 1509 pngwrite.c if (png_ptr == NULL)
png_ptr 1513 pngwrite.c png_warning(png_ptr, "Only compression method 8 is supported by PNG");
png_ptr 1515 pngwrite.c png_ptr->zlib_text_method = method;
png_ptr 1523 pngwrite.c if (png_ptr == NULL)
png_ptr 1526 pngwrite.c png_ptr->write_row_fn = write_row_fn;
png_ptr 1536 pngwrite.c if (png_ptr == NULL)
png_ptr 1539 pngwrite.c png_ptr->transformations |= PNG_USER_TRANSFORM;
png_ptr 1540 pngwrite.c png_ptr->write_user_transform_fn = write_user_transform_fn;
png_ptr 1550 pngwrite.c if (png_ptr == NULL || info_ptr == NULL)
png_ptr 1555 pngwrite.c png_app_error(png_ptr, "no rows for png_write_image to write");
png_ptr 1560 pngwrite.c png_write_info(png_ptr, info_ptr);
png_ptr 1567 pngwrite.c png_set_invert_mono(png_ptr);
png_ptr 1569 pngwrite.c png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
png_ptr 1578 pngwrite.c png_set_shift(png_ptr, &info_ptr->sig_bit);
png_ptr 1580 pngwrite.c png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
png_ptr 1586 pngwrite.c png_set_packing(png_ptr);
png_ptr 1588 pngwrite.c png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
png_ptr 1594 pngwrite.c png_set_swap_alpha(png_ptr);
png_ptr 1596 pngwrite.c png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
png_ptr 1610 pngwrite.c png_app_error(png_ptr,
png_ptr 1614 pngwrite.c png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
png_ptr 1618 pngwrite.c png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
png_ptr 1620 pngwrite.c png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_FILLER not supported");
png_ptr 1627 pngwrite.c png_set_bgr(png_ptr);
png_ptr 1629 pngwrite.c png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
png_ptr 1635 pngwrite.c png_set_swap(png_ptr);
png_ptr 1637 pngwrite.c png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
png_ptr 1643 pngwrite.c png_set_packswap(png_ptr);
png_ptr 1645 pngwrite.c png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
png_ptr 1651 pngwrite.c png_set_invert_alpha(png_ptr);
png_ptr 1653 pngwrite.c png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
png_ptr 1659 pngwrite.c png_write_image(png_ptr, info_ptr->row_pointers);
png_ptr 1662 pngwrite.c png_write_end(png_ptr, info_ptr);
png_ptr 1675 pngwrite.c png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, image,
png_ptr 1678 pngwrite.c if (png_ptr != NULL)
png_ptr 1680 pngwrite.c png_infop info_ptr = png_create_info_struct(png_ptr);
png_ptr 1685 pngwrite.c png_malloc_warn(png_ptr, (sizeof *control)));
png_ptr 1691 pngwrite.c control->png_ptr = png_ptr;
png_ptr 1700 pngwrite.c png_destroy_info_struct(png_ptr, &info_ptr);
png_ptr 1703 pngwrite.c png_destroy_write_struct(&png_ptr, NULL);
png_ptr 1734 pngwrite.c png_structrp png_ptr = image->opaque->png_ptr;
png_ptr 1760 pngwrite.c png_error(png_ptr, "png_write_image: internal call error");
png_ptr 1823 pngwrite.c png_write_row(png_ptr, png_voidcast(png_const_bytep, display->local_row));
png_ptr 1891 pngwrite.c png_structrp png_ptr = image->opaque->png_ptr;
png_ptr 1947 pngwrite.c png_write_row(png_ptr, png_voidcast(png_const_bytep,
png_ptr 1973 pngwrite.c png_write_row(png_ptr, output_row);
png_ptr 2117 pngwrite.c png_set_PLTE(image->opaque->png_ptr, image->opaque->info_ptr, palette,
png_ptr 2121 pngwrite.c png_set_tRNS(image->opaque->png_ptr, image->opaque->info_ptr, tRNS,
png_ptr 2133 pngwrite.c png_structrp png_ptr = image->opaque->png_ptr;
png_ptr 2144 pngwrite.c png_set_benign_errors(png_ptr, 0/*error*/);
png_ptr 2158 pngwrite.c png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
png_ptr 2167 pngwrite.c png_error(image->opaque->png_ptr,
png_ptr 2172 pngwrite.c png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
png_ptr 2187 pngwrite.c png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_LINEAR);
png_ptr 2190 pngwrite.c png_set_cHRM_fixed(png_ptr, info_ptr,
png_ptr 2200 pngwrite.c png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
png_ptr 2206 pngwrite.c png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_sRGB_INVERSE);
png_ptr 2209 pngwrite.c png_write_info(png_ptr, info_ptr);
png_ptr 2221 pngwrite.c png_set_swap(png_ptr);
png_ptr 2228 pngwrite.c png_set_bgr(png_ptr);
png_ptr 2237 pngwrite.c png_set_swap_alpha(png_ptr);
png_ptr 2246 pngwrite.c png_set_packing(png_ptr);
png_ptr 2251 pngwrite.c png_error(png_ptr, "png_write_image: unsupported transformation");
png_ptr 2270 pngwrite.c png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_NO_FILTERS);
png_ptr 2276 pngwrite.c png_set_compression_level(png_ptr, 3);
png_ptr 2285 pngwrite.c png_bytep row = png_voidcast(png_bytep, png_malloc(png_ptr,
png_ptr 2286 pngwrite.c png_get_rowbytes(png_ptr, info_ptr)));
png_ptr 2296 pngwrite.c png_free(png_ptr, row);
png_ptr 2314 pngwrite.c png_write_row(png_ptr, row);
png_ptr 2319 pngwrite.c png_write_end(png_ptr, info_ptr);
png_ptr 2341 pngwrite.c image->opaque->png_ptr->io_ptr = file;
png_ptr 504 pngwtran.c if (png_ptr == NULL)
png_ptr 508 pngwtran.c if (png_ptr->transformations & PNG_USER_TRANSFORM)
png_ptr 509 pngwtran.c if (png_ptr->write_user_transform_fn != NULL)
png_ptr 510 pngwtran.c (*(png_ptr->write_user_transform_fn)) /* User write transform
png_ptr 512 pngwtran.c (png_ptr, /* png_ptr */
png_ptr 520 pngwtran.c png_ptr->row_buf + 1); /* start of pixel data for row */
png_ptr 524 pngwtran.c if (png_ptr->transformations & PNG_FILLER)
png_ptr 525 pngwtran.c png_do_strip_channel(row_info, png_ptr->row_buf + 1,
png_ptr 526 pngwtran.c !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
png_ptr 530 pngwtran.c if (png_ptr->transformations & PNG_PACKSWAP)
png_ptr 531 pngwtran.c png_do_packswap(row_info, png_ptr->row_buf + 1);
png_ptr 535 pngwtran.c if (png_ptr->transformations & PNG_PACK)
png_ptr 536 pngwtran.c png_do_pack(row_info, png_ptr->row_buf + 1,
png_ptr 537 pngwtran.c (png_uint_32)png_ptr->bit_depth);
png_ptr 541 pngwtran.c if (png_ptr->transformations & PNG_SWAP_BYTES)
png_ptr 542 pngwtran.c png_do_swap(row_info, png_ptr->row_buf + 1);
png_ptr 546 pngwtran.c if (png_ptr->transformations & PNG_SHIFT)
png_ptr 547 pngwtran.c png_do_shift(row_info, png_ptr->row_buf + 1,
png_ptr 548 pngwtran.c &(png_ptr->shift));
png_ptr 552 pngwtran.c if (png_ptr->transformations & PNG_SWAP_ALPHA)
png_ptr 553 pngwtran.c png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1);
png_ptr 557 pngwtran.c if (png_ptr->transformations & PNG_INVERT_ALPHA)
png_ptr 558 pngwtran.c png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1);
png_ptr 562 pngwtran.c if (png_ptr->transformations & PNG_BGR)
png_ptr 563 pngwtran.c png_do_bgr(row_info, png_ptr->row_buf + 1);
png_ptr 567 pngwtran.c if (png_ptr->transformations & PNG_INVERT_MONO)
png_ptr 568 pngwtran.c png_do_invert(row_info, png_ptr->row_buf + 1);
png_ptr 57 pngwutil.c png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;
png_ptr 61 pngwutil.c png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
png_ptr 62 pngwutil.c (png_size_t)(8 - png_ptr->sig_bytes));
png_ptr 64 pngwutil.c if (png_ptr->sig_bytes < 3)
png_ptr 65 pngwutil.c png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
png_ptr 83 pngwutil.c if (png_ptr == NULL)
png_ptr 90 pngwutil.c png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;
png_ptr 96 pngwutil.c png_write_data(png_ptr, buf, 8);
png_ptr 99 pngwutil.c png_ptr->chunk_name = chunk_name;
png_ptr 102 pngwutil.c png_reset_crc(png_ptr);
png_ptr 104 pngwutil.c png_calculate_crc(png_ptr, buf + 4, 4);
png_ptr 110 pngwutil.c png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;
png_ptr 118 pngwutil.c png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length);
png_ptr 131 pngwutil.c if (png_ptr == NULL)
png_ptr 136 pngwutil.c png_write_data(png_ptr, data, length);
png_ptr 141 pngwutil.c png_calculate_crc(png_ptr, data, length);
png_ptr 151 pngwutil.c if (png_ptr == NULL) return;
png_ptr 157 pngwutil.c png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
png_ptr 161 pngwutil.c png_save_uint_32(buf, png_ptr->crc);
png_ptr 163 pngwutil.c png_write_data(png_ptr, buf, (png_size_t)4);
png_ptr 179 pngwutil.c if (png_ptr == NULL)
png_ptr 184 pngwutil.c png_error(png_ptr, "length exceeds PNG maximum");
png_ptr 186 pngwutil.c png_write_chunk_header(png_ptr, chunk_name, (png_uint_32)length);
png_ptr 187 pngwutil.c png_write_chunk_data(png_ptr, data, length);
png_ptr 188 pngwutil.c png_write_chunk_end(png_ptr);
png_ptr 196 pngwutil.c png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,
png_ptr 210 pngwutil.c png_uint_32 h = png_ptr->height;
png_ptr 212 pngwutil.c if (png_ptr->rowbytes < 32768 && h < 32768)
png_ptr 214 pngwutil.c if (png_ptr->interlaced)
png_ptr 219 pngwutil.c png_uint_32 w = png_ptr->width;
png_ptr 220 pngwutil.c unsigned int pd = png_ptr->pixel_depth;
png_ptr 236 pngwutil.c return (png_ptr->rowbytes+1) * h;
png_ptr 298 pngwutil.c if (png_ptr->zowner != 0)
png_ptr 306 pngwutil.c PNG_STRING_FROM_CHUNK(msg+6, png_ptr->zowner);
png_ptr 314 pngwutil.c png_warning(png_ptr, msg);
png_ptr 317 pngwutil.c if (png_ptr->zowner == png_IDAT) /* don't steal from IDAT */
png_ptr 319 pngwutil.c png_ptr->zstream.msg = PNGZ_MSG_CAST("in use by IDAT");
png_ptr 323 pngwutil.c png_ptr->zowner = 0;
png_ptr 325 pngwutil.c png_error(png_ptr, msg);
png_ptr 330 pngwutil.c int level = png_ptr->zlib_level;
png_ptr 331 pngwutil.c int method = png_ptr->zlib_method;
png_ptr 332 pngwutil.c int windowBits = png_ptr->zlib_window_bits;
png_ptr 333 pngwutil.c int memLevel = png_ptr->zlib_mem_level;
png_ptr 339 pngwutil.c if (png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)
png_ptr 340 pngwutil.c strategy = png_ptr->zlib_strategy;
png_ptr 342 pngwutil.c else if (png_ptr->do_filter != PNG_FILTER_NONE)
png_ptr 352 pngwutil.c level = png_ptr->zlib_text_level;
png_ptr 353 pngwutil.c method = png_ptr->zlib_text_method;
png_ptr 354 pngwutil.c windowBits = png_ptr->zlib_text_window_bits;
png_ptr 355 pngwutil.c memLevel = png_ptr->zlib_text_mem_level;
png_ptr 356 pngwutil.c strategy = png_ptr->zlib_text_strategy;
png_ptr 391 pngwutil.c if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) &&
png_ptr 392 pngwutil.c (png_ptr->zlib_set_level != level ||
png_ptr 393 pngwutil.c png_ptr->zlib_set_method != method ||
png_ptr 394 pngwutil.c png_ptr->zlib_set_window_bits != windowBits ||
png_ptr 395 pngwutil.c png_ptr->zlib_set_mem_level != memLevel ||
png_ptr 396 pngwutil.c png_ptr->zlib_set_strategy != strategy))
png_ptr 398 pngwutil.c if (deflateEnd(&png_ptr->zstream) != Z_OK)
png_ptr 399 pngwutil.c png_warning(png_ptr, "deflateEnd failed (ignored)");
png_ptr 401 pngwutil.c png_ptr->flags &= ~PNG_FLAG_ZSTREAM_INITIALIZED;
png_ptr 407 pngwutil.c png_ptr->zstream.next_in = NULL;
png_ptr 408 pngwutil.c png_ptr->zstream.avail_in = 0;
png_ptr 409 pngwutil.c png_ptr->zstream.next_out = NULL;
png_ptr 410 pngwutil.c png_ptr->zstream.avail_out = 0;
png_ptr 415 pngwutil.c if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED)
png_ptr 416 pngwutil.c ret = deflateReset(&png_ptr->zstream);
png_ptr 420 pngwutil.c ret = deflateInit2(&png_ptr->zstream, level, method, windowBits,
png_ptr 424 pngwutil.c png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
png_ptr 431 pngwutil.c png_ptr->zowner = owner;
png_ptr 434 pngwutil.c png_zstream_error(png_ptr, ret);
png_ptr 454 pngwutil.c png_free(png_ptr, list);
png_ptr 506 pngwutil.c ret = png_deflate_claim(png_ptr, chunk_name, comp->input_len);
png_ptr 518 pngwutil.c png_compression_bufferp *end = &png_ptr->zbuffer_list;
png_ptr 523 pngwutil.c png_ptr->zstream.next_in = PNGZ_INPUT_CAST(comp->input);
png_ptr 524 pngwutil.c png_ptr->zstream.avail_in = 0; /* Set below */
png_ptr 525 pngwutil.c png_ptr->zstream.next_out = comp->output;
png_ptr 526 pngwutil.c png_ptr->zstream.avail_out = (sizeof comp->output);
png_ptr 528 pngwutil.c output_len = png_ptr->zstream.avail_out;
png_ptr 539 pngwutil.c png_ptr->zstream.avail_in = avail_in;
png_ptr 541 pngwutil.c if (png_ptr->zstream.avail_out == 0)
png_ptr 561 pngwutil.c (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
png_ptr 574 pngwutil.c png_ptr->zstream.next_out = next->output;
png_ptr 575 pngwutil.c png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
png_ptr 576 pngwutil.c output_len += png_ptr->zstream.avail_out;
png_ptr 583 pngwutil.c ret = deflate(&png_ptr->zstream,
png_ptr 589 pngwutil.c input_len += png_ptr->zstream.avail_in;
png_ptr 590 pngwutil.c png_ptr->zstream.avail_in = 0; /* safety */
png_ptr 597 pngwutil.c output_len -= png_ptr->zstream.avail_out;
png_ptr 598 pngwutil.c png_ptr->zstream.avail_out = 0; /* safety */
png_ptr 607 pngwutil.c png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long");
png_ptr 612 pngwutil.c png_zstream_error(png_ptr, ret);
png_ptr 615 pngwutil.c png_ptr->zowner = 0;
png_ptr 644 pngwutil.c png_compression_buffer *next = png_ptr->zbuffer_list;
png_ptr 651 pngwutil.c png_write_chunk_data(png_ptr, output, avail);
png_ptr 658 pngwutil.c avail = png_ptr->zbuffer_size;
png_ptr 665 pngwutil.c png_error(png_ptr, "error writing ancillary chunked compressed data");
png_ptr 736 pngwutil.c png_warning(png_ptr, "keyword truncated");
png_ptr 745 pngwutil.c png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'");
png_ptr 779 pngwutil.c png_ptr->channels = 1; break;
png_ptr 782 pngwutil.c png_error(png_ptr,
png_ptr 793 pngwutil.c png_error(png_ptr, "Invalid bit depth for RGB image");
png_ptr 795 pngwutil.c png_ptr->channels = 3;
png_ptr 805 pngwutil.c png_ptr->channels = 1;
png_ptr 809 pngwutil.c png_error(png_ptr, "Invalid bit depth for paletted image");
png_ptr 815 pngwutil.c png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
png_ptr 817 pngwutil.c png_ptr->channels = 2;
png_ptr 826 pngwutil.c png_error(png_ptr, "Invalid bit depth for RGBA image");
png_ptr 828 pngwutil.c png_ptr->channels = 4;
png_ptr 832 pngwutil.c png_error(png_ptr, "Invalid image color type specified");
png_ptr 837 pngwutil.c png_warning(png_ptr, "Invalid compression type specified");
png_ptr 852 pngwutil.c !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
png_ptr 853 pngwutil.c ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
png_ptr 860 pngwutil.c png_warning(png_ptr, "Invalid filter type specified");
png_ptr 868 pngwutil.c png_warning(png_ptr, "Invalid interlace type specified");
png_ptr 876 pngwutil.c png_ptr->bit_depth = (png_byte)bit_depth;
png_ptr 877 pngwutil.c png_ptr->color_type = (png_byte)color_type;
png_ptr 878 pngwutil.c png_ptr->interlaced = (png_byte)interlace_type;
png_ptr 880 pngwutil.c png_ptr->filter_type = (png_byte)filter_type;
png_ptr 882 pngwutil.c png_ptr->compression_type = (png_byte)compression_type;
png_ptr 883 pngwutil.c png_ptr->width = width;
png_ptr 884 pngwutil.c png_ptr->height = height;
png_ptr 886 pngwutil.c png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
png_ptr 887 pngwutil.c png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
png_ptr 889 pngwutil.c png_ptr->usr_width = png_ptr->width;
png_ptr 890 pngwutil.c png_ptr->usr_bit_depth = png_ptr->bit_depth;
png_ptr 891 pngwutil.c png_ptr->usr_channels = png_ptr->channels;
png_ptr 903 pngwutil.c png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
png_ptr 905 pngwutil.c if ((png_ptr->do_filter) == PNG_NO_FILTERS)
png_ptr 907 pngwutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
png_ptr 908 pngwutil.c png_ptr->bit_depth < 8)
png_ptr 909 pngwutil.c png_ptr->do_filter = PNG_FILTER_NONE;
png_ptr 912 pngwutil.c png_ptr->do_filter = PNG_ALL_FILTERS;
png_ptr 915 pngwutil.c png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */
png_ptr 934 pngwutil.c !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&
png_ptr 938 pngwutil.c if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_ptr 940 pngwutil.c png_error(png_ptr, "Invalid number of colors in palette");
png_ptr 945 pngwutil.c png_warning(png_ptr, "Invalid number of colors in palette");
png_ptr 950 pngwutil.c if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
png_ptr 952 pngwutil.c png_warning(png_ptr,
png_ptr 958 pngwutil.c png_ptr->num_palette = (png_uint_16)num_pal;
png_ptr 959 pngwutil.c png_debug1(3, "num_palette = %d", png_ptr->num_palette);
png_ptr 961 pngwutil.c png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));
png_ptr 969 pngwutil.c png_write_chunk_data(png_ptr, buf, (png_size_t)3);
png_ptr 983 pngwutil.c png_write_chunk_data(png_ptr, buf, (png_size_t)3);
png_ptr 987 pngwutil.c png_write_chunk_end(png_ptr);
png_ptr 988 pngwutil.c png_ptr->mode |= PNG_HAVE_PLTE;
png_ptr 1012 pngwutil.c if (png_ptr->zowner != png_IDAT)
png_ptr 1019 pngwutil.c if (png_ptr->zbuffer_list == NULL)
png_ptr 1021 pngwutil.c png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp,
png_ptr 1022 pngwutil.c png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
png_ptr 1023 pngwutil.c png_ptr->zbuffer_list->next = NULL;
png_ptr 1027 pngwutil.c png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next);
png_ptr 1030 pngwutil.c if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK)
png_ptr 1031 pngwutil.c png_error(png_ptr, png_ptr->zstream.msg);
png_ptr 1036 pngwutil.c png_ptr->zstream.next_out = png_ptr->zbuffer_list->output;
png_ptr 1037 pngwutil.c png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
png_ptr 1044 pngwutil.c png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
png_ptr 1045 pngwutil.c png_ptr->zstream.avail_in = 0; /* set below */
png_ptr 1056 pngwutil.c png_ptr->zstream.avail_in = avail;
png_ptr 1059 pngwutil.c ret = deflate(&png_ptr->zstream, input_len > 0 ? Z_NO_FLUSH : flush);
png_ptr 1062 pngwutil.c input_len += png_ptr->zstream.avail_in;
png_ptr 1063 pngwutil.c png_ptr->zstream.avail_in = 0;
png_ptr 1069 pngwutil.c if (png_ptr->zstream.avail_out == 0)
png_ptr 1071 pngwutil.c png_bytep data = png_ptr->zbuffer_list->output;
png_ptr 1072 pngwutil.c uInt size = png_ptr->zbuffer_size;
png_ptr 1078 pngwutil.c if (!(png_ptr->mode & PNG_HAVE_IDAT) &&
png_ptr 1079 pngwutil.c png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
png_ptr 1080 pngwutil.c optimize_cmf(data, png_image_size(png_ptr));
png_ptr 1083 pngwutil.c png_write_complete_chunk(png_ptr, png_IDAT, data, size);
png_ptr 1084 pngwutil.c png_ptr->mode |= PNG_HAVE_IDAT;
png_ptr 1086 pngwutil.c png_ptr->zstream.next_out = data;
png_ptr 1087 pngwutil.c png_ptr->zstream.avail_out = size;
png_ptr 1109 pngwutil.c png_error(png_ptr, "Z_OK on Z_FINISH with output space");
png_ptr 1120 pngwutil.c png_bytep data = png_ptr->zbuffer_list->output;
png_ptr 1121 pngwutil.c uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out;
png_ptr 1124 pngwutil.c if (!(png_ptr->mode & PNG_HAVE_IDAT) &&
png_ptr 1125 pngwutil.c png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
png_ptr 1126 pngwutil.c optimize_cmf(data, png_image_size(png_ptr));
png_ptr 1129 pngwutil.c png_write_complete_chunk(png_ptr, png_IDAT, data, size);
png_ptr 1130 pngwutil.c png_ptr->zstream.avail_out = 0;
png_ptr 1131 pngwutil.c png_ptr->zstream.next_out = NULL;
png_ptr 1132 pngwutil.c png_ptr->mode |= PNG_HAVE_IDAT | PNG_AFTER_IDAT;
png_ptr 1134 pngwutil.c png_ptr->zowner = 0; /* Release the stream */
png_ptr 1141 pngwutil.c png_zstream_error(png_ptr, ret);
png_ptr 1142 pngwutil.c png_error(png_ptr, png_ptr->zstream.msg);
png_ptr 1153 pngwutil.c png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0);
png_ptr 1154 pngwutil.c png_ptr->mode |= PNG_HAVE_IEND;
png_ptr 1168 pngwutil.c png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
png_ptr 1182 pngwutil.c png_warning(png_ptr,
png_ptr 1186 pngwutil.c png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
png_ptr 1208 pngwutil.c png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */
png_ptr 1213 pngwutil.c png_error(png_ptr, "ICC profile too short");
png_ptr 1217 pngwutil.c png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)");
png_ptr 1223 pngwutil.c png_error(png_ptr, "Profile length does not match profile");
png_ptr 1226 pngwutil.c name_len = png_check_keyword(png_ptr, name, new_name);
png_ptr 1229 pngwutil.c png_error(png_ptr, "iCCP: invalid keyword");
png_ptr 1239 pngwutil.c if (png_text_compress(png_ptr, png_iCCP, &comp, name_len) != Z_OK)
png_ptr 1240 pngwutil.c png_error(png_ptr, png_ptr->zstream.msg);
png_ptr 1242 pngwutil.c png_write_chunk_header(png_ptr, png_iCCP, name_len + comp.output_len);
png_ptr 1244 pngwutil.c png_write_chunk_data(png_ptr, new_name, name_len);
png_ptr 1246 pngwutil.c png_write_compressed_data_out(png_ptr, &comp);
png_ptr 1248 pngwutil.c png_write_chunk_end(png_ptr);
png_ptr 1269 pngwutil.c name_len = png_check_keyword(png_ptr, spalette->name, new_name);
png_ptr 1272 pngwutil.c png_error(png_ptr, "sPLT: invalid keyword");
png_ptr 1275 pngwutil.c png_write_chunk_header(png_ptr, png_sPLT,
png_ptr 1278 pngwutil.c png_write_chunk_data(png_ptr, (png_bytep)new_name,
png_ptr 1281 pngwutil.c png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1);
png_ptr 1305 pngwutil.c png_write_chunk_data(png_ptr, entrybuf, entry_size);
png_ptr 1329 pngwutil.c png_write_chunk_data(png_ptr, entrybuf, entry_size);
png_ptr 1333 pngwutil.c png_write_chunk_end(png_ptr);
png_ptr 1353 pngwutil.c png_ptr->usr_bit_depth);
png_ptr 1359 pngwutil.c png_warning(png_ptr, "Invalid sBIT depth specified");
png_ptr 1371 pngwutil.c if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
png_ptr 1373 pngwutil.c png_warning(png_ptr, "Invalid sBIT depth specified");
png_ptr 1383 pngwutil.c if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
png_ptr 1385 pngwutil.c png_warning(png_ptr, "Invalid sBIT depth specified");
png_ptr 1392 pngwutil.c png_write_complete_chunk(png_ptr, png_sBIT, buf, size);
png_ptr 1418 pngwutil.c png_write_complete_chunk(png_ptr, png_cHRM, buf, 32);
png_ptr 1434 pngwutil.c if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
png_ptr 1436 pngwutil.c png_app_warning(png_ptr,
png_ptr 1442 pngwutil.c png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha,
png_ptr 1449 pngwutil.c if (tran->gray >= (1 << png_ptr->bit_depth))
png_ptr 1451 pngwutil.c png_app_warning(png_ptr,
png_ptr 1458 pngwutil.c png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
png_ptr 1468 pngwutil.c if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
png_ptr 1473 pngwutil.c png_app_warning(png_ptr,
png_ptr 1478 pngwutil.c png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
png_ptr 1483 pngwutil.c png_app_warning(png_ptr, "Can't write tRNS with an alpha channel");
png_ptr 1501 pngwutil.c (png_ptr->num_palette ||
png_ptr 1502 pngwutil.c (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&
png_ptr 1504 pngwutil.c back->index >= png_ptr->num_palette)
png_ptr 1506 pngwutil.c png_warning(png_ptr, "Invalid background palette index");
png_ptr 1511 pngwutil.c png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
png_ptr 1520 pngwutil.c if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
png_ptr 1525 pngwutil.c png_warning(png_ptr,
png_ptr 1531 pngwutil.c png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
png_ptr 1536 pngwutil.c if (back->gray >= (1 << png_ptr->bit_depth))
png_ptr 1538 pngwutil.c png_warning(png_ptr,
png_ptr 1545 pngwutil.c png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
png_ptr 1560 pngwutil.c if (num_hist > (int)png_ptr->num_palette)
png_ptr 1563 pngwutil.c png_ptr->num_palette);
png_ptr 1565 pngwutil.c png_warning(png_ptr, "Invalid number of histogram entries specified");
png_ptr 1569 pngwutil.c png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
png_ptr 1574 pngwutil.c png_write_chunk_data(png_ptr, buf, (png_size_t)2);
png_ptr 1577 pngwutil.c png_write_chunk_end(png_ptr);
png_ptr 1592 pngwutil.c key_len = png_check_keyword(png_ptr, key, new_key);
png_ptr 1595 pngwutil.c png_error(png_ptr, "tEXt: invalid keyword");
png_ptr 1604 pngwutil.c png_error(png_ptr, "tEXt: text too long");
png_ptr 1607 pngwutil.c png_write_chunk_header(png_ptr, png_tEXt,
png_ptr 1615 pngwutil.c png_write_chunk_data(png_ptr, new_key, key_len + 1);
png_ptr 1618 pngwutil.c png_write_chunk_data(png_ptr, (png_const_bytep)text, text_len);
png_ptr 1620 pngwutil.c png_write_chunk_end(png_ptr);
png_ptr 1638 pngwutil.c png_write_tEXt(png_ptr, key, text, 0);
png_ptr 1643 pngwutil.c png_error(png_ptr, "zTXt: invalid compression type");
png_ptr 1645 pngwutil.c key_len = png_check_keyword(png_ptr, key, new_key);
png_ptr 1648 pngwutil.c png_error(png_ptr, "zTXt: invalid keyword");
png_ptr 1658 pngwutil.c if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK)
png_ptr 1659 pngwutil.c png_error(png_ptr, png_ptr->zstream.msg);
png_ptr 1662 pngwutil.c png_write_chunk_header(png_ptr, png_zTXt, key_len + comp.output_len);
png_ptr 1665 pngwutil.c png_write_chunk_data(png_ptr, new_key, key_len);
png_ptr 1668 pngwutil.c png_write_compressed_data_out(png_ptr, &comp);
png_ptr 1671 pngwutil.c png_write_chunk_end(png_ptr);
png_ptr 1688 pngwutil.c key_len = png_check_keyword(png_ptr, key, new_key);
png_ptr 1691 pngwutil.c png_error(png_ptr, "iTXt: invalid keyword");
png_ptr 1707 pngwutil.c png_error(png_ptr, "iTXt: invalid compression");
png_ptr 1744 pngwutil.c if (png_text_compress(png_ptr, png_iTXt, &comp, prefix_len) != Z_OK)
png_ptr 1745 pngwutil.c png_error(png_ptr, png_ptr->zstream.msg);
png_ptr 1751 pngwutil.c png_error(png_ptr, "iTXt: uncompressed text too long");
png_ptr 1757 pngwutil.c png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len);
png_ptr 1759 pngwutil.c png_write_chunk_data(png_ptr, new_key, key_len);
png_ptr 1761 pngwutil.c png_write_chunk_data(png_ptr, (png_const_bytep)lang, lang_len);
png_ptr 1763 pngwutil.c png_write_chunk_data(png_ptr, (png_const_bytep)lang_key, lang_key_len);
png_ptr 1766 pngwutil.c png_write_compressed_data_out(png_ptr, &comp);
png_ptr 1769 pngwutil.c png_write_chunk_data(png_ptr, (png_const_bytep)text, comp.input_len);
png_ptr 1771 pngwutil.c png_write_chunk_end(png_ptr);
png_ptr 1786 pngwutil.c png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
png_ptr 1792 pngwutil.c png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
png_ptr 1812 pngwutil.c png_error(png_ptr, "Unrecognized equation type for pCAL chunk");
png_ptr 1814 pngwutil.c purpose_len = png_check_keyword(png_ptr, purpose, new_purpose);
png_ptr 1817 pngwutil.c png_error(png_ptr, "pCAL: invalid keyword");
png_ptr 1826 pngwutil.c params_len = (png_size_tp)png_malloc(png_ptr,
png_ptr 1841 pngwutil.c png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len);
png_ptr 1842 pngwutil.c png_write_chunk_data(png_ptr, new_purpose, purpose_len);
png_ptr 1847 pngwutil.c png_write_chunk_data(png_ptr, buf, (png_size_t)10);
png_ptr 1848 pngwutil.c png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len);
png_ptr 1852 pngwutil.c png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]);
png_ptr 1855 pngwutil.c png_free(png_ptr, params_len);
png_ptr 1856 pngwutil.c png_write_chunk_end(png_ptr);
png_ptr 1877 pngwutil.c png_warning(png_ptr, "Can't write sCAL (buffer too small)");
png_ptr 1886 pngwutil.c png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len);
png_ptr 1902 pngwutil.c png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
png_ptr 1908 pngwutil.c png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
png_ptr 1927 pngwutil.c png_warning(png_ptr, "Invalid time specified for tIME chunk");
png_ptr 1938 pngwutil.c png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
png_ptr 1967 pngwutil.c usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth;
png_ptr 1968 pngwutil.c buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1;
png_ptr 1971 pngwutil.c png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
png_ptr 1972 pngwutil.c png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth;
png_ptr 1975 pngwutil.c png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size);
png_ptr 1977 pngwutil.c png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
png_ptr 1981 pngwutil.c if (png_ptr->do_filter & PNG_FILTER_SUB)
png_ptr 1983 pngwutil.c png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1);
png_ptr 1985 pngwutil.c png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
png_ptr 1989 pngwutil.c if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
png_ptr 1992 pngwutil.c png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, buf_size);
png_ptr 1994 pngwutil.c if (png_ptr->do_filter & PNG_FILTER_UP)
png_ptr 1996 pngwutil.c png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
png_ptr 1997 pngwutil.c png_ptr->rowbytes + 1);
png_ptr 1999 pngwutil.c png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
png_ptr 2002 pngwutil.c if (png_ptr->do_filter & PNG_FILTER_AVG)
png_ptr 2004 pngwutil.c png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
png_ptr 2005 pngwutil.c png_ptr->rowbytes + 1);
png_ptr 2007 pngwutil.c png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
png_ptr 2010 pngwutil.c if (png_ptr->do_filter & PNG_FILTER_PAETH)
png_ptr 2012 pngwutil.c png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
png_ptr 2013 pngwutil.c png_ptr->rowbytes + 1);
png_ptr 2015 pngwutil.c png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
png_ptr 2022 pngwutil.c if (png_ptr->interlaced)
png_ptr 2024 pngwutil.c if (!(png_ptr->transformations & PNG_INTERLACE))
png_ptr 2026 pngwutil.c png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
png_ptr 2029 pngwutil.c png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
png_ptr 2035 pngwutil.c png_ptr->num_rows = png_ptr->height;
png_ptr 2036 pngwutil.c png_ptr->usr_width = png_ptr->width;
png_ptr 2043 pngwutil.c png_ptr->num_rows = png_ptr->height;
png_ptr 2044 pngwutil.c png_ptr->usr_width = png_ptr->width;
png_ptr 2071 pngwutil.c png_ptr->row_number++;
png_ptr 2074 pngwutil.c if (png_ptr->row_number < png_ptr->num_rows)
png_ptr 2079 pngwutil.c if (png_ptr->interlaced)
png_ptr 2081 pngwutil.c png_ptr->row_number = 0;
png_ptr 2082 pngwutil.c if (png_ptr->transformations & PNG_INTERLACE)
png_ptr 2084 pngwutil.c png_ptr->pass++;
png_ptr 2092 pngwutil.c png_ptr->pass++;
png_ptr 2094 pngwutil.c if (png_ptr->pass >= 7)
png_ptr 2097 pngwutil.c png_ptr->usr_width = (png_ptr->width +
png_ptr 2098 pngwutil.c png_pass_inc[png_ptr->pass] - 1 -
png_ptr 2099 pngwutil.c png_pass_start[png_ptr->pass]) /
png_ptr 2100 pngwutil.c png_pass_inc[png_ptr->pass];
png_ptr 2102 pngwutil.c png_ptr->num_rows = (png_ptr->height +
png_ptr 2103 pngwutil.c png_pass_yinc[png_ptr->pass] - 1 -
png_ptr 2104 pngwutil.c png_pass_ystart[png_ptr->pass]) /
png_ptr 2105 pngwutil.c png_pass_yinc[png_ptr->pass];
png_ptr 2107 pngwutil.c if (png_ptr->transformations & PNG_INTERLACE)
png_ptr 2110 pngwutil.c } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
png_ptr 2115 pngwutil.c if (png_ptr->pass < 7)
png_ptr 2117 pngwutil.c if (png_ptr->prev_row != NULL)
png_ptr 2118 pngwutil.c memset(png_ptr->prev_row, 0,
png_ptr 2119 pngwutil.c (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
png_ptr 2120 pngwutil.c png_ptr->usr_bit_depth, png_ptr->width)) + 1);
png_ptr 2129 pngwutil.c png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH);
png_ptr 2332 pngwutil.c png_byte filter_to_do = png_ptr->do_filter;
png_ptr 2335 pngwutil.c int num_p_filters = png_ptr->num_prev_filters;
png_ptr 2341 pngwutil.c if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS)
png_ptr 2351 pngwutil.c prev_row = png_ptr->prev_row;
png_ptr 2353 pngwutil.c best_row = png_ptr->row_buf;
png_ptr 2400 pngwutil.c if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
png_ptr 2410 pngwutil.c if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
png_ptr 2412 pngwutil.c sumlo = (sumlo * png_ptr->filter_weights[j]) >>
png_ptr 2415 pngwutil.c sumhi = (sumhi * png_ptr->filter_weights[j]) >>
png_ptr 2424 pngwutil.c sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
png_ptr 2427 pngwutil.c sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
png_ptr 2447 pngwutil.c for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
png_ptr 2459 pngwutil.c best_row = png_ptr->sub_row;
png_ptr 2474 pngwutil.c if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
png_ptr 2483 pngwutil.c if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
png_ptr 2485 pngwutil.c lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
png_ptr 2488 pngwutil.c lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
png_ptr 2493 pngwutil.c lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
png_ptr 2496 pngwutil.c lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
png_ptr 2507 pngwutil.c for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
png_ptr 2527 pngwutil.c if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
png_ptr 2536 pngwutil.c if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
png_ptr 2538 pngwutil.c sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>
png_ptr 2541 pngwutil.c sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>
png_ptr 2546 pngwutil.c sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
png_ptr 2549 pngwutil.c sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
png_ptr 2563 pngwutil.c best_row = png_ptr->sub_row;
png_ptr 2573 pngwutil.c for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
png_ptr 2580 pngwutil.c best_row = png_ptr->up_row;
png_ptr 2592 pngwutil.c if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
png_ptr 2601 pngwutil.c if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
png_ptr 2603 pngwutil.c lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
png_ptr 2606 pngwutil.c lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
png_ptr 2611 pngwutil.c lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
png_ptr 2614 pngwutil.c lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
png_ptr 2625 pngwutil.c for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
png_ptr 2637 pngwutil.c if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
png_ptr 2646 pngwutil.c if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
png_ptr 2648 pngwutil.c sumlo = (sumlo * png_ptr->filter_weights[j]) >>
png_ptr 2651 pngwutil.c sumhi = (sumhi * png_ptr->filter_weights[j]) >>
png_ptr 2656 pngwutil.c sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
png_ptr 2659 pngwutil.c sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
png_ptr 2673 pngwutil.c best_row = png_ptr->up_row;
png_ptr 2683 pngwutil.c for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
png_ptr 2694 pngwutil.c best_row = png_ptr->avg_row;
png_ptr 2705 pngwutil.c if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
png_ptr 2714 pngwutil.c if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)
png_ptr 2716 pngwutil.c lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
png_ptr 2719 pngwutil.c lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
png_ptr 2724 pngwutil.c lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
png_ptr 2727 pngwutil.c lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
png_ptr 2738 pngwutil.c for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
png_ptr 2758 pngwutil.c if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
png_ptr 2767 pngwutil.c if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
png_ptr 2769 pngwutil.c sumlo = (sumlo * png_ptr->filter_weights[j]) >>
png_ptr 2772 pngwutil.c sumhi = (sumhi * png_ptr->filter_weights[j]) >>
png_ptr 2777 pngwutil.c sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
png_ptr 2780 pngwutil.c sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
png_ptr 2794 pngwutil.c best_row = png_ptr->avg_row;
png_ptr 2804 pngwutil.c for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
png_ptr 2835 pngwutil.c best_row = png_ptr->paeth_row;
png_ptr 2846 pngwutil.c if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
png_ptr 2855 pngwutil.c if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
png_ptr 2857 pngwutil.c lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
png_ptr 2860 pngwutil.c lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
png_ptr 2865 pngwutil.c lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
png_ptr 2868 pngwutil.c lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
png_ptr 2879 pngwutil.c for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
png_ptr 2933 pngwutil.c if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
png_ptr 2942 pngwutil.c if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
png_ptr 2944 pngwutil.c sumlo = (sumlo * png_ptr->filter_weights[j]) >>
png_ptr 2947 pngwutil.c sumhi = (sumhi * png_ptr->filter_weights[j]) >>
png_ptr 2952 pngwutil.c sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
png_ptr 2955 pngwutil.c sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
png_ptr 2968 pngwutil.c best_row = png_ptr->paeth_row;
png_ptr 2974 pngwutil.c png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1);
png_ptr 2979 pngwutil.c if (png_ptr->num_prev_filters > 0)
png_ptr 2985 pngwutil.c png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];
png_ptr 2988 pngwutil.c png_ptr->prev_filters[j] = best_row[0];
png_ptr 3004 pngwutil.c png_compress_IDAT(png_ptr, filtered_row, full_row_length, Z_NO_FLUSH);
png_ptr 3007 pngwutil.c if (png_ptr->prev_row != NULL)
png_ptr 3011 pngwutil.c tptr = png_ptr->prev_row;
png_ptr 3012 pngwutil.c png_ptr->prev_row = png_ptr->row_buf;
png_ptr 3013 pngwutil.c png_ptr->row_buf = tptr;
png_ptr 3017 pngwutil.c png_write_finish_row(png_ptr);
png_ptr 3020 pngwutil.c png_ptr->flush_rows++;
png_ptr 3022 pngwutil.c if (png_ptr->flush_dist > 0 &&
png_ptr 3023 pngwutil.c png_ptr->flush_rows >= png_ptr->flush_dist)
png_ptr 3025 pngwutil.c png_write_flush(png_ptr);