home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 58 / pcpp58a.iso / extras / quake 3 source / Q3A_ToolSource.exe / Main / jmemnobs.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-02  |  2.7 KB  |  104 lines
  1. /*
  2.  * jmemnobs.c
  3.  *
  4.  * Copyright (C) 1992-1994, 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 really simple implementation of the system-
  9.  * dependent portion of the JPEG memory manager.  This implementation
  10.  * assumes that no backing-store files are needed: all required space
  11.  * can be obtained from ri.Malloc().
  12.  * This is very portable in the sense that it'll compile on almost anything,
  13.  * but you'd better have lots of main memory (or virtual memory) if you want
  14.  * to process big images.
  15.  * Note that the max_memory_to_use option is ignored by this implementation.
  16.  */
  17.  
  18. #define JPEG_INTERNALS
  19. #include "jinclude.h"
  20. #include "jpeglib.h"
  21. #include "jmemsys.h"        /* import the system-dependent declarations */
  22.  
  23. /*
  24.  * Memory allocation and ri.Freeing are controlled by the regular library
  25.  * routines ri.Malloc() and ri.Free().
  26.  */
  27.  
  28. GLOBAL void *
  29. jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
  30. {
  31.   return (void *) malloc(sizeofobject);
  32. }
  33.  
  34. GLOBAL void
  35. jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
  36. {
  37.   free(object);
  38. }
  39.  
  40.  
  41. /*
  42.  * "Large" objects are treated the same as "small" ones.
  43.  * NB: although we include FAR keywords in the routine declarations,
  44.  * this file won't actually work in 80x86 small/medium model; at least,
  45.  * you probably won't be able to process useful-size images in only 64KB.
  46.  */
  47.  
  48. GLOBAL void FAR *
  49. jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
  50. {
  51.   return (void FAR *) malloc(sizeofobject);
  52. }
  53.  
  54. GLOBAL void
  55. jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
  56. {
  57.   free(object);
  58. }
  59.  
  60.  
  61. /*
  62.  * This routine computes the total memory space available for allocation.
  63.  * Here we always say, "we got all you want bud!"
  64.  */
  65.  
  66. GLOBAL long
  67. jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
  68.             long max_bytes_needed, long already_allocated)
  69. {
  70.   return max_bytes_needed;
  71. }
  72.  
  73.  
  74. /*
  75.  * Backing store (temporary file) management.
  76.  * Since jpeg_mem_available always promised the moon,
  77.  * this should never be called and we can just error out.
  78.  */
  79.  
  80. GLOBAL void
  81. jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
  82.              long total_bytes_needed)
  83. {
  84.   ERREXIT(cinfo, JERR_NO_BACKING_STORE);
  85. }
  86.  
  87.  
  88. /*
  89.  * These routines take care of any system-dependent initialization and
  90.  * cleanup required.  Here, there isn't any.
  91.  */
  92.  
  93. GLOBAL long
  94. jpeg_mem_init (j_common_ptr cinfo)
  95. {
  96.   return 0;            /* just set max_memory_to_use to 0 */
  97. }
  98.  
  99. GLOBAL void
  100. jpeg_mem_term (j_common_ptr cinfo)
  101. {
  102.   /* no work */
  103. }
  104.