id/doom3-bfg
0
0
Fork 0
mirror of https://github.com/id-Software/DOOM-3-BFG.git synced 2024-11-27 06:13:27 +00:00
Code Issues Projects Releases Packages Wiki Activity
doom3-bfg/neo/renderer/jpeg-6/jmemdos.cpp
Brian Harris 5016f605b8 Initial commit
2012-11-26 12:58:24 -06:00

639 lines
20 KiB
C++
Raw Permalink Blame History

/*
* jmemdos.c
*
* Copyright (C) 1992-1994, 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
#if MAX_ALLOC_CHUNK >= 65535L /* make sure jconfig.h got this right */
MAX_ALLOC_CHUNK should be less than 64 K. /* deliberate syntax error */
#endif
/*
* Declarations for assembly-language support routines (see jmemdosa.asm).
*
* The functions are declared "far" as are all 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
}
Reference in a new issue View git blame Copy permalink