LCOV - code coverage report
Current view: directory - media/libjpeg - jmemnobs.c (source / functions) Found Hit Coverage
Test: app.info Lines: 19 14 73.7 %
Date: 2012-06-02 Functions: 8 6 75.0 %

       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              24 : jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
      36                 : {
      37              24 :   return (void *) malloc(sizeofobject);
      38                 : }
      39                 : 
      40                 : GLOBAL(void)
      41              24 : jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
      42                 : {
      43              24 :   free(object);
      44              24 : }
      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              61 : jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
      56                 : {
      57              61 :   return (void FAR *) malloc(sizeofobject);
      58                 : }
      59                 : 
      60                 : GLOBAL(void)
      61              61 : jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
      62                 : {
      63              61 :   free(object);
      64              61 : }
      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               8 : jpeg_mem_init (j_common_ptr cinfo)
     101                 : {
     102               8 :   return 0;                     /* just set max_memory_to_use to 0 */
     103                 : }
     104                 : 
     105                 : GLOBAL(void)
     106               8 : jpeg_mem_term (j_common_ptr cinfo)
     107                 : {
     108                 :   /* no work */
     109               8 : }

Generated by: LCOV version 1.7