be more precise in long long int literal specification for ANSI compilers (gcc3 requi...
[flac.git] / src / libFLAC / memory.c
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2001,2002,2003,2004  Josh Coalson
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * - Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *
11  * - Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditions and the following disclaimer in the
13  * documentation and/or other materials provided with the distribution.
14  *
15  * - Neither the name of the Xiph.org Foundation nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "private/memory.h"
33 #include "FLAC/assert.h"
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38
39 void *FLAC__memory_alloc_aligned(size_t bytes, void **aligned_address)
40 {
41         void *x;
42
43         FLAC__ASSERT(0 != aligned_address);
44
45 #ifdef FLAC__ALIGN_MALLOC_DATA
46         /* align on 32-byte (256-bit) boundary */
47         x = malloc(bytes+31);
48         *aligned_address = (void*)(((unsigned)x + 31) & -32);
49 #else
50         x = malloc(bytes);
51         *aligned_address = x;
52 #endif
53         return x;
54 }
55
56 FLAC__bool FLAC__memory_alloc_aligned_int32_array(unsigned elements, FLAC__int32 **unaligned_pointer, FLAC__int32 **aligned_pointer)
57 {
58         FLAC__int32 *pa, *pu; /* aligned pointer, unaligned pointer */
59
60         FLAC__ASSERT(elements > 0);
61         FLAC__ASSERT(0 != unaligned_pointer);
62         FLAC__ASSERT(0 != aligned_pointer);
63         FLAC__ASSERT(unaligned_pointer != aligned_pointer);
64
65         pu = (FLAC__int32*)FLAC__memory_alloc_aligned(sizeof(FLAC__int32) * elements, (void**)&pa);
66         if(0 == pu) {
67                 return false;
68         }
69         else {
70                 if(*unaligned_pointer != 0)
71                         free(*unaligned_pointer);
72                 *unaligned_pointer = pu;
73                 *aligned_pointer = pa;
74                 return true;
75         }
76 }
77
78 FLAC__bool FLAC__memory_alloc_aligned_uint32_array(unsigned elements, FLAC__uint32 **unaligned_pointer, FLAC__uint32 **aligned_pointer)
79 {
80         FLAC__uint32 *pa, *pu; /* aligned pointer, unaligned pointer */
81
82         FLAC__ASSERT(elements > 0);
83         FLAC__ASSERT(0 != unaligned_pointer);
84         FLAC__ASSERT(0 != aligned_pointer);
85         FLAC__ASSERT(unaligned_pointer != aligned_pointer);
86
87         pu = (FLAC__uint32*)FLAC__memory_alloc_aligned(sizeof(FLAC__uint32) * elements, (void**)&pa);
88         if(0 == pu) {
89                 return false;
90         }
91         else {
92                 if(*unaligned_pointer != 0)
93                         free(*unaligned_pointer);
94                 *unaligned_pointer = pu;
95                 *aligned_pointer = pa;
96                 return true;
97         }
98 }
99
100 FLAC__bool FLAC__memory_alloc_aligned_uint64_array(unsigned elements, FLAC__uint64 **unaligned_pointer, FLAC__uint64 **aligned_pointer)
101 {
102         FLAC__uint64 *pa, *pu; /* aligned pointer, unaligned pointer */
103
104         FLAC__ASSERT(elements > 0);
105         FLAC__ASSERT(0 != unaligned_pointer);
106         FLAC__ASSERT(0 != aligned_pointer);
107         FLAC__ASSERT(unaligned_pointer != aligned_pointer);
108
109         pu = (FLAC__uint64*)FLAC__memory_alloc_aligned(sizeof(FLAC__uint64) * elements, (void**)&pa);
110         if(0 == pu) {
111                 return false;
112         }
113         else {
114                 if(*unaligned_pointer != 0)
115                         free(*unaligned_pointer);
116                 *unaligned_pointer = pu;
117                 *aligned_pointer = pa;
118                 return true;
119         }
120 }
121
122 FLAC__bool FLAC__memory_alloc_aligned_unsigned_array(unsigned elements, unsigned **unaligned_pointer, unsigned **aligned_pointer)
123 {
124         unsigned *pa, *pu; /* aligned pointer, unaligned pointer */
125
126         FLAC__ASSERT(elements > 0);
127         FLAC__ASSERT(0 != unaligned_pointer);
128         FLAC__ASSERT(0 != aligned_pointer);
129         FLAC__ASSERT(unaligned_pointer != aligned_pointer);
130
131         pu = (unsigned*)FLAC__memory_alloc_aligned(sizeof(unsigned) * elements, (void**)&pa);
132         if(0 == pu) {
133                 return false;
134         }
135         else {
136                 if(*unaligned_pointer != 0)
137                         free(*unaligned_pointer);
138                 *unaligned_pointer = pu;
139                 *aligned_pointer = pa;
140                 return true;
141         }
142 }
143
144 FLAC__bool FLAC__memory_alloc_aligned_real_array(unsigned elements, FLAC__real **unaligned_pointer, FLAC__real **aligned_pointer)
145 {
146         FLAC__real *pa, *pu; /* aligned pointer, unaligned pointer */
147
148         FLAC__ASSERT(elements > 0);
149         FLAC__ASSERT(0 != unaligned_pointer);
150         FLAC__ASSERT(0 != aligned_pointer);
151         FLAC__ASSERT(unaligned_pointer != aligned_pointer);
152
153         pu = (FLAC__real*)FLAC__memory_alloc_aligned(sizeof(FLAC__real) * elements, (void**)&pa);
154         if(0 == pu) {
155                 return false;
156         }
157         else {
158                 if(*unaligned_pointer != 0)
159                         free(*unaligned_pointer);
160                 *unaligned_pointer = pu;
161                 *aligned_pointer = pa;
162                 return true;
163         }
164 }