Statistics
| Branch: | Revision:

ffmpeg / libavutil / mem.c @ 80a07f6e

History | View | Annotate | Download (4.53 KB)

1 d01fe86d Fabrice Bellard
/*
2 cea8f6f3 Luca Abeni
 * default memory allocator for libavutil
3 406792e7 Diego Biurrun
 * Copyright (c) 2002 Fabrice Bellard
4 d01fe86d Fabrice Bellard
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 d01fe86d Fabrice Bellard
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 d01fe86d Fabrice Bellard
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 d01fe86d Fabrice Bellard
 * 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 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 d01fe86d Fabrice Bellard
 */
21 115329f1 Diego Biurrun
22 983e3246 Michael Niedermayer
/**
23 bad5537e Diego Biurrun
 * @file libavutil/mem.c
24 89c9ff50 Diego Biurrun
 * default memory allocator for libavutil
25 983e3246 Michael Niedermayer
 */
26 115329f1 Diego Biurrun
27 dfcb6b56 Diego Biurrun
#include "config.h"
28 8e1e6f31 Fabrice Bellard
29 dfcb6b56 Diego Biurrun
#include <limits.h>
30 1f91cdce Ramiro Polla
#include <stdlib.h>
31 dfcb6b56 Diego Biurrun
#include <string.h>
32 b250f9c6 Aurelien Jacobs
#if HAVE_MALLOC_H
33 d01fe86d Fabrice Bellard
#include <malloc.h>
34
#endif
35
36 4ae40685 Måns Rullgård
#include "avutil.h"
37 77652a6a Diego Biurrun
#include "mem.h"
38
39 89c9ff50 Diego Biurrun
/* here we can use OS-dependent allocation functions */
40 1e60e933 Diego Biurrun
#undef free
41
#undef malloc
42
#undef realloc
43
44 4ae40685 Måns Rullgård
#ifdef MALLOC_PREFIX
45
46
#define malloc         AV_JOIN(MALLOC_PREFIX, malloc)
47
#define memalign       AV_JOIN(MALLOC_PREFIX, memalign)
48
#define posix_memalign AV_JOIN(MALLOC_PREFIX, posix_memalign)
49
#define realloc        AV_JOIN(MALLOC_PREFIX, realloc)
50
#define free           AV_JOIN(MALLOC_PREFIX, free)
51
52
void *malloc(size_t size);
53
void *memalign(size_t align, size_t size);
54
int   posix_memalign(void **ptr, size_t align, size_t size);
55
void *realloc(void *ptr, size_t size);
56
void  free(void *ptr);
57
58
#endif /* MALLOC_PREFIX */
59
60 89c9ff50 Diego Biurrun
/* You can redefine av_malloc and av_free in your project to use your
61 d01fe86d Fabrice Bellard
   memory allocator. You do not need to suppress this file because the
62 89c9ff50 Diego Biurrun
   linker will do it automatically. */
63 d01fe86d Fabrice Bellard
64 18f77016 Zdenek Kabelac
void *av_malloc(unsigned int size)
65 d01fe86d Fabrice Bellard
{
66 1f91cdce Ramiro Polla
    void *ptr = NULL;
67 b250f9c6 Aurelien Jacobs
#if CONFIG_MEMALIGN_HACK
68 ed96aeea Dieter
    long diff;
69 88730be6 Måns Rullgård
#endif
70 0ecca7a4 Michael Niedermayer
71 7d77d5f6 Diego Biurrun
    /* let's disallow possible ambiguous cases */
72 0a7c36af Michael Niedermayer
    if(size > (INT_MAX-16) )
73 0ecca7a4 Michael Niedermayer
        return NULL;
74 115329f1 Diego Biurrun
75 b250f9c6 Aurelien Jacobs
#if CONFIG_MEMALIGN_HACK
76 a9493601 Herve W
    ptr = malloc(size+16);
77
    if(!ptr)
78
        return ptr;
79 ed96aeea Dieter
    diff= ((-(long)ptr - 1)&15) + 1;
80 90d30570 avcoder
    ptr = (char*)ptr + diff;
81 da9b170c Michael Niedermayer
    ((char*)ptr)[-1]= diff;
82 b250f9c6 Aurelien Jacobs
#elif HAVE_POSIX_MEMALIGN
83 a90de11d Patrik Kullman
    if (posix_memalign(&ptr,16,size))
84
        ptr = NULL;
85 b250f9c6 Aurelien Jacobs
#elif HAVE_MEMALIGN
86 8f2b21a8 Michael Niedermayer
    ptr = memalign(16,size);
87 115329f1 Diego Biurrun
    /* Why 64?
88 d01fe86d Fabrice Bellard
       Indeed, we should align it:
89
         on 4 for 386
90
         on 16 for 486
91 89c9ff50 Diego Biurrun
         on 32 for 586, PPro - K6-III
92 bb270c08 Diego Biurrun
         on 64 for K7 (maybe for P3 too).
93 d01fe86d Fabrice Bellard
       Because L1 and L2 caches are aligned on those values.
94
       But I don't want to code such logic here!
95
     */
96 8f2b21a8 Michael Niedermayer
     /* Why 16?
97 7ce68923 Diego Biurrun
        Because some CPUs need alignment, for example SSE2 on P4, & most RISC CPUs
98 8f2b21a8 Michael Niedermayer
        it will just trigger an exception and the unaligned load will be done in the
99 89c9ff50 Diego Biurrun
        exception handler or it will just segfault (SSE2 on P4).
100 2cab6401 Diego Biurrun
        Why not larger? Because I did not see a difference in benchmarks ...
101 8f2b21a8 Michael Niedermayer
     */
102 89c9ff50 Diego Biurrun
     /* benchmarks with P3
103 bb270c08 Diego Biurrun
        memalign(64)+1          3071,3051,3032
104
        memalign(64)+2          3051,3032,3041
105
        memalign(64)+4          2911,2896,2915
106
        memalign(64)+8          2545,2554,2550
107
        memalign(64)+16         2543,2572,2563
108
        memalign(64)+32         2546,2545,2571
109
        memalign(64)+64         2570,2533,2558
110 115329f1 Diego Biurrun

111 89c9ff50 Diego Biurrun
        BTW, malloc seems to do 8-byte alignment by default here.
112 8f2b21a8 Michael Niedermayer
     */
113 d01fe86d Fabrice Bellard
#else
114
    ptr = malloc(size);
115
#endif
116
    return ptr;
117
}
118
119 8e1e6f31 Fabrice Bellard
void *av_realloc(void *ptr, unsigned int size)
120
{
121 b250f9c6 Aurelien Jacobs
#if CONFIG_MEMALIGN_HACK
122 0a7c36af Michael Niedermayer
    int diff;
123
#endif
124 88730be6 Måns Rullgård
125 7d77d5f6 Diego Biurrun
    /* let's disallow possible ambiguous cases */
126 a9493601 Herve W
    if(size > (INT_MAX-16) )
127 0ecca7a4 Michael Niedermayer
        return NULL;
128
129 b250f9c6 Aurelien Jacobs
#if CONFIG_MEMALIGN_HACK
130 0a7c36af Michael Niedermayer
    //FIXME this isn't aligned correctly, though it probably isn't needed
131
    if(!ptr) return av_malloc(size);
132
    diff= ((char*)ptr)[-1];
133 90d30570 avcoder
    return (char*)realloc((char*)ptr - diff, size + diff) + diff;
134 0a7c36af Michael Niedermayer
#else
135
    return realloc(ptr, size);
136 da9b170c Michael Niedermayer
#endif
137 b7a22d84 Michael Niedermayer
}
138
139 d01fe86d Fabrice Bellard
void av_free(void *ptr)
140
{
141
    /* XXX: this test should not be needed on most libcs */
142
    if (ptr)
143 b250f9c6 Aurelien Jacobs
#if CONFIG_MEMALIGN_HACK
144 90d30570 avcoder
        free((char*)ptr - ((char*)ptr)[-1]);
145 da9b170c Michael Niedermayer
#else
146 d01fe86d Fabrice Bellard
        free(ptr);
147 da9b170c Michael Niedermayer
#endif
148 d01fe86d Fabrice Bellard
}
149
150 79e47000 Luca Barbato
void av_freep(void *arg)
151
{
152
    void **ptr= (void**)arg;
153
    av_free(*ptr);
154
    *ptr = NULL;
155
}
156
157
void *av_mallocz(unsigned int size)
158
{
159 11362767 Michael Niedermayer
    void *ptr = av_malloc(size);
160 79e47000 Luca Barbato
    if (ptr)
161
        memset(ptr, 0, size);
162
    return ptr;
163
}
164
165
char *av_strdup(const char *s)
166
{
167 fdf35f26 Michael Niedermayer
    char *ptr= NULL;
168
    if(s){
169 19757f61 Michael Niedermayer
        int len = strlen(s) + 1;
170
        ptr = av_malloc(len);
171
        if (ptr)
172
            memcpy(ptr, s, len);
173 fdf35f26 Michael Niedermayer
    }
174 79e47000 Luca Barbato
    return ptr;
175
}