]> git.jsancho.org Git - lugaru.git/blob - jpeg-6b/jmemdos.c
JPG support.
[lugaru.git] / jpeg-6b / jmemdos.c
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 *)
166 jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
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 *)
183 jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
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)
208 jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
209                     long max_bytes_needed, long already_allocated)
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)
243 read_file_store (j_common_ptr cinfo, backing_store_ptr info,
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)
259 write_file_store (j_common_ptr cinfo, backing_store_ptr info,
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)
275 close_file_store (j_common_ptr cinfo, backing_store_ptr info)
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)
288 open_file_store (j_common_ptr cinfo, backing_store_ptr info,
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;
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)
333 read_xms_store (j_common_ptr cinfo, backing_store_ptr info,
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)
366 write_xms_store (j_common_ptr cinfo, backing_store_ptr info,
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)
401 close_xms_store (j_common_ptr cinfo, backing_store_ptr info)
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)
414 open_xms_store (j_common_ptr cinfo, backing_store_ptr info,
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)
491 read_ems_store (j_common_ptr cinfo, backing_store_ptr info,
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)
516 write_ems_store (j_common_ptr cinfo, backing_store_ptr info,
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)
541 close_ems_store (j_common_ptr cinfo, backing_store_ptr info)
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)
554 open_ems_store (j_common_ptr cinfo, backing_store_ptr info,
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)
599 jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
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)
623 jpeg_mem_init (j_common_ptr cinfo)
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)
630 jpeg_mem_term (j_common_ptr cinfo)
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 }