1 |
|
/***************************************************************************** |
2 |
|
* |
3 |
|
* XVID MPEG-4 VIDEO CODEC |
4 |
|
* - Aligned memory allocator - |
5 |
|
* |
6 |
|
* This program is an implementation of a part of one or more MPEG-4 |
7 |
|
* Video tools as specified in ISO/IEC 14496-2 standard. Those intending |
8 |
|
* to use this software module in hardware or software products are |
9 |
|
* advised that its use may infringe existing patents or copyrights, and |
10 |
|
* any such use would be at such party's own risk. The original |
11 |
|
* developer of this software module and his/her company, and subsequent |
12 |
|
* editors and their companies, will have no liability for use of this |
13 |
|
* software or modifications or derivatives thereof. |
14 |
|
* |
15 |
|
* This program is free software ; you can redistribute it and/or modify |
16 |
|
* it under the terms of the GNU General Public License as published by |
17 |
|
* the Free Software Foundation ; either version 2 of the License, or |
18 |
|
* (at your option) any later version. |
19 |
|
* |
20 |
|
* This program is distributed in the hope that it will be useful, |
21 |
|
* but WITHOUT ANY WARRANTY ; without even the implied warranty of |
22 |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
23 |
|
* GNU General Public License for more details. |
24 |
|
* |
25 |
|
* You should have received a copy of the GNU General Public License |
26 |
|
* along with this program ; if not, write to the Free Software |
27 |
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
28 |
|
* |
29 |
|
****************************************************************************/ |
30 |
|
/***************************************************************************** |
31 |
|
* |
32 |
|
* History |
33 |
|
* |
34 |
|
* - Thu Jun 13 23:50:07 2002 Added legal header |
35 |
|
* |
36 |
|
* $Id$ |
37 |
|
* |
38 |
|
****************************************************************************/ |
39 |
|
|
40 |
|
|
41 |
#include <stdlib.h> |
#include <stdlib.h> |
42 |
#include <stdio.h> |
#include <stdio.h> |
43 |
#include "mem_align.h" |
#include "mem_align.h" |
44 |
|
|
45 |
void *xvid_malloc(size_t size, uint8_t alignment) |
/***************************************************************************** |
46 |
|
* xvid_malloc |
47 |
|
* |
48 |
|
* This function allocates 'size' bytes (usable by the user) on the heap and |
49 |
|
* takes care of the requested 'alignment'. |
50 |
|
* In order to align the allocated memory block, the xvid_malloc allocates |
51 |
|
* 'size' bytes + 'alignment' bytes. So try to keep alignment very small |
52 |
|
* when allocating small pieces of memory. |
53 |
|
* |
54 |
|
* NB : a block allocated by xvid_malloc _must_ be freed with xvid_free |
55 |
|
* (the libc free will return an error) |
56 |
|
* |
57 |
|
* Returned value : - NULL on error |
58 |
|
* - Pointer to the allocated aligned block |
59 |
|
* |
60 |
|
****************************************************************************/ |
61 |
|
|
62 |
|
void * |
63 |
|
xvid_malloc(size_t size, |
64 |
|
uint8_t alignment) |
65 |
{ |
{ |
66 |
uint8_t *mem_ptr; |
uint8_t *mem_ptr; |
67 |
|
|
68 |
if(alignment == 0) |
if (!alignment) { |
69 |
{ |
|
70 |
|
/* We have not to satisfy any alignment */ |
71 |
if((mem_ptr = (uint8_t *) malloc(size + 1)) != NULL) { |
if((mem_ptr = (uint8_t *) malloc(size + 1)) != NULL) { |
72 |
*mem_ptr = 0; |
|
73 |
|
/* Store (mem_ptr - "real allocated memory") in *(mem_ptr-1) */ |
74 |
|
*mem_ptr = 1; |
75 |
|
|
76 |
|
/* Return the mem_ptr pointer */ |
77 |
return (void *) mem_ptr++; |
return (void *) mem_ptr++; |
78 |
|
|
79 |
} |
} |
80 |
} |
|
81 |
else |
} else { |
|
{ |
|
82 |
uint8_t *tmp; |
uint8_t *tmp; |
83 |
|
|
84 |
|
/* |
85 |
|
* Allocate the required size memory + alignment so we |
86 |
|
* can realign the data if necessary |
87 |
|
*/ |
88 |
|
|
89 |
if((tmp = (uint8_t *) malloc(size + alignment)) != NULL) { |
if((tmp = (uint8_t *) malloc(size + alignment)) != NULL) { |
90 |
mem_ptr = (uint8_t *) (((uint32_t) tmp / alignment) * alignment + alignment); |
|
91 |
*(mem_ptr - 1) = (alignment - 1) - ((uint32_t) tmp % alignment); |
/* Align the tmp pointer */ |
92 |
|
mem_ptr = |
93 |
|
(uint8_t *) ((ptr_t) (tmp + alignment - 1) & |
94 |
|
(~(ptr_t) (alignment - 1))); |
95 |
|
|
96 |
|
/* |
97 |
|
* Special case where malloc have already satisfied the alignment |
98 |
|
* We must add alignment to mem_ptr because we must store |
99 |
|
* (mem_ptr - tmp) in *(mem_ptr-1) |
100 |
|
* If we do not add alignment to mem_ptr then *(mem_ptr-1) points |
101 |
|
* to a forbidden memory space |
102 |
|
*/ |
103 |
|
if (mem_ptr == tmp) |
104 |
|
mem_ptr += alignment; |
105 |
|
|
106 |
|
/* |
107 |
|
* (mem_ptr - tmp) is stored in *(mem_ptr-1) so we are able to retrieve |
108 |
|
* the real malloc block allocated and free it in xvid_free |
109 |
|
*/ |
110 |
|
*(mem_ptr - 1) = (uint8_t) (mem_ptr - tmp); |
111 |
|
|
112 |
|
/* Return the aligned pointer */ |
113 |
return (void *) mem_ptr; |
return (void *) mem_ptr; |
114 |
|
|
115 |
} |
} |
116 |
} |
} |
117 |
|
|
118 |
return NULL; |
return NULL; |
119 |
|
|
120 |
} |
} |
121 |
|
|
122 |
void xvid_free(void *mem_ptr) |
/***************************************************************************** |
123 |
|
* xvid_free |
124 |
|
* |
125 |
|
* Free a previously 'xvid_malloc' allocated block. Does not free NULL |
126 |
|
* references. |
127 |
|
* |
128 |
|
* Returned value : None. |
129 |
|
* |
130 |
|
****************************************************************************/ |
131 |
|
|
132 |
|
void |
133 |
|
xvid_free(void *mem_ptr) |
134 |
{ |
{ |
|
uint8_t *tmp; |
|
135 |
|
|
136 |
tmp = (uint8_t *) mem_ptr - 1; |
/* *(mem_ptr - 1) give us the offset to the real malloc block */ |
137 |
mem_ptr = tmp - *tmp; |
if (mem_ptr) |
138 |
|
free((uint8_t *) mem_ptr - *((uint8_t *) mem_ptr - 1)); |
139 |
|
|
|
free(mem_ptr); |
|
140 |
} |
} |