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 }