ReactOS  0.4.11-dev-765-g5e024bf
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 
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);
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;
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
604  if (open_xms_store(cinfo, info, total_bytes_needed))
605  return;
606 #endif
607 #if EMS_SUPPORTED
608  if (open_ems_store(cinfo, info, total_bytes_needed))
609  return;
610 #endif
611  if (open_file_store(cinfo, info, total_bytes_needed))
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 }
#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
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED LPLOOKUPSERVICE_COMPLETION_ROUTINE HANDLE * handle
Definition: sock.c:82
XMSPTR dst
Definition: jmemdos.c:326
#define TRUE
Definition: types.h:120
unsigned short bx
Definition: jmemdos.c:103
unsigned short dx
Definition: jmemdos.c:103
#define far_free(x)
Definition: jmemdos.c:70
#define SRC_PTR(spec)
Definition: jmemdos.c:477
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define LOBYTE(W)
Definition: jmemdos.c:487
#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
void far * ptr
Definition: jmemdos.c:318
#define free
Definition: debug_ros.c:5
unsigned short ax
Definition: jmemdos.c:99
GLintptr offset
Definition: glext.h:5920
void far * EMSPTR
Definition: jmemdos.c:464
#define HIBYTE(W)
Definition: jmemdos.c:486
GLuint buffer
Definition: glext.h:5915
XMSH dst_handle
Definition: jmemdos.c:325
const char * filename
Definition: ioapi.h:135
Definition: wpp.c:33
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 far
Definition: windef.h:114
#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
#define sprintf(buf, format,...)
Definition: sprintf.c:55
long length
Definition: jmemdos.c:322
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:91
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
#define FALSE
Definition: types.h:117
long offset
Definition: jmemdos.c:317
#define GLOBAL
Definition: assyntax.h:275
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
#define FAR
Definition: guiddef.h:36
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
static PVOID ptr
Definition: dispmode.c:27
ecx edi ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 mm1 mm5 paddd mm0 paddd mm4 mm0 mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 mm1 paddd mm0 mm0 packssdw mm0 movd eax movw ax
Definition: synth_sse3d.h:171
#define TRACEMS1(cinfo, lvl, code, p1)
Definition: jerror.h:268
smooth NULL
Definition: ftsmooth.c:416
long length
Definition: jmemdos.c:467
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
static int next_file_num
Definition: jmemdos.c:125
#define LOCAL(type)
Definition: jmorecfg.h:289
#define ODD(X)
Definition: jmemdos.c:329
#define TRACEMSS(cinfo, lvl, code, str)
Definition: jerror.h:299
You forgot to define USE_MSDOS_MEMMGR in jconfig h typedef void far * XMSDRIVER
Definition: jmemdos.c:97
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
GLsizeiptr size
Definition: glext.h:5919
long min_bytes_needed
Definition: jmemsys.h:104
static XMSDRIVER xms_driver
Definition: jmemdos.c:314
#define SRC_TYPE(spec)
Definition: jmemdos.c:473
#define DST_PAGE(spec)
Definition: jmemdos.c:481
GLuint GLuint GLsizei count
Definition: gl.h:1545
void far * ds_si
Definition: jmemdos.c:100
unsigned short dx
Definition: jmemdos.c:99
#define EMSPAGESIZE
Definition: jmemdos.c:484
XMSPTR src
Definition: jmemdos.c:324
static const WCHAR L[]
Definition: oid.c:1087
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
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
GLfloat CONST GLvector4f * in
Definition: m_xform.h:122
close_xms_store(j_common_ptr cinfo, backing_store_ptr info)
Definition: jmemdos.c:401
void far * ds_si
Definition: jmemdos.c:104
#define METHODDEF(type)
Definition: jmorecfg.h:287
XMSH src_handle
Definition: jmemdos.c:323
_Check_return_ char *__cdecl getenv(_In_z_ const char *_VarName)
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
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
unsigned short ax
Definition: jmemdos.c:103
static LPCWSTR LPCWSTR LPCWSTR env
Definition: db.cpp:158
void *malloc JPP((size_t size))
#define DST_TYPE(spec)
Definition: jmemdos.c:478
Definition: name.c:36
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 malloc
Definition: debug_ros.c:4
#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
#define SRC_PAGE(spec)
Definition: jmemdos.c:476
#define ERREXITS(cinfo, code, str)
Definition: jerror.h:243
#define DEFAULT_MAX_MEM
Definition: jmemdos.c:204
select_file_name(char *fname)
Definition: jmemdos.c:128