libs/jpeg6/jmemnobs.cpp

   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 "radiant_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 }