Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(57)

Side by Side Diff: jmemsys.h

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

Powered by Google App Engine
This is Rietveld 408576698