forked from edivando-fpc/BGRABitmap
-
Notifications
You must be signed in to change notification settings - Fork 0
/
jmemsys.pas
177 lines (137 loc) · 7.58 KB
/
jmemsys.pas
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
Unit jmemsys;
{$i FPImage.inc}{$H+}
{ This is a skeleton you need to create a working system-dependent
JPEG memory manager.
No other modules need include it. (The system-independent portion is
jmemmgr.c; there are several different versions of the system-dependent
portion.)
This code will not compile - Check JMEMDOS.PAS for an example }
{ Original: jmemsys.h; Copyright (C) 1992-1996, Thomas G. Lane. }
interface
uses
jmorecfg,
jpeglib;
{ The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
be requested in a single call to jpeg_get_large (and jpeg_get_small for that
matter, but that case should never come into play). This macro is needed
to model the 64Kb-segment-size limit of far addressing on 80x86 machines.
On those machines, we expect that jconfig.h will provide a proper value.
On machines with 32-bit flat address spaces, any large constant may be used.
NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type
size_t and will be a multiple of sizeof(align_type). }
{$ifdef USE_MSDOS_MEMMGR} { Define this if you use jmemdos.c }
const
MAX_ALLOC_CHUNK = long(65520); { Maximum request to malloc() }
{$else}
const
MAX_ALLOC_CHUNK = long(1000000000);
{$endif}
{ Initial opening of a backing-store object. This must fill in the
read/write/close pointers in the object. The read/write routines
may take an error exit if the specified maximum file size is exceeded.
(If jpeg_mem_available always returns a large value, this routine can
just take an error exit.) }
EXTERN procedure jpeg_open_backing_store (cinfo : j_common_ptr;
info : backing_store_ptr;
total_bytes_needed : long);
{ These routines take care of any system-dependent initialization and
cleanup required. jpeg_mem_init will be called before anything is
allocated (and, therefore, nothing in cinfo is of use except the error
manager pointer). It should return a suitable default value for
max_memory_to_use; this may subsequently be overridden by the surrounding
application. (Note that max_memory_to_use is only important if
jpeg_mem_available chooses to consult it ... no one else will.)
jpeg_mem_term may assume that all requested memory has been freed and that
all opened backing-store objects have been closed. }
EXTERN function jpeg_mem_init (cinfo : j_common_ptr) : long;
EXTERN procedure jpeg_mem_term (cinfo : j_common_ptr);
implementation
{ This structure holds whatever state is needed to access a single
backing-store object. The read/write/close method pointers are called
by jmemmgr.c to manipulate the backing-store object; all other fields
are private to the system-dependent backing store routines. }
const
TEMP_NAME_LENGTH = 64; { max length of a temporary file's name }
{$ifdef USE_MSDOS_MEMMGR} { DOS-specific junk }
type
XMSH = ushort; { type of extended-memory handles }
EMSH = ushort; { type of expanded-memory handles }
handle_union = record
case byte of
0:(file_handle : short); { DOS file handle if it's a temp file }
1:(xms_handle : XMSH); { handle if it's a chunk of XMS }
2:(ems_handle : EMSH); { handle if it's a chunk of EMS }
end;
{$endif - USE_MSDOS_MEMMGR }
type
backing_store_ptr = ^backing_store_info;
backing_store_info = record
{ Methods for reading/writing/closing this backing-store object }
read_backing_store : procedure (cinfo : j_common_ptr;
info : backing_store_ptr;
buffer_address : pointer; {far}
file_offset : long;
byte_count : long);
write_backing_store : procedure (cinfo : j_common_ptr;
info : backing_store_ptr;
buffer_address : pointer; {far}
file_offset : long;
byte_count : long);
close_backing_store : procedure (cinfo : j_common_ptr;
info : backing_store_ptr);
{ Private fields for system-dependent backing-store management }
{$ifdef USE_MSDOS_MEMMGR}
{ For the MS-DOS manager (jmemdos.c), we need: }
handle : handle_union; { reference to backing-store storage object }
temp_name : string[TEMP_NAME_LENGTH]; { name if it's a file }
{$else}
{ For a typical implementation with temp files, we need: }
temp_file : FILE; { stdio reference to temp file }
temp_name : string[TEMP_NAME_LENGTH]; { name of temp file }
{$endif}
end;
{ These two functions are used to allocate and release small chunks of
memory. (Typically the total amount requested through jpeg_get_small is
no more than 20K or so; this will be requested in chunks of a few K each.)
Behavior should be the same as for the standard library functions malloc
and free; in particular, jpeg_get_small must return NIL on failure.
On most systems, these ARE malloc and free. jpeg_free_small is passed the
size of the object being freed, just in case it's needed.
On an 80x86 machine using small-data memory model, these manage near heap. }
EXTERN function jpeg_get_small (cinfo : j_common_ptr;
sizeofobject : size_t) : pointer;
EXTERN procedure jpeg_free_small (cinfo : j_common_ptr;
object : pointer;
sizeofobject : size_t);
{ These two functions are used to allocate and release large chunks of
memory (up to the total free space designated by jpeg_mem_available).
The interface is the same as above, except that on an 80x86 machine,
far pointers are used. On most other machines these are identical to
the jpeg_get/free_small routines; but we keep them separate anyway,
in case a different allocation strategy is desirable for large chunks. }
EXTERN function jpeg_get_large (cinfo : j_common_ptr cinfo;
sizeofobject : size_t) : pointer; {far}
EXTERN procedure jpeg_free_large (cinfo : j_common_ptr;
object : pointer; {far}
sizeofobject : size_t);
{ This routine computes the total space still available for allocation by
jpeg_get_large. If more space than this is needed, backing store will be
used. NOTE: any memory already allocated must not be counted.
There is a minimum space requirement, corresponding to the minimum
feasible buffer sizes; jmemmgr.c will request that much space even if
jpeg_mem_available returns zero. The maximum space needed, enough to hold
all working storage in memory, is also passed in case it is useful.
Finally, the total space already allocated is passed. If no better
method is available, cinfo->mem->max_memory_to_use - already_allocated
is often a suitable calculation.
It is OK for jpeg_mem_available to underestimate the space available
(that'll just lead to more backing-store access than is really necessary).
However, an overestimate will lead to failure. Hence it's wise to subtract
a slop factor from the true available space. 5% should be enough.
On machines with lots of virtual memory, any large constant may be returned.
Conversely, zero may be returned to always use the minimum amount of memory.}
EXTERN function jpeg_mem_available (cinfo : j_common_ptr;
min_bytes_needed : long;
max_bytes_needed : long;
already_allocated : long) : long;
end.