diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemmgr.c')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemmgr.c | 2238 |
1 files changed, 1119 insertions, 1119 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemmgr.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemmgr.c index 92ee3ac..f0e83fb 100644 --- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemmgr.c +++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemmgr.c | |||
@@ -1,1119 +1,1119 @@ | |||
1 | /* | 1 | /* |
2 | * jmemmgr.c | 2 | * jmemmgr.c |
3 | * | 3 | * |
4 | * Copyright (C) 1991-1997, Thomas G. Lane. | 4 | * Copyright (C) 1991-1997, Thomas G. Lane. |
5 | * Modified 2011 by Guido Vollbeding. | 5 | * Modified 2011 by Guido Vollbeding. |
6 | * This file is part of the Independent JPEG Group's software. | 6 | * This file is part of the Independent JPEG Group's software. |
7 | * For conditions of distribution and use, see the accompanying README file. | 7 | * For conditions of distribution and use, see the accompanying README file. |
8 | * | 8 | * |
9 | * This file contains the JPEG system-independent memory management | 9 | * This file contains the JPEG system-independent memory management |
10 | * routines. This code is usable across a wide variety of machines; most | 10 | * routines. This code is usable across a wide variety of machines; most |
11 | * of the system dependencies have been isolated in a separate file. | 11 | * of the system dependencies have been isolated in a separate file. |
12 | * The major functions provided here are: | 12 | * The major functions provided here are: |
13 | * * pool-based allocation and freeing of memory; | 13 | * * pool-based allocation and freeing of memory; |
14 | * * policy decisions about how to divide available memory among the | 14 | * * policy decisions about how to divide available memory among the |
15 | * virtual arrays; | 15 | * virtual arrays; |
16 | * * control logic for swapping virtual arrays between main memory and | 16 | * * control logic for swapping virtual arrays between main memory and |
17 | * backing storage. | 17 | * backing storage. |
18 | * The separate system-dependent file provides the actual backing-storage | 18 | * The separate system-dependent file provides the actual backing-storage |
19 | * access code, and it contains the policy decision about how much total | 19 | * access code, and it contains the policy decision about how much total |
20 | * main memory to use. | 20 | * main memory to use. |
21 | * This file is system-dependent in the sense that some of its functions | 21 | * This file is system-dependent in the sense that some of its functions |
22 | * are unnecessary in some systems. For example, if there is enough virtual | 22 | * are unnecessary in some systems. For example, if there is enough virtual |
23 | * memory so that backing storage will never be used, much of the virtual | 23 | * memory so that backing storage will never be used, much of the virtual |
24 | * array control logic could be removed. (Of course, if you have that much | 24 | * array control logic could be removed. (Of course, if you have that much |
25 | * memory then you shouldn't care about a little bit of unused code...) | 25 | * memory then you shouldn't care about a little bit of unused code...) |
26 | */ | 26 | */ |
27 | 27 | ||
28 | #define JPEG_INTERNALS | 28 | #define JPEG_INTERNALS |
29 | #define AM_MEMORY_MANAGER /* we define jvirt_Xarray_control structs */ | 29 | #define AM_MEMORY_MANAGER /* we define jvirt_Xarray_control structs */ |
30 | #include "jinclude.h" | 30 | #include "jinclude.h" |
31 | #include "jpeglib.h" | 31 | #include "jpeglib.h" |
32 | #include "jmemsys.h" /* import the system-dependent declarations */ | 32 | #include "jmemsys.h" /* import the system-dependent declarations */ |
33 | 33 | ||
34 | #ifndef NO_GETENV | 34 | #ifndef NO_GETENV |
35 | #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare getenv() */ | 35 | #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare getenv() */ |
36 | extern char * getenv JPP((const char * name)); | 36 | extern char * getenv JPP((const char * name)); |
37 | #endif | 37 | #endif |
38 | #endif | 38 | #endif |
39 | 39 | ||
40 | 40 | ||
41 | /* | 41 | /* |
42 | * Some important notes: | 42 | * Some important notes: |
43 | * The allocation routines provided here must never return NULL. | 43 | * The allocation routines provided here must never return NULL. |
44 | * They should exit to error_exit if unsuccessful. | 44 | * They should exit to error_exit if unsuccessful. |
45 | * | 45 | * |
46 | * It's not a good idea to try to merge the sarray and barray routines, | 46 | * It's not a good idea to try to merge the sarray and barray routines, |
47 | * even though they are textually almost the same, because samples are | 47 | * even though they are textually almost the same, because samples are |
48 | * usually stored as bytes while coefficients are shorts or ints. Thus, | 48 | * usually stored as bytes while coefficients are shorts or ints. Thus, |
49 | * in machines where byte pointers have a different representation from | 49 | * in machines where byte pointers have a different representation from |
50 | * word pointers, the resulting machine code could not be the same. | 50 | * word pointers, the resulting machine code could not be the same. |
51 | */ | 51 | */ |
52 | 52 | ||
53 | 53 | ||
54 | /* | 54 | /* |
55 | * Many machines require storage alignment: longs must start on 4-byte | 55 | * Many machines require storage alignment: longs must start on 4-byte |
56 | * boundaries, doubles on 8-byte boundaries, etc. On such machines, malloc() | 56 | * boundaries, doubles on 8-byte boundaries, etc. On such machines, malloc() |
57 | * always returns pointers that are multiples of the worst-case alignment | 57 | * always returns pointers that are multiples of the worst-case alignment |
58 | * requirement, and we had better do so too. | 58 | * requirement, and we had better do so too. |
59 | * There isn't any really portable way to determine the worst-case alignment | 59 | * There isn't any really portable way to determine the worst-case alignment |
60 | * requirement. This module assumes that the alignment requirement is | 60 | * requirement. This module assumes that the alignment requirement is |
61 | * multiples of sizeof(ALIGN_TYPE). | 61 | * multiples of sizeof(ALIGN_TYPE). |
62 | * By default, we define ALIGN_TYPE as double. This is necessary on some | 62 | * By default, we define ALIGN_TYPE as double. This is necessary on some |
63 | * workstations (where doubles really do need 8-byte alignment) and will work | 63 | * workstations (where doubles really do need 8-byte alignment) and will work |
64 | * fine on nearly everything. If your machine has lesser alignment needs, | 64 | * fine on nearly everything. If your machine has lesser alignment needs, |
65 | * you can save a few bytes by making ALIGN_TYPE smaller. | 65 | * you can save a few bytes by making ALIGN_TYPE smaller. |
66 | * The only place I know of where this will NOT work is certain Macintosh | 66 | * The only place I know of where this will NOT work is certain Macintosh |
67 | * 680x0 compilers that define double as a 10-byte IEEE extended float. | 67 | * 680x0 compilers that define double as a 10-byte IEEE extended float. |
68 | * Doing 10-byte alignment is counterproductive because longwords won't be | 68 | * Doing 10-byte alignment is counterproductive because longwords won't be |
69 | * aligned well. Put "#define ALIGN_TYPE long" in jconfig.h if you have | 69 | * aligned well. Put "#define ALIGN_TYPE long" in jconfig.h if you have |
70 | * such a compiler. | 70 | * such a compiler. |
71 | */ | 71 | */ |
72 | 72 | ||
73 | #ifndef ALIGN_TYPE /* so can override from jconfig.h */ | 73 | #ifndef ALIGN_TYPE /* so can override from jconfig.h */ |
74 | #define ALIGN_TYPE double | 74 | #define ALIGN_TYPE double |
75 | #endif | 75 | #endif |
76 | 76 | ||
77 | 77 | ||
78 | /* | 78 | /* |
79 | * We allocate objects from "pools", where each pool is gotten with a single | 79 | * We allocate objects from "pools", where each pool is gotten with a single |
80 | * request to jpeg_get_small() or jpeg_get_large(). There is no per-object | 80 | * request to jpeg_get_small() or jpeg_get_large(). There is no per-object |
81 | * overhead within a pool, except for alignment padding. Each pool has a | 81 | * overhead within a pool, except for alignment padding. Each pool has a |
82 | * header with a link to the next pool of the same class. | 82 | * header with a link to the next pool of the same class. |
83 | * Small and large pool headers are identical except that the latter's | 83 | * Small and large pool headers are identical except that the latter's |
84 | * link pointer must be FAR on 80x86 machines. | 84 | * link pointer must be FAR on 80x86 machines. |
85 | * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE | 85 | * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE |
86 | * field. This forces the compiler to make SIZEOF(small_pool_hdr) a multiple | 86 | * field. This forces the compiler to make SIZEOF(small_pool_hdr) a multiple |
87 | * of the alignment requirement of ALIGN_TYPE. | 87 | * of the alignment requirement of ALIGN_TYPE. |
88 | */ | 88 | */ |
89 | 89 | ||
90 | typedef union small_pool_struct * small_pool_ptr; | 90 | typedef union small_pool_struct * small_pool_ptr; |
91 | 91 | ||
92 | typedef union small_pool_struct { | 92 | typedef union small_pool_struct { |
93 | struct { | 93 | struct { |
94 | small_pool_ptr next; /* next in list of pools */ | 94 | small_pool_ptr next; /* next in list of pools */ |
95 | size_t bytes_used; /* how many bytes already used within pool */ | 95 | size_t bytes_used; /* how many bytes already used within pool */ |
96 | size_t bytes_left; /* bytes still available in this pool */ | 96 | size_t bytes_left; /* bytes still available in this pool */ |
97 | } hdr; | 97 | } hdr; |
98 | ALIGN_TYPE dummy; /* included in union to ensure alignment */ | 98 | ALIGN_TYPE dummy; /* included in union to ensure alignment */ |
99 | } small_pool_hdr; | 99 | } small_pool_hdr; |
100 | 100 | ||
101 | typedef union large_pool_struct FAR * large_pool_ptr; | 101 | typedef union large_pool_struct FAR * large_pool_ptr; |
102 | 102 | ||
103 | typedef union large_pool_struct { | 103 | typedef union large_pool_struct { |
104 | struct { | 104 | struct { |
105 | large_pool_ptr next; /* next in list of pools */ | 105 | large_pool_ptr next; /* next in list of pools */ |
106 | size_t bytes_used; /* how many bytes already used within pool */ | 106 | size_t bytes_used; /* how many bytes already used within pool */ |
107 | size_t bytes_left; /* bytes still available in this pool */ | 107 | size_t bytes_left; /* bytes still available in this pool */ |
108 | } hdr; | 108 | } hdr; |
109 | ALIGN_TYPE dummy; /* included in union to ensure alignment */ | 109 | ALIGN_TYPE dummy; /* included in union to ensure alignment */ |
110 | } large_pool_hdr; | 110 | } large_pool_hdr; |
111 | 111 | ||
112 | 112 | ||
113 | /* | 113 | /* |
114 | * Here is the full definition of a memory manager object. | 114 | * Here is the full definition of a memory manager object. |
115 | */ | 115 | */ |
116 | 116 | ||
117 | typedef struct { | 117 | typedef struct { |
118 | struct jpeg_memory_mgr pub; /* public fields */ | 118 | struct jpeg_memory_mgr pub; /* public fields */ |
119 | 119 | ||
120 | /* Each pool identifier (lifetime class) names a linked list of pools. */ | 120 | /* Each pool identifier (lifetime class) names a linked list of pools. */ |
121 | small_pool_ptr small_list[JPOOL_NUMPOOLS]; | 121 | small_pool_ptr small_list[JPOOL_NUMPOOLS]; |
122 | large_pool_ptr large_list[JPOOL_NUMPOOLS]; | 122 | large_pool_ptr large_list[JPOOL_NUMPOOLS]; |
123 | 123 | ||
124 | /* Since we only have one lifetime class of virtual arrays, only one | 124 | /* Since we only have one lifetime class of virtual arrays, only one |
125 | * linked list is necessary (for each datatype). Note that the virtual | 125 | * linked list is necessary (for each datatype). Note that the virtual |
126 | * array control blocks being linked together are actually stored somewhere | 126 | * array control blocks being linked together are actually stored somewhere |
127 | * in the small-pool list. | 127 | * in the small-pool list. |
128 | */ | 128 | */ |
129 | jvirt_sarray_ptr virt_sarray_list; | 129 | jvirt_sarray_ptr virt_sarray_list; |
130 | jvirt_barray_ptr virt_barray_list; | 130 | jvirt_barray_ptr virt_barray_list; |
131 | 131 | ||
132 | /* This counts total space obtained from jpeg_get_small/large */ | 132 | /* This counts total space obtained from jpeg_get_small/large */ |
133 | long total_space_allocated; | 133 | long total_space_allocated; |
134 | 134 | ||
135 | /* alloc_sarray and alloc_barray set this value for use by virtual | 135 | /* alloc_sarray and alloc_barray set this value for use by virtual |
136 | * array routines. | 136 | * array routines. |
137 | */ | 137 | */ |
138 | JDIMENSION last_rowsperchunk; /* from most recent alloc_sarray/barray */ | 138 | JDIMENSION last_rowsperchunk; /* from most recent alloc_sarray/barray */ |
139 | } my_memory_mgr; | 139 | } my_memory_mgr; |
140 | 140 | ||
141 | typedef my_memory_mgr * my_mem_ptr; | 141 | typedef my_memory_mgr * my_mem_ptr; |
142 | 142 | ||
143 | 143 | ||
144 | /* | 144 | /* |
145 | * The control blocks for virtual arrays. | 145 | * The control blocks for virtual arrays. |
146 | * Note that these blocks are allocated in the "small" pool area. | 146 | * Note that these blocks are allocated in the "small" pool area. |
147 | * System-dependent info for the associated backing store (if any) is hidden | 147 | * System-dependent info for the associated backing store (if any) is hidden |
148 | * inside the backing_store_info struct. | 148 | * inside the backing_store_info struct. |
149 | */ | 149 | */ |
150 | 150 | ||
151 | struct jvirt_sarray_control { | 151 | struct jvirt_sarray_control { |
152 | JSAMPARRAY mem_buffer; /* => the in-memory buffer */ | 152 | JSAMPARRAY mem_buffer; /* => the in-memory buffer */ |
153 | JDIMENSION rows_in_array; /* total virtual array height */ | 153 | JDIMENSION rows_in_array; /* total virtual array height */ |
154 | JDIMENSION samplesperrow; /* width of array (and of memory buffer) */ | 154 | JDIMENSION samplesperrow; /* width of array (and of memory buffer) */ |
155 | JDIMENSION maxaccess; /* max rows accessed by access_virt_sarray */ | 155 | JDIMENSION maxaccess; /* max rows accessed by access_virt_sarray */ |
156 | JDIMENSION rows_in_mem; /* height of memory buffer */ | 156 | JDIMENSION rows_in_mem; /* height of memory buffer */ |
157 | JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ | 157 | JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ |
158 | JDIMENSION cur_start_row; /* first logical row # in the buffer */ | 158 | JDIMENSION cur_start_row; /* first logical row # in the buffer */ |
159 | JDIMENSION first_undef_row; /* row # of first uninitialized row */ | 159 | JDIMENSION first_undef_row; /* row # of first uninitialized row */ |
160 | boolean pre_zero; /* pre-zero mode requested? */ | 160 | boolean pre_zero; /* pre-zero mode requested? */ |
161 | boolean dirty; /* do current buffer contents need written? */ | 161 | boolean dirty; /* do current buffer contents need written? */ |
162 | boolean b_s_open; /* is backing-store data valid? */ | 162 | boolean b_s_open; /* is backing-store data valid? */ |
163 | jvirt_sarray_ptr next; /* link to next virtual sarray control block */ | 163 | jvirt_sarray_ptr next; /* link to next virtual sarray control block */ |
164 | backing_store_info b_s_info; /* System-dependent control info */ | 164 | backing_store_info b_s_info; /* System-dependent control info */ |
165 | }; | 165 | }; |
166 | 166 | ||
167 | struct jvirt_barray_control { | 167 | struct jvirt_barray_control { |
168 | JBLOCKARRAY mem_buffer; /* => the in-memory buffer */ | 168 | JBLOCKARRAY mem_buffer; /* => the in-memory buffer */ |
169 | JDIMENSION rows_in_array; /* total virtual array height */ | 169 | JDIMENSION rows_in_array; /* total virtual array height */ |
170 | JDIMENSION blocksperrow; /* width of array (and of memory buffer) */ | 170 | JDIMENSION blocksperrow; /* width of array (and of memory buffer) */ |
171 | JDIMENSION maxaccess; /* max rows accessed by access_virt_barray */ | 171 | JDIMENSION maxaccess; /* max rows accessed by access_virt_barray */ |
172 | JDIMENSION rows_in_mem; /* height of memory buffer */ | 172 | JDIMENSION rows_in_mem; /* height of memory buffer */ |
173 | JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ | 173 | JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ |
174 | JDIMENSION cur_start_row; /* first logical row # in the buffer */ | 174 | JDIMENSION cur_start_row; /* first logical row # in the buffer */ |
175 | JDIMENSION first_undef_row; /* row # of first uninitialized row */ | 175 | JDIMENSION first_undef_row; /* row # of first uninitialized row */ |
176 | boolean pre_zero; /* pre-zero mode requested? */ | 176 | boolean pre_zero; /* pre-zero mode requested? */ |
177 | boolean dirty; /* do current buffer contents need written? */ | 177 | boolean dirty; /* do current buffer contents need written? */ |
178 | boolean b_s_open; /* is backing-store data valid? */ | 178 | boolean b_s_open; /* is backing-store data valid? */ |
179 | jvirt_barray_ptr next; /* link to next virtual barray control block */ | 179 | jvirt_barray_ptr next; /* link to next virtual barray control block */ |
180 | backing_store_info b_s_info; /* System-dependent control info */ | 180 | backing_store_info b_s_info; /* System-dependent control info */ |
181 | }; | 181 | }; |
182 | 182 | ||
183 | 183 | ||
184 | #ifdef MEM_STATS /* optional extra stuff for statistics */ | 184 | #ifdef MEM_STATS /* optional extra stuff for statistics */ |
185 | 185 | ||
186 | LOCAL(void) | 186 | LOCAL(void) |
187 | print_mem_stats (j_common_ptr cinfo, int pool_id) | 187 | print_mem_stats (j_common_ptr cinfo, int pool_id) |
188 | { | 188 | { |
189 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; | 189 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; |
190 | small_pool_ptr shdr_ptr; | 190 | small_pool_ptr shdr_ptr; |
191 | large_pool_ptr lhdr_ptr; | 191 | large_pool_ptr lhdr_ptr; |
192 | 192 | ||
193 | /* Since this is only a debugging stub, we can cheat a little by using | 193 | /* Since this is only a debugging stub, we can cheat a little by using |
194 | * fprintf directly rather than going through the trace message code. | 194 | * fprintf directly rather than going through the trace message code. |
195 | * This is helpful because message parm array can't handle longs. | 195 | * This is helpful because message parm array can't handle longs. |
196 | */ | 196 | */ |
197 | fprintf(stderr, "Freeing pool %d, total space = %ld\n", | 197 | fprintf(stderr, "Freeing pool %d, total space = %ld\n", |
198 | pool_id, mem->total_space_allocated); | 198 | pool_id, mem->total_space_allocated); |
199 | 199 | ||
200 | for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL; | 200 | for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL; |
201 | lhdr_ptr = lhdr_ptr->hdr.next) { | 201 | lhdr_ptr = lhdr_ptr->hdr.next) { |
202 | fprintf(stderr, " Large chunk used %ld\n", | 202 | fprintf(stderr, " Large chunk used %ld\n", |
203 | (long) lhdr_ptr->hdr.bytes_used); | 203 | (long) lhdr_ptr->hdr.bytes_used); |
204 | } | 204 | } |
205 | 205 | ||
206 | for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL; | 206 | for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL; |
207 | shdr_ptr = shdr_ptr->hdr.next) { | 207 | shdr_ptr = shdr_ptr->hdr.next) { |
208 | fprintf(stderr, " Small chunk used %ld free %ld\n", | 208 | fprintf(stderr, " Small chunk used %ld free %ld\n", |
209 | (long) shdr_ptr->hdr.bytes_used, | 209 | (long) shdr_ptr->hdr.bytes_used, |
210 | (long) shdr_ptr->hdr.bytes_left); | 210 | (long) shdr_ptr->hdr.bytes_left); |
211 | } | 211 | } |
212 | } | 212 | } |
213 | 213 | ||
214 | #endif /* MEM_STATS */ | 214 | #endif /* MEM_STATS */ |
215 | 215 | ||
216 | 216 | ||
217 | LOCAL(void) | 217 | LOCAL(void) |
218 | out_of_memory (j_common_ptr cinfo, int which) | 218 | out_of_memory (j_common_ptr cinfo, int which) |
219 | /* Report an out-of-memory error and stop execution */ | 219 | /* Report an out-of-memory error and stop execution */ |
220 | /* If we compiled MEM_STATS support, report alloc requests before dying */ | 220 | /* If we compiled MEM_STATS support, report alloc requests before dying */ |
221 | { | 221 | { |
222 | #ifdef MEM_STATS | 222 | #ifdef MEM_STATS |
223 | cinfo->err->trace_level = 2; /* force self_destruct to report stats */ | 223 | cinfo->err->trace_level = 2; /* force self_destruct to report stats */ |
224 | #endif | 224 | #endif |
225 | ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which); | 225 | ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which); |
226 | } | 226 | } |
227 | 227 | ||
228 | 228 | ||
229 | /* | 229 | /* |
230 | * Allocation of "small" objects. | 230 | * Allocation of "small" objects. |
231 | * | 231 | * |
232 | * For these, we use pooled storage. When a new pool must be created, | 232 | * For these, we use pooled storage. When a new pool must be created, |
233 | * we try to get enough space for the current request plus a "slop" factor, | 233 | * we try to get enough space for the current request plus a "slop" factor, |
234 | * where the slop will be the amount of leftover space in the new pool. | 234 | * where the slop will be the amount of leftover space in the new pool. |
235 | * The speed vs. space tradeoff is largely determined by the slop values. | 235 | * The speed vs. space tradeoff is largely determined by the slop values. |
236 | * A different slop value is provided for each pool class (lifetime), | 236 | * A different slop value is provided for each pool class (lifetime), |
237 | * and we also distinguish the first pool of a class from later ones. | 237 | * and we also distinguish the first pool of a class from later ones. |
238 | * NOTE: the values given work fairly well on both 16- and 32-bit-int | 238 | * NOTE: the values given work fairly well on both 16- and 32-bit-int |
239 | * machines, but may be too small if longs are 64 bits or more. | 239 | * machines, but may be too small if longs are 64 bits or more. |
240 | */ | 240 | */ |
241 | 241 | ||
242 | static const size_t first_pool_slop[JPOOL_NUMPOOLS] = | 242 | static const size_t first_pool_slop[JPOOL_NUMPOOLS] = |
243 | { | 243 | { |
244 | 1600, /* first PERMANENT pool */ | 244 | 1600, /* first PERMANENT pool */ |
245 | 16000 /* first IMAGE pool */ | 245 | 16000 /* first IMAGE pool */ |
246 | }; | 246 | }; |
247 | 247 | ||
248 | static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = | 248 | static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = |
249 | { | 249 | { |
250 | 0, /* additional PERMANENT pools */ | 250 | 0, /* additional PERMANENT pools */ |
251 | 5000 /* additional IMAGE pools */ | 251 | 5000 /* additional IMAGE pools */ |
252 | }; | 252 | }; |
253 | 253 | ||
254 | #define MIN_SLOP 50 /* greater than 0 to avoid futile looping */ | 254 | #define MIN_SLOP 50 /* greater than 0 to avoid futile looping */ |
255 | 255 | ||
256 | 256 | ||
257 | METHODDEF(void *) | 257 | METHODDEF(void *) |
258 | alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject) | 258 | alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject) |
259 | /* Allocate a "small" object */ | 259 | /* Allocate a "small" object */ |
260 | { | 260 | { |
261 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; | 261 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; |
262 | small_pool_ptr hdr_ptr, prev_hdr_ptr; | 262 | small_pool_ptr hdr_ptr, prev_hdr_ptr; |
263 | char * data_ptr; | 263 | char * data_ptr; |
264 | size_t odd_bytes, min_request, slop; | 264 | size_t odd_bytes, min_request, slop; |
265 | 265 | ||
266 | /* Check for unsatisfiable request (do now to ensure no overflow below) */ | 266 | /* Check for unsatisfiable request (do now to ensure no overflow below) */ |
267 | if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr))) | 267 | if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr))) |
268 | out_of_memory(cinfo, 1); /* request exceeds malloc's ability */ | 268 | out_of_memory(cinfo, 1); /* request exceeds malloc's ability */ |
269 | 269 | ||
270 | /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ | 270 | /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ |
271 | odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); | 271 | odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); |
272 | if (odd_bytes > 0) | 272 | if (odd_bytes > 0) |
273 | sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; | 273 | sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; |
274 | 274 | ||
275 | /* See if space is available in any existing pool */ | 275 | /* See if space is available in any existing pool */ |
276 | if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) | 276 | if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) |
277 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ | 277 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ |
278 | prev_hdr_ptr = NULL; | 278 | prev_hdr_ptr = NULL; |
279 | hdr_ptr = mem->small_list[pool_id]; | 279 | hdr_ptr = mem->small_list[pool_id]; |
280 | while (hdr_ptr != NULL) { | 280 | while (hdr_ptr != NULL) { |
281 | if (hdr_ptr->hdr.bytes_left >= sizeofobject) | 281 | if (hdr_ptr->hdr.bytes_left >= sizeofobject) |
282 | break; /* found pool with enough space */ | 282 | break; /* found pool with enough space */ |
283 | prev_hdr_ptr = hdr_ptr; | 283 | prev_hdr_ptr = hdr_ptr; |
284 | hdr_ptr = hdr_ptr->hdr.next; | 284 | hdr_ptr = hdr_ptr->hdr.next; |
285 | } | 285 | } |
286 | 286 | ||
287 | /* Time to make a new pool? */ | 287 | /* Time to make a new pool? */ |
288 | if (hdr_ptr == NULL) { | 288 | if (hdr_ptr == NULL) { |
289 | /* min_request is what we need now, slop is what will be leftover */ | 289 | /* min_request is what we need now, slop is what will be leftover */ |
290 | min_request = sizeofobject + SIZEOF(small_pool_hdr); | 290 | min_request = sizeofobject + SIZEOF(small_pool_hdr); |
291 | if (prev_hdr_ptr == NULL) /* first pool in class? */ | 291 | if (prev_hdr_ptr == NULL) /* first pool in class? */ |
292 | slop = first_pool_slop[pool_id]; | 292 | slop = first_pool_slop[pool_id]; |
293 | else | 293 | else |
294 | slop = extra_pool_slop[pool_id]; | 294 | slop = extra_pool_slop[pool_id]; |
295 | /* Don't ask for more than MAX_ALLOC_CHUNK */ | 295 | /* Don't ask for more than MAX_ALLOC_CHUNK */ |
296 | if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request)) | 296 | if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request)) |
297 | slop = (size_t) (MAX_ALLOC_CHUNK-min_request); | 297 | slop = (size_t) (MAX_ALLOC_CHUNK-min_request); |
298 | /* Try to get space, if fail reduce slop and try again */ | 298 | /* Try to get space, if fail reduce slop and try again */ |
299 | for (;;) { | 299 | for (;;) { |
300 | hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop); | 300 | hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop); |
301 | if (hdr_ptr != NULL) | 301 | if (hdr_ptr != NULL) |
302 | break; | 302 | break; |
303 | slop /= 2; | 303 | slop /= 2; |
304 | if (slop < MIN_SLOP) /* give up when it gets real small */ | 304 | if (slop < MIN_SLOP) /* give up when it gets real small */ |
305 | out_of_memory(cinfo, 2); /* jpeg_get_small failed */ | 305 | out_of_memory(cinfo, 2); /* jpeg_get_small failed */ |
306 | } | 306 | } |
307 | mem->total_space_allocated += min_request + slop; | 307 | mem->total_space_allocated += min_request + slop; |
308 | /* Success, initialize the new pool header and add to end of list */ | 308 | /* Success, initialize the new pool header and add to end of list */ |
309 | hdr_ptr->hdr.next = NULL; | 309 | hdr_ptr->hdr.next = NULL; |
310 | hdr_ptr->hdr.bytes_used = 0; | 310 | hdr_ptr->hdr.bytes_used = 0; |
311 | hdr_ptr->hdr.bytes_left = sizeofobject + slop; | 311 | hdr_ptr->hdr.bytes_left = sizeofobject + slop; |
312 | if (prev_hdr_ptr == NULL) /* first pool in class? */ | 312 | if (prev_hdr_ptr == NULL) /* first pool in class? */ |
313 | mem->small_list[pool_id] = hdr_ptr; | 313 | mem->small_list[pool_id] = hdr_ptr; |
314 | else | 314 | else |
315 | prev_hdr_ptr->hdr.next = hdr_ptr; | 315 | prev_hdr_ptr->hdr.next = hdr_ptr; |
316 | } | 316 | } |
317 | 317 | ||
318 | /* OK, allocate the object from the current pool */ | 318 | /* OK, allocate the object from the current pool */ |
319 | data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */ | 319 | data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */ |
320 | data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */ | 320 | data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */ |
321 | hdr_ptr->hdr.bytes_used += sizeofobject; | 321 | hdr_ptr->hdr.bytes_used += sizeofobject; |
322 | hdr_ptr->hdr.bytes_left -= sizeofobject; | 322 | hdr_ptr->hdr.bytes_left -= sizeofobject; |
323 | 323 | ||
324 | return (void *) data_ptr; | 324 | return (void *) data_ptr; |
325 | } | 325 | } |
326 | 326 | ||
327 | 327 | ||
328 | /* | 328 | /* |
329 | * Allocation of "large" objects. | 329 | * Allocation of "large" objects. |
330 | * | 330 | * |
331 | * The external semantics of these are the same as "small" objects, | 331 | * The external semantics of these are the same as "small" objects, |
332 | * except that FAR pointers are used on 80x86. However the pool | 332 | * except that FAR pointers are used on 80x86. However the pool |
333 | * management heuristics are quite different. We assume that each | 333 | * management heuristics are quite different. We assume that each |
334 | * request is large enough that it may as well be passed directly to | 334 | * request is large enough that it may as well be passed directly to |
335 | * jpeg_get_large; the pool management just links everything together | 335 | * jpeg_get_large; the pool management just links everything together |
336 | * so that we can free it all on demand. | 336 | * so that we can free it all on demand. |
337 | * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY | 337 | * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY |
338 | * structures. The routines that create these structures (see below) | 338 | * structures. The routines that create these structures (see below) |
339 | * deliberately bunch rows together to ensure a large request size. | 339 | * deliberately bunch rows together to ensure a large request size. |
340 | */ | 340 | */ |
341 | 341 | ||
342 | METHODDEF(void FAR *) | 342 | METHODDEF(void FAR *) |
343 | alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject) | 343 | alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject) |
344 | /* Allocate a "large" object */ | 344 | /* Allocate a "large" object */ |
345 | { | 345 | { |
346 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; | 346 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; |
347 | large_pool_ptr hdr_ptr; | 347 | large_pool_ptr hdr_ptr; |
348 | size_t odd_bytes; | 348 | size_t odd_bytes; |
349 | 349 | ||
350 | /* Check for unsatisfiable request (do now to ensure no overflow below) */ | 350 | /* Check for unsatisfiable request (do now to ensure no overflow below) */ |
351 | if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr))) | 351 | if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr))) |
352 | out_of_memory(cinfo, 3); /* request exceeds malloc's ability */ | 352 | out_of_memory(cinfo, 3); /* request exceeds malloc's ability */ |
353 | 353 | ||
354 | /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ | 354 | /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ |
355 | odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); | 355 | odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); |
356 | if (odd_bytes > 0) | 356 | if (odd_bytes > 0) |
357 | sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; | 357 | sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; |
358 | 358 | ||
359 | /* Always make a new pool */ | 359 | /* Always make a new pool */ |
360 | if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) | 360 | if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) |
361 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ | 361 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ |
362 | 362 | ||
363 | hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject + | 363 | hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject + |
364 | SIZEOF(large_pool_hdr)); | 364 | SIZEOF(large_pool_hdr)); |
365 | if (hdr_ptr == NULL) | 365 | if (hdr_ptr == NULL) |
366 | out_of_memory(cinfo, 4); /* jpeg_get_large failed */ | 366 | out_of_memory(cinfo, 4); /* jpeg_get_large failed */ |
367 | mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr); | 367 | mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr); |
368 | 368 | ||
369 | /* Success, initialize the new pool header and add to list */ | 369 | /* Success, initialize the new pool header and add to list */ |
370 | hdr_ptr->hdr.next = mem->large_list[pool_id]; | 370 | hdr_ptr->hdr.next = mem->large_list[pool_id]; |
371 | /* We maintain space counts in each pool header for statistical purposes, | 371 | /* We maintain space counts in each pool header for statistical purposes, |
372 | * even though they are not needed for allocation. | 372 | * even though they are not needed for allocation. |
373 | */ | 373 | */ |
374 | hdr_ptr->hdr.bytes_used = sizeofobject; | 374 | hdr_ptr->hdr.bytes_used = sizeofobject; |
375 | hdr_ptr->hdr.bytes_left = 0; | 375 | hdr_ptr->hdr.bytes_left = 0; |
376 | mem->large_list[pool_id] = hdr_ptr; | 376 | mem->large_list[pool_id] = hdr_ptr; |
377 | 377 | ||
378 | return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */ | 378 | return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */ |
379 | } | 379 | } |
380 | 380 | ||
381 | 381 | ||
382 | /* | 382 | /* |
383 | * Creation of 2-D sample arrays. | 383 | * Creation of 2-D sample arrays. |
384 | * The pointers are in near heap, the samples themselves in FAR heap. | 384 | * The pointers are in near heap, the samples themselves in FAR heap. |
385 | * | 385 | * |
386 | * To minimize allocation overhead and to allow I/O of large contiguous | 386 | * To minimize allocation overhead and to allow I/O of large contiguous |
387 | * blocks, we allocate the sample rows in groups of as many rows as possible | 387 | * blocks, we allocate the sample rows in groups of as many rows as possible |
388 | * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request. | 388 | * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request. |
389 | * NB: the virtual array control routines, later in this file, know about | 389 | * NB: the virtual array control routines, later in this file, know about |
390 | * this chunking of rows. The rowsperchunk value is left in the mem manager | 390 | * this chunking of rows. The rowsperchunk value is left in the mem manager |
391 | * object so that it can be saved away if this sarray is the workspace for | 391 | * object so that it can be saved away if this sarray is the workspace for |
392 | * a virtual array. | 392 | * a virtual array. |
393 | */ | 393 | */ |
394 | 394 | ||
395 | METHODDEF(JSAMPARRAY) | 395 | METHODDEF(JSAMPARRAY) |
396 | alloc_sarray (j_common_ptr cinfo, int pool_id, | 396 | alloc_sarray (j_common_ptr cinfo, int pool_id, |
397 | JDIMENSION samplesperrow, JDIMENSION numrows) | 397 | JDIMENSION samplesperrow, JDIMENSION numrows) |
398 | /* Allocate a 2-D sample array */ | 398 | /* Allocate a 2-D sample array */ |
399 | { | 399 | { |
400 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; | 400 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; |
401 | JSAMPARRAY result; | 401 | JSAMPARRAY result; |
402 | JSAMPROW workspace; | 402 | JSAMPROW workspace; |
403 | JDIMENSION rowsperchunk, currow, i; | 403 | JDIMENSION rowsperchunk, currow, i; |
404 | long ltemp; | 404 | long ltemp; |
405 | 405 | ||
406 | /* Calculate max # of rows allowed in one allocation chunk */ | 406 | /* Calculate max # of rows allowed in one allocation chunk */ |
407 | ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / | 407 | ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / |
408 | ((long) samplesperrow * SIZEOF(JSAMPLE)); | 408 | ((long) samplesperrow * SIZEOF(JSAMPLE)); |
409 | if (ltemp <= 0) | 409 | if (ltemp <= 0) |
410 | ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); | 410 | ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); |
411 | if (ltemp < (long) numrows) | 411 | if (ltemp < (long) numrows) |
412 | rowsperchunk = (JDIMENSION) ltemp; | 412 | rowsperchunk = (JDIMENSION) ltemp; |
413 | else | 413 | else |
414 | rowsperchunk = numrows; | 414 | rowsperchunk = numrows; |
415 | mem->last_rowsperchunk = rowsperchunk; | 415 | mem->last_rowsperchunk = rowsperchunk; |
416 | 416 | ||
417 | /* Get space for row pointers (small object) */ | 417 | /* Get space for row pointers (small object) */ |
418 | result = (JSAMPARRAY) alloc_small(cinfo, pool_id, | 418 | result = (JSAMPARRAY) alloc_small(cinfo, pool_id, |
419 | (size_t) (numrows * SIZEOF(JSAMPROW))); | 419 | (size_t) (numrows * SIZEOF(JSAMPROW))); |
420 | 420 | ||
421 | /* Get the rows themselves (large objects) */ | 421 | /* Get the rows themselves (large objects) */ |
422 | currow = 0; | 422 | currow = 0; |
423 | while (currow < numrows) { | 423 | while (currow < numrows) { |
424 | rowsperchunk = MIN(rowsperchunk, numrows - currow); | 424 | rowsperchunk = MIN(rowsperchunk, numrows - currow); |
425 | workspace = (JSAMPROW) alloc_large(cinfo, pool_id, | 425 | workspace = (JSAMPROW) alloc_large(cinfo, pool_id, |
426 | (size_t) ((size_t) rowsperchunk * (size_t) samplesperrow | 426 | (size_t) ((size_t) rowsperchunk * (size_t) samplesperrow |
427 | * SIZEOF(JSAMPLE))); | 427 | * SIZEOF(JSAMPLE))); |
428 | for (i = rowsperchunk; i > 0; i--) { | 428 | for (i = rowsperchunk; i > 0; i--) { |
429 | result[currow++] = workspace; | 429 | result[currow++] = workspace; |
430 | workspace += samplesperrow; | 430 | workspace += samplesperrow; |
431 | } | 431 | } |
432 | } | 432 | } |
433 | 433 | ||
434 | return result; | 434 | return result; |
435 | } | 435 | } |
436 | 436 | ||
437 | 437 | ||
438 | /* | 438 | /* |
439 | * Creation of 2-D coefficient-block arrays. | 439 | * Creation of 2-D coefficient-block arrays. |
440 | * This is essentially the same as the code for sample arrays, above. | 440 | * This is essentially the same as the code for sample arrays, above. |
441 | */ | 441 | */ |
442 | 442 | ||
443 | METHODDEF(JBLOCKARRAY) | 443 | METHODDEF(JBLOCKARRAY) |
444 | alloc_barray (j_common_ptr cinfo, int pool_id, | 444 | alloc_barray (j_common_ptr cinfo, int pool_id, |
445 | JDIMENSION blocksperrow, JDIMENSION numrows) | 445 | JDIMENSION blocksperrow, JDIMENSION numrows) |
446 | /* Allocate a 2-D coefficient-block array */ | 446 | /* Allocate a 2-D coefficient-block array */ |
447 | { | 447 | { |
448 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; | 448 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; |
449 | JBLOCKARRAY result; | 449 | JBLOCKARRAY result; |
450 | JBLOCKROW workspace; | 450 | JBLOCKROW workspace; |
451 | JDIMENSION rowsperchunk, currow, i; | 451 | JDIMENSION rowsperchunk, currow, i; |
452 | long ltemp; | 452 | long ltemp; |
453 | 453 | ||
454 | /* Calculate max # of rows allowed in one allocation chunk */ | 454 | /* Calculate max # of rows allowed in one allocation chunk */ |
455 | ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / | 455 | ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / |
456 | ((long) blocksperrow * SIZEOF(JBLOCK)); | 456 | ((long) blocksperrow * SIZEOF(JBLOCK)); |
457 | if (ltemp <= 0) | 457 | if (ltemp <= 0) |
458 | ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); | 458 | ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); |
459 | if (ltemp < (long) numrows) | 459 | if (ltemp < (long) numrows) |
460 | rowsperchunk = (JDIMENSION) ltemp; | 460 | rowsperchunk = (JDIMENSION) ltemp; |
461 | else | 461 | else |
462 | rowsperchunk = numrows; | 462 | rowsperchunk = numrows; |
463 | mem->last_rowsperchunk = rowsperchunk; | 463 | mem->last_rowsperchunk = rowsperchunk; |
464 | 464 | ||
465 | /* Get space for row pointers (small object) */ | 465 | /* Get space for row pointers (small object) */ |
466 | result = (JBLOCKARRAY) alloc_small(cinfo, pool_id, | 466 | result = (JBLOCKARRAY) alloc_small(cinfo, pool_id, |
467 | (size_t) (numrows * SIZEOF(JBLOCKROW))); | 467 | (size_t) (numrows * SIZEOF(JBLOCKROW))); |
468 | 468 | ||
469 | /* Get the rows themselves (large objects) */ | 469 | /* Get the rows themselves (large objects) */ |
470 | currow = 0; | 470 | currow = 0; |
471 | while (currow < numrows) { | 471 | while (currow < numrows) { |
472 | rowsperchunk = MIN(rowsperchunk, numrows - currow); | 472 | rowsperchunk = MIN(rowsperchunk, numrows - currow); |
473 | workspace = (JBLOCKROW) alloc_large(cinfo, pool_id, | 473 | workspace = (JBLOCKROW) alloc_large(cinfo, pool_id, |
474 | (size_t) ((size_t) rowsperchunk * (size_t) blocksperrow | 474 | (size_t) ((size_t) rowsperchunk * (size_t) blocksperrow |
475 | * SIZEOF(JBLOCK))); | 475 | * SIZEOF(JBLOCK))); |
476 | for (i = rowsperchunk; i > 0; i--) { | 476 | for (i = rowsperchunk; i > 0; i--) { |
477 | result[currow++] = workspace; | 477 | result[currow++] = workspace; |
478 | workspace += blocksperrow; | 478 | workspace += blocksperrow; |
479 | } | 479 | } |
480 | } | 480 | } |
481 | 481 | ||
482 | return result; | 482 | return result; |
483 | } | 483 | } |
484 | 484 | ||
485 | 485 | ||
486 | /* | 486 | /* |
487 | * About virtual array management: | 487 | * About virtual array management: |
488 | * | 488 | * |
489 | * The above "normal" array routines are only used to allocate strip buffers | 489 | * The above "normal" array routines are only used to allocate strip buffers |
490 | * (as wide as the image, but just a few rows high). Full-image-sized buffers | 490 | * (as wide as the image, but just a few rows high). Full-image-sized buffers |
491 | * are handled as "virtual" arrays. The array is still accessed a strip at a | 491 | * are handled as "virtual" arrays. The array is still accessed a strip at a |
492 | * time, but the memory manager must save the whole array for repeated | 492 | * time, but the memory manager must save the whole array for repeated |
493 | * accesses. The intended implementation is that there is a strip buffer in | 493 | * accesses. The intended implementation is that there is a strip buffer in |
494 | * memory (as high as is possible given the desired memory limit), plus a | 494 | * memory (as high as is possible given the desired memory limit), plus a |
495 | * backing file that holds the rest of the array. | 495 | * backing file that holds the rest of the array. |
496 | * | 496 | * |
497 | * The request_virt_array routines are told the total size of the image and | 497 | * The request_virt_array routines are told the total size of the image and |
498 | * the maximum number of rows that will be accessed at once. The in-memory | 498 | * the maximum number of rows that will be accessed at once. The in-memory |
499 | * buffer must be at least as large as the maxaccess value. | 499 | * buffer must be at least as large as the maxaccess value. |
500 | * | 500 | * |
501 | * The request routines create control blocks but not the in-memory buffers. | 501 | * The request routines create control blocks but not the in-memory buffers. |
502 | * That is postponed until realize_virt_arrays is called. At that time the | 502 | * That is postponed until realize_virt_arrays is called. At that time the |
503 | * total amount of space needed is known (approximately, anyway), so free | 503 | * total amount of space needed is known (approximately, anyway), so free |
504 | * memory can be divided up fairly. | 504 | * memory can be divided up fairly. |
505 | * | 505 | * |
506 | * The access_virt_array routines are responsible for making a specific strip | 506 | * The access_virt_array routines are responsible for making a specific strip |
507 | * area accessible (after reading or writing the backing file, if necessary). | 507 | * area accessible (after reading or writing the backing file, if necessary). |
508 | * Note that the access routines are told whether the caller intends to modify | 508 | * Note that the access routines are told whether the caller intends to modify |
509 | * the accessed strip; during a read-only pass this saves having to rewrite | 509 | * the accessed strip; during a read-only pass this saves having to rewrite |
510 | * data to disk. The access routines are also responsible for pre-zeroing | 510 | * data to disk. The access routines are also responsible for pre-zeroing |
511 | * any newly accessed rows, if pre-zeroing was requested. | 511 | * any newly accessed rows, if pre-zeroing was requested. |
512 | * | 512 | * |
513 | * In current usage, the access requests are usually for nonoverlapping | 513 | * In current usage, the access requests are usually for nonoverlapping |
514 | * strips; that is, successive access start_row numbers differ by exactly | 514 | * strips; that is, successive access start_row numbers differ by exactly |
515 | * num_rows = maxaccess. This means we can get good performance with simple | 515 | * num_rows = maxaccess. This means we can get good performance with simple |
516 | * buffer dump/reload logic, by making the in-memory buffer be a multiple | 516 | * buffer dump/reload logic, by making the in-memory buffer be a multiple |
517 | * of the access height; then there will never be accesses across bufferload | 517 | * of the access height; then there will never be accesses across bufferload |
518 | * boundaries. The code will still work with overlapping access requests, | 518 | * boundaries. The code will still work with overlapping access requests, |
519 | * but it doesn't handle bufferload overlaps very efficiently. | 519 | * but it doesn't handle bufferload overlaps very efficiently. |
520 | */ | 520 | */ |
521 | 521 | ||
522 | 522 | ||
523 | METHODDEF(jvirt_sarray_ptr) | 523 | METHODDEF(jvirt_sarray_ptr) |
524 | request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero, | 524 | request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero, |
525 | JDIMENSION samplesperrow, JDIMENSION numrows, | 525 | JDIMENSION samplesperrow, JDIMENSION numrows, |
526 | JDIMENSION maxaccess) | 526 | JDIMENSION maxaccess) |
527 | /* Request a virtual 2-D sample array */ | 527 | /* Request a virtual 2-D sample array */ |
528 | { | 528 | { |
529 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; | 529 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; |
530 | jvirt_sarray_ptr result; | 530 | jvirt_sarray_ptr result; |
531 | 531 | ||
532 | /* Only IMAGE-lifetime virtual arrays are currently supported */ | 532 | /* Only IMAGE-lifetime virtual arrays are currently supported */ |
533 | if (pool_id != JPOOL_IMAGE) | 533 | if (pool_id != JPOOL_IMAGE) |
534 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ | 534 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ |
535 | 535 | ||
536 | /* get control block */ | 536 | /* get control block */ |
537 | result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id, | 537 | result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id, |
538 | SIZEOF(struct jvirt_sarray_control)); | 538 | SIZEOF(struct jvirt_sarray_control)); |
539 | 539 | ||
540 | result->mem_buffer = NULL; /* marks array not yet realized */ | 540 | result->mem_buffer = NULL; /* marks array not yet realized */ |
541 | result->rows_in_array = numrows; | 541 | result->rows_in_array = numrows; |
542 | result->samplesperrow = samplesperrow; | 542 | result->samplesperrow = samplesperrow; |
543 | result->maxaccess = maxaccess; | 543 | result->maxaccess = maxaccess; |
544 | result->pre_zero = pre_zero; | 544 | result->pre_zero = pre_zero; |
545 | result->b_s_open = FALSE; /* no associated backing-store object */ | 545 | result->b_s_open = FALSE; /* no associated backing-store object */ |
546 | result->next = mem->virt_sarray_list; /* add to list of virtual arrays */ | 546 | result->next = mem->virt_sarray_list; /* add to list of virtual arrays */ |
547 | mem->virt_sarray_list = result; | 547 | mem->virt_sarray_list = result; |
548 | 548 | ||
549 | return result; | 549 | return result; |
550 | } | 550 | } |
551 | 551 | ||
552 | 552 | ||
553 | METHODDEF(jvirt_barray_ptr) | 553 | METHODDEF(jvirt_barray_ptr) |
554 | request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero, | 554 | request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero, |
555 | JDIMENSION blocksperrow, JDIMENSION numrows, | 555 | JDIMENSION blocksperrow, JDIMENSION numrows, |
556 | JDIMENSION maxaccess) | 556 | JDIMENSION maxaccess) |
557 | /* Request a virtual 2-D coefficient-block array */ | 557 | /* Request a virtual 2-D coefficient-block array */ |
558 | { | 558 | { |
559 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; | 559 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; |
560 | jvirt_barray_ptr result; | 560 | jvirt_barray_ptr result; |
561 | 561 | ||
562 | /* Only IMAGE-lifetime virtual arrays are currently supported */ | 562 | /* Only IMAGE-lifetime virtual arrays are currently supported */ |
563 | if (pool_id != JPOOL_IMAGE) | 563 | if (pool_id != JPOOL_IMAGE) |
564 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ | 564 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ |
565 | 565 | ||
566 | /* get control block */ | 566 | /* get control block */ |
567 | result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id, | 567 | result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id, |
568 | SIZEOF(struct jvirt_barray_control)); | 568 | SIZEOF(struct jvirt_barray_control)); |
569 | 569 | ||
570 | result->mem_buffer = NULL; /* marks array not yet realized */ | 570 | result->mem_buffer = NULL; /* marks array not yet realized */ |
571 | result->rows_in_array = numrows; | 571 | result->rows_in_array = numrows; |
572 | result->blocksperrow = blocksperrow; | 572 | result->blocksperrow = blocksperrow; |
573 | result->maxaccess = maxaccess; | 573 | result->maxaccess = maxaccess; |
574 | result->pre_zero = pre_zero; | 574 | result->pre_zero = pre_zero; |
575 | result->b_s_open = FALSE; /* no associated backing-store object */ | 575 | result->b_s_open = FALSE; /* no associated backing-store object */ |
576 | result->next = mem->virt_barray_list; /* add to list of virtual arrays */ | 576 | result->next = mem->virt_barray_list; /* add to list of virtual arrays */ |
577 | mem->virt_barray_list = result; | 577 | mem->virt_barray_list = result; |
578 | 578 | ||
579 | return result; | 579 | return result; |
580 | } | 580 | } |
581 | 581 | ||
582 | 582 | ||
583 | METHODDEF(void) | 583 | METHODDEF(void) |
584 | realize_virt_arrays (j_common_ptr cinfo) | 584 | realize_virt_arrays (j_common_ptr cinfo) |
585 | /* Allocate the in-memory buffers for any unrealized virtual arrays */ | 585 | /* Allocate the in-memory buffers for any unrealized virtual arrays */ |
586 | { | 586 | { |
587 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; | 587 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; |
588 | long space_per_minheight, maximum_space, avail_mem; | 588 | long space_per_minheight, maximum_space, avail_mem; |
589 | long minheights, max_minheights; | 589 | long minheights, max_minheights; |
590 | jvirt_sarray_ptr sptr; | 590 | jvirt_sarray_ptr sptr; |
591 | jvirt_barray_ptr bptr; | 591 | jvirt_barray_ptr bptr; |
592 | 592 | ||
593 | /* Compute the minimum space needed (maxaccess rows in each buffer) | 593 | /* Compute the minimum space needed (maxaccess rows in each buffer) |
594 | * and the maximum space needed (full image height in each buffer). | 594 | * and the maximum space needed (full image height in each buffer). |
595 | * These may be of use to the system-dependent jpeg_mem_available routine. | 595 | * These may be of use to the system-dependent jpeg_mem_available routine. |
596 | */ | 596 | */ |
597 | space_per_minheight = 0; | 597 | space_per_minheight = 0; |
598 | maximum_space = 0; | 598 | maximum_space = 0; |
599 | for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { | 599 | for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { |
600 | if (sptr->mem_buffer == NULL) { /* if not realized yet */ | 600 | if (sptr->mem_buffer == NULL) { /* if not realized yet */ |
601 | space_per_minheight += (long) sptr->maxaccess * | 601 | space_per_minheight += (long) sptr->maxaccess * |
602 | (long) sptr->samplesperrow * SIZEOF(JSAMPLE); | 602 | (long) sptr->samplesperrow * SIZEOF(JSAMPLE); |
603 | maximum_space += (long) sptr->rows_in_array * | 603 | maximum_space += (long) sptr->rows_in_array * |
604 | (long) sptr->samplesperrow * SIZEOF(JSAMPLE); | 604 | (long) sptr->samplesperrow * SIZEOF(JSAMPLE); |
605 | } | 605 | } |
606 | } | 606 | } |
607 | for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { | 607 | for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { |
608 | if (bptr->mem_buffer == NULL) { /* if not realized yet */ | 608 | if (bptr->mem_buffer == NULL) { /* if not realized yet */ |
609 | space_per_minheight += (long) bptr->maxaccess * | 609 | space_per_minheight += (long) bptr->maxaccess * |
610 | (long) bptr->blocksperrow * SIZEOF(JBLOCK); | 610 | (long) bptr->blocksperrow * SIZEOF(JBLOCK); |
611 | maximum_space += (long) bptr->rows_in_array * | 611 | maximum_space += (long) bptr->rows_in_array * |
612 | (long) bptr->blocksperrow * SIZEOF(JBLOCK); | 612 | (long) bptr->blocksperrow * SIZEOF(JBLOCK); |
613 | } | 613 | } |
614 | } | 614 | } |
615 | 615 | ||
616 | if (space_per_minheight <= 0) | 616 | if (space_per_minheight <= 0) |
617 | return; /* no unrealized arrays, no work */ | 617 | return; /* no unrealized arrays, no work */ |
618 | 618 | ||
619 | /* Determine amount of memory to actually use; this is system-dependent. */ | 619 | /* Determine amount of memory to actually use; this is system-dependent. */ |
620 | avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space, | 620 | avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space, |
621 | mem->total_space_allocated); | 621 | mem->total_space_allocated); |
622 | 622 | ||
623 | /* If the maximum space needed is available, make all the buffers full | 623 | /* If the maximum space needed is available, make all the buffers full |
624 | * height; otherwise parcel it out with the same number of minheights | 624 | * height; otherwise parcel it out with the same number of minheights |
625 | * in each buffer. | 625 | * in each buffer. |
626 | */ | 626 | */ |
627 | if (avail_mem >= maximum_space) | 627 | if (avail_mem >= maximum_space) |
628 | max_minheights = 1000000000L; | 628 | max_minheights = 1000000000L; |
629 | else { | 629 | else { |
630 | max_minheights = avail_mem / space_per_minheight; | 630 | max_minheights = avail_mem / space_per_minheight; |
631 | /* If there doesn't seem to be enough space, try to get the minimum | 631 | /* If there doesn't seem to be enough space, try to get the minimum |
632 | * anyway. This allows a "stub" implementation of jpeg_mem_available(). | 632 | * anyway. This allows a "stub" implementation of jpeg_mem_available(). |
633 | */ | 633 | */ |
634 | if (max_minheights <= 0) | 634 | if (max_minheights <= 0) |
635 | max_minheights = 1; | 635 | max_minheights = 1; |
636 | } | 636 | } |
637 | 637 | ||
638 | /* Allocate the in-memory buffers and initialize backing store as needed. */ | 638 | /* Allocate the in-memory buffers and initialize backing store as needed. */ |
639 | 639 | ||
640 | for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { | 640 | for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { |
641 | if (sptr->mem_buffer == NULL) { /* if not realized yet */ | 641 | if (sptr->mem_buffer == NULL) { /* if not realized yet */ |
642 | minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L; | 642 | minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L; |
643 | if (minheights <= max_minheights) { | 643 | if (minheights <= max_minheights) { |
644 | /* This buffer fits in memory */ | 644 | /* This buffer fits in memory */ |
645 | sptr->rows_in_mem = sptr->rows_in_array; | 645 | sptr->rows_in_mem = sptr->rows_in_array; |
646 | } else { | 646 | } else { |
647 | /* It doesn't fit in memory, create backing store. */ | 647 | /* It doesn't fit in memory, create backing store. */ |
648 | sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess); | 648 | sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess); |
649 | jpeg_open_backing_store(cinfo, & sptr->b_s_info, | 649 | jpeg_open_backing_store(cinfo, & sptr->b_s_info, |
650 | (long) sptr->rows_in_array * | 650 | (long) sptr->rows_in_array * |
651 | (long) sptr->samplesperrow * | 651 | (long) sptr->samplesperrow * |
652 | (long) SIZEOF(JSAMPLE)); | 652 | (long) SIZEOF(JSAMPLE)); |
653 | sptr->b_s_open = TRUE; | 653 | sptr->b_s_open = TRUE; |
654 | } | 654 | } |
655 | sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE, | 655 | sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE, |
656 | sptr->samplesperrow, sptr->rows_in_mem); | 656 | sptr->samplesperrow, sptr->rows_in_mem); |
657 | sptr->rowsperchunk = mem->last_rowsperchunk; | 657 | sptr->rowsperchunk = mem->last_rowsperchunk; |
658 | sptr->cur_start_row = 0; | 658 | sptr->cur_start_row = 0; |
659 | sptr->first_undef_row = 0; | 659 | sptr->first_undef_row = 0; |
660 | sptr->dirty = FALSE; | 660 | sptr->dirty = FALSE; |
661 | } | 661 | } |
662 | } | 662 | } |
663 | 663 | ||
664 | for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { | 664 | for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { |
665 | if (bptr->mem_buffer == NULL) { /* if not realized yet */ | 665 | if (bptr->mem_buffer == NULL) { /* if not realized yet */ |
666 | minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L; | 666 | minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L; |
667 | if (minheights <= max_minheights) { | 667 | if (minheights <= max_minheights) { |
668 | /* This buffer fits in memory */ | 668 | /* This buffer fits in memory */ |
669 | bptr->rows_in_mem = bptr->rows_in_array; | 669 | bptr->rows_in_mem = bptr->rows_in_array; |
670 | } else { | 670 | } else { |
671 | /* It doesn't fit in memory, create backing store. */ | 671 | /* It doesn't fit in memory, create backing store. */ |
672 | bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess); | 672 | bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess); |
673 | jpeg_open_backing_store(cinfo, & bptr->b_s_info, | 673 | jpeg_open_backing_store(cinfo, & bptr->b_s_info, |
674 | (long) bptr->rows_in_array * | 674 | (long) bptr->rows_in_array * |
675 | (long) bptr->blocksperrow * | 675 | (long) bptr->blocksperrow * |
676 | (long) SIZEOF(JBLOCK)); | 676 | (long) SIZEOF(JBLOCK)); |
677 | bptr->b_s_open = TRUE; | 677 | bptr->b_s_open = TRUE; |
678 | } | 678 | } |
679 | bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE, | 679 | bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE, |
680 | bptr->blocksperrow, bptr->rows_in_mem); | 680 | bptr->blocksperrow, bptr->rows_in_mem); |
681 | bptr->rowsperchunk = mem->last_rowsperchunk; | 681 | bptr->rowsperchunk = mem->last_rowsperchunk; |
682 | bptr->cur_start_row = 0; | 682 | bptr->cur_start_row = 0; |
683 | bptr->first_undef_row = 0; | 683 | bptr->first_undef_row = 0; |
684 | bptr->dirty = FALSE; | 684 | bptr->dirty = FALSE; |
685 | } | 685 | } |
686 | } | 686 | } |
687 | } | 687 | } |
688 | 688 | ||
689 | 689 | ||
690 | LOCAL(void) | 690 | LOCAL(void) |
691 | do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing) | 691 | do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing) |
692 | /* Do backing store read or write of a virtual sample array */ | 692 | /* Do backing store read or write of a virtual sample array */ |
693 | { | 693 | { |
694 | long bytesperrow, file_offset, byte_count, rows, thisrow, i; | 694 | long bytesperrow, file_offset, byte_count, rows, thisrow, i; |
695 | 695 | ||
696 | bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE); | 696 | bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE); |
697 | file_offset = ptr->cur_start_row * bytesperrow; | 697 | file_offset = ptr->cur_start_row * bytesperrow; |
698 | /* Loop to read or write each allocation chunk in mem_buffer */ | 698 | /* Loop to read or write each allocation chunk in mem_buffer */ |
699 | for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { | 699 | for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { |
700 | /* One chunk, but check for short chunk at end of buffer */ | 700 | /* One chunk, but check for short chunk at end of buffer */ |
701 | rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); | 701 | rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); |
702 | /* Transfer no more than is currently defined */ | 702 | /* Transfer no more than is currently defined */ |
703 | thisrow = (long) ptr->cur_start_row + i; | 703 | thisrow = (long) ptr->cur_start_row + i; |
704 | rows = MIN(rows, (long) ptr->first_undef_row - thisrow); | 704 | rows = MIN(rows, (long) ptr->first_undef_row - thisrow); |
705 | /* Transfer no more than fits in file */ | 705 | /* Transfer no more than fits in file */ |
706 | rows = MIN(rows, (long) ptr->rows_in_array - thisrow); | 706 | rows = MIN(rows, (long) ptr->rows_in_array - thisrow); |
707 | if (rows <= 0) /* this chunk might be past end of file! */ | 707 | if (rows <= 0) /* this chunk might be past end of file! */ |
708 | break; | 708 | break; |
709 | byte_count = rows * bytesperrow; | 709 | byte_count = rows * bytesperrow; |
710 | if (writing) | 710 | if (writing) |
711 | (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, | 711 | (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, |
712 | (void FAR *) ptr->mem_buffer[i], | 712 | (void FAR *) ptr->mem_buffer[i], |
713 | file_offset, byte_count); | 713 | file_offset, byte_count); |
714 | else | 714 | else |
715 | (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, | 715 | (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, |
716 | (void FAR *) ptr->mem_buffer[i], | 716 | (void FAR *) ptr->mem_buffer[i], |
717 | file_offset, byte_count); | 717 | file_offset, byte_count); |
718 | file_offset += byte_count; | 718 | file_offset += byte_count; |
719 | } | 719 | } |
720 | } | 720 | } |
721 | 721 | ||
722 | 722 | ||
723 | LOCAL(void) | 723 | LOCAL(void) |
724 | do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing) | 724 | do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing) |
725 | /* Do backing store read or write of a virtual coefficient-block array */ | 725 | /* Do backing store read or write of a virtual coefficient-block array */ |
726 | { | 726 | { |
727 | long bytesperrow, file_offset, byte_count, rows, thisrow, i; | 727 | long bytesperrow, file_offset, byte_count, rows, thisrow, i; |
728 | 728 | ||
729 | bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK); | 729 | bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK); |
730 | file_offset = ptr->cur_start_row * bytesperrow; | 730 | file_offset = ptr->cur_start_row * bytesperrow; |
731 | /* Loop to read or write each allocation chunk in mem_buffer */ | 731 | /* Loop to read or write each allocation chunk in mem_buffer */ |
732 | for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { | 732 | for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { |
733 | /* One chunk, but check for short chunk at end of buffer */ | 733 | /* One chunk, but check for short chunk at end of buffer */ |
734 | rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); | 734 | rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); |
735 | /* Transfer no more than is currently defined */ | 735 | /* Transfer no more than is currently defined */ |
736 | thisrow = (long) ptr->cur_start_row + i; | 736 | thisrow = (long) ptr->cur_start_row + i; |
737 | rows = MIN(rows, (long) ptr->first_undef_row - thisrow); | 737 | rows = MIN(rows, (long) ptr->first_undef_row - thisrow); |
738 | /* Transfer no more than fits in file */ | 738 | /* Transfer no more than fits in file */ |
739 | rows = MIN(rows, (long) ptr->rows_in_array - thisrow); | 739 | rows = MIN(rows, (long) ptr->rows_in_array - thisrow); |
740 | if (rows <= 0) /* this chunk might be past end of file! */ | 740 | if (rows <= 0) /* this chunk might be past end of file! */ |
741 | break; | 741 | break; |
742 | byte_count = rows * bytesperrow; | 742 | byte_count = rows * bytesperrow; |
743 | if (writing) | 743 | if (writing) |
744 | (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, | 744 | (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, |
745 | (void FAR *) ptr->mem_buffer[i], | 745 | (void FAR *) ptr->mem_buffer[i], |
746 | file_offset, byte_count); | 746 | file_offset, byte_count); |
747 | else | 747 | else |
748 | (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, | 748 | (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, |
749 | (void FAR *) ptr->mem_buffer[i], | 749 | (void FAR *) ptr->mem_buffer[i], |
750 | file_offset, byte_count); | 750 | file_offset, byte_count); |
751 | file_offset += byte_count; | 751 | file_offset += byte_count; |
752 | } | 752 | } |
753 | } | 753 | } |
754 | 754 | ||
755 | 755 | ||
756 | METHODDEF(JSAMPARRAY) | 756 | METHODDEF(JSAMPARRAY) |
757 | access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr, | 757 | access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr, |
758 | JDIMENSION start_row, JDIMENSION num_rows, | 758 | JDIMENSION start_row, JDIMENSION num_rows, |
759 | boolean writable) | 759 | boolean writable) |
760 | /* Access the part of a virtual sample array starting at start_row */ | 760 | /* Access the part of a virtual sample array starting at start_row */ |
761 | /* and extending for num_rows rows. writable is true if */ | 761 | /* and extending for num_rows rows. writable is true if */ |
762 | /* caller intends to modify the accessed area. */ | 762 | /* caller intends to modify the accessed area. */ |
763 | { | 763 | { |
764 | JDIMENSION end_row = start_row + num_rows; | 764 | JDIMENSION end_row = start_row + num_rows; |
765 | JDIMENSION undef_row; | 765 | JDIMENSION undef_row; |
766 | 766 | ||
767 | /* debugging check */ | 767 | /* debugging check */ |
768 | if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || | 768 | if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || |
769 | ptr->mem_buffer == NULL) | 769 | ptr->mem_buffer == NULL) |
770 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); | 770 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); |
771 | 771 | ||
772 | /* Make the desired part of the virtual array accessible */ | 772 | /* Make the desired part of the virtual array accessible */ |
773 | if (start_row < ptr->cur_start_row || | 773 | if (start_row < ptr->cur_start_row || |
774 | end_row > ptr->cur_start_row+ptr->rows_in_mem) { | 774 | end_row > ptr->cur_start_row+ptr->rows_in_mem) { |
775 | if (! ptr->b_s_open) | 775 | if (! ptr->b_s_open) |
776 | ERREXIT(cinfo, JERR_VIRTUAL_BUG); | 776 | ERREXIT(cinfo, JERR_VIRTUAL_BUG); |
777 | /* Flush old buffer contents if necessary */ | 777 | /* Flush old buffer contents if necessary */ |
778 | if (ptr->dirty) { | 778 | if (ptr->dirty) { |
779 | do_sarray_io(cinfo, ptr, TRUE); | 779 | do_sarray_io(cinfo, ptr, TRUE); |
780 | ptr->dirty = FALSE; | 780 | ptr->dirty = FALSE; |
781 | } | 781 | } |
782 | /* Decide what part of virtual array to access. | 782 | /* Decide what part of virtual array to access. |
783 | * Algorithm: if target address > current window, assume forward scan, | 783 | * Algorithm: if target address > current window, assume forward scan, |
784 | * load starting at target address. If target address < current window, | 784 | * load starting at target address. If target address < current window, |
785 | * assume backward scan, load so that target area is top of window. | 785 | * assume backward scan, load so that target area is top of window. |
786 | * Note that when switching from forward write to forward read, will have | 786 | * Note that when switching from forward write to forward read, will have |
787 | * start_row = 0, so the limiting case applies and we load from 0 anyway. | 787 | * start_row = 0, so the limiting case applies and we load from 0 anyway. |
788 | */ | 788 | */ |
789 | if (start_row > ptr->cur_start_row) { | 789 | if (start_row > ptr->cur_start_row) { |
790 | ptr->cur_start_row = start_row; | 790 | ptr->cur_start_row = start_row; |
791 | } else { | 791 | } else { |
792 | /* use long arithmetic here to avoid overflow & unsigned problems */ | 792 | /* use long arithmetic here to avoid overflow & unsigned problems */ |
793 | long ltemp; | 793 | long ltemp; |
794 | 794 | ||
795 | ltemp = (long) end_row - (long) ptr->rows_in_mem; | 795 | ltemp = (long) end_row - (long) ptr->rows_in_mem; |
796 | if (ltemp < 0) | 796 | if (ltemp < 0) |
797 | ltemp = 0; /* don't fall off front end of file */ | 797 | ltemp = 0; /* don't fall off front end of file */ |
798 | ptr->cur_start_row = (JDIMENSION) ltemp; | 798 | ptr->cur_start_row = (JDIMENSION) ltemp; |
799 | } | 799 | } |
800 | /* Read in the selected part of the array. | 800 | /* Read in the selected part of the array. |
801 | * During the initial write pass, we will do no actual read | 801 | * During the initial write pass, we will do no actual read |
802 | * because the selected part is all undefined. | 802 | * because the selected part is all undefined. |
803 | */ | 803 | */ |
804 | do_sarray_io(cinfo, ptr, FALSE); | 804 | do_sarray_io(cinfo, ptr, FALSE); |
805 | } | 805 | } |
806 | /* Ensure the accessed part of the array is defined; prezero if needed. | 806 | /* Ensure the accessed part of the array is defined; prezero if needed. |
807 | * To improve locality of access, we only prezero the part of the array | 807 | * To improve locality of access, we only prezero the part of the array |
808 | * that the caller is about to access, not the entire in-memory array. | 808 | * that the caller is about to access, not the entire in-memory array. |
809 | */ | 809 | */ |
810 | if (ptr->first_undef_row < end_row) { | 810 | if (ptr->first_undef_row < end_row) { |
811 | if (ptr->first_undef_row < start_row) { | 811 | if (ptr->first_undef_row < start_row) { |
812 | if (writable) /* writer skipped over a section of array */ | 812 | if (writable) /* writer skipped over a section of array */ |
813 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); | 813 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); |
814 | undef_row = start_row; /* but reader is allowed to read ahead */ | 814 | undef_row = start_row; /* but reader is allowed to read ahead */ |
815 | } else { | 815 | } else { |
816 | undef_row = ptr->first_undef_row; | 816 | undef_row = ptr->first_undef_row; |
817 | } | 817 | } |
818 | if (writable) | 818 | if (writable) |
819 | ptr->first_undef_row = end_row; | 819 | ptr->first_undef_row = end_row; |
820 | if (ptr->pre_zero) { | 820 | if (ptr->pre_zero) { |
821 | size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE); | 821 | size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE); |
822 | undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ | 822 | undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ |
823 | end_row -= ptr->cur_start_row; | 823 | end_row -= ptr->cur_start_row; |
824 | while (undef_row < end_row) { | 824 | while (undef_row < end_row) { |
825 | FMEMZERO((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); | 825 | FMEMZERO((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); |
826 | undef_row++; | 826 | undef_row++; |
827 | } | 827 | } |
828 | } else { | 828 | } else { |
829 | if (! writable) /* reader looking at undefined data */ | 829 | if (! writable) /* reader looking at undefined data */ |
830 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); | 830 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); |
831 | } | 831 | } |
832 | } | 832 | } |
833 | /* Flag the buffer dirty if caller will write in it */ | 833 | /* Flag the buffer dirty if caller will write in it */ |
834 | if (writable) | 834 | if (writable) |
835 | ptr->dirty = TRUE; | 835 | ptr->dirty = TRUE; |
836 | /* Return address of proper part of the buffer */ | 836 | /* Return address of proper part of the buffer */ |
837 | return ptr->mem_buffer + (start_row - ptr->cur_start_row); | 837 | return ptr->mem_buffer + (start_row - ptr->cur_start_row); |
838 | } | 838 | } |
839 | 839 | ||
840 | 840 | ||
841 | METHODDEF(JBLOCKARRAY) | 841 | METHODDEF(JBLOCKARRAY) |
842 | access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr, | 842 | access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr, |
843 | JDIMENSION start_row, JDIMENSION num_rows, | 843 | JDIMENSION start_row, JDIMENSION num_rows, |
844 | boolean writable) | 844 | boolean writable) |
845 | /* Access the part of a virtual block array starting at start_row */ | 845 | /* Access the part of a virtual block array starting at start_row */ |
846 | /* and extending for num_rows rows. writable is true if */ | 846 | /* and extending for num_rows rows. writable is true if */ |
847 | /* caller intends to modify the accessed area. */ | 847 | /* caller intends to modify the accessed area. */ |
848 | { | 848 | { |
849 | JDIMENSION end_row = start_row + num_rows; | 849 | JDIMENSION end_row = start_row + num_rows; |
850 | JDIMENSION undef_row; | 850 | JDIMENSION undef_row; |
851 | 851 | ||
852 | /* debugging check */ | 852 | /* debugging check */ |
853 | if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || | 853 | if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || |
854 | ptr->mem_buffer == NULL) | 854 | ptr->mem_buffer == NULL) |
855 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); | 855 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); |
856 | 856 | ||
857 | /* Make the desired part of the virtual array accessible */ | 857 | /* Make the desired part of the virtual array accessible */ |
858 | if (start_row < ptr->cur_start_row || | 858 | if (start_row < ptr->cur_start_row || |
859 | end_row > ptr->cur_start_row+ptr->rows_in_mem) { | 859 | end_row > ptr->cur_start_row+ptr->rows_in_mem) { |
860 | if (! ptr->b_s_open) | 860 | if (! ptr->b_s_open) |
861 | ERREXIT(cinfo, JERR_VIRTUAL_BUG); | 861 | ERREXIT(cinfo, JERR_VIRTUAL_BUG); |
862 | /* Flush old buffer contents if necessary */ | 862 | /* Flush old buffer contents if necessary */ |
863 | if (ptr->dirty) { | 863 | if (ptr->dirty) { |
864 | do_barray_io(cinfo, ptr, TRUE); | 864 | do_barray_io(cinfo, ptr, TRUE); |
865 | ptr->dirty = FALSE; | 865 | ptr->dirty = FALSE; |
866 | } | 866 | } |
867 | /* Decide what part of virtual array to access. | 867 | /* Decide what part of virtual array to access. |
868 | * Algorithm: if target address > current window, assume forward scan, | 868 | * Algorithm: if target address > current window, assume forward scan, |
869 | * load starting at target address. If target address < current window, | 869 | * load starting at target address. If target address < current window, |
870 | * assume backward scan, load so that target area is top of window. | 870 | * assume backward scan, load so that target area is top of window. |
871 | * Note that when switching from forward write to forward read, will have | 871 | * Note that when switching from forward write to forward read, will have |
872 | * start_row = 0, so the limiting case applies and we load from 0 anyway. | 872 | * start_row = 0, so the limiting case applies and we load from 0 anyway. |
873 | */ | 873 | */ |
874 | if (start_row > ptr->cur_start_row) { | 874 | if (start_row > ptr->cur_start_row) { |
875 | ptr->cur_start_row = start_row; | 875 | ptr->cur_start_row = start_row; |
876 | } else { | 876 | } else { |
877 | /* use long arithmetic here to avoid overflow & unsigned problems */ | 877 | /* use long arithmetic here to avoid overflow & unsigned problems */ |
878 | long ltemp; | 878 | long ltemp; |
879 | 879 | ||
880 | ltemp = (long) end_row - (long) ptr->rows_in_mem; | 880 | ltemp = (long) end_row - (long) ptr->rows_in_mem; |
881 | if (ltemp < 0) | 881 | if (ltemp < 0) |
882 | ltemp = 0; /* don't fall off front end of file */ | 882 | ltemp = 0; /* don't fall off front end of file */ |
883 | ptr->cur_start_row = (JDIMENSION) ltemp; | 883 | ptr->cur_start_row = (JDIMENSION) ltemp; |
884 | } | 884 | } |
885 | /* Read in the selected part of the array. | 885 | /* Read in the selected part of the array. |
886 | * During the initial write pass, we will do no actual read | 886 | * During the initial write pass, we will do no actual read |
887 | * because the selected part is all undefined. | 887 | * because the selected part is all undefined. |
888 | */ | 888 | */ |
889 | do_barray_io(cinfo, ptr, FALSE); | 889 | do_barray_io(cinfo, ptr, FALSE); |
890 | } | 890 | } |
891 | /* Ensure the accessed part of the array is defined; prezero if needed. | 891 | /* Ensure the accessed part of the array is defined; prezero if needed. |
892 | * To improve locality of access, we only prezero the part of the array | 892 | * To improve locality of access, we only prezero the part of the array |
893 | * that the caller is about to access, not the entire in-memory array. | 893 | * that the caller is about to access, not the entire in-memory array. |
894 | */ | 894 | */ |
895 | if (ptr->first_undef_row < end_row) { | 895 | if (ptr->first_undef_row < end_row) { |
896 | if (ptr->first_undef_row < start_row) { | 896 | if (ptr->first_undef_row < start_row) { |
897 | if (writable) /* writer skipped over a section of array */ | 897 | if (writable) /* writer skipped over a section of array */ |
898 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); | 898 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); |
899 | undef_row = start_row; /* but reader is allowed to read ahead */ | 899 | undef_row = start_row; /* but reader is allowed to read ahead */ |
900 | } else { | 900 | } else { |
901 | undef_row = ptr->first_undef_row; | 901 | undef_row = ptr->first_undef_row; |
902 | } | 902 | } |
903 | if (writable) | 903 | if (writable) |
904 | ptr->first_undef_row = end_row; | 904 | ptr->first_undef_row = end_row; |
905 | if (ptr->pre_zero) { | 905 | if (ptr->pre_zero) { |
906 | size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK); | 906 | size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK); |
907 | undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ | 907 | undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ |
908 | end_row -= ptr->cur_start_row; | 908 | end_row -= ptr->cur_start_row; |
909 | while (undef_row < end_row) { | 909 | while (undef_row < end_row) { |
910 | FMEMZERO((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); | 910 | FMEMZERO((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); |
911 | undef_row++; | 911 | undef_row++; |
912 | } | 912 | } |
913 | } else { | 913 | } else { |
914 | if (! writable) /* reader looking at undefined data */ | 914 | if (! writable) /* reader looking at undefined data */ |
915 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); | 915 | ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); |
916 | } | 916 | } |
917 | } | 917 | } |
918 | /* Flag the buffer dirty if caller will write in it */ | 918 | /* Flag the buffer dirty if caller will write in it */ |
919 | if (writable) | 919 | if (writable) |
920 | ptr->dirty = TRUE; | 920 | ptr->dirty = TRUE; |
921 | /* Return address of proper part of the buffer */ | 921 | /* Return address of proper part of the buffer */ |
922 | return ptr->mem_buffer + (start_row - ptr->cur_start_row); | 922 | return ptr->mem_buffer + (start_row - ptr->cur_start_row); |
923 | } | 923 | } |
924 | 924 | ||
925 | 925 | ||
926 | /* | 926 | /* |
927 | * Release all objects belonging to a specified pool. | 927 | * Release all objects belonging to a specified pool. |
928 | */ | 928 | */ |
929 | 929 | ||
930 | METHODDEF(void) | 930 | METHODDEF(void) |
931 | free_pool (j_common_ptr cinfo, int pool_id) | 931 | free_pool (j_common_ptr cinfo, int pool_id) |
932 | { | 932 | { |
933 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; | 933 | my_mem_ptr mem = (my_mem_ptr) cinfo->mem; |
934 | small_pool_ptr shdr_ptr; | 934 | small_pool_ptr shdr_ptr; |
935 | large_pool_ptr lhdr_ptr; | 935 | large_pool_ptr lhdr_ptr; |
936 | size_t space_freed; | 936 | size_t space_freed; |
937 | 937 | ||
938 | if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) | 938 | if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) |
939 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ | 939 | ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ |
940 | 940 | ||
941 | #ifdef MEM_STATS | 941 | #ifdef MEM_STATS |
942 | if (cinfo->err->trace_level > 1) | 942 | if (cinfo->err->trace_level > 1) |
943 | print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */ | 943 | print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */ |
944 | #endif | 944 | #endif |
945 | 945 | ||
946 | /* If freeing IMAGE pool, close any virtual arrays first */ | 946 | /* If freeing IMAGE pool, close any virtual arrays first */ |
947 | if (pool_id == JPOOL_IMAGE) { | 947 | if (pool_id == JPOOL_IMAGE) { |
948 | jvirt_sarray_ptr sptr; | 948 | jvirt_sarray_ptr sptr; |
949 | jvirt_barray_ptr bptr; | 949 | jvirt_barray_ptr bptr; |
950 | 950 | ||
951 | for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { | 951 | for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { |
952 | if (sptr->b_s_open) { /* there may be no backing store */ | 952 | if (sptr->b_s_open) { /* there may be no backing store */ |
953 | sptr->b_s_open = FALSE; /* prevent recursive close if error */ | 953 | sptr->b_s_open = FALSE; /* prevent recursive close if error */ |
954 | (*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info); | 954 | (*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info); |
955 | } | 955 | } |
956 | } | 956 | } |
957 | mem->virt_sarray_list = NULL; | 957 | mem->virt_sarray_list = NULL; |
958 | for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { | 958 | for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { |
959 | if (bptr->b_s_open) { /* there may be no backing store */ | 959 | if (bptr->b_s_open) { /* there may be no backing store */ |
960 | bptr->b_s_open = FALSE; /* prevent recursive close if error */ | 960 | bptr->b_s_open = FALSE; /* prevent recursive close if error */ |
961 | (*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info); | 961 | (*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info); |
962 | } | 962 | } |
963 | } | 963 | } |
964 | mem->virt_barray_list = NULL; | 964 | mem->virt_barray_list = NULL; |
965 | } | 965 | } |
966 | 966 | ||
967 | /* Release large objects */ | 967 | /* Release large objects */ |
968 | lhdr_ptr = mem->large_list[pool_id]; | 968 | lhdr_ptr = mem->large_list[pool_id]; |
969 | mem->large_list[pool_id] = NULL; | 969 | mem->large_list[pool_id] = NULL; |
970 | 970 | ||
971 | while (lhdr_ptr != NULL) { | 971 | while (lhdr_ptr != NULL) { |
972 | large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next; | 972 | large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next; |
973 | space_freed = lhdr_ptr->hdr.bytes_used + | 973 | space_freed = lhdr_ptr->hdr.bytes_used + |
974 | lhdr_ptr->hdr.bytes_left + | 974 | lhdr_ptr->hdr.bytes_left + |
975 | SIZEOF(large_pool_hdr); | 975 | SIZEOF(large_pool_hdr); |
976 | jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed); | 976 | jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed); |
977 | mem->total_space_allocated -= space_freed; | 977 | mem->total_space_allocated -= space_freed; |
978 | lhdr_ptr = next_lhdr_ptr; | 978 | lhdr_ptr = next_lhdr_ptr; |
979 | } | 979 | } |
980 | 980 | ||
981 | /* Release small objects */ | 981 | /* Release small objects */ |
982 | shdr_ptr = mem->small_list[pool_id]; | 982 | shdr_ptr = mem->small_list[pool_id]; |
983 | mem->small_list[pool_id] = NULL; | 983 | mem->small_list[pool_id] = NULL; |
984 | 984 | ||
985 | while (shdr_ptr != NULL) { | 985 | while (shdr_ptr != NULL) { |
986 | small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next; | 986 | small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next; |
987 | space_freed = shdr_ptr->hdr.bytes_used + | 987 | space_freed = shdr_ptr->hdr.bytes_used + |
988 | shdr_ptr->hdr.bytes_left + | 988 | shdr_ptr->hdr.bytes_left + |
989 | SIZEOF(small_pool_hdr); | 989 | SIZEOF(small_pool_hdr); |
990 | jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed); | 990 | jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed); |
991 | mem->total_space_allocated -= space_freed; | 991 | mem->total_space_allocated -= space_freed; |
992 | shdr_ptr = next_shdr_ptr; | 992 | shdr_ptr = next_shdr_ptr; |
993 | } | 993 | } |
994 | } | 994 | } |
995 | 995 | ||
996 | 996 | ||
997 | /* | 997 | /* |
998 | * Close up shop entirely. | 998 | * Close up shop entirely. |
999 | * Note that this cannot be called unless cinfo->mem is non-NULL. | 999 | * Note that this cannot be called unless cinfo->mem is non-NULL. |
1000 | */ | 1000 | */ |
1001 | 1001 | ||
1002 | METHODDEF(void) | 1002 | METHODDEF(void) |
1003 | self_destruct (j_common_ptr cinfo) | 1003 | self_destruct (j_common_ptr cinfo) |
1004 | { | 1004 | { |
1005 | int pool; | 1005 | int pool; |
1006 | 1006 | ||
1007 | /* Close all backing store, release all memory. | 1007 | /* Close all backing store, release all memory. |
1008 | * Releasing pools in reverse order might help avoid fragmentation | 1008 | * Releasing pools in reverse order might help avoid fragmentation |
1009 | * with some (brain-damaged) malloc libraries. | 1009 | * with some (brain-damaged) malloc libraries. |
1010 | */ | 1010 | */ |
1011 | for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { | 1011 | for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { |
1012 | free_pool(cinfo, pool); | 1012 | free_pool(cinfo, pool); |
1013 | } | 1013 | } |
1014 | 1014 | ||
1015 | /* Release the memory manager control block too. */ | 1015 | /* Release the memory manager control block too. */ |
1016 | jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr)); | 1016 | jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr)); |
1017 | cinfo->mem = NULL; /* ensures I will be called only once */ | 1017 | cinfo->mem = NULL; /* ensures I will be called only once */ |
1018 | 1018 | ||
1019 | jpeg_mem_term(cinfo); /* system-dependent cleanup */ | 1019 | jpeg_mem_term(cinfo); /* system-dependent cleanup */ |
1020 | } | 1020 | } |
1021 | 1021 | ||
1022 | 1022 | ||
1023 | /* | 1023 | /* |
1024 | * Memory manager initialization. | 1024 | * Memory manager initialization. |
1025 | * When this is called, only the error manager pointer is valid in cinfo! | 1025 | * When this is called, only the error manager pointer is valid in cinfo! |
1026 | */ | 1026 | */ |
1027 | 1027 | ||
1028 | GLOBAL(void) | 1028 | GLOBAL(void) |
1029 | jinit_memory_mgr (j_common_ptr cinfo) | 1029 | jinit_memory_mgr (j_common_ptr cinfo) |
1030 | { | 1030 | { |
1031 | my_mem_ptr mem; | 1031 | my_mem_ptr mem; |
1032 | long max_to_use; | 1032 | long max_to_use; |
1033 | int pool; | 1033 | int pool; |
1034 | size_t test_mac; | 1034 | size_t test_mac; |
1035 | 1035 | ||
1036 | cinfo->mem = NULL; /* for safety if init fails */ | 1036 | cinfo->mem = NULL; /* for safety if init fails */ |
1037 | 1037 | ||
1038 | /* Check for configuration errors. | 1038 | /* Check for configuration errors. |
1039 | * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably | 1039 | * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably |
1040 | * doesn't reflect any real hardware alignment requirement. | 1040 | * doesn't reflect any real hardware alignment requirement. |
1041 | * The test is a little tricky: for X>0, X and X-1 have no one-bits | 1041 | * The test is a little tricky: for X>0, X and X-1 have no one-bits |
1042 | * in common if and only if X is a power of 2, ie has only one one-bit. | 1042 | * in common if and only if X is a power of 2, ie has only one one-bit. |
1043 | * Some compilers may give an "unreachable code" warning here; ignore it. | 1043 | * Some compilers may give an "unreachable code" warning here; ignore it. |
1044 | */ | 1044 | */ |
1045 | if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0) | 1045 | if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0) |
1046 | ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE); | 1046 | ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE); |
1047 | /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be | 1047 | /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be |
1048 | * a multiple of SIZEOF(ALIGN_TYPE). | 1048 | * a multiple of SIZEOF(ALIGN_TYPE). |
1049 | * Again, an "unreachable code" warning may be ignored here. | 1049 | * Again, an "unreachable code" warning may be ignored here. |
1050 | * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK. | 1050 | * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK. |
1051 | */ | 1051 | */ |
1052 | test_mac = (size_t) MAX_ALLOC_CHUNK; | 1052 | test_mac = (size_t) MAX_ALLOC_CHUNK; |
1053 | if ((long) test_mac != MAX_ALLOC_CHUNK || | 1053 | if ((long) test_mac != MAX_ALLOC_CHUNK || |
1054 | (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0) | 1054 | (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0) |
1055 | ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK); | 1055 | ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK); |
1056 | 1056 | ||
1057 | max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */ | 1057 | max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */ |
1058 | 1058 | ||
1059 | /* Attempt to allocate memory manager's control block */ | 1059 | /* Attempt to allocate memory manager's control block */ |
1060 | mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr)); | 1060 | mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr)); |
1061 | 1061 | ||
1062 | if (mem == NULL) { | 1062 | if (mem == NULL) { |
1063 | jpeg_mem_term(cinfo); /* system-dependent cleanup */ | 1063 | jpeg_mem_term(cinfo); /* system-dependent cleanup */ |
1064 | ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0); | 1064 | ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0); |
1065 | } | 1065 | } |
1066 | 1066 | ||
1067 | /* OK, fill in the method pointers */ | 1067 | /* OK, fill in the method pointers */ |
1068 | mem->pub.alloc_small = alloc_small; | 1068 | mem->pub.alloc_small = alloc_small; |
1069 | mem->pub.alloc_large = alloc_large; | 1069 | mem->pub.alloc_large = alloc_large; |
1070 | mem->pub.alloc_sarray = alloc_sarray; | 1070 | mem->pub.alloc_sarray = alloc_sarray; |
1071 | mem->pub.alloc_barray = alloc_barray; | 1071 | mem->pub.alloc_barray = alloc_barray; |
1072 | mem->pub.request_virt_sarray = request_virt_sarray; | 1072 | mem->pub.request_virt_sarray = request_virt_sarray; |
1073 | mem->pub.request_virt_barray = request_virt_barray; | 1073 | mem->pub.request_virt_barray = request_virt_barray; |
1074 | mem->pub.realize_virt_arrays = realize_virt_arrays; | 1074 | mem->pub.realize_virt_arrays = realize_virt_arrays; |
1075 | mem->pub.access_virt_sarray = access_virt_sarray; | 1075 | mem->pub.access_virt_sarray = access_virt_sarray; |
1076 | mem->pub.access_virt_barray = access_virt_barray; | 1076 | mem->pub.access_virt_barray = access_virt_barray; |
1077 | mem->pub.free_pool = free_pool; | 1077 | mem->pub.free_pool = free_pool; |
1078 | mem->pub.self_destruct = self_destruct; | 1078 | mem->pub.self_destruct = self_destruct; |
1079 | 1079 | ||
1080 | /* Make MAX_ALLOC_CHUNK accessible to other modules */ | 1080 | /* Make MAX_ALLOC_CHUNK accessible to other modules */ |
1081 | mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK; | 1081 | mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK; |
1082 | 1082 | ||
1083 | /* Initialize working state */ | 1083 | /* Initialize working state */ |
1084 | mem->pub.max_memory_to_use = max_to_use; | 1084 | mem->pub.max_memory_to_use = max_to_use; |
1085 | 1085 | ||
1086 | for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { | 1086 | for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { |
1087 | mem->small_list[pool] = NULL; | 1087 | mem->small_list[pool] = NULL; |
1088 | mem->large_list[pool] = NULL; | 1088 | mem->large_list[pool] = NULL; |
1089 | } | 1089 | } |
1090 | mem->virt_sarray_list = NULL; | 1090 | mem->virt_sarray_list = NULL; |
1091 | mem->virt_barray_list = NULL; | 1091 | mem->virt_barray_list = NULL; |
1092 | 1092 | ||
1093 | mem->total_space_allocated = SIZEOF(my_memory_mgr); | 1093 | mem->total_space_allocated = SIZEOF(my_memory_mgr); |
1094 | 1094 | ||
1095 | /* Declare ourselves open for business */ | 1095 | /* Declare ourselves open for business */ |
1096 | cinfo->mem = & mem->pub; | 1096 | cinfo->mem = & mem->pub; |
1097 | 1097 | ||
1098 | /* Check for an environment variable JPEGMEM; if found, override the | 1098 | /* Check for an environment variable JPEGMEM; if found, override the |
1099 | * default max_memory setting from jpeg_mem_init. Note that the | 1099 | * default max_memory setting from jpeg_mem_init. Note that the |
1100 | * surrounding application may again override this value. | 1100 | * surrounding application may again override this value. |
1101 | * If your system doesn't support getenv(), define NO_GETENV to disable | 1101 | * If your system doesn't support getenv(), define NO_GETENV to disable |
1102 | * this feature. | 1102 | * this feature. |
1103 | */ | 1103 | */ |
1104 | #ifndef NO_GETENV | 1104 | #ifndef NO_GETENV |
1105 | { char * memenv; | 1105 | { char * memenv; |
1106 | 1106 | ||
1107 | if ((memenv = getenv("JPEGMEM")) != NULL) { | 1107 | if ((memenv = getenv("JPEGMEM")) != NULL) { |
1108 | char ch = 'x'; | 1108 | char ch = 'x'; |
1109 | 1109 | ||
1110 | if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) { | 1110 | if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) { |
1111 | if (ch == 'm' || ch == 'M') | 1111 | if (ch == 'm' || ch == 'M') |
1112 | max_to_use *= 1000L; | 1112 | max_to_use *= 1000L; |
1113 | mem->pub.max_memory_to_use = max_to_use * 1000L; | 1113 | mem->pub.max_memory_to_use = max_to_use * 1000L; |
1114 | } | 1114 | } |
1115 | } | 1115 | } |
1116 | } | 1116 | } |
1117 | #endif | 1117 | #endif |
1118 | 1118 | ||
1119 | } | 1119 | } |