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