home *** CD-ROM | disk | FTP | other *** search
/ PC World Plus! (NZ) 2001 June / HDC50.iso / Info / Extras / Jpeg / SRC / JMEMANSI.C < prev    next >
C/C++ Source or Header  |  1999-08-11  |  5KB  |  168 lines
  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. }
  168.