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.
8
* This file provides an MS-DOS-compatible implementation of the system-
9
* dependent portion of the JPEG memory manager. Temporary data can be
10
* stored in extended or expanded memory as well as in regular DOS files.
12
* If you use this file, you must be sure that NEED_FAR_POINTERS is defined
13
* if you compile in a small-data memory model; it should NOT be defined if
14
* you use a large-data memory model. This file is not recommended if you
15
* are using a flat-memory-space 386 environment such as DJGCC or Watcom C.
16
* Also, this code will NOT work if struct fields are aligned on greater than
19
* Based on code contributed by Ge' Weijers.
23
* If you have both extended and expanded memory, you may want to change the
24
* order in which they are tried in jopen_backing_store. On a 286 machine
25
* expanded memory is usually faster, since extended memory access involves
26
* an expensive protected-mode-and-back switch. On 386 and better, extended
27
* memory is usually faster. As distributed, the code tries extended memory
28
* first (what? not everyone has a 386? :-).
30
* You can disable use of extended/expanded memory entirely by altering these
31
* definitions or overriding them from the Makefile (eg, -DEMS_SUPPORTED=0).
35
#define XMS_SUPPORTED 1
38
#define EMS_SUPPORTED 1
42
#define JPEG_INTERNALS
45
#include "jmemsys.h" /* import the system-dependent declarations */
47
#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare these */
48
extern void * malloc JPP((size_t size));
49
extern void free JPP((void *ptr));
50
extern char * getenv JPP((const char * name));
53
#ifdef NEED_FAR_POINTERS
56
/* These definitions work for Borland C (Turbo C) */
57
#include <alloc.h> /* need farmalloc(), farfree() */
58
#define far_malloc(x) farmalloc(x)
59
#define far_free(x) farfree(x)
61
/* These definitions work for Microsoft C and compatible compilers */
62
#include <malloc.h> /* need _fmalloc(), _ffree() */
63
#define far_malloc(x) _fmalloc(x)
64
#define far_free(x) _ffree(x)
67
#else /* not NEED_FAR_POINTERS */
69
#define far_malloc(x) malloc(x)
70
#define far_free(x) free(x)
72
#endif /* NEED_FAR_POINTERS */
74
#ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */
75
#define READ_BINARY "r"
77
#define READ_BINARY "rb"
80
#ifndef USE_MSDOS_MEMMGR /* make sure user got configuration right */
81
You forgot to define USE_MSDOS_MEMMGR in jconfig.h. /* deliberate syntax error */
84
#if MAX_ALLOC_CHUNK >= 65535L /* make sure jconfig.h got this right */
85
MAX_ALLOC_CHUNK should be less than 64K. /* deliberate syntax error */
90
* Declarations for assembly-language support routines (see jmemdosa.asm).
92
* The functions are declared "far" as are all their pointer arguments;
93
* this ensures the assembly source code will work regardless of the
94
* compiler memory model. We assume "short" is 16 bits, "long" is 32.
97
typedef void far * XMSDRIVER; /* actually a pointer to code */
98
typedef struct { /* registers for calling XMS driver */
99
unsigned short ax, dx, bx;
102
typedef struct { /* registers for calling EMS driver */
103
unsigned short ax, dx, bx;
107
extern short far jdos_open JPP((short far * handle, char far * filename));
108
extern short far jdos_close JPP((short handle));
109
extern short far jdos_seek JPP((short handle, long offset));
110
extern short far jdos_read JPP((short handle, void far * buffer,
111
unsigned short count));
112
extern short far jdos_write JPP((short handle, void far * buffer,
113
unsigned short count));
114
extern void far jxms_getdriver JPP((XMSDRIVER far *));
115
extern void far jxms_calldriver JPP((XMSDRIVER, XMScontext far *));
116
extern short far jems_available JPP((void));
117
extern void far jems_calldriver JPP((EMScontext far *));
121
* Selection of a file name for a temporary file.
122
* This is highly system-dependent, and you may want to customize it.
125
static int next_file_num; /* to distinguish among several temp files */
128
select_file_name (char * fname)
134
/* Keep generating file names till we find one that's not in use */
136
/* Get temp directory name from environment TMP or TEMP variable;
139
if ((env = (const char *) getenv("TMP")) == NULL)
140
if ((env = (const char *) getenv("TEMP")) == NULL)
142
if (*env == '\0') /* null string means "." */
144
ptr = fname; /* copy name to fname */
147
if (ptr[-1] != '\\' && ptr[-1] != '/')
148
*ptr++ = '\\'; /* append backslash if not in env variable */
149
/* Append a suitable file name */
150
next_file_num++; /* advance counter */
151
sprintf(ptr, "JPG%03d.TMP", next_file_num);
152
/* Probe to see if file name is already in use */
153
if ((tfile = fopen(fname, READ_BINARY)) == NULL)
155
fclose(tfile); /* oops, it's there; close tfile & try again */
161
* Near-memory allocation and freeing are controlled by the regular library
162
* routines malloc() and free().
166
jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
168
return (void *) malloc(sizeofobject);
172
jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
179
* "Large" objects are allocated in far memory, if possible
183
jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
185
return (void FAR *) far_malloc(sizeofobject);
189
jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
196
* This routine computes the total memory space available for allocation.
197
* It's impossible to do this in a portable way; our current solution is
198
* to make the user tell us (with a default value set at compile time).
199
* If you can actually get the available space, it's a good idea to subtract
200
* a slop factor of 5% or so.
203
#ifndef DEFAULT_MAX_MEM /* so can override from makefile */
204
#define DEFAULT_MAX_MEM 300000L /* for total usage about 450K */
208
jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
209
long max_bytes_needed, long already_allocated)
211
return cinfo->mem->max_memory_to_use - already_allocated;
216
* Backing store (temporary file) management.
217
* Backing store objects are only used when the value returned by
218
* jpeg_mem_available is less than the total space needed. You can dispense
219
* with these routines if you have plenty of virtual memory; see jmemnobs.c.
223
* For MS-DOS we support three types of backing storage:
224
* 1. Conventional DOS files. We access these by direct DOS calls rather
225
* than via the stdio package. This provides a bit better performance,
226
* but the real reason is that the buffers to be read or written are FAR.
227
* The stdio library for small-data memory models can't cope with that.
228
* 2. Extended memory, accessed per the XMS V2.0 specification.
229
* 3. Expanded memory, accessed per the LIM/EMS 4.0 specification.
230
* You'll need copies of those specs to make sense of the related code.
231
* The specs are available by Internet FTP from the SIMTEL archives
232
* (oak.oakland.edu and its various mirror sites). See files
233
* pub/msdos/microsoft/xms20.arc and pub/msdos/info/limems41.zip.
238
* Access methods for a DOS file.
243
read_file_store (j_common_ptr cinfo, backing_store_ptr info,
244
void FAR * buffer_address,
245
long file_offset, long byte_count)
247
if (jdos_seek(info->handle.file_handle, file_offset))
248
ERREXIT(cinfo, JERR_TFILE_SEEK);
249
/* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */
250
if (byte_count > 65535L) /* safety check */
251
ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
252
if (jdos_read(info->handle.file_handle, buffer_address,
253
(unsigned short) byte_count))
254
ERREXIT(cinfo, JERR_TFILE_READ);
259
write_file_store (j_common_ptr cinfo, backing_store_ptr info,
260
void FAR * buffer_address,
261
long file_offset, long byte_count)
263
if (jdos_seek(info->handle.file_handle, file_offset))
264
ERREXIT(cinfo, JERR_TFILE_SEEK);
265
/* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */
266
if (byte_count > 65535L) /* safety check */
267
ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
268
if (jdos_write(info->handle.file_handle, buffer_address,
269
(unsigned short) byte_count))
270
ERREXIT(cinfo, JERR_TFILE_WRITE);
275
close_file_store (j_common_ptr cinfo, backing_store_ptr info)
277
jdos_close(info->handle.file_handle); /* close the file */
278
remove(info->temp_name); /* delete the file */
279
/* If your system doesn't have remove(), try unlink() instead.
280
* remove() is the ANSI-standard name for this function, but
281
* unlink() was more common in pre-ANSI systems.
283
TRACEMSS(cinfo, 1, JTRC_TFILE_CLOSE, info->temp_name);
288
open_file_store (j_common_ptr cinfo, backing_store_ptr info,
289
long total_bytes_needed)
293
select_file_name(info->temp_name);
294
if (jdos_open((short far *) & handle, (char far *) info->temp_name)) {
295
/* might as well exit since jpeg_open_backing_store will fail anyway */
296
ERREXITS(cinfo, JERR_TFILE_CREATE, info->temp_name);
299
info->handle.file_handle = handle;
300
info->read_backing_store = read_file_store;
301
info->write_backing_store = write_file_store;
302
info->close_backing_store = close_file_store;
303
TRACEMSS(cinfo, 1, JTRC_TFILE_OPEN, info->temp_name);
304
return TRUE; /* succeeded */
309
* Access methods for extended memory.
314
static XMSDRIVER xms_driver; /* saved address of XMS driver */
316
typedef union { /* either long offset or real-mode pointer */
321
typedef struct { /* XMS move specification structure */
329
#define ODD(X) (((X) & 1L) != 0)
333
read_xms_store (j_common_ptr cinfo, backing_store_ptr info,
334
void FAR * buffer_address,
335
long file_offset, long byte_count)
341
/* The XMS driver can't cope with an odd length, so handle the last byte
342
* specially if byte_count is odd. We don't expect this to be common.
345
spec.length = byte_count & (~ 1L);
346
spec.src_handle = info->handle.xms_handle;
347
spec.src.offset = file_offset;
349
spec.dst.ptr = buffer_address;
351
ctx.ds_si = (void far *) & spec;
352
ctx.ax = 0x0b00; /* EMB move */
353
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
355
ERREXIT(cinfo, JERR_XMS_READ);
357
if (ODD(byte_count)) {
358
read_xms_store(cinfo, info, (void FAR *) endbuffer,
359
file_offset + byte_count - 1L, 2L);
360
((char FAR *) buffer_address)[byte_count - 1L] = endbuffer[0];
366
write_xms_store (j_common_ptr cinfo, backing_store_ptr info,
367
void FAR * buffer_address,
368
long file_offset, long byte_count)
374
/* The XMS driver can't cope with an odd length, so handle the last byte
375
* specially if byte_count is odd. We don't expect this to be common.
378
spec.length = byte_count & (~ 1L);
380
spec.src.ptr = buffer_address;
381
spec.dst_handle = info->handle.xms_handle;
382
spec.dst.offset = file_offset;
384
ctx.ds_si = (void far *) & spec;
385
ctx.ax = 0x0b00; /* EMB move */
386
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
388
ERREXIT(cinfo, JERR_XMS_WRITE);
390
if (ODD(byte_count)) {
391
read_xms_store(cinfo, info, (void FAR *) endbuffer,
392
file_offset + byte_count - 1L, 2L);
393
endbuffer[0] = ((char FAR *) buffer_address)[byte_count - 1L];
394
write_xms_store(cinfo, info, (void FAR *) endbuffer,
395
file_offset + byte_count - 1L, 2L);
401
close_xms_store (j_common_ptr cinfo, backing_store_ptr info)
405
ctx.dx = info->handle.xms_handle;
407
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
408
TRACEMS1(cinfo, 1, JTRC_XMS_CLOSE, info->handle.xms_handle);
409
/* we ignore any error return from the driver */
414
open_xms_store (j_common_ptr cinfo, backing_store_ptr info,
415
long total_bytes_needed)
419
/* Get address of XMS driver */
420
jxms_getdriver((XMSDRIVER far *) & xms_driver);
421
if (xms_driver == NULL)
422
return FALSE; /* no driver to be had */
424
/* Get version number, must be >= 2.00 */
426
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
427
if (ctx.ax < (unsigned short) 0x0200)
430
/* Try to get space (expressed in kilobytes) */
431
ctx.dx = (unsigned short) ((total_bytes_needed + 1023L) >> 10);
433
jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
437
/* Succeeded, save the handle and away we go */
438
info->handle.xms_handle = ctx.dx;
439
info->read_backing_store = read_xms_store;
440
info->write_backing_store = write_xms_store;
441
info->close_backing_store = close_xms_store;
442
TRACEMS1(cinfo, 1, JTRC_XMS_OPEN, ctx.dx);
443
return TRUE; /* succeeded */
446
#endif /* XMS_SUPPORTED */
450
* Access methods for expanded memory.
455
/* The EMS move specification structure requires word and long fields aligned
456
* at odd byte boundaries. Some compilers will align struct fields at even
457
* byte boundaries. While it's usually possible to force byte alignment,
458
* that causes an overall performance penalty and may pose problems in merging
459
* JPEG into a larger application. Instead we accept some rather dirty code
460
* here. Note this code would fail if the hardware did not allow odd-byte
461
* word & long accesses, but all 80x86 CPUs do.
464
typedef void far * EMSPTR;
466
typedef union { /* EMS move specification structure */
467
long length; /* It's easy to access first 4 bytes */
468
char bytes[18]; /* Misaligned fields in here! */
471
/* Macros for accessing misaligned fields */
472
#define FIELD_AT(spec,offset,type) (*((type *) &(spec.bytes[offset])))
473
#define SRC_TYPE(spec) FIELD_AT(spec,4,char)
474
#define SRC_HANDLE(spec) FIELD_AT(spec,5,EMSH)
475
#define SRC_OFFSET(spec) FIELD_AT(spec,7,unsigned short)
476
#define SRC_PAGE(spec) FIELD_AT(spec,9,unsigned short)
477
#define SRC_PTR(spec) FIELD_AT(spec,7,EMSPTR)
478
#define DST_TYPE(spec) FIELD_AT(spec,11,char)
479
#define DST_HANDLE(spec) FIELD_AT(spec,12,EMSH)
480
#define DST_OFFSET(spec) FIELD_AT(spec,14,unsigned short)
481
#define DST_PAGE(spec) FIELD_AT(spec,16,unsigned short)
482
#define DST_PTR(spec) FIELD_AT(spec,14,EMSPTR)
484
#define EMSPAGESIZE 16384L /* gospel, see the EMS specs */
486
#define HIBYTE(W) (((W) >> 8) & 0xFF)
487
#define LOBYTE(W) ((W) & 0xFF)
491
read_ems_store (j_common_ptr cinfo, backing_store_ptr info,
492
void FAR * buffer_address,
493
long file_offset, long byte_count)
498
spec.length = byte_count;
500
SRC_HANDLE(spec) = info->handle.ems_handle;
501
SRC_PAGE(spec) = (unsigned short) (file_offset / EMSPAGESIZE);
502
SRC_OFFSET(spec) = (unsigned short) (file_offset % EMSPAGESIZE);
504
DST_HANDLE(spec) = 0;
505
DST_PTR(spec) = buffer_address;
507
ctx.ds_si = (void far *) & spec;
508
ctx.ax = 0x5700; /* move memory region */
509
jems_calldriver((EMScontext far *) & ctx);
510
if (HIBYTE(ctx.ax) != 0)
511
ERREXIT(cinfo, JERR_EMS_READ);
516
write_ems_store (j_common_ptr cinfo, backing_store_ptr info,
517
void FAR * buffer_address,
518
long file_offset, long byte_count)
523
spec.length = byte_count;
525
SRC_HANDLE(spec) = 0;
526
SRC_PTR(spec) = buffer_address;
528
DST_HANDLE(spec) = info->handle.ems_handle;
529
DST_PAGE(spec) = (unsigned short) (file_offset / EMSPAGESIZE);
530
DST_OFFSET(spec) = (unsigned short) (file_offset % EMSPAGESIZE);
532
ctx.ds_si = (void far *) & spec;
533
ctx.ax = 0x5700; /* move memory region */
534
jems_calldriver((EMScontext far *) & ctx);
535
if (HIBYTE(ctx.ax) != 0)
536
ERREXIT(cinfo, JERR_EMS_WRITE);
541
close_ems_store (j_common_ptr cinfo, backing_store_ptr info)
546
ctx.dx = info->handle.ems_handle;
547
jems_calldriver((EMScontext far *) & ctx);
548
TRACEMS1(cinfo, 1, JTRC_EMS_CLOSE, info->handle.ems_handle);
549
/* we ignore any error return from the driver */
554
open_ems_store (j_common_ptr cinfo, backing_store_ptr info,
555
long total_bytes_needed)
559
/* Is EMS driver there? */
560
if (! jems_available())
563
/* Get status, make sure EMS is OK */
565
jems_calldriver((EMScontext far *) & ctx);
566
if (HIBYTE(ctx.ax) != 0)
569
/* Get version, must be >= 4.0 */
571
jems_calldriver((EMScontext far *) & ctx);
572
if (HIBYTE(ctx.ax) != 0 || LOBYTE(ctx.ax) < 0x40)
575
/* Try to allocate requested space */
577
ctx.bx = (unsigned short) ((total_bytes_needed + EMSPAGESIZE-1L) / EMSPAGESIZE);
578
jems_calldriver((EMScontext far *) & ctx);
579
if (HIBYTE(ctx.ax) != 0)
582
/* Succeeded, save the handle and away we go */
583
info->handle.ems_handle = ctx.dx;
584
info->read_backing_store = read_ems_store;
585
info->write_backing_store = write_ems_store;
586
info->close_backing_store = close_ems_store;
587
TRACEMS1(cinfo, 1, JTRC_EMS_OPEN, ctx.dx);
588
return TRUE; /* succeeded */
591
#endif /* EMS_SUPPORTED */
595
* Initial opening of a backing-store object.
599
jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
600
long total_bytes_needed)
602
/* Try extended memory, then expanded memory, then regular file. */
604
if (open_xms_store(cinfo, info, total_bytes_needed))
608
if (open_ems_store(cinfo, info, total_bytes_needed))
611
if (open_file_store(cinfo, info, total_bytes_needed))
613
ERREXITS(cinfo, JERR_TFILE_CREATE, "");
618
* These routines take care of any system-dependent initialization and
623
jpeg_mem_init (j_common_ptr cinfo)
625
next_file_num = 0; /* initialize temp file name generator */
626
return DEFAULT_MAX_MEM; /* default for max_memory_to_use */
630
jpeg_mem_term (j_common_ptr cinfo)
632
/* Microsoft C, at least in v6.00A, will not successfully reclaim freed
633
* blocks of size > 32Kbytes unless we give it a kick in the rear, like so:
added
removed
source/Irrlicht/jpeglib/jmemdos.c
