FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavutil/mem.c
Date: 2024-04-27 00:58:15
Exec Total Coverage
Lines: 214 251 85.3%
Functions: 26 28 92.9%
Branches: 101 146 69.2%
Line Branch Exec Source
1 /*
2 * default memory allocator for libavutil
3 * Copyright (c) 2002 Fabrice Bellard
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * @file
24 * default memory allocator for libavutil
25 */
26
27 #define _XOPEN_SOURCE 600
28
29 #include "config.h"
30
31 #include <limits.h>
32 #include <stdint.h>
33 #include <stdlib.h>
34 #include <stdatomic.h>
35 #include <string.h>
36 #if HAVE_MALLOC_H
37 #include <malloc.h>
38 #endif
39
40 #include "attributes.h"
41 #include "avassert.h"
42 #include "dynarray.h"
43 #include "error.h"
44 #include "internal.h"
45 #include "intreadwrite.h"
46 #include "macros.h"
47 #include "mem.h"
48
49 #ifdef MALLOC_PREFIX
50
51 #define malloc AV_JOIN(MALLOC_PREFIX, malloc)
52 #define memalign AV_JOIN(MALLOC_PREFIX, memalign)
53 #define posix_memalign AV_JOIN(MALLOC_PREFIX, posix_memalign)
54 #define realloc AV_JOIN(MALLOC_PREFIX, realloc)
55 #define free AV_JOIN(MALLOC_PREFIX, free)
56
57 void *malloc(size_t size);
58 void *memalign(size_t align, size_t size);
59 int posix_memalign(void **ptr, size_t align, size_t size);
60 void *realloc(void *ptr, size_t size);
61 void free(void *ptr);
62
63 #endif /* MALLOC_PREFIX */
64
65 #define ALIGN (HAVE_SIMD_ALIGN_64 ? 64 : (HAVE_SIMD_ALIGN_32 ? 32 : 16))
66
67 #define FF_MEMORY_POISON 0x2a
68
69 /* NOTE: if you want to override these functions with your own
70 * implementations (not recommended) you have to link libav* as
71 * dynamic libraries and remove -Wl,-Bsymbolic from the linker flags.
72 * Note that this will cost performance. */
73
74 static atomic_size_t max_alloc_size = INT_MAX;
75
76 ✗ void av_max_alloc(size_t max){
77 ✗ atomic_store_explicit(&max_alloc_size, max, memory_order_relaxed);
78 ✗ }
79
80 7024445 static int size_mult(size_t a, size_t b, size_t *r)
81 {
82 size_t t;
83
84 #if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_mul_overflow)
85
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7024445 times.
 7024445 if (__builtin_mul_overflow(a, b, &t))
86 ✗ return AVERROR(EINVAL);
87 #else
88 t = a * b;
89 /* Hack inspired from glibc: don't try the division if nelem and elsize
90 * are both less than sqrt(SIZE_MAX). */
91 if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
92 return AVERROR(EINVAL);
93 #endif
94 7024445 *r = t;
95 7024445 return 0;
96 }
97
98 23901946 void *av_malloc(size_t size)
99 {
100 23901946 void *ptr = NULL;
101
102
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23901946 times.
 23901946 if (size > atomic_load_explicit(&max_alloc_size, memory_order_relaxed))
103 ✗ return NULL;
104
105 #if HAVE_POSIX_MEMALIGN
106
2/2
✓ Branch 0 taken 23885802 times.
✓ Branch 1 taken 16144 times.
 23901946 if (size) //OS X on SDK 10.6 has a broken posix_memalign implementation
107
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 23885802 times.
 23885802 if (posix_memalign(&ptr, ALIGN, size))
108 ✗ ptr = NULL;
109 #elif HAVE_ALIGNED_MALLOC
110 ptr = _aligned_malloc(size, ALIGN);
111 #elif HAVE_MEMALIGN
112 #ifndef __DJGPP__
113 ptr = memalign(ALIGN, size);
114 #else
115 ptr = memalign(size, ALIGN);
116 #endif
117 /* Why 64?
118 * Indeed, we should align it:
119 * on 4 for 386
120 * on 16 for 486
121 * on 32 for 586, PPro - K6-III
122 * on 64 for K7 (maybe for P3 too).
123 * Because L1 and L2 caches are aligned on those values.
124 * But I don't want to code such logic here!
125 */
126 /* Why 32?
127 * For AVX ASM. SSE / NEON needs only 16.
128 * Why not larger? Because I did not see a difference in benchmarks ...
129 */
130 /* benchmarks with P3
131 * memalign(64) + 1 3071, 3051, 3032
132 * memalign(64) + 2 3051, 3032, 3041
133 * memalign(64) + 4 2911, 2896, 2915
134 * memalign(64) + 8 2545, 2554, 2550
135 * memalign(64) + 16 2543, 2572, 2563
136 * memalign(64) + 32 2546, 2545, 2571
137 * memalign(64) + 64 2570, 2533, 2558
138 *
139 * BTW, malloc seems to do 8-byte alignment by default here.
140 */
141 #else
142 ptr = malloc(size);
143 #endif
144
3/4
✓ Branch 0 taken 16144 times.
✓ Branch 1 taken 23885802 times.
✓ Branch 2 taken 16144 times.
✗ Branch 3 not taken.
 23901946 if(!ptr && !size) {
145 16144 size = 1;
146 16144 ptr= av_malloc(1);
147 }
148 #if CONFIG_MEMORY_POISONING
149
1/2
✓ Branch 0 taken 23901946 times.
✗ Branch 1 not taken.
 23901946 if (ptr)
150 23901946 memset(ptr, FF_MEMORY_POISON, size);
151 #endif
152 23901946 return ptr;
153 }
154
155 10112436 void *av_realloc(void *ptr, size_t size)
156 {
157 void *ret;
158
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10112436 times.
 10112436 if (size > atomic_load_explicit(&max_alloc_size, memory_order_relaxed))
159 ✗ return NULL;
160
161 #if HAVE_ALIGNED_MALLOC
162 ret = _aligned_realloc(ptr, size + !size, ALIGN);
163 #else
164 10112436 ret = realloc(ptr, size + !size);
165 #endif
166 #if CONFIG_MEMORY_POISONING
167
3/4
✓ Branch 0 taken 10112436 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6040070 times.
✓ Branch 3 taken 4072366 times.
 10112436 if (ret && !ptr)
168 6040070 memset(ret, FF_MEMORY_POISON, size);
169 #endif
170 10112436 return ret;
171 }
172
173 62590 void *av_realloc_f(void *ptr, size_t nelem, size_t elsize)
174 {
175 size_t size;
176 void *r;
177
178
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 62590 times.
 62590 if (size_mult(elsize, nelem, &size)) {
179 ✗ av_free(ptr);
180 ✗ return NULL;
181 }
182 62590 r = av_realloc(ptr, size);
183
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62590 times.
 62590 if (!r)
184 ✗ av_free(ptr);
185 62590 return r;
186 }
187
188 19665 int av_reallocp(void *ptr, size_t size)
189 {
190 void *val;
191
192
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 19656 times.
 19665 if (!size) {
193 9 av_freep(ptr);
194 9 return 0;
195 }
196
197 19656 memcpy(&val, ptr, sizeof(val));
198 19656 val = av_realloc(val, size);
199
200
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19656 times.
 19656 if (!val) {
201 ✗ av_freep(ptr);
202 ✗ return AVERROR(ENOMEM);
203 }
204
205 19656 memcpy(ptr, &val, sizeof(val));
206 19656 return 0;
207 }
208
209 224635 void *av_malloc_array(size_t nmemb, size_t size)
210 {
211 size_t result;
212
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 224635 times.
 224635 if (size_mult(nmemb, size, &result) < 0)
213 ✗ return NULL;
214 224635 return av_malloc(result);
215 }
216
217 4461312 void *av_realloc_array(void *ptr, size_t nmemb, size_t size)
218 {
219 size_t result;
220
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4461312 times.
 4461312 if (size_mult(nmemb, size, &result) < 0)
221 ✗ return NULL;
222 4461312 return av_realloc(ptr, result);
223 }
224
225 4930 int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
226 {
227 void *val;
228
229 4930 memcpy(&val, ptr, sizeof(val));
230 4930 val = av_realloc_f(val, nmemb, size);
231 4930 memcpy(ptr, &val, sizeof(val));
232
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 4930 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 4930 if (!val && nmemb && size)
233 ✗ return AVERROR(ENOMEM);
234
235 4930 return 0;
236 }
237
238 70631277 void av_free(void *ptr)
239 {
240 #if HAVE_ALIGNED_MALLOC
241 _aligned_free(ptr);
242 #else
243 70631277 free(ptr);
244 #endif
245 70631277 }
246
247 60883017 void av_freep(void *arg)
248 {
249 void *val;
250
251 60883017 memcpy(&val, arg, sizeof(val));
252 60883017 memcpy(arg, &(void *){ NULL }, sizeof(val));
253 60883017 av_free(val);
254 60883017 }
255
256 20193887 void *av_mallocz(size_t size)
257 {
258 20193887 void *ptr = av_malloc(size);
259
1/2
✓ Branch 0 taken 20193887 times.
✗ Branch 1 not taken.
 20193887 if (ptr)
260 20193887 memset(ptr, 0, size);
261 20193887 return ptr;
262 }
263
264 2275268 void *av_calloc(size_t nmemb, size_t size)
265 {
266 size_t result;
267
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2275268 times.
 2275268 if (size_mult(nmemb, size, &result) < 0)
268 ✗ return NULL;
269 2275268 return av_mallocz(result);
270 }
271
272 1980456 char *av_strdup(const char *s)
273 {
274 1980456 char *ptr = NULL;
275
2/2
✓ Branch 0 taken 1980455 times.
✓ Branch 1 taken 1 times.
 1980456 if (s) {
276 1980455 size_t len = strlen(s) + 1;
277 1980455 ptr = av_realloc(NULL, len);
278
1/2
✓ Branch 0 taken 1980455 times.
✗ Branch 1 not taken.
 1980455 if (ptr)
279 1980455 memcpy(ptr, s, len);
280 }
281 1980456 return ptr;
282 }
283
284 ✗ char *av_strndup(const char *s, size_t len)
285 {
286 ✗ char *ret = NULL, *end;
287
288 ✗ if (!s)
289 ✗ return NULL;
290
291 ✗ end = memchr(s, 0, len);
292 ✗ if (end)
293 ✗ len = end - s;
294
295 ✗ ret = av_realloc(NULL, len + 1);
296 ✗ if (!ret)
297 ✗ return NULL;
298
299 ✗ memcpy(ret, s, len);
300 ✗ ret[len] = 0;
301 ✗ return ret;
302 }
303
304 103495 void *av_memdup(const void *p, size_t size)
305 {
306 103495 void *ptr = NULL;
307
1/2
✓ Branch 0 taken 103495 times.
✗ Branch 1 not taken.
 103495 if (p) {
308 103495 ptr = av_malloc(size);
309
1/2
✓ Branch 0 taken 103495 times.
✗ Branch 1 not taken.
 103495 if (ptr)
310 103495 memcpy(ptr, p, size);
311 }
312 103495 return ptr;
313 }
314
315 83929 int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
316 {
317 void **tab;
318 83929 memcpy(&tab, tab_ptr, sizeof(tab));
319
320
7/10
✓ Branch 0 taken 81750 times.
✓ Branch 1 taken 2179 times.
✓ Branch 2 taken 13580 times.
✓ Branch 3 taken 68170 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 81750 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 81750 times.
✓ Branch 9 taken 83929 times.
✗ Branch 10 not taken.
 83929 FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, {
321 tab[*nb_ptr] = elem;
322 memcpy(tab_ptr, &tab, sizeof(tab));
323 }, {
324 return AVERROR(ENOMEM);
325 });
326 83929 return 0;
327 }
328
329 1162 void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem)
330 {
331 void **tab;
332 1162 memcpy(&tab, tab_ptr, sizeof(tab));
333
334
7/10
✓ Branch 0 taken 227 times.
✓ Branch 1 taken 935 times.
✓ Branch 2 taken 146 times.
✓ Branch 3 taken 81 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 227 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 227 times.
✓ Branch 9 taken 1162 times.
✗ Branch 10 not taken.
 1162 FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, {
335 tab[*nb_ptr] = elem;
336 memcpy(tab_ptr, &tab, sizeof(tab));
337 }, {
338 *nb_ptr = 0;
339 av_freep(tab_ptr);
340 });
341 1162 }
342
343 531956 void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
344 const uint8_t *elem_data)
345 {
346 531956 uint8_t *tab_elem_data = NULL;
347
348
9/12
✓ Branch 0 taken 321314 times.
✓ Branch 1 taken 210642 times.
✓ Branch 2 taken 187510 times.
✓ Branch 3 taken 133804 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 321314 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 321314 times.
✓ Branch 9 taken 531956 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 191 times.
✓ Branch 12 taken 531765 times.
 531956 FF_DYNARRAY_ADD(INT_MAX, elem_size, *tab_ptr, *nb_ptr, {
349 tab_elem_data = (uint8_t *)*tab_ptr + (*nb_ptr) * elem_size;
350 if (elem_data)
351 memcpy(tab_elem_data, elem_data, elem_size);
352 else if (CONFIG_MEMORY_POISONING)
353 memset(tab_elem_data, FF_MEMORY_POISON, elem_size);
354 }, {
355 av_freep(tab_ptr);
356 *nb_ptr = 0;
357 });
358 531956 return tab_elem_data;
359 }
360
361 140188 static void fill16(uint8_t *dst, int len)
362 {
363 140188 uint32_t v = AV_RN16(dst - 2);
364
365 140188 v |= v << 16;
366
367
2/2
✓ Branch 0 taken 81569738 times.
✓ Branch 1 taken 140188 times.
 81709926 while (len >= 4) {
368 81569738 AV_WN32(dst, v);
369 81569738 dst += 4;
370 81569738 len -= 4;
371 }
372
373
2/2
✓ Branch 0 taken 268205 times.
✓ Branch 1 taken 140188 times.
 408393 while (len--) {
374 268205 *dst = dst[-2];
375 268205 dst++;
376 }
377 140188 }
378
379 594 static void fill24(uint8_t *dst, int len)
380 {
381 #if HAVE_BIGENDIAN
382 uint32_t v = AV_RB24(dst - 3);
383 uint32_t a = v << 8 | v >> 16;
384 uint32_t b = v << 16 | v >> 8;
385 uint32_t c = v << 24 | v;
386 #else
387 594 uint32_t v = AV_RL24(dst - 3);
388 594 uint32_t a = v | v << 24;
389 594 uint32_t b = v >> 8 | v << 16;
390 594 uint32_t c = v >> 16 | v << 8;
391 #endif
392
393
2/2
✓ Branch 0 taken 348 times.
✓ Branch 1 taken 594 times.
 942 while (len >= 12) {
394 348 AV_WN32(dst, a);
395 348 AV_WN32(dst + 4, b);
396 348 AV_WN32(dst + 8, c);
397 348 dst += 12;
398 348 len -= 12;
399 }
400
401
2/2
✓ Branch 0 taken 139 times.
✓ Branch 1 taken 455 times.
 594 if (len >= 4) {
402 139 AV_WN32(dst, a);
403 139 dst += 4;
404 139 len -= 4;
405 }
406
407
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 581 times.
 594 if (len >= 4) {
408 13 AV_WN32(dst, b);
409 13 dst += 4;
410 13 len -= 4;
411 }
412
413
2/2
✓ Branch 0 taken 1436 times.
✓ Branch 1 taken 594 times.
 2030 while (len--) {
414 1436 *dst = dst[-3];
415 1436 dst++;
416 }
417 594 }
418
419 14560 static void fill32(uint8_t *dst, int len)
420 {
421 14560 uint32_t v = AV_RN32(dst - 4);
422
423 #if HAVE_FAST_64BIT
424 14560 uint64_t v2= v + ((uint64_t)v<<32);
425
2/2
✓ Branch 0 taken 98850 times.
✓ Branch 1 taken 14560 times.
 113410 while (len >= 32) {
426 98850 AV_WN64(dst , v2);
427 98850 AV_WN64(dst+ 8, v2);
428 98850 AV_WN64(dst+16, v2);
429 98850 AV_WN64(dst+24, v2);
430 98850 dst += 32;
431 98850 len -= 32;
432 }
433 #endif
434
435
2/2
✓ Branch 0 taken 54517 times.
✓ Branch 1 taken 14560 times.
 69077 while (len >= 4) {
436 54517 AV_WN32(dst, v);
437 54517 dst += 4;
438 54517 len -= 4;
439 }
440
441
2/2
✓ Branch 0 taken 2266 times.
✓ Branch 1 taken 14560 times.
 16826 while (len--) {
442 2266 *dst = dst[-4];
443 2266 dst++;
444 }
445 14560 }
446
447 798923 void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
448 {
449 798923 const uint8_t *src = &dst[-back];
450
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 798923 times.
 798923 if (!back)
451 ✗ return;
452
453
2/2
✓ Branch 0 taken 5265 times.
✓ Branch 1 taken 793658 times.
 798923 if (back == 1) {
454 5265 memset(dst, *src, cnt);
455
2/2
✓ Branch 0 taken 140188 times.
✓ Branch 1 taken 653470 times.
 793658 } else if (back == 2) {
456 140188 fill16(dst, cnt);
457
2/2
✓ Branch 0 taken 594 times.
✓ Branch 1 taken 652876 times.
 653470 } else if (back == 3) {
458 594 fill24(dst, cnt);
459
2/2
✓ Branch 0 taken 14560 times.
✓ Branch 1 taken 638316 times.
 652876 } else if (back == 4) {
460 14560 fill32(dst, cnt);
461 } else {
462
2/2
✓ Branch 0 taken 103538 times.
✓ Branch 1 taken 534778 times.
 638316 if (cnt >= 16) {
463 103538 int blocklen = back;
464
2/2
✓ Branch 0 taken 31656 times.
✓ Branch 1 taken 103538 times.
 135194 while (cnt > blocklen) {
465 31656 memcpy(dst, src, blocklen);
466 31656 dst += blocklen;
467 31656 cnt -= blocklen;
468 31656 blocklen <<= 1;
469 }
470 103538 memcpy(dst, src, cnt);
471 103538 return;
472 }
473
2/2
✓ Branch 0 taken 116277 times.
✓ Branch 1 taken 418501 times.
 534778 if (cnt >= 8) {
474 116277 AV_COPY32U(dst, src);
475 116277 AV_COPY32U(dst + 4, src + 4);
476 116277 src += 8;
477 116277 dst += 8;
478 116277 cnt -= 8;
479 }
480
2/2
✓ Branch 0 taken 383459 times.
✓ Branch 1 taken 151319 times.
 534778 if (cnt >= 4) {
481 383459 AV_COPY32U(dst, src);
482 383459 src += 4;
483 383459 dst += 4;
484 383459 cnt -= 4;
485 }
486
2/2
✓ Branch 0 taken 192819 times.
✓ Branch 1 taken 341959 times.
 534778 if (cnt >= 2) {
487 192819 AV_COPY16U(dst, src);
488 192819 src += 2;
489 192819 dst += 2;
490 192819 cnt -= 2;
491 }
492
2/2
✓ Branch 0 taken 118885 times.
✓ Branch 1 taken 415893 times.
 534778 if (cnt)
493 118885 *dst = *src;
494 }
495 }
496
497 1948771 void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
498 {
499 size_t max_size;
500
501
2/2
✓ Branch 0 taken 1842326 times.
✓ Branch 1 taken 106445 times.
 1948771 if (min_size <= *size)
502 1842326 return ptr;
503
504 106445 max_size = atomic_load_explicit(&max_alloc_size, memory_order_relaxed);
505 /* *size is an unsigned, so the real maximum is <= UINT_MAX. */
506 106445 max_size = FFMIN(max_size, UINT_MAX);
507
508
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 106445 times.
 106445 if (min_size > max_size) {
509 ✗ *size = 0;
510 ✗ return NULL;
511 }
512
513 106445 min_size = FFMIN(max_size, FFMAX(min_size + min_size / 16 + 32, min_size));
514
515 106445 ptr = av_realloc(ptr, min_size);
516 /* we could set this to the unmodified min_size but this is safer
517 * if the user lost the ptr and uses NULL now
518 */
519
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 106445 times.
 106445 if (!ptr)
520 ✗ min_size = 0;
521
522 106445 *size = min_size;
523
524 106445 return ptr;
525 }
526
527 367254 static inline void fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
528 {
529 size_t max_size;
530 void *val;
531
532 367254 memcpy(&val, ptr, sizeof(val));
533
2/2
✓ Branch 0 taken 323016 times.
✓ Branch 1 taken 44238 times.
 367254 if (min_size <= *size) {
534
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 323016 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 323016 av_assert0(val || !min_size);
535 323016 return;
536 }
537
538 44238 max_size = atomic_load_explicit(&max_alloc_size, memory_order_relaxed);
539 /* *size is an unsigned, so the real maximum is <= UINT_MAX. */
540 44238 max_size = FFMIN(max_size, UINT_MAX);
541
542
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44238 times.
 44238 if (min_size > max_size) {
543 ✗ av_freep(ptr);
544 ✗ *size = 0;
545 ✗ return;
546 }
547 44238 min_size = FFMIN(max_size, FFMAX(min_size + min_size / 16 + 32, min_size));
548 44238 av_freep(ptr);
549
2/2
✓ Branch 0 taken 42186 times.
✓ Branch 1 taken 2052 times.
 44238 val = zero_realloc ? av_mallocz(min_size) : av_malloc(min_size);
550 44238 memcpy(ptr, &val, sizeof(val));
551
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44238 times.
 44238 if (!val)
552 ✗ min_size = 0;
553 44238 *size = min_size;
554 44238 return;
555 }
556
557 90026 void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
558 {
559 90026 fast_malloc(ptr, size, min_size, 0);
560 90026 }
561
562 277228 void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
563 {
564 277228 fast_malloc(ptr, size, min_size, 1);
565 277228 }
566
567 640 int av_size_mult(size_t a, size_t b, size_t *r)
568 {
569 640 return size_mult(a, b, r);
570 }
571