}}#else/* this is the model-independent version. Since the standard I/O library   can't handle far buffers in the medium and small models, we have to copy   the data.*/#define NEAR_BUF_SIZE 1024#define MIN(a,b) (a <= b ? a : b)static voidpngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length){   png_uint_32 check;   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */   png_FILE_p io_ptr;   /* Check if data really is near. If so, use usual code. */   near_data = (png_byte *)CVT_PTR_NOCHECK(data);   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);   if ((png_bytep)near_data == data)   {      WRITEFILE(io_ptr, near_data, length, check);   }   else   {      png_byte buf[NEAR_BUF_SIZE];      png_size_t written, remaining, err;      check = 0;      remaining = length;      do      {         written = MIN(NEAR_BUF_SIZE, remaining);         png_memcpy(buf, data, written); /* copy far buffer to near buffer */         WRITEFILE(io_ptr, buf, written, err);         if (err != written)            break;         else            check += err;         data += written;         remaining -= written;      }      while (remaining != 0);   }   if (check != length)   {      png_error(png_ptr, "Write Error");   }}#endif /* USE_FAR_KEYWORD *//* This function is called when there is a warning, but the library thinks * it can continue anyway.  Replacement functions don't have to do anything * here if you don't want to.  In the default configuration, png_ptr is * not used, but it is passed in case it may be useful. */static voidpngtest_warning(png_structp png_ptr, png_const_charp message){   PNG_CONST char *name = "UNKNOWN (ERROR!)";   if (png_ptr != NULL && png_ptr->error_ptr != NULL)      name = png_ptr->error_ptr;   fprintf(STDERR, "%s: libpng warning: %s\n", name, message);}/* This is the default error handling function.  Note that replacements for * this function MUST NOT RETURN, or the program will likely crash.  This * function is used by default, or if the program supplies NULL for the * error function pointer in png_set_error_fn(). */static voidpngtest_error(png_structp png_ptr, png_const_charp message){   pngtest_warning(png_ptr, message);   /* We can return because png_error calls the default handler, which is    * actually OK in this case. */}#endif /* PNG_NO_STDIO *//* END of code to validate stdio-free compilation *//* START of code to validate memory allocation and deallocation */#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG/* Allocate memory.  For reasonable files, size should never exceed   64K.  However, zlib may allocate more then 64K if you don't tell   it not to.  See zconf.h and png.h for more information.  zlib does   need to allocate exactly 64K, so whatever you call here must   have the ability to do that.   This piece of code can be compiled to validate max 64K allocations   by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K. */typedef struct memory_information{   png_uint_32               size;   png_voidp                 pointer;   struct memory_information FAR *next;} memory_information;typedef memory_information FAR *memory_infop;static memory_infop pinformation = NULL;static int current_allocation = 0;static int maximum_allocation = 0;static int total_allocation = 0;static int num_allocations = 0;png_voidp png_debug_malloc PNGARG((png_structp png_ptr, png_uint_32 size));void png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr));png_voidppng_debug_malloc(png_structp png_ptr, png_uint_32 size){   /* png_malloc has already tested for NULL; png_create_struct calls      png_debug_malloc directly, with png_ptr == NULL which is OK */   if (size == 0)      return (NULL);   /* This calls the library allocator twice, once to get the requested      buffer and once to get a new free list entry. */   {      /* Disable malloc_fn and free_fn */      memory_infop pinfo;      png_set_mem_fn(png_ptr, NULL, NULL, NULL);      pinfo = (memory_infop)png_malloc(png_ptr,         (png_uint_32)png_sizeof (*pinfo));      pinfo->size = size;      current_allocation += size;      total_allocation += size;      num_allocations ++;      if (current_allocation > maximum_allocation)         maximum_allocation = current_allocation;      pinfo->pointer = (png_voidp)png_malloc(png_ptr, size);      /* Restore malloc_fn and free_fn */      png_set_mem_fn(png_ptr, png_voidp_NULL, (png_malloc_ptr)png_debug_malloc,         (png_free_ptr)png_debug_free);      if (size != 0 && pinfo->pointer == NULL)      {         current_allocation -= size;         total_allocation -= size;         png_error(png_ptr,           "out of memory in pngtest->png_debug_malloc.");      }      pinfo->next = pinformation;      pinformation = pinfo;      /* Make sure the caller isn't assuming zeroed memory. */      png_memset(pinfo->pointer, 0xdd, pinfo->size);      if(verbose)         printf("png_malloc %lu bytes at %x\n",size,pinfo->pointer);      assert(pinfo->size != 12345678);      return (png_voidp)(pinfo->pointer);   }}/* Free a pointer.  It is removed from the list at the same time. */voidpng_debug_free(png_structp png_ptr, png_voidp ptr){   if (png_ptr == NULL)      fprintf(STDERR, "NULL pointer to png_debug_free.\n");   if (ptr == 0)   {#if 0 /* This happens all the time. */      fprintf(STDERR, "WARNING: freeing NULL pointer\n");#endif      return;   }   /* Unlink the element from the list. */   {      memory_infop FAR *ppinfo = &pinformation;      for (;;)      {         memory_infop pinfo = *ppinfo;         if (pinfo->pointer == ptr)         {            *ppinfo = pinfo->next;            current_allocation -= pinfo->size;            if (current_allocation < 0)               fprintf(STDERR, "Duplicate free of memory\n");            /* We must free the list element too, but first kill               the memory that is to be freed. */            png_memset(ptr, 0x55, pinfo->size);            png_free_default(png_ptr, pinfo);            pinfo=NULL;            break;         }         if (pinfo->next == NULL)         {            fprintf(STDERR, "Pointer %x not found\n", (unsigned int)ptr);            break;         }         ppinfo = &pinfo->next;      }   }   /* Finally free the data. */   if(verbose)      printf("Freeing %x\n",ptr);   png_free_default(png_ptr, ptr);   ptr=NULL;}#endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG *//* END of code to test memory allocation/deallocation *//* Test one file */inttest_one_file(PNG_CONST char *inname, PNG_CONST char *outname){   static png_FILE_p fpin;   static png_FILE_p fpout;  /* "static" prevents setjmp corruption */   png_structp read_ptr;   png_infop read_info_ptr, end_info_ptr;#ifdef PNG_WRITE_SUPPORTED   png_structp write_ptr;   png_infop write_info_ptr;   png_infop write_end_info_ptr;#else   png_structp write_ptr = NULL;   png_infop write_info_ptr = NULL;   png_infop write_end_info_ptr = NULL;#endif   png_bytep row_buf;   png_uint_32 y;   png_uint_32 width, height;   int num_pass, pass;   int bit_depth, color_type;#ifdef PNG_SETJMP_SUPPORTED#ifdef USE_FAR_KEYWORD   jmp_buf jmpbuf;#endif#endif#if defined(_WIN32_WCE)   TCHAR path[MAX_PATH];#endif   char inbuf[256], outbuf[256];   row_buf = NULL;#if defined(_WIN32_WCE)   MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);   if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)#else   if ((fpin = fopen(inname, "rb")) == NULL)#endif   {      fprintf(STDERR, "Could not find input file %s\n", inname);      return (1);   }#if defined(_WIN32_WCE)   MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);   if ((fpout = CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE)#else   if ((fpout = fopen(outname, "wb")) == NULL)#endif   {      fprintf(STDERR, "Could not open output file %s\n", outname);      FCLOSE(fpin);      return (1);   }   png_debug(0, "Allocating read and write structures\n");#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG   read_ptr = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,      png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);#else   read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,      png_error_ptr_NULL, png_error_ptr_NULL);#endif#if defined(PNG_NO_STDIO)   png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,       pngtest_warning);#endif#ifdef PNG_WRITE_SUPPORTED#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG   write_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,      png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);#else   write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,      png_error_ptr_NULL, png_error_ptr_NULL);#endif#if defined(PNG_NO_STDIO)   png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,       pngtest_warning);#endif#endif   png_debug(0, "Allocating read_info, write_info and end_info structures\n");   read_info_ptr = png_create_info_struct(read_ptr);   end_info_ptr = png_create_info_struct(read_ptr);#ifdef PNG_WRITE_SUPPORTED   write_info_ptr = png_create_info_struct(write_ptr);   write_end_info_ptr = png_create_info_struct(write_ptr);#endif#ifdef PNG_SETJMP_SUPPORTED   png_debug(0, "Setting jmpbuf for read struct\n");#ifdef USE_FAR_KEYWORD   if (setjmp(jmpbuf))#else   if (setjmp(png_jmpbuf(read_ptr)))#endif   {      fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);      if (row_buf)         png_free(read_ptr, row_buf);      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);#ifdef PNG_WRITE_SUPPORTED      png_destroy_info_struct(write_ptr, &write_end_info_ptr);      png_destroy_write_struct(&write_ptr, &write_info_ptr);#endif      FCLOSE(fpin);      FCLOSE(fpout);      return (1);   }#ifdef USE_FAR_KEYWORD   png_memcpy(png_jmpbuf(read_ptr),jmpbuf,png_sizeof(jmp_buf));#endif#ifdef PNG_WRITE_SUPPORTED   png_debug(0, "Setting jmpbuf for write struct\n");#ifdef USE_FAR_KEYWORD   if (setjmp(jmpbuf))#else   if (setjmp(png_jmpbuf(write_ptr)))#endif   {      fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);      png_destroy_info_struct(write_ptr, &write_end_info_ptr);#ifdef PNG_WRITE_SUPPORTED      png_destroy_write_struct(&write_ptr, &write_info_ptr);#endif      FCLOSE(fpin);      FCLOSE(fpout);      return (1);   }#ifdef USE_FAR_KEYWORD   png_memcpy(png_jmpbuf(write_ptr),jmpbuf,png_sizeof(jmp_buf));#endif#endif#endif   png_debug(0, "Initializing input and output streams\n");#if !defined(PNG_NO_STDIO)   png_init_io(read_ptr, fpin);#  ifdef PNG_WRITE_SUPPORTED   png_init_io(write_ptr, fpout);#  endif#else   png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);#  ifdef PNG_WRITE_SUPPORTED   png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,#    if defined(PNG_WRITE_FLUSH_SUPPORTED)      pngtest_flush);#    else      NULL);#    endif#  endif#endif   if(status_dots_requested == 1)   {#ifdef PNG_WRITE_SUPPORTED      png_set_write_status_fn(write_ptr, write_row_callback);#endif      png_set_read_status_fn(read_ptr, read_row_callback);   }   else   {#ifdef PNG_WRITE_SUPPORTED      png_set_write_status_fn(write_ptr, png_write_status_ptr_NULL);#endif      png_set_read_status_fn(read_ptr, png_read_status_ptr_NULL);   }#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)   {     int i;     for(i=0; i<256; i++)        filters_used[i]=0;     png_set_read_user_transform_fn(read_ptr, count_filters);   }#endif#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)