| |
| /* pngstub.c - stub functions for i/o and memory allocation |
| |
| libpng 1.0 beta 1 - version 0.71 |
| For conditions of distribution and use, see copyright notice in png.h |
| Copyright (c) 1995 Guy Eric Schalnat, Group 42, Inc. |
| June 26, 1995 |
| |
| This file provides a location for all input/output, memory location, |
| and error handling. Users which need special handling in these areas |
| are expected to modify the code in this file to meet their needs. See |
| the instructions at each function. */ |
| |
| #define PNG_INTERNAL |
| #include "png.h" |
| |
| /* Write the data to whatever output you are using. The default |
| routine writes to a file pointer. If you need to write to something |
| else, this is the place to do it. We suggest saving the old code |
| for future use, possibly in a #define. Note that this routine sometimes |
| gets called with very small lengths, so you should implement some kind |
| of simple buffering if you are using unbuffered writes. This should |
| never be asked to write more then 64K on a 16 bit machine. The cast |
| to png_size_t is there for insurance, but if you are having problems |
| with it, you can take it out. Just be sure to cast length to whatever |
| fwrite needs in that spot if you don't have a function prototype for |
| it. */ |
| void |
| png_write_data(png_struct *png_ptr, png_byte *data, png_uint_32 length) |
| { |
| png_uint_32 check; |
| |
| check = fwrite(data, 1, (png_size_t)length, png_ptr->fp); |
| if (check != length) |
| { |
| png_error(png_ptr, "Write Error"); |
| } |
| } |
| |
| /* Read the data from whatever input you are using. The default |
| routine reads from a file pointer. If you need to read from something |
| else, this is the place to do it. We suggest saving the old code |
| for future use. Note that this routine sometimes gets called with |
| very small lengths, so you should implement some kind of simple |
| buffering if you are using unbuffered reads. This should |
| never be asked to read more then 64K on a 16 bit machine. The cast |
| to png_size_t is there for insurance, but if you are having problems |
| with it, you can take it out. Just be sure to cast length to whatever |
| fread needs in that spot if you don't have a function prototype for |
| it. */ |
| void |
| png_read_data(png_struct *png_ptr, png_byte *data, png_uint_32 length) |
| { |
| png_uint_32 check; |
| |
| check = fread(data, 1, (size_t)length, png_ptr->fp); |
| if (check != length) |
| { |
| png_error(png_ptr, "Read Error"); |
| } |
| } |
| |
| /* Initialize the input/output for the png file. If you change |
| the read and write routines, you will probably need to change |
| this routine (or write your own). If you change the parameters |
| of this routine, remember to change png.h also. */ |
| void |
| png_init_io(png_struct *png_ptr, FILE *fp) |
| { |
| png_ptr->fp = fp; |
| } |
| |
| /* 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. */ |
| |
| /* Borland compilers have this habit of not giving you 64K chunks |
| that start on the segment in DOS mode. This has not been observed |
| in Windows, and of course it doesn't matter in 32 bit mode, as there |
| are no segments. Now libpng doesn't need that much memory normally, |
| but zlib does, so we have to normalize it, if necessary. It would be |
| better if zlib worked in less then 64K, but it doesn't, so we |
| have to deal with it. Truely, we are misusing farmalloc here, |
| as it is designed for use with huge pointers, which don't care |
| about segments. So we allocate a large amount of memory, and |
| divvy off segments when needed. |
| */ |
| #ifdef __TURBOC__ |
| #ifndef __WIN32__ |
| |
| /* NUM_SEG is the number of segments allocated at once */ |
| #define NUM_SEG 4 |
| typedef struct borland_seg_struct |
| { |
| void *mem_ptr; |
| void *seg_ptr[NUM_SEG]; |
| int seg_used[NUM_SEG]; |
| int num_used; |
| } borland_seg; |
| |
| borland_seg *save_array; |
| int num_save_array; |
| int max_save_array; |
| |
| #endif |
| #endif |
| |
| void * |
| png_large_malloc(png_struct *png_ptr, png_uint_32 size) |
| { |
| void *ret; |
| |
| #ifdef PNG_MAX_MALLOC_64K |
| if (size > (png_uint_32)65536L) |
| png_error(png_ptr, "Cannot Allocate > 64K"); |
| #endif |
| |
| #ifdef __TURBOC__ |
| # ifdef __WIN32__ |
| ret = farmalloc(size); |
| # else |
| |
| if (size == 65536L) |
| { |
| unsigned long offset; |
| if (!save_array) |
| { |
| ret = farmalloc(size); |
| offset = (unsigned long)(ret); |
| offset &= 0xffffL; |
| } |
| else |
| { |
| ret = (void *)0; |
| } |
| if (save_array || offset) |
| { |
| int i, j; |
| |
| if (ret) |
| farfree(ret); |
| ret = (void *)0; |
| |
| if (!save_array) |
| { |
| unsigned long offset; |
| png_byte huge *ptr; |
| int i; |
| |
| num_save_array = 1; |
| save_array = malloc(num_save_array * sizeof (borland_seg)); |
| if (!save_array) |
| png_error(png_ptr, "Out of Memory"); |
| save_array->mem_ptr = farmalloc( |
| (unsigned long)(NUM_SEG) * 65536L + 65528L); |
| if (!save_array->mem_ptr) |
| png_error(png_ptr, "Out of Memory"); |
| offset = (unsigned long)(ret); |
| offset &= 0xffffL; |
| ptr = save_array->mem_ptr; |
| if (offset) |
| ptr += 65536L - offset; |
| for (i = 0; i < NUM_SEG; i++, ptr += 65536L) |
| { |
| save_array->seg_ptr[i] = ptr; |
| save_array->seg_used[i] = 0; |
| } |
| save_array->num_used = 0; |
| } |
| |
| for (i = 0; i < num_save_array; i++) |
| { |
| for (j = 0; j < NUM_SEG; j++) |
| { |
| if (!save_array[i].seg_used[j]) |
| { |
| ret = save_array[i].seg_ptr[j]; |
| save_array[i].seg_used[j] = 1; |
| save_array[i].num_used++; |
| break; |
| } |
| } |
| if (ret) |
| break; |
| } |
| |
| if (!ret) |
| { |
| unsigned long offset; |
| png_byte huge *ptr; |
| |
| save_array = realloc(save_array, |
| (num_save_array + 1) * sizeof (borland_seg)); |
| if (!save_array) |
| png_error(png_ptr, "Out of Memory"); |
| save_array[num_save_array].mem_ptr = farmalloc( |
| (unsigned long)(NUM_SEG) * 65536L + 65528L); |
| if (!save_array[num_save_array].mem_ptr) |
| png_error(png_ptr, "Out of Memory"); |
| offset = (unsigned long)(ret); |
| offset &= 0xffffL; |
| ptr = save_array[num_save_array].mem_ptr; |
| if (offset) |
| ptr += 65536L - offset; |
| for (i = 0; i < NUM_SEG; i++, ptr += 65536L) |
| { |
| save_array[num_save_array].seg_ptr[i] = ptr; |
| save_array[num_save_array].seg_used[i] = 0; |
| } |
| ret = save_array[num_save_array].seg_ptr[0]; |
| save_array[num_save_array].seg_used[0] = 1; |
| save_array[num_save_array].num_used = 1; |
| num_save_array++; |
| } |
| } |
| } |
| else |
| { |
| ret = farmalloc(size); |
| } |
| |
| # endif /* __WIN32__ */ |
| #else /* __TURBOC__ */ |
| # ifdef _MSC_VER |
| ret = halloc(size, 1); |
| # else |
| /* everybody else, so normal malloc should do it. */ |
| ret = malloc(size); |
| # endif |
| #endif |
| |
| if (!ret) |
| { |
| png_error(png_ptr, "Out of Memory"); |
| } |
| |
| return ret; |
| } |
| |
| /* free a pointer allocated by png_large_malloc(). In the default |
| configuration, png_ptr is not used, but is passed in case it |
| is needed. If ptr is NULL, return without taking any action. */ |
| void |
| png_large_free(png_struct *png_ptr, void *ptr) |
| { |
| if (!png_ptr) |
| return; |
| |
| if (ptr != (void *)0) |
| { |
| #ifdef __TURBOC__ |
| # ifndef __WIN32__ |
| int i, j; |
| |
| for (i = 0; i < num_save_array; i++) |
| { |
| for (j = 0; j < NUM_SEG; j++) |
| { |
| if (ptr == save_array[i].seg_ptr[j]) |
| { |
| printf("freeing pointer: i, j: %d, %d\n", i, j); |
| save_array[i].seg_used[j] = 0; |
| ptr = 0; |
| save_array[i].num_used--; |
| if (!save_array[i].num_used) |
| { |
| int k; |
| printf("freeing array: %d\n", i); |
| num_save_array--; |
| farfree(save_array[i].mem_ptr); |
| for (k = i; k < num_save_array; k++) |
| save_array[k] = save_array[k + 1]; |
| if (!num_save_array) |
| { |
| free(save_array); |
| save_array = 0; |
| } |
| } |
| break; |
| } |
| } |
| if (!ptr) |
| break; |
| } |
| |
| # endif |
| if (ptr) |
| farfree(ptr); |
| #else |
| # ifdef _MSC_VER |
| hfree(ptr); |
| # else |
| free(ptr); |
| # endif |
| #endif |
| } |
| } |
| |
| /* Allocate memory. This is called for smallish blocks only It |
| should not get anywhere near 64K. */ |
| void * |
| png_malloc(png_struct *png_ptr, png_uint_32 size) |
| { |
| void *ret; |
| |
| if (!png_ptr) |
| return ((void *)0); |
| |
| #ifdef PNG_MAX_MALLOC_64K |
| if (size > (png_uint_32)65536L) |
| png_error(png_ptr, "Cannot Allocate > 64K"); |
| #endif |
| |
| ret = malloc((png_size_t)size); |
| |
| if (!ret) |
| { |
| png_error(png_ptr, "Out of Memory"); |
| } |
| |
| return ret; |
| } |
| |
| /* Reallocate memory. This will not get near 64K on a |
| even marginally reasonable file. */ |
| void * |
| png_realloc(png_struct *png_ptr, void *ptr, png_uint_32 size) |
| { |
| void *ret; |
| |
| if (!png_ptr) |
| return ((void *)0); |
| |
| #ifdef PNG_MAX_MALLOC_64K |
| if (size > (png_uint_32)65536L) |
| png_error(png_ptr, "Cannot Allocate > 64K"); |
| #endif |
| |
| ret = realloc(ptr, (png_size_t)size); |
| |
| if (!ret) |
| { |
| png_error(png_ptr, "Out of Memory"); |
| } |
| |
| return ret; |
| } |
| |
| /* free a pointer allocated by png_malloc(). In the default |
| configuration, png_ptr is not used, but is passed incase it |
| is needed. If ptr is NULL, return without taking any action. */ |
| void |
| png_free(png_struct *png_ptr, void *ptr) |
| { |
| if (!png_ptr) |
| return; |
| |
| if (ptr != (void *)0) |
| free(ptr); |
| } |
| |
| /* This function is called whenever there is an error. Replace with |
| however you wish to handle the error. Note that this function |
| MUST NOT return, or the program will crash */ |
| void |
| png_error(png_struct *png_ptr, char *message) |
| { |
| fprintf(stderr, "libpng error: %s\n", message); |
| |
| longjmp(png_ptr->jmpbuf, 1); |
| } |
| |
| /* This function is called when there is a warning, but the library |
| thinks it can continue anyway. You 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. */ |
| void |
| png_warning(png_struct *png_ptr, char *message) |
| { |
| if (!png_ptr) |
| return; |
| |
| fprintf(stderr, "libpng warning: %s\n", message); |
| } |
| |
