jmemdos.c

Go to the documentation of this file.

/*
 * jmemdos.c
 *
 * Copyright (C) 1992-1997, Thomas G. Lane.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
 * This file provides an MS-DOS-compatible implementation of the system-
 * dependent portion of the JPEG memory manager.  Temporary data can be
 * stored in extended or expanded memory as well as in regular DOS files.
 *
 * If you use this file, you must be sure that NEED_FAR_POINTERS is defined
 * if you compile in a small-data memory model; it should NOT be defined if
 * you use a large-data memory model.  This file is not recommended if you
 * are using a flat-memory-space 386 environment such as DJGCC or Watcom C.
 * Also, this code will NOT work if struct fields are aligned on greater than
 * 2-byte boundaries.
 *
 * Based on code contributed by Ge' Weijers.
 */
 
/*
 * If you have both extended and expanded memory, you may want to change the
 * order in which they are tried in jopen_backing_store.  On a 286 machine
 * expanded memory is usually faster, since extended memory access involves
 * an expensive protected-mode-and-back switch.  On 386 and better, extended
 * memory is usually faster.  As distributed, the code tries extended memory
 * first (what? not everyone has a 386? :-).
 *
 * You can disable use of extended/expanded memory entirely by altering these
 * definitions or overriding them from the Makefile (eg, -DEMS_SUPPORTED=0).
 */
 
#ifndef XMS_SUPPORTED
#define XMS_SUPPORTED  1
#endif
#ifndef EMS_SUPPORTED
#define EMS_SUPPORTED  1
#endif
 
 
#define JPEG_INTERNALS
#include "jinclude.h"
#include "jpeglib.h"
#include "jmemsys.h"        /* import the system-dependent declarations */
 
#ifndef HAVE_STDLIB_H       /* <stdlib.h> should declare these */
extern void * malloc JPP((size_t size));
extern void free JPP((void *ptr));
extern char * getenv JPP((const char * name));
#endif
 
#ifdef NEED_FAR_POINTERS
 
#ifdef __TURBOC__
/* These definitions work for Borland C (Turbo C) */
#include <alloc.h>      /* need farmalloc(), farfree() */
#define far_malloc(x)   farmalloc(x)
#define far_free(x) farfree(x)
#else
/* These definitions work for Microsoft C and compatible compilers */
#include <malloc.h>     /* need _fmalloc(), _ffree() */
#define far_malloc(x)   _fmalloc(x)
#define far_free(x) _ffree(x)
#endif
 
#else /* not NEED_FAR_POINTERS */
 
#define far_malloc(x)   malloc(x)
#define far_free(x) free(x)
 
#endif /* NEED_FAR_POINTERS */
 
#ifdef DONT_USE_B_MODE      /* define mode parameters for fopen() */
#define READ_BINARY "r"
#else
#define READ_BINARY "rb"
#endif
 
#ifndef USE_MSDOS_MEMMGR    /* make sure user got configuration right */
  You forgot to define USE_MSDOS_MEMMGR in jconfig.h. /* deliberate syntax error */
#endif
 
#if MAX_ALLOC_CHUNK >= 65535L   /* make sure jconfig.h got this right */
  MAX_ALLOC_CHUNK should be less than 64K. /* deliberate syntax error */
#endif
 
 
/*
 * Declarations for assembly-language support routines (see jmemdosa.asm).
 *
 * The functions are declared "far" as are all their pointer arguments;
 * this ensures the assembly source code will work regardless of the
 * compiler memory model.  We assume "short" is 16 bits, "long" is 32.
 */
 
typedef void far * XMSDRIVER;   /* actually a pointer to code */
typedef struct {        /* registers for calling XMS driver */
    unsigned short ax, dx, bx;
    void far * ds_si;
      } XMScontext;
typedef struct {        /* registers for calling EMS driver */
    unsigned short ax, dx, bx;
    void far * ds_si;
      } EMScontext;
 
extern short far jdos_open JPP((short far * handle, char far * filename));
extern short far jdos_close JPP((short handle));
extern short far jdos_seek JPP((short handle, long offset));
extern short far jdos_read JPP((short handle, void far * buffer,
                unsigned short count));
extern short far jdos_write JPP((short handle, void far * buffer,
                 unsigned short count));
extern void far jxms_getdriver JPP((XMSDRIVER far *));
extern void far jxms_calldriver JPP((XMSDRIVER, XMScontext far *));
extern short far jems_available JPP((void));
extern void far jems_calldriver JPP((EMScontext far *));
 
 
/*
 * Selection of a file name for a temporary file.
 * This is highly system-dependent, and you may want to customize it.
 */
 
static int next_file_num;   /* to distinguish among several temp files */
 
LOCAL(void)
select_file_name (char * fname)
{
  const char * env;
  char * ptr;
  FILE * tfile;
 
  /* Keep generating file names till we find one that's not in use */
  for (;;) {
    /* Get temp directory name from environment TMP or TEMP variable;
     * if none, use "."
     */
    if ((env = (const char *) getenv("TMP")) == NULL)
      if ((env = (const char *) getenv("TEMP")) == NULL)
    env = ".";
    if (*env == '\0')       /* null string means "." */
      env = ".";
    ptr = fname;        /* copy name to fname */
    while (*env != '\0')
      *ptr++ = *env++;
    if (ptr[-1] != '\\' && ptr[-1] != '/')
      *ptr++ = '\\';        /* append backslash if not in env variable */
    /* Append a suitable file name */
    next_file_num++;        /* advance counter */
    sprintf(ptr, "JPG%03d.TMP", next_file_num);
    /* Probe to see if file name is already in use */
    if ((tfile = fopen(fname, READ_BINARY)) == NULL)
      break;
    fclose(tfile);      /* oops, it's there; close tfile & try again */
  }
}
 
 
/*
 * Near-memory allocation and freeing are controlled by the regular library
 * routines malloc() and free().
 */
 
GLOBAL(void *)
jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
{
  return (void *) malloc(sizeofobject);
}
 
GLOBAL(void)
jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
{
  free(object);
}
 
 
/*
 * "Large" objects are allocated in far memory, if possible
 */
 
GLOBAL(void FAR *)
jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
{
  return (void FAR *) far_malloc(sizeofobject);
}
 
GLOBAL(void)
jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
{
  far_free(object);
}
 
 
/*
 * This routine computes the total memory space available for allocation.
 * It's impossible to do this in a portable way; our current solution is
 * to make the user tell us (with a default value set at compile time).
 * If you can actually get the available space, it's a good idea to subtract
 * a slop factor of 5% or so.
 */
 
#ifndef DEFAULT_MAX_MEM     /* so can override from makefile */
#define DEFAULT_MAX_MEM     300000L /* for total usage about 450K */
#endif
 
GLOBAL(long)
jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
            long max_bytes_needed, long already_allocated)
{
  return cinfo->mem->max_memory_to_use - already_allocated;
}
 
 
/*
 * Backing store (temporary file) management.
 * Backing store objects are only used when the value returned by
 * jpeg_mem_available is less than the total space needed.  You can dispense
 * with these routines if you have plenty of virtual memory; see jmemnobs.c.
 */
 
/*
 * For MS-DOS we support three types of backing storage:
 *   1. Conventional DOS files.  We access these by direct DOS calls rather
 *      than via the stdio package.  This provides a bit better performance,
 *      but the real reason is that the buffers to be read or written are FAR.
 *      The stdio library for small-data memory models can't cope with that.
 *   2. Extended memory, accessed per the XMS V2.0 specification.
 *   3. Expanded memory, accessed per the LIM/EMS 4.0 specification.
 * You'll need copies of those specs to make sense of the related code.
 * The specs are available by Internet FTP from the SIMTEL archives 
 * (oak.oakland.edu and its various mirror sites).  See files
 * pub/msdos/microsoft/xms20.arc and pub/msdos/info/limems41.zip.
 */
 
 
/*
 * Access methods for a DOS file.
 */
 
 
METHODDEF(void)
read_file_store (j_common_ptr cinfo, backing_store_ptr info,
         void FAR * buffer_address,
         long file_offset, long byte_count)
{
  if (jdos_seek(info->handle.file_handle, file_offset))
    ERREXIT(cinfo, JERR_TFILE_SEEK);
  /* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */
  if (byte_count > 65535L)  /* safety check */
    ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
  if (jdos_read(info->handle.file_handle, buffer_address,
        (unsigned short) byte_count))
    ERREXIT(cinfo, JERR_TFILE_READ);
}
 
 
METHODDEF(void)
write_file_store (j_common_ptr cinfo, backing_store_ptr info,
          void FAR * buffer_address,
          long file_offset, long byte_count)
{
  if (jdos_seek(info->handle.file_handle, file_offset))
    ERREXIT(cinfo, JERR_TFILE_SEEK);
  /* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */
  if (byte_count > 65535L)  /* safety check */
    ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
  if (jdos_write(info->handle.file_handle, buffer_address,
         (unsigned short) byte_count))
    ERREXIT(cinfo, JERR_TFILE_WRITE);
}
 
 
METHODDEF(void)
close_file_store (j_common_ptr cinfo, backing_store_ptr info)
{
  jdos_close(info->handle.file_handle); /* close the file */
  remove(info->temp_name);  /* delete the file */
/* If your system doesn't have remove(), try unlink() instead.
 * remove() is the ANSI-standard name for this function, but
 * unlink() was more common in pre-ANSI systems.
 */
  TRACEMSS(cinfo, 1, JTRC_TFILE_CLOSE, info->temp_name);
}
 
 
LOCAL(boolean)
open_file_store (j_common_ptr cinfo, backing_store_ptr info,
         long total_bytes_needed)
{
  short handle;
 
  select_file_name(info->temp_name);
  if (jdos_open((short far *) & handle, (char far *) info->temp_name)) {
    /* might as well exit since jpeg_open_backing_store will fail anyway */
    ERREXITS(cinfo, JERR_TFILE_CREATE, info->temp_name);
    return FALSE;
  }
  info->handle.file_handle = handle;
  info->read_backing_store = read_file_store;
  info->write_backing_store = write_file_store;
  info->close_backing_store = close_file_store;
  TRACEMSS(cinfo, 1, JTRC_TFILE_OPEN, info->temp_name);
  return TRUE;          /* succeeded */
}
 
 
/*
 * Access methods for extended memory.
 */
 
#if XMS_SUPPORTED
 
static XMSDRIVER xms_driver;    /* saved address of XMS driver */
 
typedef union {         /* either long offset or real-mode pointer */
    long offset;
    void far * ptr;
      } XMSPTR;
 
typedef struct {        /* XMS move specification structure */
    long length;
    XMSH src_handle;
    XMSPTR src;
    XMSH dst_handle;
    XMSPTR dst;
      } XMSspec;
 
#define ODD(X)  (((X) & 1L) != 0)
 
 
METHODDEF(void)
read_xms_store (j_common_ptr cinfo, backing_store_ptr info,
        void FAR * buffer_address,
        long file_offset, long byte_count)
{
  XMScontext ctx;
  XMSspec spec;
  char endbuffer[2];
 
  /* The XMS driver can't cope with an odd length, so handle the last byte
   * specially if byte_count is odd.  We don't expect this to be common.
   */
 
  spec.length = byte_count & (~ 1L);
  spec.src_handle = info->handle.xms_handle;
  spec.src.offset = file_offset;
  spec.dst_handle = 0;
  spec.dst.ptr = buffer_address;
  
  ctx.ds_si = (void far *) & spec;
  ctx.ax = 0x0b00;      /* EMB move */
  jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  if (ctx.ax != 1)
    ERREXIT(cinfo, JERR_XMS_READ);
 
  if (ODD(byte_count)) {
    read_xms_store(cinfo, info, (void FAR *) endbuffer,
           file_offset + byte_count - 1L, 2L);
    ((char FAR *) buffer_address)[byte_count - 1L] = endbuffer[0];
  }
}
 
 
METHODDEF(void)
write_xms_store (j_common_ptr cinfo, backing_store_ptr info,
         void FAR * buffer_address,
         long file_offset, long byte_count)
{
  XMScontext ctx;
  XMSspec spec;
  char endbuffer[2];
 
  /* The XMS driver can't cope with an odd length, so handle the last byte
   * specially if byte_count is odd.  We don't expect this to be common.
   */
 
  spec.length = byte_count & (~ 1L);
  spec.src_handle = 0;
  spec.src.ptr = buffer_address;
  spec.dst_handle = info->handle.xms_handle;
  spec.dst.offset = file_offset;
 
  ctx.ds_si = (void far *) & spec;
  ctx.ax = 0x0b00;      /* EMB move */
  jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  if (ctx.ax != 1)
    ERREXIT(cinfo, JERR_XMS_WRITE);
 
  if (ODD(byte_count)) {
    read_xms_store(cinfo, info, (void FAR *) endbuffer,
           file_offset + byte_count - 1L, 2L);
    endbuffer[0] = ((char FAR *) buffer_address)[byte_count - 1L];
    write_xms_store(cinfo, info, (void FAR *) endbuffer,
            file_offset + byte_count - 1L, 2L);
  }
}
 
 
METHODDEF(void)
close_xms_store (j_common_ptr cinfo, backing_store_ptr info)
{
  XMScontext ctx;
 
  ctx.dx = info->handle.xms_handle;
  ctx.ax = 0x0a00;
  jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  TRACEMS1(cinfo, 1, JTRC_XMS_CLOSE, info->handle.xms_handle);
  /* we ignore any error return from the driver */
}
 
 
LOCAL(boolean)
open_xms_store (j_common_ptr cinfo, backing_store_ptr info,
        long total_bytes_needed)
{
  XMScontext ctx;
 
  /* Get address of XMS driver */
  jxms_getdriver((XMSDRIVER far *) & xms_driver);
  if (xms_driver == NULL)
    return FALSE;       /* no driver to be had */
 
  /* Get version number, must be >= 2.00 */
  ctx.ax = 0x0000;
  jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  if (ctx.ax < (unsigned short) 0x0200)
    return FALSE;
 
  /* Try to get space (expressed in kilobytes) */
  ctx.dx = (unsigned short) ((total_bytes_needed + 1023L) >> 10);
  ctx.ax = 0x0900;
  jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  if (ctx.ax != 1)
    return FALSE;
 
  /* Succeeded, save the handle and away we go */
  info->handle.xms_handle = ctx.dx;
  info->read_backing_store = read_xms_store;
  info->write_backing_store = write_xms_store;
  info->close_backing_store = close_xms_store;
  TRACEMS1(cinfo, 1, JTRC_XMS_OPEN, ctx.dx);
  return TRUE;          /* succeeded */
}
 
#endif /* XMS_SUPPORTED */
 
 
/*
 * Access methods for expanded memory.
 */
 
#if EMS_SUPPORTED
 
/* The EMS move specification structure requires word and long fields aligned
 * at odd byte boundaries.  Some compilers will align struct fields at even
 * byte boundaries.  While it's usually possible to force byte alignment,
 * that causes an overall performance penalty and may pose problems in merging
 * JPEG into a larger application.  Instead we accept some rather dirty code
 * here.  Note this code would fail if the hardware did not allow odd-byte
 * word & long accesses, but all 80x86 CPUs do.
 */
 
typedef void far * EMSPTR;
 
typedef union {         /* EMS move specification structure */
    long length;        /* It's easy to access first 4 bytes */
    char bytes[18];     /* Misaligned fields in here! */
      } EMSspec;
 
/* Macros for accessing misaligned fields */
#define FIELD_AT(spec,offset,type)  (*((type *) &(spec.bytes[offset])))
#define SRC_TYPE(spec)      FIELD_AT(spec,4,char)
#define SRC_HANDLE(spec)    FIELD_AT(spec,5,EMSH)
#define SRC_OFFSET(spec)    FIELD_AT(spec,7,unsigned short)
#define SRC_PAGE(spec)      FIELD_AT(spec,9,unsigned short)
#define SRC_PTR(spec)       FIELD_AT(spec,7,EMSPTR)
#define DST_TYPE(spec)      FIELD_AT(spec,11,char)
#define DST_HANDLE(spec)    FIELD_AT(spec,12,EMSH)
#define DST_OFFSET(spec)    FIELD_AT(spec,14,unsigned short)
#define DST_PAGE(spec)      FIELD_AT(spec,16,unsigned short)
#define DST_PTR(spec)       FIELD_AT(spec,14,EMSPTR)
 
#define EMSPAGESIZE 16384L  /* gospel, see the EMS specs */
 
#define HIBYTE(W)  (((W) >> 8) & 0xFF)
#define LOBYTE(W)  ((W) & 0xFF)
 
 
METHODDEF(void)
read_ems_store (j_common_ptr cinfo, backing_store_ptr info,
        void FAR * buffer_address,
        long file_offset, long byte_count)
{
  EMScontext ctx;
  EMSspec spec;
 
  spec.length = byte_count;
  SRC_TYPE(spec) = 1;
  SRC_HANDLE(spec) = info->handle.ems_handle;
  SRC_PAGE(spec)   = (unsigned short) (file_offset / EMSPAGESIZE);
  SRC_OFFSET(spec) = (unsigned short) (file_offset % EMSPAGESIZE);
  DST_TYPE(spec) = 0;
  DST_HANDLE(spec) = 0;
  DST_PTR(spec)    = buffer_address;
  
  ctx.ds_si = (void far *) & spec;
  ctx.ax = 0x5700;      /* move memory region */
  jems_calldriver((EMScontext far *) & ctx);
  if (HIBYTE(ctx.ax) != 0)
    ERREXIT(cinfo, JERR_EMS_READ);
}
 
 
METHODDEF(void)
write_ems_store (j_common_ptr cinfo, backing_store_ptr info,
         void FAR * buffer_address,
         long file_offset, long byte_count)
{
  EMScontext ctx;
  EMSspec spec;
 
  spec.length = byte_count;
  SRC_TYPE(spec) = 0;
  SRC_HANDLE(spec) = 0;
  SRC_PTR(spec)    = buffer_address;
  DST_TYPE(spec) = 1;
  DST_HANDLE(spec) = info->handle.ems_handle;
  DST_PAGE(spec)   = (unsigned short) (file_offset / EMSPAGESIZE);
  DST_OFFSET(spec) = (unsigned short) (file_offset % EMSPAGESIZE);
  
  ctx.ds_si = (void far *) & spec;
  ctx.ax = 0x5700;      /* move memory region */
  jems_calldriver((EMScontext far *) & ctx);
  if (HIBYTE(ctx.ax) != 0)
    ERREXIT(cinfo, JERR_EMS_WRITE);
}
 
 
METHODDEF(void)
close_ems_store (j_common_ptr cinfo, backing_store_ptr info)
{
  EMScontext ctx;
 
  ctx.ax = 0x4500;
  ctx.dx = info->handle.ems_handle;
  jems_calldriver((EMScontext far *) & ctx);
  TRACEMS1(cinfo, 1, JTRC_EMS_CLOSE, info->handle.ems_handle);
  /* we ignore any error return from the driver */
}
 
 
LOCAL(boolean)
open_ems_store (j_common_ptr cinfo, backing_store_ptr info,
        long total_bytes_needed)
{
  EMScontext ctx;
 
  /* Is EMS driver there? */
  if (! jems_available())
    return FALSE;
 
  /* Get status, make sure EMS is OK */
  ctx.ax = 0x4000;
  jems_calldriver((EMScontext far *) & ctx);
  if (HIBYTE(ctx.ax) != 0)
    return FALSE;
 
  /* Get version, must be >= 4.0 */
  ctx.ax = 0x4600;
  jems_calldriver((EMScontext far *) & ctx);
  if (HIBYTE(ctx.ax) != 0 || LOBYTE(ctx.ax) < 0x40)
    return FALSE;
 
  /* Try to allocate requested space */
  ctx.ax = 0x4300;
  ctx.bx = (unsigned short) ((total_bytes_needed + EMSPAGESIZE-1L) / EMSPAGESIZE);
  jems_calldriver((EMScontext far *) & ctx);
  if (HIBYTE(ctx.ax) != 0)
    return FALSE;
 
  /* Succeeded, save the handle and away we go */
  info->handle.ems_handle = ctx.dx;
  info->read_backing_store = read_ems_store;
  info->write_backing_store = write_ems_store;
  info->close_backing_store = close_ems_store;
  TRACEMS1(cinfo, 1, JTRC_EMS_OPEN, ctx.dx);
  return TRUE;          /* succeeded */
}
 
#endif /* EMS_SUPPORTED */
 
 
/*
 * Initial opening of a backing-store object.
 */
 
GLOBAL(void)
jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
             long total_bytes_needed)
{
  /* Try extended memory, then expanded memory, then regular file. */
#if XMS_SUPPORTED
  if (open_xms_store(cinfo, info, total_bytes_needed))
    return;
#endif
#if EMS_SUPPORTED
  if (open_ems_store(cinfo, info, total_bytes_needed))
    return;
#endif
  if (open_file_store(cinfo, info, total_bytes_needed))
    return;
  ERREXITS(cinfo, JERR_TFILE_CREATE, "");
}
 
 
/*
 * These routines take care of any system-dependent initialization and
 * cleanup required.
 */
 
GLOBAL(long)
jpeg_mem_init (j_common_ptr cinfo)
{
  next_file_num = 0;        /* initialize temp file name generator */
  return DEFAULT_MAX_MEM;   /* default for max_memory_to_use */
}
 
GLOBAL(void)
jpeg_mem_term (j_common_ptr cinfo)
{
  /* Microsoft C, at least in v6.00A, will not successfully reclaim freed
   * blocks of size > 32Kbytes unless we give it a kick in the rear, like so:
   */
#ifdef NEED_FHEAPMIN
  _fheapmin();
#endif
}