Visualization Library 2.0.0-b5

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
jmemdos.c
Go to the documentation of this file.
1 /*
2  * jmemdos.c
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 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.
11  *
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
17  * 2-byte boundaries.
18  *
19  * Based on code contributed by Ge' Weijers.
20  */
21 
22 /*
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? :-).
29  *
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).
32  */
33 
34 #ifndef XMS_SUPPORTED
35 #define XMS_SUPPORTED 1
36 #endif
37 #ifndef EMS_SUPPORTED
38 #define EMS_SUPPORTED 1
39 #endif
40 
41 
42 #define JPEG_INTERNALS
43 #include "jinclude.h"
44 #include "jpeglib.h"
45 #include "jmemsys.h" /* import the system-dependent declarations */
46 
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));
51 #endif
52 
53 #ifdef NEED_FAR_POINTERS
54 
55 #ifdef __TURBOC__
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)
60 #else
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)
65 #endif
66 
67 #else /* not NEED_FAR_POINTERS */
68 
69 #define far_malloc(x) malloc(x)
70 #define far_free(x) free(x)
71 
72 #endif /* NEED_FAR_POINTERS */
73 
74 #ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */
75 #define READ_BINARY "r"
76 #else
77 #define READ_BINARY "rb"
78 #endif
79 
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 */
82 #endif
83 
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 */
86 #endif
87 
88 
89 /*
90  * Declarations for assembly-language support routines (see jmemdosa.asm).
91  *
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.
95  */
96 
97 typedef void far * XMSDRIVER; /* actually a pointer to code */
98 typedef struct { /* registers for calling XMS driver */
99  unsigned short ax, dx, bx;
100  void far * ds_si;
101  } XMScontext;
102 typedef struct { /* registers for calling EMS driver */
103  unsigned short ax, dx, bx;
104  void far * ds_si;
105  } EMScontext;
106 
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 *));
118 
119 
120 /*
121  * Selection of a file name for a temporary file.
122  * This is highly system-dependent, and you may want to customize it.
123  */
124 
125 static int next_file_num; /* to distinguish among several temp files */
126 
127 LOCAL(void)
128 select_file_name (char * fname)
129 {
130  const char * env;
131  char * ptr;
132  FILE * tfile;
133 
134  /* Keep generating file names till we find one that's not in use */
135  for (;;) {
136  /* Get temp directory name from environment TMP or TEMP variable;
137  * if none, use "."
138  */
139  if ((env = (const char *) getenv("TMP")) == NULL)
140  if ((env = (const char *) getenv("TEMP")) == NULL)
141  env = ".";
142  if (*env == '\0') /* null string means "." */
143  env = ".";
144  ptr = fname; /* copy name to fname */
145  while (*env != '\0')
146  *ptr++ = *env++;
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)
154  break;
155  fclose(tfile); /* oops, it's there; close tfile & try again */
156  }
157 }
158 
159 
160 /*
161  * Near-memory allocation and freeing are controlled by the regular library
162  * routines malloc() and free().
163  */
164 
165 GLOBAL(void *)
167 {
168  return (void *) malloc(sizeofobject);
169 }
170 
171 GLOBAL(void)
172 jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
173 {
174  free(object);
175 }
176 
177 
178 /*
179  * "Large" objects are allocated in far memory, if possible
180  */
181 
182 GLOBAL(void FAR *)
184 {
185  return (void FAR *) far_malloc(sizeofobject);
186 }
187 
188 GLOBAL(void)
189 jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
190 {
191  far_free(object);
192 }
193 
194 
195 /*
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.
201  */
202 
203 #ifndef DEFAULT_MAX_MEM /* so can override from makefile */
204 #define DEFAULT_MAX_MEM 300000L /* for total usage about 450K */
205 #endif
206 
207 GLOBAL(long)
210 {
211  return cinfo->mem->max_memory_to_use - already_allocated;
212 }
213 
214 
215 /*
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.
220  */
221 
222 /*
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.
234  */
235 
236 
237 /*
238  * Access methods for a DOS file.
239  */
240 
241 
242 METHODDEF(void)
244  void FAR * buffer_address,
245  long file_offset, long byte_count)
246 {
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);
255 }
256 
257 
258 METHODDEF(void)
260  void FAR * buffer_address,
261  long file_offset, long byte_count)
262 {
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);
271 }
272 
273 
274 METHODDEF(void)
276 {
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.
282  */
283  TRACEMSS(cinfo, 1, JTRC_TFILE_CLOSE, info->temp_name);
284 }
285 
286 
287 LOCAL(boolean)
289  long total_bytes_needed)
290 {
291  short handle;
292 
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);
297  return FALSE;
298  }
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 */
305 }
306 
307 
308 /*
309  * Access methods for extended memory.
310  */
311 
312 #if XMS_SUPPORTED
313 
314 static XMSDRIVER xms_driver; /* saved address of XMS driver */
315 
316 typedef union { /* either long offset or real-mode pointer */
317  long offset;
318  void far * ptr;
319  } XMSPTR;
320 
321 typedef struct { /* XMS move specification structure */
322  long length;
323  XMSH src_handle;
324  XMSPTR src;
325  XMSH dst_handle;
326  XMSPTR dst;
327  } XMSspec;
328 
329 #define ODD(X) (((X) & 1L) != 0)
330 
331 
332 METHODDEF(void)
334  void FAR * buffer_address,
335  long file_offset, long byte_count)
336 {
337  XMScontext ctx;
338  XMSspec spec;
339  char endbuffer[2];
340 
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.
343  */
344 
345  spec.length = byte_count & (~ 1L);
346  spec.src_handle = info->handle.xms_handle;
347  spec.src.offset = file_offset;
348  spec.dst_handle = 0;
349  spec.dst.ptr = buffer_address;
350 
351  ctx.ds_si = (void far *) & spec;
352  ctx.ax = 0x0b00; /* EMB move */
353  jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
354  if (ctx.ax != 1)
355  ERREXIT(cinfo, JERR_XMS_READ);
356 
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];
361  }
362 }
363 
364 
365 METHODDEF(void)
367  void FAR * buffer_address,
368  long file_offset, long byte_count)
369 {
370  XMScontext ctx;
371  XMSspec spec;
372  char endbuffer[2];
373 
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.
376  */
377 
378  spec.length = byte_count & (~ 1L);
379  spec.src_handle = 0;
380  spec.src.ptr = buffer_address;
381  spec.dst_handle = info->handle.xms_handle;
382  spec.dst.offset = file_offset;
383 
384  ctx.ds_si = (void far *) & spec;
385  ctx.ax = 0x0b00; /* EMB move */
386  jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
387  if (ctx.ax != 1)
388  ERREXIT(cinfo, JERR_XMS_WRITE);
389 
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);
396  }
397 }
398 
399 
400 METHODDEF(void)
402 {
403  XMScontext ctx;
404 
405  ctx.dx = info->handle.xms_handle;
406  ctx.ax = 0x0a00;
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 */
410 }
411 
412 
413 LOCAL(boolean)
415  long total_bytes_needed)
416 {
417  XMScontext ctx;
418 
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 */
423 
424  /* Get version number, must be >= 2.00 */
425  ctx.ax = 0x0000;
426  jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
427  if (ctx.ax < (unsigned short) 0x0200)
428  return FALSE;
429 
430  /* Try to get space (expressed in kilobytes) */
431  ctx.dx = (unsigned short) ((total_bytes_needed + 1023L) >> 10);
432  ctx.ax = 0x0900;
433  jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
434  if (ctx.ax != 1)
435  return FALSE;
436 
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 */
444 }
445 
446 #endif /* XMS_SUPPORTED */
447 
448 
449 /*
450  * Access methods for expanded memory.
451  */
452 
453 #if EMS_SUPPORTED
454 
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.
462  */
463 
464 typedef void far * EMSPTR;
465 
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! */
469  } EMSspec;
470 
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)
483 
484 #define EMSPAGESIZE 16384L /* gospel, see the EMS specs */
485 
486 #define HIBYTE(W) (((W) >> 8) & 0xFF)
487 #define LOBYTE(W) ((W) & 0xFF)
488 
489 
490 METHODDEF(void)
492  void FAR * buffer_address,
493  long file_offset, long byte_count)
494 {
495  EMScontext ctx;
496  EMSspec spec;
497 
498  spec.length = byte_count;
499  SRC_TYPE(spec) = 1;
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);
503  DST_TYPE(spec) = 0;
504  DST_HANDLE(spec) = 0;
505  DST_PTR(spec) = buffer_address;
506 
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);
512 }
513 
514 
515 METHODDEF(void)
517  void FAR * buffer_address,
518  long file_offset, long byte_count)
519 {
520  EMScontext ctx;
521  EMSspec spec;
522 
523  spec.length = byte_count;
524  SRC_TYPE(spec) = 0;
525  SRC_HANDLE(spec) = 0;
526  SRC_PTR(spec) = buffer_address;
527  DST_TYPE(spec) = 1;
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);
531 
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);
537 }
538 
539 
540 METHODDEF(void)
542 {
543  EMScontext ctx;
544 
545  ctx.ax = 0x4500;
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 */
550 }
551 
552 
553 LOCAL(boolean)
555  long total_bytes_needed)
556 {
557  EMScontext ctx;
558 
559  /* Is EMS driver there? */
560  if (! jems_available())
561  return FALSE;
562 
563  /* Get status, make sure EMS is OK */
564  ctx.ax = 0x4000;
565  jems_calldriver((EMScontext far *) & ctx);
566  if (HIBYTE(ctx.ax) != 0)
567  return FALSE;
568 
569  /* Get version, must be >= 4.0 */
570  ctx.ax = 0x4600;
571  jems_calldriver((EMScontext far *) & ctx);
572  if (HIBYTE(ctx.ax) != 0 || LOBYTE(ctx.ax) < 0x40)
573  return FALSE;
574 
575  /* Try to allocate requested space */
576  ctx.ax = 0x4300;
577  ctx.bx = (unsigned short) ((total_bytes_needed + EMSPAGESIZE-1L) / EMSPAGESIZE);
578  jems_calldriver((EMScontext far *) & ctx);
579  if (HIBYTE(ctx.ax) != 0)
580  return FALSE;
581 
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 */
589 }
590 
591 #endif /* EMS_SUPPORTED */
592 
593 
594 /*
595  * Initial opening of a backing-store object.
596  */
597 
598 GLOBAL(void)
600  long total_bytes_needed)
601 {
602  /* Try extended memory, then expanded memory, then regular file. */
603 #if XMS_SUPPORTED
605  return;
606 #endif
607 #if EMS_SUPPORTED
609  return;
610 #endif
612  return;
613  ERREXITS(cinfo, JERR_TFILE_CREATE, "");
614 }
615 
616 
617 /*
618  * These routines take care of any system-dependent initialization and
619  * cleanup required.
620  */
621 
622 GLOBAL(long)
624 {
625  next_file_num = 0; /* initialize temp file name generator */
626  return DEFAULT_MAX_MEM; /* default for max_memory_to_use */
627 }
628 
629 GLOBAL(void)
631 {
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:
634  */
635 #ifdef NEED_FHEAPMIN
636  _fheapmin();
637 #endif
638 }
GLenum GLuint GLenum GLsizei length
#define DST_PTR(spec)
Definition: jmemdos.c:482
#define READ_BINARY
Definition: jmemdos.c:77
jpeg_get_small(j_common_ptr cinfo, size_t sizeofobject)
Definition: jmemdos.c:166
char temp_name[TEMP_NAME_LENGTH]
Definition: jmemsys.h:166
#define far_free(x)
Definition: jmemdos.c:70
#define SRC_PTR(spec)
Definition: jmemdos.c:477
#define LOBYTE(W)
Definition: jmemdos.c:487
#define NULL
Definition: ftobjs.h:61
#define SRC_OFFSET(spec)
Definition: jmemdos.c:475
long long max_bytes_needed
Definition: jmemsys.h:104
#define far_malloc(x)
Definition: jmemdos.c:69
png_voidp ptr
Definition: png.h:1908
void far * EMSPTR
Definition: jmemdos.c:464
#define HIBYTE(W)
Definition: jmemdos.c:486
char * malloc()
#define ERREXIT(cinfo, code)
Definition: jerror.h:205
const char * filename
Definition: ioapi.h:135
write_xms_store(j_common_ptr cinfo, backing_store_ptr info, void FAR *buffer_address, long file_offset, long byte_count)
Definition: jmemdos.c:366
#define DST_OFFSET(spec)
Definition: jmemdos.c:480
size_t sizeofobject
Definition: jmemsys.h:47
open_ems_store(j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed)
Definition: jmemdos.c:554
You forgot to define USE_MSDOS_MEMMGR in jconfig h MAX_ALLOC_CHUNK should be less than typedef void far * XMSDRIVER
Definition: jmemdos.c:97
write_ems_store(j_common_ptr cinfo, backing_store_ptr info, void FAR *buffer_address, long file_offset, long byte_count)
Definition: jmemdos.c:516
read_file_store(j_common_ptr cinfo, backing_store_ptr info, void FAR *buffer_address, long file_offset, long byte_count)
Definition: jmemdos.c:243
#define TRACEMS1(cinfo, lvl, code, p1)
Definition: jerror.h:255
read_ems_store(j_common_ptr cinfo, backing_store_ptr info, void FAR *buffer_address, long file_offset, long byte_count)
Definition: jmemdos.c:491
jpeg_mem_init(j_common_ptr cinfo)
Definition: jmemdos.c:623
backing_store_ptr long total_bytes_needed
Definition: jmemsys.h:181
GLenum GLenum dst
#define LOCAL(type)
Definition: jmorecfg.h:189
#define ODD(X)
Definition: jmemdos.c:329
#define TRACEMSS(cinfo, lvl, code, str)
Definition: jerror.h:286
close_file_store(j_common_ptr cinfo, backing_store_ptr info)
Definition: jmemdos.c:275
close_ems_store(j_common_ptr cinfo, backing_store_ptr info)
Definition: jmemdos.c:541
long min_bytes_needed
Definition: jmemsys.h:104
#define SRC_TYPE(spec)
Definition: jmemdos.c:473
GLuint buffer
int free()
#define DST_PAGE(spec)
Definition: jmemdos.c:481
GLenum src
#define FAR
Definition: zconf.h:215
GLintptr offset
#define EMSPAGESIZE
Definition: jmemdos.c:484
#define FALSE
Definition: ftobjs.h:57
long long long already_allocated
Definition: jmemsys.h:104
open_file_store(j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed)
Definition: jmemdos.c:288
GLuint const GLchar * name
close_xms_store(j_common_ptr cinfo, backing_store_ptr info)
Definition: jmemdos.c:401
#define GLOBAL(type)
Definition: jmorecfg.h:191
backing_store_ptr info
Definition: jmemsys.h:181
#define METHODDEF(type)
Definition: jmorecfg.h:187
jpeg_mem_term(j_common_ptr cinfo)
Definition: jmemdos.c:630
jpeg_open_backing_store(j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed)
Definition: jmemdos.c:599
GLuint in
jpeg_mem_available(j_common_ptr cinfo, long min_bytes_needed, long max_bytes_needed, long already_allocated)
Definition: jmemdos.c:208
write_file_store(j_common_ptr cinfo, backing_store_ptr info, void FAR *buffer_address, long file_offset, long byte_count)
Definition: jmemdos.c:259
jpeg_free_large(j_common_ptr cinfo, void FAR *object, size_t sizeofobject)
Definition: jmemdos.c:189
short far jdos_open JPP((short far *handle, char far *filename))
#define DST_TYPE(spec)
Definition: jmemdos.c:478
GLuint GLuint GLsizei count
open_xms_store(j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed)
Definition: jmemdos.c:414
jpeg_free_small(j_common_ptr cinfo, void *object, size_t sizeofobject)
Definition: jmemdos.c:172
#define DST_HANDLE(spec)
Definition: jmemdos.c:479
#define MAX_ALLOC_CHUNK
Definition: jmemsys.h:78
read_xms_store(j_common_ptr cinfo, backing_store_ptr info, void FAR *buffer_address, long file_offset, long byte_count)
Definition: jmemdos.c:333
#define SRC_HANDLE(spec)
Definition: jmemdos.c:474
jpeg_get_large(j_common_ptr cinfo, size_t sizeofobject)
Definition: jmemdos.c:183
GLsizeiptr size
#define TRUE
Definition: ftobjs.h:53
#define SRC_PAGE(spec)
Definition: jmemdos.c:476
#define ERREXITS(cinfo, code, str)
Definition: jerror.h:230
#define DEFAULT_MAX_MEM
Definition: jmemdos.c:204
select_file_name(char *fname)
Definition: jmemdos.c:128