| 1 |
/* |
| 2 |
* jmemsys.h |
| 3 |
* |
| 4 |
* Copyright (C) 1992-1997, Thomas G. Lane. |
| 5 |
* This file is part of the Independent JPEG Group's software. |
| 6 |
* For conditions of distribution and use, see the accompanying README file. |
| 7 |
* |
| 8 |
* This include file defines the interface between the system-independent |
| 9 |
* and system-dependent portions of the JPEG memory manager. No other |
| 10 |
* modules need include it. (The system-independent portion is jmemmgr.c; |
| 11 |
* there are several different versions of the system-dependent portion.) |
| 12 |
* |
| 13 |
* This file works as-is for the system-dependent memory managers supplied |
| 14 |
* in the IJG distribution. You may need to modify it if you write a |
| 15 |
* custom memory manager. If system-dependent changes are needed in |
| 16 |
* this file, the best method is to #ifdef them based on a configuration |
| 17 |
* symbol supplied in jconfig.h, as we have done with USE_MSDOS_MEMMGR |
| 18 |
* and USE_MAC_MEMMGR. |
| 19 |
*/ |
| 20 |
|
| 21 |
|
| 22 |
/* Short forms of external names for systems with brain-damaged linkers. */ |
| 23 |
|
| 24 |
#ifdef NEED_SHORT_EXTERNAL_NAMES |
| 25 |
#define jpeg_get_small jGetSmall |
| 26 |
#define jpeg_free_small jFreeSmall |
| 27 |
#define jpeg_get_large jGetLarge |
| 28 |
#define jpeg_free_large jFreeLarge |
| 29 |
#define jpeg_mem_available jMemAvail |
| 30 |
#define jpeg_open_backing_store jOpenBackStore |
| 31 |
#define jpeg_mem_init jMemInit |
| 32 |
#define jpeg_mem_term jMemTerm |
| 33 |
#endif /* NEED_SHORT_EXTERNAL_NAMES */ |
| 34 |
|
| 35 |
#ifdef NEED_12_BIT_NAMES |
| 36 |
#define jpeg_get_small jpeg_get_small_12 |
| 37 |
#define jpeg_free_small jpeg_free_small_12 |
| 38 |
#define jpeg_get_large jpeg_get_large_12 |
| 39 |
#define jpeg_free_large jpeg_free_large_12 |
| 40 |
#define jpeg_mem_available jpeg_mem_available_12 |
| 41 |
#define jpeg_open_backing_store jpeg_open_backing_store_12 |
| 42 |
#define jpeg_mem_init jpeg_mem_init_12 |
| 43 |
#define jpeg_mem_term jpeg_mem_term_12 |
| 44 |
#elif defined(RENAME_INTERNAL_LIBJPEG_SYMBOLS) |
| 45 |
#define jpeg_get_small gdal_jpeg_get_small |
| 46 |
#define jpeg_free_small gdal_jpeg_free_small |
| 47 |
#define jpeg_get_large gdal_jpeg_get_large |
| 48 |
#define jpeg_free_large gdal_jpeg_free_large |
| 49 |
#define jpeg_mem_available gdal_jpeg_mem_available |
| 50 |
#define jpeg_open_backing_store gdal_jpeg_open_backing_store |
| 51 |
#define jpeg_mem_init gdal_jpeg_mem_init |
| 52 |
#define jpeg_mem_term gdal_jpeg_mem_term |
| 53 |
#endif |
| 54 |
|
| 55 |
|
| 56 |
/* |
| 57 |
* These two functions are used to allocate and release small chunks of |
| 58 |
* memory. (Typically the total amount requested through jpeg_get_small is |
| 59 |
* no more than 20K or so; this will be requested in chunks of a few K each.) |
| 60 |
* Behavior should be the same as for the standard library functions malloc |
| 61 |
* and free; in particular, jpeg_get_small must return NULL on failure. |
| 62 |
* On most systems, these ARE malloc and free. jpeg_free_small is passed the |
| 63 |
* size of the object being freed, just in case it's needed. |
| 64 |
* On an 80x86 machine using small-data memory model, these manage near heap. |
| 65 |
*/ |
| 66 |
|
| 67 |
EXTERN(void *) jpeg_get_small JPP((j_common_ptr cinfo, size_t sizeofobject)); |
| 68 |
EXTERN(void) jpeg_free_small JPP((j_common_ptr cinfo, void * object, |
| 69 |
size_t sizeofobject)); |
| 70 |
|
| 71 |
/* |
| 72 |
* These two functions are used to allocate and release large chunks of |
| 73 |
* memory (up to the total free space designated by jpeg_mem_available). |
| 74 |
* The interface is the same as above, except that on an 80x86 machine, |
| 75 |
* far pointers are used. On most other machines these are identical to |
| 76 |
* the jpeg_get/free_small routines; but we keep them separate anyway, |
| 77 |
* in case a different allocation strategy is desirable for large chunks. |
| 78 |
*/ |
| 79 |
|
| 80 |
EXTERN(void FAR *) jpeg_get_large JPP((j_common_ptr cinfo, |
| 81 |
size_t sizeofobject)); |
| 82 |
EXTERN(void) jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object, |
| 83 |
size_t sizeofobject)); |
| 84 |
|
| 85 |
/* |
| 86 |
* The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may |
| 87 |
* be requested in a single call to jpeg_get_large (and jpeg_get_small for that |
| 88 |
* matter, but that case should never come into play). This macro is needed |
| 89 |
* to model the 64Kb-segment-size limit of far addressing on 80x86 machines. |
| 90 |
* On those machines, we expect that jconfig.h will provide a proper value. |
| 91 |
* On machines with 32-bit flat address spaces, any large constant may be used. |
| 92 |
* |
| 93 |
* NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type |
| 94 |
* size_t and will be a multiple of sizeof(align_type). |
| 95 |
*/ |
| 96 |
|
| 97 |
#ifndef MAX_ALLOC_CHUNK /* may be overridden in jconfig.h */ |
| 98 |
#define MAX_ALLOC_CHUNK 1000000000L |
| 99 |
#endif |
| 100 |
|
| 101 |
/* |
| 102 |
* This routine computes the total space still available for allocation by |
| 103 |
* jpeg_get_large. If more space than this is needed, backing store will be |
| 104 |
* used. NOTE: any memory already allocated must not be counted. |
| 105 |
* |
| 106 |
* There is a minimum space requirement, corresponding to the minimum |
| 107 |
* feasible buffer sizes; jmemmgr.c will request that much space even if |
| 108 |
* jpeg_mem_available returns zero. The maximum space needed, enough to hold |
| 109 |
* all working storage in memory, is also passed in case it is useful. |
| 110 |
* Finally, the total space already allocated is passed. If no better |
| 111 |
* method is available, cinfo->mem->max_memory_to_use - already_allocated |
| 112 |
* is often a suitable calculation. |
| 113 |
* |
| 114 |
* It is OK for jpeg_mem_available to underestimate the space available |
| 115 |
* (that'll just lead to more backing-store access than is really necessary). |
| 116 |
* However, an overestimate will lead to failure. Hence it's wise to subtract |
| 117 |
* a slop factor from the true available space. 5% should be enough. |
| 118 |
* |
| 119 |
* On machines with lots of virtual memory, any large constant may be returned. |
| 120 |
* Conversely, zero may be returned to always use the minimum amount of memory. |
| 121 |
*/ |
| 122 |
|
| 123 |
EXTERN(long) jpeg_mem_available JPP((j_common_ptr cinfo, |
| 124 |
long min_bytes_needed, |
| 125 |
long max_bytes_needed, |
| 126 |
long already_allocated)); |
| 127 |
|
| 128 |
|
| 129 |
/* |
| 130 |
* This structure holds whatever state is needed to access a single |
| 131 |
* backing-store object. The read/write/close method pointers are called |
| 132 |
* by jmemmgr.c to manipulate the backing-store object; all other fields |
| 133 |
* are private to the system-dependent backing store routines. |
| 134 |
*/ |
| 135 |
|
| 136 |
#define TEMP_NAME_LENGTH 64 /* max length of a temporary file's name */ |
| 137 |
|
| 138 |
|
| 139 |
#ifdef USE_MSDOS_MEMMGR /* DOS-specific junk */ |
| 140 |
|
| 141 |
typedef unsigned short XMSH; /* type of extended-memory handles */ |
| 142 |
typedef unsigned short EMSH; /* type of expanded-memory handles */ |
| 143 |
|
| 144 |
typedef union { |
| 145 |
short file_handle; /* DOS file handle if it's a temp file */ |
| 146 |
XMSH xms_handle; /* handle if it's a chunk of XMS */ |
| 147 |
EMSH ems_handle; /* handle if it's a chunk of EMS */ |
| 148 |
} handle_union; |
| 149 |
|
| 150 |
#endif /* USE_MSDOS_MEMMGR */ |
| 151 |
|
| 152 |
#ifdef USE_MAC_MEMMGR /* Mac-specific junk */ |
| 153 |
#include <Files.h> |
| 154 |
#endif /* USE_MAC_MEMMGR */ |
| 155 |
|
| 156 |
|
| 157 |
typedef struct backing_store_struct * backing_store_ptr; |
| 158 |
|
| 159 |
typedef struct backing_store_struct { |
| 160 |
/* Methods for reading/writing/closing this backing-store object */ |
| 161 |
JMETHOD(void, read_backing_store, (j_common_ptr cinfo, |
| 162 |
backing_store_ptr info, |
| 163 |
void FAR * buffer_address, |
| 164 |
long file_offset, long byte_count)); |
| 165 |
JMETHOD(void, write_backing_store, (j_common_ptr cinfo, |
| 166 |
backing_store_ptr info, |
| 167 |
void FAR * buffer_address, |
| 168 |
long file_offset, long byte_count)); |
| 169 |
JMETHOD(void, close_backing_store, (j_common_ptr cinfo, |
| 170 |
backing_store_ptr info)); |
| 171 |
|
| 172 |
/* Private fields for system-dependent backing-store management */ |
| 173 |
#ifdef USE_MSDOS_MEMMGR |
| 174 |
/* For the MS-DOS manager (jmemdos.c), we need: */ |
| 175 |
handle_union handle; /* reference to backing-store storage object */ |
| 176 |
char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */ |
| 177 |
#else |
| 178 |
#ifdef USE_MAC_MEMMGR |
| 179 |
/* For the Mac manager (jmemmac.c), we need: */ |
| 180 |
short temp_file; /* file reference number to temp file */ |
| 181 |
FSSpec tempSpec; /* the FSSpec for the temp file */ |
| 182 |
char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */ |
| 183 |
#else |
| 184 |
/* For a typical implementation with temp files, we need: */ |
| 185 |
FILE * temp_file; /* stdio reference to temp file */ |
| 186 |
char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */ |
| 187 |
#endif |
| 188 |
#endif |
| 189 |
} backing_store_info; |
| 190 |
|
| 191 |
|
| 192 |
/* |
| 193 |
* Initial opening of a backing-store object. This must fill in the |
| 194 |
* read/write/close pointers in the object. The read/write routines |
| 195 |
* may take an error exit if the specified maximum file size is exceeded. |
| 196 |
* (If jpeg_mem_available always returns a large value, this routine can |
| 197 |
* just take an error exit.) |
| 198 |
*/ |
| 199 |
|
| 200 |
EXTERN(void) jpeg_open_backing_store JPP((j_common_ptr cinfo, |
| 201 |
backing_store_ptr info, |
| 202 |
long total_bytes_needed)); |
| 203 |
|
| 204 |
|
| 205 |
/* |
| 206 |
* These routines take care of any system-dependent initialization and |
| 207 |
* cleanup required. jpeg_mem_init will be called before anything is |
| 208 |
* allocated (and, therefore, nothing in cinfo is of use except the error |
| 209 |
* manager pointer). It should return a suitable default value for |
| 210 |
* max_memory_to_use; this may subsequently be overridden by the surrounding |
| 211 |
* application. (Note that max_memory_to_use is only important if |
| 212 |
* jpeg_mem_available chooses to consult it ... no one else will.) |
| 213 |
* jpeg_mem_term may assume that all requested memory has been freed and that |
| 214 |
* all opened backing-store objects have been closed. |
| 215 |
*/ |
| 216 |
|
| 217 |
EXTERN(long) jpeg_mem_init JPP((j_common_ptr cinfo)); |
| 218 |
EXTERN(void) jpeg_mem_term JPP((j_common_ptr cinfo)); |