1 // Copyright 2012 Google Inc. All Rights Reserved.
2 //
3 // Use of this source code is governed by a BSD-style license
4 // that can be found in the COPYING file in the root of the source
5 // tree. An additional intellectual property rights grant can be found
6 // in the file PATENTS. All contributing project authors may
7 // be found in the AUTHORS file in the root of the source tree.
8 // -----------------------------------------------------------------------------
9 //
10 // Misc. common utility functions
11 //
12 // Author: Skal (pascal.massimino@gmail.com)
13
14 #include <stdlib.h>
15 #include <string.h> // for memcpy()
16 #include "../webp/decode.h"
17 #include "../webp/encode.h"
18 #include "./utils.h"
19
20 // If PRINT_MEM_INFO is defined, extra info (like total memory used, number of
21 // alloc/free etc) is printed. For debugging/tuning purpose only (it's slow,
22 // and not multi-thread safe!).
23 // An interesting alternative is valgrind's 'massif' tool:
24 // http://valgrind.org/docs/manual/ms-manual.html
25 // Here is an example command line:
26 /* valgrind --tool=massif --massif-out-file=massif.out \
27 --stacks=yes --alloc-fn=WebPSafeAlloc --alloc-fn=WebPSafeCalloc
28 ms_print massif.out
29 */
30 // In addition:
31 // * if PRINT_MEM_TRAFFIC is defined, all the details of the malloc/free cycles
32 // are printed.
33 // * if MALLOC_FAIL_AT is defined, the global environment variable
34 // $MALLOC_FAIL_AT is used to simulate a memory error when calloc or malloc
35 // is called for the nth time. Example usage:
36 // export MALLOC_FAIL_AT=50 && ./examples/cwebp input.png
37 // * if MALLOC_LIMIT is defined, the global environment variable $MALLOC_LIMIT
38 // sets the maximum amount of memory (in bytes) made available to libwebp.
39 // This can be used to emulate environment with very limited memory.
40 // Example: export MALLOC_LIMIT=64000000 && ./examples/dwebp picture.webp
41
42 // #define PRINT_MEM_INFO
43 // #define PRINT_MEM_TRAFFIC
44 // #define MALLOC_FAIL_AT
45 // #define MALLOC_LIMIT
46
47 //------------------------------------------------------------------------------
48 // Checked memory allocation
49
50 #if defined(PRINT_MEM_INFO)
51
52 #include <stdio.h>
53
54 static int num_malloc_calls = 0;
55 static int num_calloc_calls = 0;
56 static int num_free_calls = 0;
57 static int countdown_to_fail = 0; // 0 = off
58
59 typedef struct MemBlock MemBlock;
60 struct MemBlock {
61 void* ptr_;
62 size_t size_;
63 MemBlock* next_;
64 };
65
66 static MemBlock* all_blocks = NULL;
67 static size_t total_mem = 0;
68 static size_t total_mem_allocated = 0;
69 static size_t high_water_mark = 0;
70 static size_t mem_limit = 0;
71
72 static int exit_registered = 0;
73
PrintMemInfo(void)74 static void PrintMemInfo(void) {
75 fprintf(stderr, "\nMEMORY INFO:\n");
76 fprintf(stderr, "num calls to: malloc = %4d\n", num_malloc_calls);
77 fprintf(stderr, " calloc = %4d\n", num_calloc_calls);
78 fprintf(stderr, " free = %4d\n", num_free_calls);
79 fprintf(stderr, "total_mem: %u\n", (uint32_t)total_mem);
80 fprintf(stderr, "total_mem allocated: %u\n", (uint32_t)total_mem_allocated);
81 fprintf(stderr, "high-water mark: %u\n", (uint32_t)high_water_mark);
82 while (all_blocks != NULL) {
83 MemBlock* b = all_blocks;
84 all_blocks = b->next_;
85 free(b);
86 }
87 }
88
Increment(int * const v)89 static void Increment(int* const v) {
90 if (!exit_registered) {
91 #if defined(MALLOC_FAIL_AT)
92 {
93 const char* const malloc_fail_at_str = getenv("MALLOC_FAIL_AT");
94 if (malloc_fail_at_str != NULL) {
95 countdown_to_fail = atoi(malloc_fail_at_str);
96 }
97 }
98 #endif
99 #if defined(MALLOC_LIMIT)
100 {
101 const char* const malloc_limit_str = getenv("MALLOC_LIMIT");
102 if (malloc_limit_str != NULL) {
103 mem_limit = atoi(malloc_limit_str);
104 }
105 }
106 #endif
107 (void)countdown_to_fail;
108 (void)mem_limit;
109 atexit(PrintMemInfo);
110 exit_registered = 1;
111 }
112 ++*v;
113 }
114
AddMem(void * ptr,size_t size)115 static void AddMem(void* ptr, size_t size) {
116 if (ptr != NULL) {
117 MemBlock* const b = (MemBlock*)malloc(sizeof(*b));
118 if (b == NULL) abort();
119 b->next_ = all_blocks;
120 all_blocks = b;
121 b->ptr_ = ptr;
122 b->size_ = size;
123 total_mem += size;
124 total_mem_allocated += size;
125 #if defined(PRINT_MEM_TRAFFIC)
126 #if defined(MALLOC_FAIL_AT)
127 fprintf(stderr, "fail-count: %5d [mem=%u]\n",
128 num_malloc_calls + num_calloc_calls, (uint32_t)total_mem);
129 #else
130 fprintf(stderr, "Mem: %u (+%u)\n", (uint32_t)total_mem, (uint32_t)size);
131 #endif
132 #endif
133 if (total_mem > high_water_mark) high_water_mark = total_mem;
134 }
135 }
136
SubMem(void * ptr)137 static void SubMem(void* ptr) {
138 if (ptr != NULL) {
139 MemBlock** b = &all_blocks;
140 // Inefficient search, but that's just for debugging.
141 while (*b != NULL && (*b)->ptr_ != ptr) b = &(*b)->next_;
142 if (*b == NULL) {
143 fprintf(stderr, "Invalid pointer free! (%p)\n", ptr);
144 abort();
145 }
146 {
147 MemBlock* const block = *b;
148 *b = block->next_;
149 total_mem -= block->size_;
150 #if defined(PRINT_MEM_TRAFFIC)
151 fprintf(stderr, "Mem: %u (-%u)\n",
152 (uint32_t)total_mem, (uint32_t)block->size_);
153 #endif
154 free(block);
155 }
156 }
157 }
158
159 #else
160 #define Increment(v) do {} while (0)
161 #define AddMem(p, s) do {} while (0)
162 #define SubMem(p) do {} while (0)
163 #endif
164
165 // Returns 0 in case of overflow of nmemb * size.
CheckSizeArgumentsOverflow(uint64_t nmemb,size_t size)166 static int CheckSizeArgumentsOverflow(uint64_t nmemb, size_t size) {
167 const uint64_t total_size = nmemb * size;
168 if (nmemb == 0) return 1;
169 if ((uint64_t)size > WEBP_MAX_ALLOCABLE_MEMORY / nmemb) return 0;
170 if (total_size != (size_t)total_size) return 0;
171 #if defined(PRINT_MEM_INFO) && defined(MALLOC_FAIL_AT)
172 if (countdown_to_fail > 0 && --countdown_to_fail == 0) {
173 return 0; // fake fail!
174 }
175 #endif
176 #if defined(MALLOC_LIMIT)
177 if (mem_limit > 0 && total_mem + total_size >= mem_limit) {
178 return 0; // fake fail!
179 }
180 #endif
181
182 return 1;
183 }
184
WebPSafeMalloc(uint64_t nmemb,size_t size)185 void* WebPSafeMalloc(uint64_t nmemb, size_t size) {
186 void* ptr;
187 Increment(&num_malloc_calls);
188 if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
189 assert(nmemb * size > 0);
190 ptr = malloc((size_t)(nmemb * size));
191 AddMem(ptr, (size_t)(nmemb * size));
192 return ptr;
193 }
194
WebPSafeCalloc(uint64_t nmemb,size_t size)195 void* WebPSafeCalloc(uint64_t nmemb, size_t size) {
196 void* ptr;
197 Increment(&num_calloc_calls);
198 if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
199 assert(nmemb * size > 0);
200 ptr = calloc((size_t)nmemb, size);
201 AddMem(ptr, (size_t)(nmemb * size));
202 return ptr;
203 }
204
WebPSafeFree(void * const ptr)205 void WebPSafeFree(void* const ptr) {
206 if (ptr != NULL) {
207 Increment(&num_free_calls);
208 SubMem(ptr);
209 }
210 free(ptr);
211 }
212
213 // Public API function.
WebPFree(void * ptr)214 void WebPFree(void* ptr) {
215 free(ptr);
216 }
217
218 //------------------------------------------------------------------------------
219
WebPCopyPlane(const uint8_t * src,int src_stride,uint8_t * dst,int dst_stride,int width,int height)220 void WebPCopyPlane(const uint8_t* src, int src_stride,
221 uint8_t* dst, int dst_stride, int width, int height) {
222 assert(src != NULL && dst != NULL);
223 assert(src_stride >= width && dst_stride >= width);
224 while (height-- > 0) {
225 memcpy(dst, src, width);
226 src += src_stride;
227 dst += dst_stride;
228 }
229 }
230
WebPCopyPixels(const WebPPicture * const src,WebPPicture * const dst)231 void WebPCopyPixels(const WebPPicture* const src, WebPPicture* const dst) {
232 assert(src != NULL && dst != NULL);
233 assert(src->width == dst->width && src->height == dst->height);
234 assert(src->use_argb && dst->use_argb);
235 WebPCopyPlane((uint8_t*)src->argb, 4 * src->argb_stride, (uint8_t*)dst->argb,
236 4 * dst->argb_stride, 4 * src->width, src->height);
237 }
238
239 //------------------------------------------------------------------------------
240