src/utils/mem_align.c

/*****************************************************************************
 *
 *  XVID MPEG-4 VIDEO CODEC
 *  - Aligned memory allocator -
 *
 *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>
 *               2002 Edouard Gomez
 *
 *  This file is part of XviD, a free MPEG-4 video encoder/decoder
 *
 *  XviD is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 *  Under section 8 of the GNU General Public License, the copyright
 *  holders of XVID explicitly forbid distribution in the following
 *  countries:
 *
 *    - Japan
 *    - United States of America
 *
 *  Linking XviD statically or dynamically with other modules is making a
 *  combined work based on XviD.  Thus, the terms and conditions of the
 *  GNU General Public License cover the whole combination.
 *
 *  As a special exception, the copyright holders of XviD give you
 *  permission to link XviD with independent modules that communicate with
 *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the
 *  license terms of these independent modules, and to copy and distribute
 *  the resulting combined work under terms of your choice, provided that
 *  every copy of the combined work is accompanied by a complete copy of
 *  the source code of XviD (the version of XviD used to produce the
 *  combined work), being distributed under the terms of the GNU General
 *  Public License plus this exception.  An independent module is a module
 *  which is not derived from or based on XviD.
 *
 *  Note that people who make modified versions of XviD are not obligated
 *  to grant this special exception for their modified versions; it is
 *  their choice whether to do so.  The GNU General Public License gives
 *  permission to release a modified version without this exception; this
 *  exception also makes it possible to release a modified version which
 *  carries forward this exception.
 *
 * $Id: mem_align.c,v 1.12 2002/11/27 21:20:33 edgomez Exp $
 *
 ****************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include "mem_align.h"

/*****************************************************************************
 * xvid_malloc
 *
 * This function allocates 'size' bytes (usable by the user) on the heap and
 * takes care of the requested 'alignment'.
 * In order to align the allocated memory block, the xvid_malloc allocates
 * 'size' bytes + 'alignment' bytes. So try to keep alignment very small
 * when allocating small pieces of memory.
 *
 * NB : a block allocated by xvid_malloc _must_ be freed with xvid_free
 *      (the libc free will return an error)
 *
 * Returned value : - NULL on error
 *                  - Pointer to the allocated aligned block
 *
 ****************************************************************************/

void *
xvid_malloc(size_t size,
                        uint8_t alignment)
{
        uint8_t *mem_ptr;

        if (!alignment) {

                /* We have not to satisfy any alignment */
                if ((mem_ptr = (uint8_t *) malloc(size + 1)) != NULL) {

                        /* Store (mem_ptr - "real allocated memory") in *(mem_ptr-1) */
                        *mem_ptr = 1;

                        /* Return the mem_ptr pointer */
                        return (void *)(mem_ptr+1);

                }

        } else {
                uint8_t *tmp;

                /*
                 * Allocate the required size memory + alignment so we
                 * can realign the data if necessary
                 */

                if ((tmp = (uint8_t *) malloc(size + alignment)) != NULL) {

                        /* Align the tmp pointer */
                        mem_ptr =
                                (uint8_t *) ((ptr_t) (tmp + alignment - 1) &
                                                         (~(ptr_t) (alignment - 1)));

                        /*
                         * Special case where malloc have already satisfied the alignment
                         * We must add alignment to mem_ptr because we must store
                         * (mem_ptr - tmp) in *(mem_ptr-1)
                         * If we do not add alignment to mem_ptr then *(mem_ptr-1) points
                         * to a forbidden memory space
                         */
                        if (mem_ptr == tmp)
                                mem_ptr += alignment;

                        /*
                         * (mem_ptr - tmp) is stored in *(mem_ptr-1) so we are able to retrieve
                         * the real malloc block allocated and free it in xvid_free
                         */
                        *(mem_ptr - 1) = (uint8_t) (mem_ptr - tmp);

                        /* Return the aligned pointer */
                        return (void *) mem_ptr;

                }
        }

        return NULL;

}

/*****************************************************************************
 * xvid_free
 *
 * Free a previously 'xvid_malloc' allocated block. Does not free NULL
 * references.
 *
 * Returned value : None.
 *
 ****************************************************************************/

void
xvid_free(void *mem_ptr)
{

        /* *(mem_ptr - 1) give us the offset to the real malloc block */
        if (mem_ptr)
                free((uint8_t *) mem_ptr - *((uint8_t *) mem_ptr - 1));

}
Revision:	1.13
Committed:	Sun Dec 15 01:12:01 2002 UTC (21 years, 9 months ago) by edgomez
Content type:	text/plain
Branch:	MAIN
Changes since 1.12:	+2 -2 lines
Log Message:	Fix the fix
#	User	Rev	Content
1	edgomez	1.7	/*****************************************************************************
2			*
3			* XVID MPEG-4 VIDEO CODEC
4			* - Aligned memory allocator -
5			*
6	edgomez	1.10	* Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>
7	edgomez	1.9	* 2002 Edouard Gomez
8			*
9	edgomez	1.11	* This file is part of XviD, a free MPEG-4 video encoder/decoder
10			*
11			* XviD is free software; you can redistribute it and/or modify it
12			* under the terms of the GNU General Public License as published by
13			* the Free Software Foundation; either version 2 of the License, or
14	edgomez	1.7	* (at your option) any later version.
15			*
16			* This program is distributed in the hope that it will be useful,
17	edgomez	1.11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	edgomez	1.7	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19			* GNU General Public License for more details.
20			*
21			* You should have received a copy of the GNU General Public License
22	edgomez	1.11	* along with this program; if not, write to the Free Software
23	edgomez	1.7	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24			*
25	edgomez	1.11	* Under section 8 of the GNU General Public License, the copyright
26			* holders of XVID explicitly forbid distribution in the following
27			* countries:
28			*
29			* - Japan
30			* - United States of America
31			*
32			* Linking XviD statically or dynamically with other modules is making a
33			* combined work based on XviD. Thus, the terms and conditions of the
34			* GNU General Public License cover the whole combination.
35			*
36			* As a special exception, the copyright holders of XviD give you
37			* permission to link XviD with independent modules that communicate with
38			* XviD solely through the VFW1.1 and DShow interfaces, regardless of the
39			* license terms of these independent modules, and to copy and distribute
40			* the resulting combined work under terms of your choice, provided that
41			* every copy of the combined work is accompanied by a complete copy of
42			* the source code of XviD (the version of XviD used to produce the
43			* combined work), being distributed under the terms of the GNU General
44			* Public License plus this exception. An independent module is a module
45			* which is not derived from or based on XviD.
46			*
47			* Note that people who make modified versions of XviD are not obligated
48			* to grant this special exception for their modified versions; it is
49			* their choice whether to do so. The GNU General Public License gives
50			* permission to release a modified version without this exception; this
51			* exception also makes it possible to release a modified version which
52			* carries forward this exception.
53			*
54	edgomez	1.13	* $Id: mem_align.c,v 1.12 2002/11/27 21:20:33 edgomez Exp $
55	edgomez	1.7	*
56			****************************************************************************/
57
58	Isibaar	1.2	#include <stdlib.h>
59			#include <stdio.h>
60			#include "mem_align.h"
61
62	edgomez	1.7	/*****************************************************************************
63			* xvid_malloc
64			*
65			* This function allocates 'size' bytes (usable by the user) on the heap and
66			* takes care of the requested 'alignment'.
67			* In order to align the allocated memory block, the xvid_malloc allocates
68			* 'size' bytes + 'alignment' bytes. So try to keep alignment very small
69			* when allocating small pieces of memory.
70			*
71			* NB : a block allocated by xvid_malloc _must_ be freed with xvid_free
72			* (the libc free will return an error)
73			*
74			* Returned value : - NULL on error
75			* - Pointer to the allocated aligned block
76			*
77			****************************************************************************/
78
79	edgomez	1.6	void *
80			xvid_malloc(size_t size,
81			uint8_t alignment)
82	Isibaar	1.2	{
83	edgomez	1.3	uint8_t *mem_ptr;
84	edgomez	1.6
85			if (!alignment) {
86	edgomez	1.4
87			/* We have not to satisfy any alignment */
88	edgomez	1.6	if ((mem_ptr = (uint8_t *) malloc(size + 1)) != NULL) {
89	edgomez	1.4
90			/* Store (mem_ptr - "real allocated memory") in (mem_ptr-1) /
91	edgomez	1.13	*mem_ptr = 1;
92	edgomez	1.4
93			/* Return the mem_ptr pointer */
94	edgomez	1.12	return (void *)(mem_ptr+1);
95	edgomez	1.4
96	edgomez	1.3	}
97	edgomez	1.4
98	edgomez	1.6	} else {
99	edgomez	1.3	uint8_t *tmp;
100	edgomez	1.6
101	edgomez	1.4	/*
102			* Allocate the required size memory + alignment so we
103			* can realign the data if necessary
104			*/
105
106	edgomez	1.6	if ((tmp = (uint8_t *) malloc(size + alignment)) != NULL) {
107	edgomez	1.4
108			/* Align the tmp pointer */
109	edgomez	1.6	mem_ptr =
110	Isibaar	1.8	(uint8_t *) ((ptr_t) (tmp + alignment - 1) &
111			(~(ptr_t) (alignment - 1)));
112	edgomez	1.4
113			/*
114			* Special case where malloc have already satisfied the alignment
115			* We must add alignment to mem_ptr because we must store
116			* (mem_ptr - tmp) in *(mem_ptr-1)
117			* If we do not add alignment to mem_ptr then *(mem_ptr-1) points
118			* to a forbidden memory space
119			*/
120	edgomez	1.6	if (mem_ptr == tmp)
121			mem_ptr += alignment;
122	edgomez	1.4
123			/*
124			* (mem_ptr - tmp) is stored in *(mem_ptr-1) so we are able to retrieve
125			* the real malloc block allocated and free it in xvid_free
126			*/
127	edgomez	1.6	*(mem_ptr - 1) = (uint8_t) (mem_ptr - tmp);
128	edgomez	1.4
129			/* Return the aligned pointer */
130	edgomez	1.3	return (void *) mem_ptr;
131	edgomez	1.4
132	edgomez	1.3	}
133			}
134
135			return NULL;
136	Isibaar	1.2
137			}
138	edgomez	1.7
139			/*****************************************************************************
140			* xvid_free
141			*
142			* Free a previously 'xvid_malloc' allocated block. Does not free NULL
143			* references.
144			*
145			* Returned value : None.
146			*
147			****************************************************************************/
148	Isibaar	1.2
149	edgomez	1.6	void
150			xvid_free(void *mem_ptr)
151	Isibaar	1.2	{
152
153	edgomez	1.4	/* (mem_ptr - 1) give us the offset to the real malloc block /
154	edgomez	1.6	if (mem_ptr)
155			free((uint8_t ) mem_ptr - ((uint8_t *) mem_ptr - 1));
156	Isibaar	1.2
157			}