Line data    Source code

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