Пример #1
0
/* free all memory used by the read */
void PNGAPI
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
                        png_infopp end_info_ptr_ptr)
{
    png_structp png_ptr = NULL;
    png_infop info_ptr = NULL, end_info_ptr = NULL;
#ifdef PNG_USER_MEM_SUPPORTED
    png_free_ptr free_fn = NULL;
    png_voidp mem_ptr = NULL;
#endif

    png_debug(1, "in png_destroy_read_struct\n");
    if (png_ptr_ptr != NULL)
        png_ptr = *png_ptr_ptr;

    if (info_ptr_ptr != NULL)
        info_ptr = *info_ptr_ptr;

    if (end_info_ptr_ptr != NULL)
        end_info_ptr = *end_info_ptr_ptr;

#ifdef PNG_USER_MEM_SUPPORTED
    free_fn = png_ptr->free_fn;
    mem_ptr = png_ptr->mem_ptr;
#endif

    png_read_destroy(png_ptr, info_ptr, end_info_ptr);

    if (info_ptr != NULL)
    {
#if defined(PNG_TEXT_SUPPORTED)
        png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);
#endif

#ifdef PNG_USER_MEM_SUPPORTED
        png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
                             (png_voidp)mem_ptr);
#else
        png_destroy_struct((png_voidp)info_ptr);
#endif
        *info_ptr_ptr = NULL;
    }

    if (end_info_ptr != NULL)
    {
#if defined(PNG_READ_TEXT_SUPPORTED)
        png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);
#endif
#ifdef PNG_USER_MEM_SUPPORTED
        png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,
                             (png_voidp)mem_ptr);
#else
        png_destroy_struct((png_voidp)end_info_ptr);
#endif
        *end_info_ptr_ptr = NULL;
    }

    if (png_ptr != NULL)
    {
#ifdef PNG_USER_MEM_SUPPORTED
        png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
                             (png_voidp)mem_ptr);
#else
        png_destroy_struct((png_voidp)png_ptr);
#endif
        *png_ptr_ptr = NULL;
    }
}
Пример #2
0
/* Free memory allocated by a png_create_struct() call */
void /* PRIVATE */
png_destroy_struct(png_voidp struct_ptr)
{
#ifdef PNG_USER_MEM_SUPPORTED
   png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
}
Пример #3
0
/* Alternate create PNG structure for reading, and allocate any memory needed. */
png_structp PNGAPI
png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
                         png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
                         png_malloc_ptr malloc_fn, png_free_ptr free_fn)
{
#endif /* PNG_USER_MEM_SUPPORTED */

#ifdef PNG_SETJMP_SUPPORTED
    volatile
#endif
    png_structp png_ptr;

#ifdef PNG_SETJMP_SUPPORTED
#ifdef USE_FAR_KEYWORD
    jmp_buf jmpbuf;
#endif
#endif

    int i;

    png_debug(1, "in png_create_read_struct");
#ifdef PNG_USER_MEM_SUPPORTED
    png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
              (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
#else
    png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
#endif
    if (png_ptr == NULL)
        return (NULL);

    /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED
    png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
    png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
#endif

#ifdef PNG_SETJMP_SUPPORTED
#ifdef USE_FAR_KEYWORD
    if (setjmp(jmpbuf))
#else
    if (setjmp(png_ptr->jmpbuf))
#endif
    {
        png_free(png_ptr, png_ptr->zbuf);
        png_ptr->zbuf = NULL;
#ifdef PNG_USER_MEM_SUPPORTED
        png_destroy_struct_2((png_voidp)png_ptr,
                             (png_free_ptr)free_fn, (png_voidp)mem_ptr);
#else
        png_destroy_struct((png_voidp)png_ptr);
#endif
        return (NULL);
    }
#ifdef USE_FAR_KEYWORD
    png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
#endif
#endif

#ifdef PNG_USER_MEM_SUPPORTED
    png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
#endif

    png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

    if (user_png_ver) {
        i = 0;
        do {
            if (user_png_ver[i] != png_libpng_ver[i])
                png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
        } while (png_libpng_ver[i++]);
    } else
        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;


    if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) {
        /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
         * we must recompile any applications that use any older library version.
         * For versions after libpng 1.0, we will be compatible, so we need
         * only check the first digit.
         */
        if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
                (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
                (user_png_ver[0] == '0' && user_png_ver[2] < '9')) {
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
            char msg[80];
            if (user_png_ver) {
                png_snprintf(msg, 80,
                             "Application was compiled with png.h from libpng-%.20s",
                             user_png_ver);
                png_warning(png_ptr, msg);
            }
            png_snprintf(msg, 80,
                         "Application  is  running with png.c from libpng-%.20s",
                         png_libpng_ver);
            png_warning(png_ptr, msg);
#endif
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
            png_ptr->flags = 0;
#endif
            png_error(png_ptr,
                      "Incompatible libpng version in application and library");
        }
    }

    /* Initialize zbuf - compression buffer */
    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
                                          (png_uint_32)png_ptr->zbuf_size);
    png_ptr->zstream.zalloc = png_zalloc;
    png_ptr->zstream.zfree = png_zfree;
    png_ptr->zstream.opaque = (voidpf)png_ptr;

    switch (inflateInit(&png_ptr->zstream)) {
        case Z_OK: /* Do nothing */
            break;
        case Z_MEM_ERROR:
        case Z_STREAM_ERROR:
            png_error(png_ptr, "zlib memory error");
            break;
        case Z_VERSION_ERROR:
            png_error(png_ptr, "zlib version error");
            break;
        default:
            png_error(png_ptr, "Unknown zlib error");
    }

    png_ptr->zstream.next_out = png_ptr->zbuf;
    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

    png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);

#ifdef PNG_SETJMP_SUPPORTED
    /* Applications that neglect to set up their own setjmp() and then encounter
       a png_error() will longjmp here.  Since the jmpbuf is then meaningless we
       abort instead of returning. */
#ifdef USE_FAR_KEYWORD
    if (setjmp(jmpbuf))
        PNG_ABORT();
    png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
#else
    if (setjmp(png_ptr->jmpbuf))
        PNG_ABORT();
#endif
#endif
    return (png_ptr);
}
Пример #4
0
/* Free memory allocated by a png_create_struct() call */
void
png_destroy_struct(png_voidp struct_ptr)
{
#ifdef PNG_USER_MEM_SUPPORTED
   png_destroy_struct_2(struct_ptr, (png_free_ptr)NULL);
}
Пример #5
0
/* free all memory used by the read */
void
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
   png_infopp end_info_ptr_ptr)
{
   png_structp png_ptr = NULL;
   png_infop info_ptr = NULL, end_info_ptr = NULL;
#ifdef PNG_USER_MEM_SUPPORTED
   png_free_ptr free_fn = NULL;
#endif /* PNG_USER_MEM_SUPPORTED */

   png_debug(1, "in png_destroy_read_struct\n");
   /* save jump buffer and error functions */
   if (png_ptr_ptr != NULL)
      png_ptr = *png_ptr_ptr;

   if (info_ptr_ptr != NULL)
      info_ptr = *info_ptr_ptr;

   if (end_info_ptr_ptr != NULL)
      end_info_ptr = *end_info_ptr_ptr;

#ifdef PNG_USER_MEM_SUPPORTED
   free_fn = png_ptr->free_fn;
#endif

   png_read_destroy(png_ptr, info_ptr, end_info_ptr);

   if (info_ptr != NULL)
   {
#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
      png_free(png_ptr, info_ptr->text);
#endif

#ifdef PNG_USER_MEM_SUPPORTED
      png_destroy_struct_2((png_voidp)info_ptr, free_fn);
#else
      png_destroy_struct((png_voidp)info_ptr);
#endif
      *info_ptr_ptr = (png_infop)NULL;
   }

   if (end_info_ptr != NULL)
   {
#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
      png_free(png_ptr, end_info_ptr->text);
#endif
#ifdef PNG_USER_MEM_SUPPORTED
      png_destroy_struct_2((png_voidp)end_info_ptr, free_fn);
#else
      png_destroy_struct((png_voidp)end_info_ptr);
#endif
      *end_info_ptr_ptr = (png_infop)NULL;
   }

   if (png_ptr != NULL)
   {
#ifdef PNG_USER_MEM_SUPPORTED
      png_destroy_struct_2((png_voidp)png_ptr, free_fn);
#else
      png_destroy_struct((png_voidp)png_ptr);
#endif
      *png_ptr_ptr = (png_structp)NULL;
   }
}
Пример #6
0
png_structp PNGAPI
png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
                         png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
                         png_malloc_ptr malloc_fn, png_free_ptr free_fn)
{
#endif

    png_structp png_ptr;

#ifdef PNG_SETJMP_SUPPORTED
#ifdef USE_FAR_KEYWORD
    jmp_buf jmpbuf;
#endif
#endif

    int i;

    png_debug(1, "in png_create_read_struct\n");
#ifdef PNG_USER_MEM_SUPPORTED
    png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
              (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
#else
    png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
#endif
    if (png_ptr == NULL)
        return (NULL);

#if !defined(PNG_1_0_X)
#ifdef PNG_MMX_CODE_SUPPORTED
    png_init_mmx_flags(png_ptr);
#endif
#endif


#ifdef PNG_SET_USER_LIMITS_SUPPORTED
    png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
    png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
#endif

#ifdef PNG_SETJMP_SUPPORTED
#ifdef USE_FAR_KEYWORD
    if (setjmp(jmpbuf))
#else
    if (setjmp(png_ptr->jmpbuf))
#endif
    {
        png_free(png_ptr, png_ptr->zbuf);
        png_ptr->zbuf=NULL;
#ifdef PNG_USER_MEM_SUPPORTED
        png_destroy_struct_2((png_voidp)png_ptr,
                             (png_free_ptr)free_fn, (png_voidp)mem_ptr);
#else
        png_destroy_struct((png_voidp)png_ptr);
#endif
        return (NULL);
    }
#ifdef USE_FAR_KEYWORD
    png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));
#endif
#endif

#ifdef PNG_USER_MEM_SUPPORTED
    png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
#endif

    png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

    i=0;
    do
    {
        if(user_png_ver[i] != png_libpng_ver[i])
            png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
    } while (png_libpng_ver[i++]);

    if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
    {
        if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
                (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
                (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
        {
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
            char msg[80];
            if (user_png_ver)
            {
                png_snprintf(msg, 80,
                             "Application was compiled with png.h from libpng-%.20s",
                             user_png_ver);
                png_warning(png_ptr, msg);
            }
            png_snprintf(msg, 80,
                         "Application  is  running with png.c from libpng-%.20s",
                         png_libpng_ver);
            png_warning(png_ptr, msg);
#endif
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
            png_ptr->flags=0;
#endif
            png_error(png_ptr,
                      "Incompatible libpng version in application and library");
        }
    }


    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
                                          (png_uint_32)png_ptr->zbuf_size);
    png_ptr->zstream.zalloc = png_zalloc;
    png_ptr->zstream.zfree = png_zfree;
    png_ptr->zstream.opaque = (voidpf)png_ptr;

    switch (inflateInit(&png_ptr->zstream))
    {
    case Z_OK:
        break;
    case Z_MEM_ERROR:
    case Z_STREAM_ERROR:
        png_error(png_ptr, "zlib memory error");
        break;
    case Z_VERSION_ERROR:
        png_error(png_ptr, "zlib version error");
        break;
    default:
        png_error(png_ptr, "Unknown zlib error");
    }

    png_ptr->zstream.next_out = png_ptr->zbuf;
    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

    png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);

#ifdef PNG_SETJMP_SUPPORTED
#ifdef USE_FAR_KEYWORD
    if (setjmp(jmpbuf))
        PNG_ABORT();
    png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));
#else
    if (setjmp(png_ptr->jmpbuf))
        PNG_ABORT();
#endif
#endif
    return (png_ptr);
}