mem.c 4.43 KB
Newer Older
1
/*
2
 * default memory allocator for libavutil
3
 * Copyright (c) 2002 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * 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
 * Libav is distributed in the hope that it will be useful,
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

Michael Niedermayer's avatar
Michael Niedermayer committed
22
/**
23
 * @file
24
 * default memory allocator for libavutil
Michael Niedermayer's avatar
Michael Niedermayer committed
25
 */
26

27
#include "config.h"
28

29
#include <limits.h>
30
#include <stdlib.h>
31
#include <string.h>
32
#if HAVE_MALLOC_H
33 34 35
#include <malloc.h>
#endif

36
#include "avutil.h"
37 38
#include "mem.h"

39
/* here we can use OS-dependent allocation functions */
40 41 42 43
#undef free
#undef malloc
#undef realloc

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
#ifdef MALLOC_PREFIX

#define malloc         AV_JOIN(MALLOC_PREFIX, malloc)
#define memalign       AV_JOIN(MALLOC_PREFIX, memalign)
#define posix_memalign AV_JOIN(MALLOC_PREFIX, posix_memalign)
#define realloc        AV_JOIN(MALLOC_PREFIX, realloc)
#define free           AV_JOIN(MALLOC_PREFIX, free)

void *malloc(size_t size);
void *memalign(size_t align, size_t size);
int   posix_memalign(void **ptr, size_t align, size_t size);
void *realloc(void *ptr, size_t size);
void  free(void *ptr);

#endif /* MALLOC_PREFIX */

60
/* You can redefine av_malloc and av_free in your project to use your
61
   memory allocator. You do not need to suppress this file because the
62
   linker will do it automatically. */
63

64
void *av_malloc(size_t size)
65
{
66
    void *ptr = NULL;
67
#if CONFIG_MEMALIGN_HACK
68
    long diff;
69
#endif
70

71
    /* let's disallow possible ambiguous cases */
72
    if(size > (INT_MAX-16) )
73
        return NULL;
74

75
#if CONFIG_MEMALIGN_HACK
76 77 78
    ptr = malloc(size+16);
    if(!ptr)
        return ptr;
79
    diff= ((-(long)ptr - 1)&15) + 1;
avcoder's avatar
avcoder committed
80
    ptr = (char*)ptr + diff;
81
    ((char*)ptr)[-1]= diff;
82
#elif HAVE_POSIX_MEMALIGN
83 84
    if (posix_memalign(&ptr,16,size))
        ptr = NULL;
85
#elif HAVE_MEMALIGN
Michael Niedermayer's avatar
Michael Niedermayer committed
86
    ptr = memalign(16,size);
87
    /* Why 64?
88 89 90
       Indeed, we should align it:
         on 4 for 386
         on 16 for 486
91
         on 32 for 586, PPro - K6-III
92
         on 64 for K7 (maybe for P3 too).
93 94 95
       Because L1 and L2 caches are aligned on those values.
       But I don't want to code such logic here!
     */
Michael Niedermayer's avatar
Michael Niedermayer committed
96
     /* Why 16?
Diego Biurrun's avatar
Diego Biurrun committed
97
        Because some CPUs need alignment, for example SSE2 on P4, & most RISC CPUs
Michael Niedermayer's avatar
Michael Niedermayer committed
98
        it will just trigger an exception and the unaligned load will be done in the
99
        exception handler or it will just segfault (SSE2 on P4).
Diego Biurrun's avatar
Diego Biurrun committed
100
        Why not larger? Because I did not see a difference in benchmarks ...
Michael Niedermayer's avatar
Michael Niedermayer committed
101
     */
102
     /* benchmarks with P3
103 104 105 106 107 108 109
        memalign(64)+1          3071,3051,3032
        memalign(64)+2          3051,3032,3041
        memalign(64)+4          2911,2896,2915
        memalign(64)+8          2545,2554,2550
        memalign(64)+16         2543,2572,2563
        memalign(64)+32         2546,2545,2571
        memalign(64)+64         2570,2533,2558
110

111
        BTW, malloc seems to do 8-byte alignment by default here.
Michael Niedermayer's avatar
Michael Niedermayer committed
112
     */
113 114 115 116 117 118
#else
    ptr = malloc(size);
#endif
    return ptr;
}

119
void *av_realloc(void *ptr, size_t size)
120
{
121
#if CONFIG_MEMALIGN_HACK
122 123
    int diff;
#endif
124

125
    /* let's disallow possible ambiguous cases */
126
    if(size > (INT_MAX-16) )
127 128
        return NULL;

129
#if CONFIG_MEMALIGN_HACK
130 131 132
    //FIXME this isn't aligned correctly, though it probably isn't needed
    if(!ptr) return av_malloc(size);
    diff= ((char*)ptr)[-1];
avcoder's avatar
avcoder committed
133
    return (char*)realloc((char*)ptr - diff, size + diff) + diff;
134 135
#else
    return realloc(ptr, size);
136
#endif
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
137 138
}

139 140
void av_free(void *ptr)
{
141
#if CONFIG_MEMALIGN_HACK
142
    if (ptr)
avcoder's avatar
avcoder committed
143
        free((char*)ptr - ((char*)ptr)[-1]);
144
#else
145
    free(ptr);
146
#endif
147 148
}

149 150 151 152 153 154 155
void av_freep(void *arg)
{
    void **ptr= (void**)arg;
    av_free(*ptr);
    *ptr = NULL;
}

156
void *av_mallocz(size_t size)
157
{
158
    void *ptr = av_malloc(size);
159 160 161 162 163 164 165
    if (ptr)
        memset(ptr, 0, size);
    return ptr;
}

char *av_strdup(const char *s)
{
166 167
    char *ptr= NULL;
    if(s){
Michael Niedermayer's avatar
indent  
Michael Niedermayer committed
168 169 170 171
        int len = strlen(s) + 1;
        ptr = av_malloc(len);
        if (ptr)
            memcpy(ptr, s, len);
172
    }
173 174 175
    return ptr;
}