Suppress -Wunused-function for pdfium's third-party libraries.
[pdfium.git] / samples / fx_lpng / lpng_v163 / fx_pngmem.c
1 /* pngmem.c - stub functions for memory allocation\r
2  *\r
3  * Last changed in libpng 1.6.0 [February 14, 2013]\r
4  * Copyright (c) 1998-2013 Glenn Randers-Pehrson\r
5  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
6  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
7  *\r
8  * This code is released under the libpng license.\r
9  * For conditions of distribution and use, see the disclaimer\r
10  * and license in png.h\r
11  *\r
12  * This file provides a location for all memory allocation.  Users who\r
13  * need special memory handling are expected to supply replacement\r
14  * functions for png_malloc() and png_free(), and to use\r
15  * png_create_read_struct_2() and png_create_write_struct_2() to\r
16  * identify the replacement functions.\r
17  */\r
18 \r
19 #include "pngpriv.h"\r
20 \r
21 #if defined(_FX_MANAGED_CODE_) && defined(__cplusplus)\r
22 extern "C" {\r
23 #endif\r
24 \r
25 void*   FXMEM_DefaultAlloc(int byte_size, int);\r
26 void    FXMEM_DefaultFree(void* pointer, int);\r
27 \r
28 #if defined(_FX_MANAGED_CODE_) && defined(__cplusplus)\r
29 }\r
30 #endif\r
31 \r
32 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
33 /* Free a png_struct */\r
34 void /* PRIVATE */\r
35 png_destroy_png_struct(png_structrp png_ptr)\r
36 {\r
37    if (png_ptr != NULL)\r
38    {\r
39       /* png_free might call png_error and may certainly call\r
40        * png_get_mem_ptr, so fake a temporary png_struct to support this.\r
41        */\r
42       png_struct dummy_struct = *png_ptr;\r
43       memset(png_ptr, 0, (sizeof *png_ptr));\r
44       png_free(&dummy_struct, png_ptr);\r
45 \r
46 #     ifdef PNG_SETJMP_SUPPORTED\r
47          /* We may have a jmp_buf left to deallocate. */\r
48          png_free_jmpbuf(&dummy_struct);\r
49 #     endif\r
50    }\r
51 }\r
52 \r
53 /* Allocate memory.  For reasonable files, size should never exceed\r
54  * 64K.  However, zlib may allocate more then 64K if you don't tell\r
55  * it not to.  See zconf.h and png.h for more information.  zlib does\r
56  * need to allocate exactly 64K, so whatever you call here must\r
57  * have the ability to do that.\r
58  */\r
59 PNG_FUNCTION(png_voidp,PNGAPI\r
60 png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)\r
61 {\r
62    png_voidp ret;\r
63 \r
64    ret = png_malloc(png_ptr, size);\r
65 \r
66    if (ret != NULL)\r
67       memset(ret, 0, size);\r
68 \r
69    return ret;\r
70 }\r
71 \r
72 /* png_malloc_base, an internal function added at libpng 1.6.0, does the work of\r
73  * allocating memory, taking into account limits and PNG_USER_MEM_SUPPORTED.\r
74  * Checking and error handling must happen outside this routine; it returns NULL\r
75  * if the allocation cannot be done (for any reason.)\r
76  */\r
77 PNG_FUNCTION(png_voidp /* PRIVATE */,\r
78 png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),\r
79    PNG_ALLOCATED)\r
80 {\r
81    /* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS\r
82     * allocators have also been removed in 1.6.0, so any 16-bit system now has\r
83     * to implement a user memory handler.  This checks to be sure it isn't\r
84     * called with big numbers.\r
85     */\r
86 #ifdef PNG_USER_MEM_SUPPORTED\r
87    PNG_UNUSED(png_ptr)\r
88 #endif\r
89    if (size > 0 && size <= PNG_SIZE_MAX\r
90 #     ifdef PNG_MAX_MALLOC_64K\r
91          && size <= 65536U\r
92 #     endif\r
93       )\r
94    {\r
95 #ifdef PNG_USER_MEM_SUPPORTED\r
96       if (png_ptr != NULL && png_ptr->malloc_fn != NULL)\r
97          return png_ptr->malloc_fn(png_constcast(png_structrp,png_ptr), size);\r
98 \r
99       else\r
100 #endif\r
101          return FXMEM_DefaultAlloc((int)size, 0);\r
102          //return malloc((size_t)size); /* checked for truncation above */\r
103    }\r
104 \r
105    else\r
106       return NULL;\r
107 }\r
108 \r
109 /* This is really here only to work round a spurious warning in GCC 4.6 and 4.7\r
110  * that arises because of the checks in png_realloc_array that are repeated in\r
111  * png_malloc_array.\r
112  */\r
113 static png_voidp\r
114 png_malloc_array_checked(png_const_structrp png_ptr, int nelements,\r
115    size_t element_size)\r
116 {\r
117    png_alloc_size_t req = nelements; /* known to be > 0 */\r
118 \r
119    if (req <= PNG_SIZE_MAX/element_size)\r
120       return png_malloc_base(png_ptr, req * element_size);\r
121 \r
122    /* The failure case when the request is too large */\r
123    return NULL;\r
124 }\r
125 \r
126 PNG_FUNCTION(png_voidp /* PRIVATE */,\r
127 png_malloc_array,(png_const_structrp png_ptr, int nelements,\r
128    size_t element_size),PNG_ALLOCATED)\r
129 {\r
130    if (nelements <= 0 || element_size == 0)\r
131       png_error(png_ptr, "internal error: array alloc");\r
132 \r
133    return png_malloc_array_checked(png_ptr, nelements, element_size);\r
134 }\r
135 \r
136 PNG_FUNCTION(png_voidp /* PRIVATE */,\r
137 png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,\r
138    int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED)\r
139 {\r
140    /* These are internal errors: */\r
141    if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||\r
142       (old_array == NULL && old_elements > 0))\r
143       png_error(png_ptr, "internal error: array realloc");\r
144 \r
145    /* Check for overflow on the elements count (so the caller does not have to\r
146     * check.)\r
147     */\r
148    if (add_elements <= INT_MAX - old_elements)\r
149    {\r
150       png_voidp new_array = png_malloc_array_checked(png_ptr,\r
151          old_elements+add_elements, element_size);\r
152 \r
153       if (new_array != NULL)\r
154       {\r
155          /* Because png_malloc_array worked the size calculations below cannot\r
156           * overflow.\r
157           */\r
158          if (old_elements > 0)\r
159             memcpy(new_array, old_array, element_size*(unsigned)old_elements);\r
160 \r
161          memset((char*)new_array + element_size*(unsigned)old_elements, 0,\r
162             element_size*(unsigned)add_elements);\r
163 \r
164          return new_array;\r
165       }\r
166    }\r
167 \r
168    return NULL; /* error */\r
169 }\r
170 \r
171 /* Various functions that have different error handling are derived from this.\r
172  * png_malloc always exists, but if PNG_USER_MEM_SUPPORTED is defined a separate\r
173  * function png_malloc_default is also provided.\r
174  */\r
175 PNG_FUNCTION(png_voidp,PNGAPI\r
176 png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)\r
177 {\r
178    png_voidp ret;\r
179 \r
180    if (png_ptr == NULL)\r
181       return NULL;\r
182 \r
183    ret = png_malloc_base(png_ptr, size);\r
184 \r
185    if (ret == NULL)\r
186        png_error(png_ptr, "Out of memory"); /* 'm' means png_malloc */\r
187 \r
188    return ret;\r
189 }\r
190 \r
191 #ifdef PNG_USER_MEM_SUPPORTED\r
192 PNG_FUNCTION(png_voidp,PNGAPI\r
193 png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),\r
194    PNG_ALLOCATED PNG_DEPRECATED)\r
195 {\r
196    png_voidp ret;\r
197 \r
198    if (png_ptr == NULL)\r
199       return NULL;\r
200 \r
201    /* Passing 'NULL' here bypasses the application provided memory handler. */\r
202    ret = png_malloc_base(NULL/*use malloc*/, size);\r
203 \r
204    if (ret == NULL)\r
205       png_error(png_ptr, "Out of Memory"); /* 'M' means png_malloc_default */\r
206 \r
207    return ret;\r
208 }\r
209 #endif /* PNG_USER_MEM_SUPPORTED */\r
210 \r
211 /* This function was added at libpng version 1.2.3.  The png_malloc_warn()\r
212  * function will issue a png_warning and return NULL instead of issuing a\r
213  * png_error, if it fails to allocate the requested memory.\r
214  */\r
215 PNG_FUNCTION(png_voidp,PNGAPI\r
216 png_malloc_warn,(png_const_structrp png_ptr, png_alloc_size_t size),\r
217    PNG_ALLOCATED)\r
218 {\r
219    if (png_ptr != NULL)\r
220    {\r
221       png_voidp ret = png_malloc_base(png_ptr, size);\r
222 \r
223       if (ret != NULL)\r
224          return ret;\r
225 \r
226       png_warning(png_ptr, "Out of memory");\r
227    }\r
228 \r
229    return NULL;\r
230 }\r
231 \r
232 /* Free a pointer allocated by png_malloc().  If ptr is NULL, return\r
233  * without taking any action.\r
234  */\r
235 void PNGAPI\r
236 png_free(png_const_structrp png_ptr, png_voidp ptr)\r
237 {\r
238    if (png_ptr == NULL || ptr == NULL)\r
239       return;\r
240 \r
241 #ifdef PNG_USER_MEM_SUPPORTED\r
242    if (png_ptr->free_fn != NULL)\r
243       png_ptr->free_fn(png_constcast(png_structrp,png_ptr), ptr);\r
244 \r
245    else\r
246       png_free_default(png_ptr, ptr);\r
247 }\r
248 \r
249 PNG_FUNCTION(void,PNGAPI\r
250 png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED)\r
251 {\r
252    if (png_ptr == NULL || ptr == NULL)\r
253       return;\r
254 #endif /* PNG_USER_MEM_SUPPORTED */\r
255 \r
256    FXMEM_DefaultFree(ptr, 0);\r
257    //free(ptr);\r
258 }\r
259 \r
260 #ifdef PNG_USER_MEM_SUPPORTED\r
261 /* This function is called when the application wants to use another method\r
262  * of allocating and freeing memory.\r
263  */\r
264 void PNGAPI\r
265 png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr\r
266   malloc_fn, png_free_ptr free_fn)\r
267 {\r
268    if (png_ptr != NULL)\r
269    {\r
270       png_ptr->mem_ptr = mem_ptr;\r
271       png_ptr->malloc_fn = malloc_fn;\r
272       png_ptr->free_fn = free_fn;\r
273    }\r
274 }\r
275 \r
276 /* This function returns a pointer to the mem_ptr associated with the user\r
277  * functions.  The application should free any memory associated with this\r
278  * pointer before png_write_destroy and png_read_destroy are called.\r
279  */\r
280 png_voidp PNGAPI\r
281 png_get_mem_ptr(png_const_structrp png_ptr)\r
282 {\r
283    if (png_ptr == NULL)\r
284       return NULL;\r
285 \r
286    return png_ptr->mem_ptr;\r
287 }\r
288 #endif /* PNG_USER_MEM_SUPPORTED */\r
289 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r