www.pudn.com > imgport.rar > jmemdos.c, change:2008-11-05,size:19615b


/* 
 * 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 
}