jmemnobs.c - vx32 - Local 9vx git repository for patches.
 (HTM) git clone git://r-36.net/vx32
 (DIR) Log
 (DIR) Files
 (DIR) Refs
       ---
       jmemnobs.c (2772B)
       ---
            1 /*
            2  * jmemnobs.c
            3  *
            4  * Copyright (C) 1992-1996, 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 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 #ifndef HAVE_STDLIB_H                /* <stdlib.h> should declare malloc(),free() */
           24 extern void * malloc JPP((size_t size));
           25 extern void free JPP((void *ptr));
           26 #endif
           27 
           28 
           29 /*
           30  * Memory allocation and freeing are controlled by the regular library
           31  * routines malloc() and free().
           32  */
           33 
           34 GLOBAL(void *)
           35 jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
           36 {
           37   return (void *) malloc(sizeofobject);
           38 }
           39 
           40 GLOBAL(void)
           41 jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
           42 {
           43   free(object);
           44 }
           45 
           46 
           47 /*
           48  * "Large" objects are treated the same as "small" ones.
           49  * NB: although we include FAR keywords in the routine declarations,
           50  * this file won't actually work in 80x86 small/medium model; at least,
           51  * you probably won't be able to process useful-size images in only 64KB.
           52  */
           53 
           54 GLOBAL(void FAR *)
           55 jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
           56 {
           57   return (void FAR *) malloc(sizeofobject);
           58 }
           59 
           60 GLOBAL(void)
           61 jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
           62 {
           63   free(object);
           64 }
           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(long)
           73 jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
           74                     long max_bytes_needed, long already_allocated)
           75 {
           76   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 jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
           88                          long total_bytes_needed)
           89 {
           90   ERREXIT(cinfo, JERR_NO_BACKING_STORE);
           91 }
           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 jpeg_mem_init (j_common_ptr cinfo)
          101 {
          102   return 0;                        /* just set max_memory_to_use to 0 */
          103 }
          104 
          105 GLOBAL(void)
          106 jpeg_mem_term (j_common_ptr cinfo)
          107 {
          108   /* no work */
          109 }