compiler/libjpeg/main/jmemnobs.c

   1 /*
   2     $Id$
   3
   4     Changes:
   5     1.4.03: Use AllocVec/FreeVec instead of malloc/free because of problems in jpeg.datatype
   6 */
   7
   8 /*
   9  * jmemnobs.c
  10  *
  11  * Copyright (C) 1992-1996, Thomas G. Lane.
  12  * This file is part of the Independent JPEG Group's software.
  13  * For conditions of distribution and use, see the accompanying README file.
  14  *
  15  * This file provides a really simple implementation of the system-
  16  * dependent portion of the JPEG memory manager.  This implementation
  17  * assumes that no backing-store files are needed: all required space
  18  * can be obtained from malloc().
  19  * This is very portable in the sense that it'll compile on almost anything,
  20  * but you'd better have lots of main memory (or virtual memory) if you want
  21  * to process big images.
  22  * Note that the max_memory_to_use option is ignored by this implementation.
  23  */
  24
  25 #include <proto/exec.h>
  26 #include <exec/memory.h>
  27
  28 #define JPEG_INTERNALS
  29 #include "jinclude.h"
  30 #include "jpeglib.h"
  31 #include "jmemsys.h"            /* import the system-dependent declarations */
  32
  33 #include "debug.h"
  34
  35 #define malloc(size) AllocVec((size), MEMF_ANY)
  36 #define free(mem) FreeVec(mem)
  37
  38 #ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
  39 extern void * malloc JPP((size_t size));
  40 extern void free JPP((void *ptr));
  41 #endif
  42
  43
  44 /*
  45  * Memory allocation and freeing are controlled by the regular library
  46  * routines malloc() and free().
  47  */
  48
  49 JGLOBAL(void *)
  50 jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
  51 {
  52   D(bug("libjpeg: alloc small %ld\n", (long)sizeofobject));
  53   return (void *) malloc(sizeofobject);
  54 }
  55
  56 JGLOBAL(void)
  57 jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
  58 {
  59   free(object);
  60 }
  61
  62
  63 /*
  64  * "Large" objects are treated the same as "small" ones.
  65  * NB: although we include FAR keywords in the routine declarations,
  66  * this file won't actually work in 80x86 small/medium model; at least,
  67  * you probably won't be able to process useful-size images in only 64KB.
  68  */
  69
  70 JGLOBAL(void FAR *)
  71 jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
  72 {
  73   D(bug("libjpeg: alloc large %ld\n", (long)sizeofobject));
  74   return (void FAR *) malloc(sizeofobject);
  75 }
  76
  77 JGLOBAL(void)
  78 jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
  79 {
  80   free(object);
  81 }
  82
  83
  84 /*
  85  * This routine computes the total memory space available for allocation.
  86  * Here we always say, "we got all you want bud!"
  87  */
  88
  89 JGLOBAL(long)
  90 jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
  91                     long max_bytes_needed, long already_allocated)
  92 {
  93   return max_bytes_needed;
  94 }
  95
  96
  97 /*
  98  * Backing store (temporary file) management.
  99  * Since jpeg_mem_available always promised the moon,
 100  * this should never be called and we can just error out.
 101  */
 102
 103 JGLOBAL(void)
 104 jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
 105                          long total_bytes_needed)
 106 {
 107   ERREXIT(cinfo, JERR_NO_BACKING_STORE);
 108 }
 109
 110
 111 /*
 112  * These routines take care of any system-dependent initialization and
 113  * cleanup required.  Here, there isn't any.
 114  */
 115
 116 JGLOBAL(long)
 117 jpeg_mem_init (j_common_ptr cinfo)
 118 {
 119   return 0;                     /* just set max_memory_to_use to 0 */
 120 }
 121
 122 JGLOBAL(void)
 123 jpeg_mem_term (j_common_ptr cinfo)
 124 {
 125   /* no work */
 126 }