libs/jpeg/jmemansi.c

   1 /*
   2  * jmemansi.c
   3  *
   4  * Copyright (C) 1992-1996, 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 a simple generic implementation of the system-
   9  * dependent portion of the JPEG memory manager.  This implementation
  10  * assumes that you have the ANSI-standard library routine tmpfile().
  11  * Also, the problem of determining the amount of memory available
  12  * is shoved onto the user.
  13  */
  14
  15 #define JPEG_INTERNALS
  16 #include "jinclude.h"
  17 #include "jpeglib.h"
  18 #include "jmemsys.h"            /* import the system-dependent declarations */
  19
  20 #ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
  21 extern void * malloc JPP((size_t size));
  22 extern void free JPP((void *ptr));
  23 #endif
  24
  25 #ifndef SEEK_SET                /* pre-ANSI systems may not define this; */
  26 #define SEEK_SET  0             /* if not, assume 0 is correct */
  27 #endif
  28
  29
  30 /*
  31  * Memory allocation and freeing are controlled by the regular library
  32  * routines malloc() and free().
  33  */
  34
  35 GLOBAL(void *)
  36 jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
  37 {
  38   return (void *) malloc(sizeofobject);
  39 }
  40
  41 GLOBAL(void)
  42 jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
  43 {
  44   free(object);
  45 }
  46
  47
  48 /*
  49  * "Large" objects are treated the same as "small" ones.
  50  * NB: although we include FAR keywords in the routine declarations,
  51  * this file won't actually work in 80x86 small/medium model; at least,
  52  * you probably won't be able to process useful-size images in only 64KB.
  53  */
  54
  55 GLOBAL(void FAR *)
  56 jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
  57 {
  58   return (void FAR *) malloc(sizeofobject);
  59 }
  60
  61 GLOBAL(void)
  62 jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
  63 {
  64   free(object);
  65 }
  66
  67
  68 /*
  69  * This routine computes the total memory space available for allocation.
  70  * It's impossible to do this in a portable way; our current solution is
  71  * to make the user tell us (with a default value set at compile time).
  72  * If you can actually get the available space, it's a good idea to subtract
  73  * a slop factor of 5% or so.
  74  */
  75
  76 #ifndef DEFAULT_MAX_MEM         /* so can override from makefile */
  77 #define DEFAULT_MAX_MEM         1000000L /* default: one megabyte */
  78 #endif
  79
  80 GLOBAL(long)
  81 jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
  82                     long max_bytes_needed, long already_allocated)
  83 {
  84   return cinfo->mem->max_memory_to_use - already_allocated;
  85 }
  86
  87
  88 /*
  89  * Backing store (temporary file) management.
  90  * Backing store objects are only used when the value returned by
  91  * jpeg_mem_available is less than the total space needed.  You can dispense
  92  * with these routines if you have plenty of virtual memory; see jmemnobs.c.
  93  */
  94
  95
  96 METHODDEF(void)
  97 read_backing_store (j_common_ptr cinfo, backing_store_ptr info,
  98                     void FAR * buffer_address,
  99                     long file_offset, long byte_count)
 100 {
 101   if (fseek(info->temp_file, file_offset, SEEK_SET))
 102     ERREXIT(cinfo, JERR_TFILE_SEEK);
 103   if (JFREAD(info->temp_file, buffer_address, byte_count)
 104       != (size_t) byte_count)
 105     ERREXIT(cinfo, JERR_TFILE_READ);
 106 }
 107
 108
 109 METHODDEF(void)
 110 write_backing_store (j_common_ptr cinfo, backing_store_ptr info,
 111                      void FAR * buffer_address,
 112                      long file_offset, long byte_count)
 113 {
 114   if (fseek(info->temp_file, file_offset, SEEK_SET))
 115     ERREXIT(cinfo, JERR_TFILE_SEEK);
 116   if (JFWRITE(info->temp_file, buffer_address, byte_count)
 117       != (size_t) byte_count)
 118     ERREXIT(cinfo, JERR_TFILE_WRITE);
 119 }
 120
 121
 122 METHODDEF(void)
 123 close_backing_store (j_common_ptr cinfo, backing_store_ptr info)
 124 {
 125   fclose(info->temp_file);
 126   /* Since this implementation uses tmpfile() to create the file,
 127    * no explicit file deletion is needed.
 128    */
 129 }
 130
 131
 132 /*
 133  * Initial opening of a backing-store object.
 134  *
 135  * This version uses tmpfile(), which constructs a suitable file name
 136  * behind the scenes.  We don't have to use info->temp_name[] at all;
 137  * indeed, we can't even find out the actual name of the temp file.
 138  */
 139
 140 GLOBAL(void)
 141 jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
 142                          long total_bytes_needed)
 143 {
 144   if ((info->temp_file = tmpfile()) == NULL)
 145     ERREXITS(cinfo, JERR_TFILE_CREATE, "");
 146   info->read_backing_store = read_backing_store;
 147   info->write_backing_store = write_backing_store;
 148   info->close_backing_store = close_backing_store;
 149 }
 150
 151
 152 /*
 153  * These routines take care of any system-dependent initialization and
 154  * cleanup required.
 155  */
 156
 157 GLOBAL(long)
 158 jpeg_mem_init (j_common_ptr cinfo)
 159 {
 160   return DEFAULT_MAX_MEM;       /* default for max_memory_to_use */
 161 }
 162
 163 GLOBAL(void)
 164 jpeg_mem_term (j_common_ptr cinfo)
 165 {
 166   /* no work */
 167 }