Lines Matching defs:png_ptr
26 png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
29 if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
31 png_write_sig(png_ptr); /* write PNG signature */
33 if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))
35 png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n");
36 png_ptr->mng_features_permitted=0;
40 png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
54 png_write_gAMA(png_ptr, info_ptr->gamma);
57 png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);
64 png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);
68 png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,
73 png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
79 png_write_cHRM(png_ptr,
86 png_write_cHRM_fixed(png_ptr,
106 int keep=png_handle_as_unknown(png_ptr, up->name);
111 (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
113 png_write_chunk(png_ptr, up->name, up->data, up->size);
118 png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
123 png_write_info(png_structp png_ptr, png_infop info_ptr)
131 png_write_info_before_PLTE(png_ptr, info_ptr);
134 png_write_PLTE(png_ptr, info_ptr->palette,
137 png_error(png_ptr, "Valid palette required for paletted images\n");
144 if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
152 png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values),
158 png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
162 png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
166 png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
171 png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
178 png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,
182 png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
185 png_warning(png_ptr,
192 png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
198 png_write_tIME(png_ptr, &(info_ptr->mod_time));
199 png_ptr->mode |= PNG_WROTE_tIME;
205 png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
218 png_write_iTXt(png_ptr,
225 png_warning(png_ptr, "Unable to write international text\n");
235 png_write_zTXt(png_ptr, info_ptr->text[i].key,
239 png_warning(png_ptr, "Unable to write compressed text\n");
248 png_write_tEXt(png_ptr, info_ptr->text[i].key,
252 png_warning(png_ptr, "Unable to write uncompressed text\n");
270 int keep=png_handle_as_unknown(png_ptr, up->name);
275 (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
277 png_write_chunk(png_ptr, up->name, up->data, up->size);
290 png_write_end(png_structp png_ptr, png_infop info_ptr)
293 if (!(png_ptr->mode & PNG_HAVE_IDAT))
294 png_error(png_ptr, "No IDATs written into file");
305 !(png_ptr->mode & PNG_WROTE_tIME))
306 png_write_tIME(png_ptr, &(info_ptr->mod_time));
319 png_write_iTXt(png_ptr,
326 png_warning(png_ptr, "Unable to write international text\n");
335 png_write_zTXt(png_ptr, info_ptr->text[i].key,
339 png_warning(png_ptr, "Unable to write compressed text\n");
348 png_write_tEXt(png_ptr, info_ptr->text[i].key,
351 png_warning(png_ptr, "Unable to write uncompressed text\n");
370 int keep=png_handle_as_unknown(png_ptr, up->name);
374 (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
376 png_write_chunk(png_ptr, up->name, up->data, up->size);
383 png_ptr->mode |= PNG_AFTER_IDAT;
386 png_write_IEND(png_ptr);
389 because they do not set png_ptr->output_flush_fn */
390 png_flush(png_ptr);
421 /* Initialize png_ptr structure, and allocate any memory needed */
431 /* Alternate initialize png_ptr structure, and allocate any memory needed */
438 png_structp png_ptr;
447 png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
450 png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
452 if (png_ptr == NULL)
457 png_init_mmx_flags(png_ptr); /* 1.2.0 addition */
463 png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
464 png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
471 if (setjmp(png_ptr->jmpbuf))
474 png_free(png_ptr, png_ptr->zbuf);
475 png_ptr->zbuf=NULL;
476 png_destroy_struct(png_ptr);
480 png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));
485 png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
487 png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
493 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
496 if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
513 png_warning(png_ptr, msg);
517 png_warning(png_ptr, msg);
520 png_ptr->flags=0;
522 png_error(png_ptr,
528 png_ptr->zbuf_size = PNG_ZBUF_SIZE;
529 png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
530 (png_uint_32)png_ptr->zbuf_size);
532 png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
536 png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
547 png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));
549 if (setjmp(png_ptr->jmpbuf))
553 return (png_ptr);
556 /* Initialize png_ptr structure, and allocate any memory needed */
559 png_write_init(png_structp png_ptr)
562 png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0);
566 png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,
575 png_ptr->warning_fn=NULL;
580 png_warning(png_ptr, msg);
584 png_warning(png_ptr, msg);
589 png_ptr->error_fn=NULL;
591 png_ptr->flags=0;
593 png_error(png_ptr,
598 png_ptr->error_fn=NULL;
600 png_ptr->flags=0;
602 png_error(png_ptr,
605 png_write_init_3(&png_ptr, user_png_ver, png_struct_size);
613 png_structp png_ptr=*ptr_ptr;
623 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
625 png_ptr->warning_fn=NULL;
626 png_warning(png_ptr,
637 png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));
642 png_destroy_struct(png_ptr);
643 png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
644 *ptr_ptr = png_ptr;
648 png_memset(png_ptr, 0, png_sizeof (png_struct));
652 png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
653 png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
658 png_init_mmx_flags(png_ptr); /* 1.2.0 addition */
664 png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));
667 png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
671 png_ptr->zbuf_size = PNG_ZBUF_SIZE;
672 png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
673 (png_uint_32)png_ptr->zbuf_size);
676 png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
687 png_write_rows(png_structp png_ptr, png_bytepp row,
697 png_write_row(png_ptr, *rp);
705 png_write_image(png_structp png_ptr, png_bytepp image)
715 num_pass = png_set_interlace_handling(png_ptr);
723 for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
725 png_write_row(png_ptr, *rp);
732 png_write_row(png_structp png_ptr, png_bytep row)
735 png_ptr->row_number, png_ptr->pass);
737 if (png_ptr->row_number == 0 && png_ptr->pass == 0)
740 if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
741 png_error(png_ptr,
746 if (png_ptr->transformations & PNG_INVERT_MONO)
747 png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");
750 if (png_ptr->transformations & PNG_FILLER)
751 png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined.");
754 if (png_ptr->transformations & PNG_PACKSWAP)
755 png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined.");
758 if (png_ptr->transformations & PNG_PACK)
759 png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined.");
762 if (png_ptr->transformations & PNG_SHIFT)
763 png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined.");
766 if (png_ptr->transformations & PNG_BGR)
767 png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined.");
770 if (png_ptr->transformations & PNG_SWAP_BYTES)
771 png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined.");
774 png_write_start_row(png_ptr);
779 if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
781 switch (png_ptr->pass)
784 if (png_ptr->row_number & 0x07)
786 png_write_finish_row(png_ptr);
791 if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
793 png_write_finish_row(png_ptr);
798 if ((png_ptr->row_number & 0x07) != 4)
800 png_write_finish_row(png_ptr);
805 if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)
807 png_write_finish_row(png_ptr);
812 if ((png_ptr->row_number & 0x03) != 2)
814 png_write_finish_row(png_ptr);
819 if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)
821 png_write_finish_row(png_ptr);
826 if (!(png_ptr->row_number & 0x01))
828 png_write_finish_row(png_ptr);
837 png_ptr->row_info.color_type = png_ptr->color_type;
838 png_ptr->row_info.width = png_ptr->usr_width;
839 png_ptr->row_info.channels = png_ptr->usr_channels;
840 png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;
841 png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
842 png_ptr->row_info.channels);
844 png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
845 png_ptr->row_info.width);
847 png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);
848 png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width);
849 png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);
850 png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);
851 png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);
852 png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes);
855 png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,
856 png_ptr->row_info.rowbytes);
860 if (png_ptr->interlaced && png_ptr->pass < 6 &&
861 (png_ptr->transformations & PNG_INTERLACE))
863 png_do_write_interlace(&(png_ptr->row_info),
864 png_ptr->row_buf + 1, png_ptr->pass);
866 if (!(png_ptr->row_info.width))
868 png_write_finish_row(png_ptr);
875 if (png_ptr->transformations)
876 png_do_write_transformations(png_ptr);
888 if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
889 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
892 png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
897 png_write_find_filter(png_ptr, &(png_ptr->row_info));
899 if (png_ptr->write_row_fn != NULL)
900 (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
906 png_set_flush(png_structp png_ptr, int nrows)
909 png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
914 png_write_flush(png_structp png_ptr)
920 if (png_ptr->row_number >= png_ptr->num_rows)
928 ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);
934 if (png_ptr->zstream.msg != NULL)
935 png_error(png_ptr, png_ptr->zstream.msg);
937 png_error(png_ptr, "zlib error");
940 if (!(png_ptr->zstream.avail_out))
943 png_write_IDAT(png_ptr, png_ptr->zbuf,
944 png_ptr->zbuf_size);
945 png_ptr->zstream.next_out = png_ptr->zbuf;
946 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
952 if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)
955 png_write_IDAT(png_ptr, png_ptr->zbuf,
956 png_ptr->zbuf_size - png_ptr->zstream.avail_out);
957 png_ptr->zstream.next_out = png_ptr->zbuf;
958 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
960 png_ptr->flush_rows = 0;
961 png_flush(png_ptr);
969 png_structp png_ptr = NULL;
979 png_ptr = *png_ptr_ptr;
981 free_fn = png_ptr->free_fn;
982 mem_ptr = png_ptr->mem_ptr;
991 png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
994 if (png_ptr->num_chunk_list)
996 png_free(png_ptr, png_ptr->chunk_list);
997 png_ptr->chunk_list=NULL;
998 png_ptr->num_chunk_list=0;
1011 if (png_ptr != NULL)
1013 png_write_destroy(png_ptr);
1015 png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
1018 png_destroy_struct((png_voidp)png_ptr);
1025 /* Free any memory used in png_ptr struct (old method) */
1027 png_write_destroy(png_structp png_ptr)
1041 deflateEnd(&png_ptr->zstream);
1044 png_free(png_ptr, png_ptr->zbuf);
1045 png_free(png_ptr, png_ptr->row_buf);
1046 png_free(png_ptr, png_ptr->prev_row);
1047 png_free(png_ptr, png_ptr->sub_row);
1048 png_free(png_ptr, png_ptr->up_row);
1049 png_free(png_ptr, png_ptr->avg_row);
1050 png_free(png_ptr, png_ptr->paeth_row);
1053 png_free(png_ptr, png_ptr->time_buffer);
1057 png_free(png_ptr, png_ptr->prev_filters);
1058 png_free(png_ptr, png_ptr->filter_weights);
1059 png_free(png_ptr, png_ptr->inv_filter_weights);
1060 png_free(png_ptr, png_ptr->filter_costs);
1061 png_free(png_ptr, png_ptr->inv_filter_costs);
1066 png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));
1069 error_fn = png_ptr->error_fn;
1070 warning_fn = png_ptr->warning_fn;
1071 error_ptr = png_ptr->error_ptr;
1073 free_fn = png_ptr->free_fn;
1076 png_memset(png_ptr, 0, png_sizeof (png_struct));
1078 png_ptr->error_fn = error_fn;
1079 png_ptr->warning_fn = warning_fn;
1080 png_ptr->error_ptr = error_ptr;
1082 png_ptr->free_fn = free_fn;
1086 png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));
1092 png_set_filter(png_structp png_ptr, int method, int filters)
1096 if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
1106 case 7: png_warning(png_ptr, "Unknown row filter for method 0");
1107 case PNG_FILTER_VALUE_NONE: png_ptr->do_filter=PNG_FILTER_NONE; break;
1108 case PNG_FILTER_VALUE_SUB: png_ptr->do_filter=PNG_FILTER_SUB; break;
1109 case PNG_FILTER_VALUE_UP: png_ptr->do_filter=PNG_FILTER_UP; break;
1110 case PNG_FILTER_VALUE_AVG: png_ptr->do_filter=PNG_FILTER_AVG; break;
1111 case PNG_FILTER_VALUE_PAETH: png_ptr->do_filter=PNG_FILTER_PAETH;break;
1112 default: png_ptr->do_filter = (png_byte)filters; break;
1124 if (png_ptr->row_buf != NULL)
1126 if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)
1128 png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
1129 (png_ptr->rowbytes + 1));
1130 png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
1133 if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)
1135 if (png_ptr->prev_row == NULL)
1137 png_warning(png_ptr, "Can't add Up filter after starting");
1138 png_ptr->do_filter &= ~PNG_FILTER_UP;
1142 png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
1143 (png_ptr->rowbytes + 1));
1144 png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
1148 if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)
1150 if (png_ptr->prev_row == NULL)
1152 png_warning(png_ptr, "Can't add Average filter after starting");
1153 png_ptr->do_filter &= ~PNG_FILTER_AVG;
1157 png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
1158 (png_ptr->rowbytes + 1));
1159 png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
1163 if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&
1164 png_ptr->paeth_row == NULL)
1166 if (png_ptr->prev_row == NULL)
1168 png_warning(png_ptr, "Can't add Paeth filter after starting");
1169 png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);
1173 png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
1174 (png_ptr->rowbytes + 1));
1175 png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
1179 if (png_ptr->do_filter == PNG_NO_FILTERS)
1180 png_ptr->do_filter = PNG_FILTER_NONE;
1184 png_error(png_ptr, "Unknown custom filter method");
1196 png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
1205 png_warning(png_ptr, "Unknown filter heuristic method");
1220 png_ptr->num_prev_filters = (png_byte)num_weights;
1221 png_ptr->heuristic_method = (png_byte)heuristic_method;
1225 if (png_ptr->prev_filters == NULL)
1227 png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,
1233 png_ptr->prev_filters[i] = 255;
1237 if (png_ptr->filter_weights == NULL)
1239 png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,
1242 png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,
1246 png_ptr->inv_filter_weights[i] =
1247 png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
1255 png_ptr->inv_filter_weights[i] =
1256 png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
1260 png_ptr->inv_filter_weights[i] =
1262 png_ptr->filter_weights[i] =
1269 * need to be based on png_ptr->filter.
1271 if (png_ptr->filter_costs == NULL)
1273 png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,
1276 png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,
1281 png_ptr->inv_filter_costs[i] =
1282 png_ptr->filter_costs[i] = PNG_COST_FACTOR;
1297 png_ptr->inv_filter_costs[i] =
1298 png_ptr->filter_costs[i] = PNG_COST_FACTOR;
1302 png_ptr->inv_filter_costs[i] =
1304 png_ptr->filter_costs[i] =
1312 png_set_compression_level(png_structp png_ptr, int level)
1315 png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;
1316 png_ptr->zlib_level = level;
1320 png_set_compression_mem_level(png_structp png_ptr, int mem_level)
1323 png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;
1324 png_ptr->zlib_mem_level = mem_level;
1328 png_set_compression_strategy(png_structp png_ptr, int strategy)
1331 png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
1332 png_ptr->zlib_strategy = strategy;
1336 png_set_compression_window_bits(png_structp png_ptr, int window_bits)
1339 png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
1341 png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
1346 png_warning(png_ptr, "Compression window is being reset to 512");
1350 png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;
1351 png_ptr->zlib_window_bits = window_bits;
1355 png_set_compression_method(png_structp png_ptr, int method)
1359 png_warning(png_ptr, "Only compression method 8 is supported by PNG");
1360 png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;
1361 png_ptr->zlib_method = method;
1365 png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)
1367 png_ptr->write_row_fn = write_row_fn;
1372 png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
1376 png_ptr->transformations |= PNG_USER_TRANSFORM;
1377 png_ptr->write_user_transform_fn = write_user_transform_fn;
1384 png_write_png(png_structp png_ptr, png_infop info_ptr,
1390 png_set_invert_alpha(png_ptr);
1394 png_write_info(png_ptr, info_ptr);
1401 png_set_invert_mono(png_ptr);
1410 png_set_shift(png_ptr, &info_ptr->sig_bit);
1416 png_set_packing(png_ptr);
1422 png_set_swap_alpha(png_ptr);
1430 png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
1436 png_set_bgr(png_ptr);
1442 png_set_swap(png_ptr);
1448 png_set_packswap(png_ptr);
1455 png_write_image(png_ptr, info_ptr->row_pointers);
1458 png_write_end(png_ptr, info_ptr);