1793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 2793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * jmemmgr.c 3793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 4793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Copyright (C) 1991-1997, Thomas G. Lane. 5793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Modified 2011-2012 by Guido Vollbeding. 6793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * This file is part of the Independent JPEG Group's software. 7793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * For conditions of distribution and use, see the accompanying README file. 8793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 9793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * This file contains the JPEG system-independent memory management 10793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * routines. This code is usable across a wide variety of machines; most 11793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * of the system dependencies have been isolated in a separate file. 12793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The major functions provided here are: 13793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * * pool-based allocation and freeing of memory; 14793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * * policy decisions about how to divide available memory among the 15793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * virtual arrays; 16793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * * control logic for swapping virtual arrays between main memory and 17793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * backing storage. 18793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The separate system-dependent file provides the actual backing-storage 19793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * access code, and it contains the policy decision about how much total 20793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * main memory to use. 21793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * This file is system-dependent in the sense that some of its functions 22793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * are unnecessary in some systems. For example, if there is enough virtual 23793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * memory so that backing storage will never be used, much of the virtual 24793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * array control logic could be removed. (Of course, if you have that much 25793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * memory then you shouldn't care about a little bit of unused code...) 26793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 27793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 28793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#define JPEG_INTERNALS 29793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#define AM_MEMORY_MANAGER /* we define jvirt_Xarray_control structs */ 30793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#include "jinclude.h" 31793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#include "jpeglib.h" 32793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#include "jmemsys.h" /* import the system-dependent declarations */ 33793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 34793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#ifndef NO_GETENV 35793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare getenv() */ 36793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerextern char * getenv JPP((const char * name)); 37793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#endif 38793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#endif 39793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 40793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 41793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 42793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Some important notes: 43793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The allocation routines provided here must never return NULL. 44793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * They should exit to error_exit if unsuccessful. 45793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 46793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * It's not a good idea to try to merge the sarray and barray routines, 47793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * even though they are textually almost the same, because samples are 48793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * usually stored as bytes while coefficients are shorts or ints. Thus, 49793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * in machines where byte pointers have a different representation from 50793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * word pointers, the resulting machine code could not be the same. 51793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 52793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 53793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 54793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 55793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Many machines require storage alignment: longs must start on 4-byte 56793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * boundaries, doubles on 8-byte boundaries, etc. On such machines, malloc() 57793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * always returns pointers that are multiples of the worst-case alignment 58793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * requirement, and we had better do so too. 59793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * There isn't any really portable way to determine the worst-case alignment 60793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * requirement. This module assumes that the alignment requirement is 61793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * multiples of sizeof(ALIGN_TYPE). 62793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * By default, we define ALIGN_TYPE as double. This is necessary on some 63793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * workstations (where doubles really do need 8-byte alignment) and will work 64793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * fine on nearly everything. If your machine has lesser alignment needs, 65793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * you can save a few bytes by making ALIGN_TYPE smaller. 66793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The only place I know of where this will NOT work is certain Macintosh 67793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 680x0 compilers that define double as a 10-byte IEEE extended float. 68793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Doing 10-byte alignment is counterproductive because longwords won't be 69793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * aligned well. Put "#define ALIGN_TYPE long" in jconfig.h if you have 70793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * such a compiler. 71793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 72793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 73793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#ifndef ALIGN_TYPE /* so can override from jconfig.h */ 74793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#define ALIGN_TYPE double 75793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#endif 76793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 77793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 78793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 79793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * We allocate objects from "pools", where each pool is gotten with a single 80793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * request to jpeg_get_small() or jpeg_get_large(). There is no per-object 81793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * overhead within a pool, except for alignment padding. Each pool has a 82793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * header with a link to the next pool of the same class. 83793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Small and large pool headers are identical except that the latter's 84793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * link pointer must be FAR on 80x86 machines. 85793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE 86793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * field. This forces the compiler to make SIZEOF(small_pool_hdr) a multiple 87793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * of the alignment requirement of ALIGN_TYPE. 88793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 89793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 90793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslertypedef union small_pool_struct * small_pool_ptr; 91793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 92793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslertypedef union small_pool_struct { 93793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler struct { 94793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler small_pool_ptr next; /* next in list of pools */ 95793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t bytes_used; /* how many bytes already used within pool */ 96793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t bytes_left; /* bytes still available in this pool */ 97793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } hdr; 98793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ALIGN_TYPE dummy; /* included in union to ensure alignment */ 99793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} small_pool_hdr; 100793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 101793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslertypedef union large_pool_struct FAR * large_pool_ptr; 102793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 103793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslertypedef union large_pool_struct { 104793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler struct { 105793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler large_pool_ptr next; /* next in list of pools */ 106793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t bytes_used; /* how many bytes already used within pool */ 107793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t bytes_left; /* bytes still available in this pool */ 108793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } hdr; 109793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ALIGN_TYPE dummy; /* included in union to ensure alignment */ 110793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} large_pool_hdr; 111793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 112793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 113793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 114793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Here is the full definition of a memory manager object. 115793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 116793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 117793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslertypedef struct { 118793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler struct jpeg_memory_mgr pub; /* public fields */ 119793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 120793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Each pool identifier (lifetime class) names a linked list of pools. */ 121793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler small_pool_ptr small_list[JPOOL_NUMPOOLS]; 122793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler large_pool_ptr large_list[JPOOL_NUMPOOLS]; 123793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 124793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Since we only have one lifetime class of virtual arrays, only one 125793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * linked list is necessary (for each datatype). Note that the virtual 126793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * array control blocks being linked together are actually stored somewhere 127793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * in the small-pool list. 128793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 129793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_sarray_ptr virt_sarray_list; 130793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_barray_ptr virt_barray_list; 131793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 132793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* This counts total space obtained from jpeg_get_small/large */ 133793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long total_space_allocated; 134793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 135793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* alloc_sarray and alloc_barray set this value for use by virtual 136793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * array routines. 137793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 138793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION last_rowsperchunk; /* from most recent alloc_sarray/barray */ 139793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} my_memory_mgr; 140793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 141793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslertypedef my_memory_mgr * my_mem_ptr; 142793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 143793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 144793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 145793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The control blocks for virtual arrays. 146793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Note that these blocks are allocated in the "small" pool area. 147793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * System-dependent info for the associated backing store (if any) is hidden 148793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * inside the backing_store_info struct. 149793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 150793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 151793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerstruct jvirt_sarray_control { 152793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JSAMPARRAY mem_buffer; /* => the in-memory buffer */ 153793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION rows_in_array; /* total virtual array height */ 154793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION samplesperrow; /* width of array (and of memory buffer) */ 155793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION maxaccess; /* max rows accessed by access_virt_sarray */ 156793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION rows_in_mem; /* height of memory buffer */ 157793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ 158793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION cur_start_row; /* first logical row # in the buffer */ 159793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION first_undef_row; /* row # of first uninitialized row */ 160793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler boolean pre_zero; /* pre-zero mode requested? */ 161793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler boolean dirty; /* do current buffer contents need written? */ 162793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler boolean b_s_open; /* is backing-store data valid? */ 163793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_sarray_ptr next; /* link to next virtual sarray control block */ 164793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler backing_store_info b_s_info; /* System-dependent control info */ 165793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler}; 166793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 167793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerstruct jvirt_barray_control { 168793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JBLOCKARRAY mem_buffer; /* => the in-memory buffer */ 169793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION rows_in_array; /* total virtual array height */ 170793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION blocksperrow; /* width of array (and of memory buffer) */ 171793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION maxaccess; /* max rows accessed by access_virt_barray */ 172793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION rows_in_mem; /* height of memory buffer */ 173793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ 174793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION cur_start_row; /* first logical row # in the buffer */ 175793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION first_undef_row; /* row # of first uninitialized row */ 176793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler boolean pre_zero; /* pre-zero mode requested? */ 177793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler boolean dirty; /* do current buffer contents need written? */ 178793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler boolean b_s_open; /* is backing-store data valid? */ 179793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_barray_ptr next; /* link to next virtual barray control block */ 180793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler backing_store_info b_s_info; /* System-dependent control info */ 181793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler}; 182793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 183793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 184793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#ifdef MEM_STATS /* optional extra stuff for statistics */ 185793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 186793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerLOCAL(void) 187793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerprint_mem_stats (j_common_ptr cinfo, int pool_id) 188793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 189793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem = (my_mem_ptr) cinfo->mem; 190793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler small_pool_ptr shdr_ptr; 191793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler large_pool_ptr lhdr_ptr; 192793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 193793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Since this is only a debugging stub, we can cheat a little by using 194793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * fprintf directly rather than going through the trace message code. 195793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * This is helpful because message parm array can't handle longs. 196793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 197793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler fprintf(stderr, "Freeing pool %d, total space = %ld\n", 198793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler pool_id, mem->total_space_allocated); 199793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 200793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL; 201793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler lhdr_ptr = lhdr_ptr->hdr.next) { 202793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler fprintf(stderr, " Large chunk used %ld\n", 203793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) lhdr_ptr->hdr.bytes_used); 204793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 205793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 206793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL; 207793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler shdr_ptr = shdr_ptr->hdr.next) { 208793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler fprintf(stderr, " Small chunk used %ld free %ld\n", 209793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) shdr_ptr->hdr.bytes_used, 210793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) shdr_ptr->hdr.bytes_left); 211793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 212793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 213793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 214793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#endif /* MEM_STATS */ 215793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 216793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 217793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerLOCAL(noreturn_t) 218793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerout_of_memory (j_common_ptr cinfo, int which) 219793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Report an out-of-memory error and stop execution */ 220793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* If we compiled MEM_STATS support, report alloc requests before dying */ 221793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 222793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#ifdef MEM_STATS 223793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler cinfo->err->trace_level = 2; /* force self_destruct to report stats */ 224793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#endif 225793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which); 226793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 227793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 228793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 229793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 230793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Allocation of "small" objects. 231793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 232793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * For these, we use pooled storage. When a new pool must be created, 233793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * we try to get enough space for the current request plus a "slop" factor, 234793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * where the slop will be the amount of leftover space in the new pool. 235793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The speed vs. space tradeoff is largely determined by the slop values. 236793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * A different slop value is provided for each pool class (lifetime), 237793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * and we also distinguish the first pool of a class from later ones. 238793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * NOTE: the values given work fairly well on both 16- and 32-bit-int 239793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * machines, but may be too small if longs are 64 bits or more. 240793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 241793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 242793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerstatic const size_t first_pool_slop[JPOOL_NUMPOOLS] = 243793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 244793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1600, /* first PERMANENT pool */ 245793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 16000 /* first IMAGE pool */ 246793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler}; 247793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 248793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerstatic const size_t extra_pool_slop[JPOOL_NUMPOOLS] = 249793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 250793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 0, /* additional PERMANENT pools */ 251793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 5000 /* additional IMAGE pools */ 252793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler}; 253793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 254793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#define MIN_SLOP 50 /* greater than 0 to avoid futile looping */ 255793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 256793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 257793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(void *) 258793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presleralloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject) 259793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Allocate a "small" object */ 260793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 261793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem = (my_mem_ptr) cinfo->mem; 262793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler small_pool_ptr hdr_ptr, prev_hdr_ptr; 263793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler char * data_ptr; 264793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t odd_bytes, min_request, slop; 265793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 266793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Check for unsatisfiable request (do now to ensure no overflow below) */ 267793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr))) 268793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler out_of_memory(cinfo, 1); /* request exceeds malloc's ability */ 269793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 270793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ 271793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); 272793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (odd_bytes > 0) 273793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; 274793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 275793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* See if space is available in any existing pool */ 276793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) 277793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ 278793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler prev_hdr_ptr = NULL; 279793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr = mem->small_list[pool_id]; 280793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler while (hdr_ptr != NULL) { 281793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (hdr_ptr->hdr.bytes_left >= sizeofobject) 282793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler break; /* found pool with enough space */ 283793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler prev_hdr_ptr = hdr_ptr; 284793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr = hdr_ptr->hdr.next; 285793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 286793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 287793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Time to make a new pool? */ 288793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (hdr_ptr == NULL) { 289793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* min_request is what we need now, slop is what will be leftover */ 290793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler min_request = sizeofobject + SIZEOF(small_pool_hdr); 291793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (prev_hdr_ptr == NULL) /* first pool in class? */ 292793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler slop = first_pool_slop[pool_id]; 293793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler else 294793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler slop = extra_pool_slop[pool_id]; 295793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Don't ask for more than MAX_ALLOC_CHUNK */ 296793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request)) 297793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler slop = (size_t) (MAX_ALLOC_CHUNK-min_request); 298793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Try to get space, if fail reduce slop and try again */ 299793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (;;) { 300793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop); 301793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (hdr_ptr != NULL) 302793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler break; 303793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler slop /= 2; 304793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (slop < MIN_SLOP) /* give up when it gets real small */ 305793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler out_of_memory(cinfo, 2); /* jpeg_get_small failed */ 306793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 307793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->total_space_allocated += min_request + slop; 308793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Success, initialize the new pool header and add to end of list */ 309793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr->hdr.next = NULL; 310793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr->hdr.bytes_used = 0; 311793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr->hdr.bytes_left = sizeofobject + slop; 312793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (prev_hdr_ptr == NULL) /* first pool in class? */ 313793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->small_list[pool_id] = hdr_ptr; 314793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler else 315793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler prev_hdr_ptr->hdr.next = hdr_ptr; 316793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 317793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 318793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* OK, allocate the object from the current pool */ 319793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */ 320793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */ 321793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr->hdr.bytes_used += sizeofobject; 322793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr->hdr.bytes_left -= sizeofobject; 323793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 324793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler return (void *) data_ptr; 325793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 326793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 327793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 328793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 329793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Allocation of "large" objects. 330793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 331793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The external semantics of these are the same as "small" objects, 332793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * except that FAR pointers are used on 80x86. However the pool 333793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * management heuristics are quite different. We assume that each 334793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * request is large enough that it may as well be passed directly to 335793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * jpeg_get_large; the pool management just links everything together 336793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * so that we can free it all on demand. 337793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY 338793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * structures. The routines that create these structures (see below) 339793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * deliberately bunch rows together to ensure a large request size. 340793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 341793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 342793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(void FAR *) 343793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presleralloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject) 344793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Allocate a "large" object */ 345793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 346793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem = (my_mem_ptr) cinfo->mem; 347793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler large_pool_ptr hdr_ptr; 348793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t odd_bytes; 349793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 350793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Check for unsatisfiable request (do now to ensure no overflow below) */ 351793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr))) 352793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler out_of_memory(cinfo, 3); /* request exceeds malloc's ability */ 353793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 354793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ 355793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); 356793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (odd_bytes > 0) 357793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; 358793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 359793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Always make a new pool */ 360793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) 361793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ 362793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 363793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject + 364793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler SIZEOF(large_pool_hdr)); 365793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (hdr_ptr == NULL) 366793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler out_of_memory(cinfo, 4); /* jpeg_get_large failed */ 367793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr); 368793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 369793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Success, initialize the new pool header and add to list */ 370793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr->hdr.next = mem->large_list[pool_id]; 371793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* We maintain space counts in each pool header for statistical purposes, 372793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * even though they are not needed for allocation. 373793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 374793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr->hdr.bytes_used = sizeofobject; 375793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler hdr_ptr->hdr.bytes_left = 0; 376793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->large_list[pool_id] = hdr_ptr; 377793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 378793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */ 379793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 380793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 381793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 382793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 383793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Creation of 2-D sample arrays. 384793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The pointers are in near heap, the samples themselves in FAR heap. 385793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 386793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * To minimize allocation overhead and to allow I/O of large contiguous 387793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * blocks, we allocate the sample rows in groups of as many rows as possible 388793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request. 389793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * NB: the virtual array control routines, later in this file, know about 390793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * this chunking of rows. The rowsperchunk value is left in the mem manager 391793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * object so that it can be saved away if this sarray is the workspace for 392793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * a virtual array. 393793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 394793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 395793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(JSAMPARRAY) 396793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presleralloc_sarray (j_common_ptr cinfo, int pool_id, 397793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION samplesperrow, JDIMENSION numrows) 398793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Allocate a 2-D sample array */ 399793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 400793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem = (my_mem_ptr) cinfo->mem; 401793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JSAMPARRAY result; 402793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JSAMPROW workspace; 403793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION rowsperchunk, currow, i; 404793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long ltemp; 405793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 406793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Calculate max # of rows allowed in one allocation chunk */ 407793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / 408793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ((long) samplesperrow * SIZEOF(JSAMPLE)); 409793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ltemp <= 0) 410793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); 411793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ltemp < (long) numrows) 412793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rowsperchunk = (JDIMENSION) ltemp; 413793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler else 414793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rowsperchunk = numrows; 415793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->last_rowsperchunk = rowsperchunk; 416793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 417793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Get space for row pointers (small object) */ 418793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result = (JSAMPARRAY) alloc_small(cinfo, pool_id, 419793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (size_t) (numrows * SIZEOF(JSAMPROW))); 420793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 421793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Get the rows themselves (large objects) */ 422793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler currow = 0; 423793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler while (currow < numrows) { 424793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rowsperchunk = MIN(rowsperchunk, numrows - currow); 425793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler workspace = (JSAMPROW) alloc_large(cinfo, pool_id, 426793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (size_t) ((size_t) rowsperchunk * (size_t) samplesperrow 427793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * SIZEOF(JSAMPLE))); 428793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (i = rowsperchunk; i > 0; i--) { 429793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result[currow++] = workspace; 430793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler workspace += samplesperrow; 431793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 432793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 433793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 434793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler return result; 435793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 436793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 437793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 438793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 439793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Creation of 2-D coefficient-block arrays. 440793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * This is essentially the same as the code for sample arrays, above. 441793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 442793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 443793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(JBLOCKARRAY) 444793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presleralloc_barray (j_common_ptr cinfo, int pool_id, 445793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION blocksperrow, JDIMENSION numrows) 446793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Allocate a 2-D coefficient-block array */ 447793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 448793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem = (my_mem_ptr) cinfo->mem; 449793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JBLOCKARRAY result; 450793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JBLOCKROW workspace; 451793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION rowsperchunk, currow, i; 452793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long ltemp; 453793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 454793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Calculate max # of rows allowed in one allocation chunk */ 455793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / 456793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ((long) blocksperrow * SIZEOF(JBLOCK)); 457793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ltemp <= 0) 458793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); 459793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ltemp < (long) numrows) 460793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rowsperchunk = (JDIMENSION) ltemp; 461793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler else 462793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rowsperchunk = numrows; 463793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->last_rowsperchunk = rowsperchunk; 464793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 465793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Get space for row pointers (small object) */ 466793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result = (JBLOCKARRAY) alloc_small(cinfo, pool_id, 467793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (size_t) (numrows * SIZEOF(JBLOCKROW))); 468793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 469793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Get the rows themselves (large objects) */ 470793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler currow = 0; 471793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler while (currow < numrows) { 472793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rowsperchunk = MIN(rowsperchunk, numrows - currow); 473793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler workspace = (JBLOCKROW) alloc_large(cinfo, pool_id, 474793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (size_t) ((size_t) rowsperchunk * (size_t) blocksperrow 475793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * SIZEOF(JBLOCK))); 476793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (i = rowsperchunk; i > 0; i--) { 477793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result[currow++] = workspace; 478793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler workspace += blocksperrow; 479793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 480793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 481793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 482793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler return result; 483793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 484793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 485793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 486793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 487793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * About virtual array management: 488793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 489793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The above "normal" array routines are only used to allocate strip buffers 490793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * (as wide as the image, but just a few rows high). Full-image-sized buffers 491793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * are handled as "virtual" arrays. The array is still accessed a strip at a 492793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * time, but the memory manager must save the whole array for repeated 493793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * accesses. The intended implementation is that there is a strip buffer in 494793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * memory (as high as is possible given the desired memory limit), plus a 495793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * backing file that holds the rest of the array. 496793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 497793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The request_virt_array routines are told the total size of the image and 498793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * the maximum number of rows that will be accessed at once. The in-memory 499793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * buffer must be at least as large as the maxaccess value. 500793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 501793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The request routines create control blocks but not the in-memory buffers. 502793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * That is postponed until realize_virt_arrays is called. At that time the 503793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * total amount of space needed is known (approximately, anyway), so free 504793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * memory can be divided up fairly. 505793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 506793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The access_virt_array routines are responsible for making a specific strip 507793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * area accessible (after reading or writing the backing file, if necessary). 508793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Note that the access routines are told whether the caller intends to modify 509793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * the accessed strip; during a read-only pass this saves having to rewrite 510793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * data to disk. The access routines are also responsible for pre-zeroing 511793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * any newly accessed rows, if pre-zeroing was requested. 512793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * 513793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * In current usage, the access requests are usually for nonoverlapping 514793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * strips; that is, successive access start_row numbers differ by exactly 515793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * num_rows = maxaccess. This means we can get good performance with simple 516793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * buffer dump/reload logic, by making the in-memory buffer be a multiple 517793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * of the access height; then there will never be accesses across bufferload 518793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * boundaries. The code will still work with overlapping access requests, 519793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * but it doesn't handle bufferload overlaps very efficiently. 520793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 521793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 522793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 523793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(jvirt_sarray_ptr) 524793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerrequest_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero, 525793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION samplesperrow, JDIMENSION numrows, 526793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION maxaccess) 527793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Request a virtual 2-D sample array */ 528793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 529793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem = (my_mem_ptr) cinfo->mem; 530793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_sarray_ptr result; 531793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 532793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Only IMAGE-lifetime virtual arrays are currently supported */ 533793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (pool_id != JPOOL_IMAGE) 534793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ 535793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 536793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* get control block */ 537793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id, 538793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler SIZEOF(struct jvirt_sarray_control)); 539793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 540793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->mem_buffer = NULL; /* marks array not yet realized */ 541793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->rows_in_array = numrows; 542793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->samplesperrow = samplesperrow; 543793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->maxaccess = maxaccess; 544793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->pre_zero = pre_zero; 545793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->b_s_open = FALSE; /* no associated backing-store object */ 546793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->next = mem->virt_sarray_list; /* add to list of virtual arrays */ 547793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->virt_sarray_list = result; 548793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 549793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler return result; 550793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 551793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 552793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 553793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(jvirt_barray_ptr) 554793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerrequest_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero, 555793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION blocksperrow, JDIMENSION numrows, 556793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION maxaccess) 557793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Request a virtual 2-D coefficient-block array */ 558793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 559793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem = (my_mem_ptr) cinfo->mem; 560793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_barray_ptr result; 561793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 562793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Only IMAGE-lifetime virtual arrays are currently supported */ 563793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (pool_id != JPOOL_IMAGE) 564793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ 565793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 566793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* get control block */ 567793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id, 568793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler SIZEOF(struct jvirt_barray_control)); 569793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 570793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->mem_buffer = NULL; /* marks array not yet realized */ 571793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->rows_in_array = numrows; 572793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->blocksperrow = blocksperrow; 573793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->maxaccess = maxaccess; 574793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->pre_zero = pre_zero; 575793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->b_s_open = FALSE; /* no associated backing-store object */ 576793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler result->next = mem->virt_barray_list; /* add to list of virtual arrays */ 577793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->virt_barray_list = result; 578793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 579793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler return result; 580793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 581793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 582793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 583793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(void) 584793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerrealize_virt_arrays (j_common_ptr cinfo) 585793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Allocate the in-memory buffers for any unrealized virtual arrays */ 586793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 587793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem = (my_mem_ptr) cinfo->mem; 588793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long space_per_minheight, maximum_space, avail_mem; 589793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long minheights, max_minheights; 590793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_sarray_ptr sptr; 591793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_barray_ptr bptr; 592793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 593793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Compute the minimum space needed (maxaccess rows in each buffer) 594793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * and the maximum space needed (full image height in each buffer). 595793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * These may be of use to the system-dependent jpeg_mem_available routine. 596793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 597793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler space_per_minheight = 0; 598793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler maximum_space = 0; 599793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { 600793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (sptr->mem_buffer == NULL) { /* if not realized yet */ 601793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler space_per_minheight += (long) sptr->maxaccess * 602793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) sptr->samplesperrow * SIZEOF(JSAMPLE); 603793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler maximum_space += (long) sptr->rows_in_array * 604793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) sptr->samplesperrow * SIZEOF(JSAMPLE); 605793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 606793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 607793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { 608793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (bptr->mem_buffer == NULL) { /* if not realized yet */ 609793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler space_per_minheight += (long) bptr->maxaccess * 610793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) bptr->blocksperrow * SIZEOF(JBLOCK); 611793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler maximum_space += (long) bptr->rows_in_array * 612793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) bptr->blocksperrow * SIZEOF(JBLOCK); 613793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 614793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 615793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 616793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (space_per_minheight <= 0) 617793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler return; /* no unrealized arrays, no work */ 618793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 619793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Determine amount of memory to actually use; this is system-dependent. */ 620793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space, 621793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->total_space_allocated); 622793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 623793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* If the maximum space needed is available, make all the buffers full 624793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * height; otherwise parcel it out with the same number of minheights 625793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * in each buffer. 626793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 627793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (avail_mem >= maximum_space) 628793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler max_minheights = 1000000000L; 629793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler else { 630793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler max_minheights = avail_mem / space_per_minheight; 631793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* If there doesn't seem to be enough space, try to get the minimum 632793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * anyway. This allows a "stub" implementation of jpeg_mem_available(). 633793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 634793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (max_minheights <= 0) 635793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler max_minheights = 1; 636793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 637793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 638793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Allocate the in-memory buffers and initialize backing store as needed. */ 639793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 640793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { 641793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (sptr->mem_buffer == NULL) { /* if not realized yet */ 642793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L; 643793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (minheights <= max_minheights) { 644793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* This buffer fits in memory */ 645793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->rows_in_mem = sptr->rows_in_array; 646793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } else { 647793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* It doesn't fit in memory, create backing store. */ 648793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess); 649793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jpeg_open_backing_store(cinfo, & sptr->b_s_info, 650793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) sptr->rows_in_array * 651793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) sptr->samplesperrow * 652793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) SIZEOF(JSAMPLE)); 653793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->b_s_open = TRUE; 654793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 655793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE, 656793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->samplesperrow, sptr->rows_in_mem); 657793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->rowsperchunk = mem->last_rowsperchunk; 658793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->cur_start_row = 0; 659793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->first_undef_row = 0; 660793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->dirty = FALSE; 661793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 662793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 663793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 664793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { 665793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (bptr->mem_buffer == NULL) { /* if not realized yet */ 666793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L; 667793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (minheights <= max_minheights) { 668793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* This buffer fits in memory */ 669793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->rows_in_mem = bptr->rows_in_array; 670793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } else { 671793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* It doesn't fit in memory, create backing store. */ 672793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess); 673793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jpeg_open_backing_store(cinfo, & bptr->b_s_info, 674793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) bptr->rows_in_array * 675793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) bptr->blocksperrow * 676793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (long) SIZEOF(JBLOCK)); 677793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->b_s_open = TRUE; 678793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 679793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE, 680793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->blocksperrow, bptr->rows_in_mem); 681793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->rowsperchunk = mem->last_rowsperchunk; 682793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->cur_start_row = 0; 683793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->first_undef_row = 0; 684793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->dirty = FALSE; 685793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 686793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 687793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 688793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 689793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 690793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerLOCAL(void) 691793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerdo_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing) 692793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Do backing store read or write of a virtual sample array */ 693793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 694793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long bytesperrow, file_offset, byte_count, rows, thisrow, i; 695793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 696793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE); 697793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler file_offset = ptr->cur_start_row * bytesperrow; 698793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Loop to read or write each allocation chunk in mem_buffer */ 699793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { 700793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* One chunk, but check for short chunk at end of buffer */ 701793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); 702793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Transfer no more than is currently defined */ 703793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler thisrow = (long) ptr->cur_start_row + i; 704793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rows = MIN(rows, (long) ptr->first_undef_row - thisrow); 705793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Transfer no more than fits in file */ 706793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rows = MIN(rows, (long) ptr->rows_in_array - thisrow); 707793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (rows <= 0) /* this chunk might be past end of file! */ 708793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler break; 709793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler byte_count = rows * bytesperrow; 710793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (writing) 711793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, 712793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (void FAR *) ptr->mem_buffer[i], 713793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler file_offset, byte_count); 714793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler else 715793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, 716793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (void FAR *) ptr->mem_buffer[i], 717793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler file_offset, byte_count); 718793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler file_offset += byte_count; 719793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 720793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 721793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 722793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 723793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerLOCAL(void) 724793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerdo_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing) 725793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Do backing store read or write of a virtual coefficient-block array */ 726793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 727793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long bytesperrow, file_offset, byte_count, rows, thisrow, i; 728793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 729793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK); 730793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler file_offset = ptr->cur_start_row * bytesperrow; 731793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Loop to read or write each allocation chunk in mem_buffer */ 732793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { 733793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* One chunk, but check for short chunk at end of buffer */ 734793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); 735793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Transfer no more than is currently defined */ 736793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler thisrow = (long) ptr->cur_start_row + i; 737793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rows = MIN(rows, (long) ptr->first_undef_row - thisrow); 738793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Transfer no more than fits in file */ 739793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler rows = MIN(rows, (long) ptr->rows_in_array - thisrow); 740793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (rows <= 0) /* this chunk might be past end of file! */ 741793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler break; 742793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler byte_count = rows * bytesperrow; 743793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (writing) 744793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, 745793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (void FAR *) ptr->mem_buffer[i], 746793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler file_offset, byte_count); 747793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler else 748793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, 749793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (void FAR *) ptr->mem_buffer[i], 750793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler file_offset, byte_count); 751793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler file_offset += byte_count; 752793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 753793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 754793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 755793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 756793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(JSAMPARRAY) 757793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presleraccess_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr, 758793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION start_row, JDIMENSION num_rows, 759793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler boolean writable) 760793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Access the part of a virtual sample array starting at start_row */ 761793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* and extending for num_rows rows. writable is true if */ 762793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* caller intends to modify the accessed area. */ 763793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 764793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION end_row = start_row + num_rows; 765793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION undef_row; 766793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 767793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* debugging check */ 768793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || 769793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->mem_buffer == NULL) 770793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); 771793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 772793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Make the desired part of the virtual array accessible */ 773793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (start_row < ptr->cur_start_row || 774793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler end_row > ptr->cur_start_row+ptr->rows_in_mem) { 775793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (! ptr->b_s_open) 776793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_VIRTUAL_BUG); 777793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Flush old buffer contents if necessary */ 778793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ptr->dirty) { 779793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler do_sarray_io(cinfo, ptr, TRUE); 780793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->dirty = FALSE; 781793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 782793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Decide what part of virtual array to access. 783793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Algorithm: if target address > current window, assume forward scan, 784793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * load starting at target address. If target address < current window, 785793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * assume backward scan, load so that target area is top of window. 786793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Note that when switching from forward write to forward read, will have 787793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * start_row = 0, so the limiting case applies and we load from 0 anyway. 788793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 789793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (start_row > ptr->cur_start_row) { 790793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->cur_start_row = start_row; 791793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } else { 792793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* use long arithmetic here to avoid overflow & unsigned problems */ 793793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long ltemp; 794793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 795793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ltemp = (long) end_row - (long) ptr->rows_in_mem; 796793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ltemp < 0) 797793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ltemp = 0; /* don't fall off front end of file */ 798793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->cur_start_row = (JDIMENSION) ltemp; 799793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 800793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Read in the selected part of the array. 801793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * During the initial write pass, we will do no actual read 802793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * because the selected part is all undefined. 803793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 804793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler do_sarray_io(cinfo, ptr, FALSE); 805793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 806793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Ensure the accessed part of the array is defined; prezero if needed. 807793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * To improve locality of access, we only prezero the part of the array 808793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * that the caller is about to access, not the entire in-memory array. 809793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 810793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ptr->first_undef_row < end_row) { 811793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ptr->first_undef_row < start_row) { 812793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (writable) /* writer skipped over a section of array */ 813793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); 814793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler undef_row = start_row; /* but reader is allowed to read ahead */ 815793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } else { 816793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler undef_row = ptr->first_undef_row; 817793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 818793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (writable) 819793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->first_undef_row = end_row; 820793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ptr->pre_zero) { 821793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE); 822793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ 823793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler end_row -= ptr->cur_start_row; 824793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler while (undef_row < end_row) { 825793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler FMEMZERO((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); 826793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler undef_row++; 827793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 828793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } else { 829793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (! writable) /* reader looking at undefined data */ 830793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); 831793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 832793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 833793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Flag the buffer dirty if caller will write in it */ 834793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (writable) 835793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->dirty = TRUE; 836793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Return address of proper part of the buffer */ 837793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler return ptr->mem_buffer + (start_row - ptr->cur_start_row); 838793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 839793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 840793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 841793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(JBLOCKARRAY) 842793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presleraccess_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr, 843793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION start_row, JDIMENSION num_rows, 844793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler boolean writable) 845793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* Access the part of a virtual block array starting at start_row */ 846793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* and extending for num_rows rows. writable is true if */ 847793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* caller intends to modify the accessed area. */ 848793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 849793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION end_row = start_row + num_rows; 850793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler JDIMENSION undef_row; 851793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 852793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* debugging check */ 853793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || 854793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->mem_buffer == NULL) 855793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); 856793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 857793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Make the desired part of the virtual array accessible */ 858793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (start_row < ptr->cur_start_row || 859793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler end_row > ptr->cur_start_row+ptr->rows_in_mem) { 860793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (! ptr->b_s_open) 861793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_VIRTUAL_BUG); 862793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Flush old buffer contents if necessary */ 863793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ptr->dirty) { 864793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler do_barray_io(cinfo, ptr, TRUE); 865793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->dirty = FALSE; 866793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 867793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Decide what part of virtual array to access. 868793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Algorithm: if target address > current window, assume forward scan, 869793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * load starting at target address. If target address < current window, 870793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * assume backward scan, load so that target area is top of window. 871793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Note that when switching from forward write to forward read, will have 872793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * start_row = 0, so the limiting case applies and we load from 0 anyway. 873793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 874793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (start_row > ptr->cur_start_row) { 875793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->cur_start_row = start_row; 876793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } else { 877793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* use long arithmetic here to avoid overflow & unsigned problems */ 878793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long ltemp; 879793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 880793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ltemp = (long) end_row - (long) ptr->rows_in_mem; 881793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ltemp < 0) 882793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ltemp = 0; /* don't fall off front end of file */ 883793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->cur_start_row = (JDIMENSION) ltemp; 884793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 885793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Read in the selected part of the array. 886793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * During the initial write pass, we will do no actual read 887793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * because the selected part is all undefined. 888793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 889793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler do_barray_io(cinfo, ptr, FALSE); 890793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 891793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Ensure the accessed part of the array is defined; prezero if needed. 892793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * To improve locality of access, we only prezero the part of the array 893793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * that the caller is about to access, not the entire in-memory array. 894793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 895793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ptr->first_undef_row < end_row) { 896793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ptr->first_undef_row < start_row) { 897793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (writable) /* writer skipped over a section of array */ 898793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); 899793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler undef_row = start_row; /* but reader is allowed to read ahead */ 900793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } else { 901793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler undef_row = ptr->first_undef_row; 902793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 903793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (writable) 904793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->first_undef_row = end_row; 905793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ptr->pre_zero) { 906793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK); 907793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ 908793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler end_row -= ptr->cur_start_row; 909793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler while (undef_row < end_row) { 910793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler FMEMZERO((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); 911793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler undef_row++; 912793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 913793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } else { 914793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (! writable) /* reader looking at undefined data */ 915793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); 916793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 917793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 918793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Flag the buffer dirty if caller will write in it */ 919793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (writable) 920793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ptr->dirty = TRUE; 921793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Return address of proper part of the buffer */ 922793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler return ptr->mem_buffer + (start_row - ptr->cur_start_row); 923793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 924793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 925793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 926793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 927793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Release all objects belonging to a specified pool. 928793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 929793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 930793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(void) 931793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerfree_pool (j_common_ptr cinfo, int pool_id) 932793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 933793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem = (my_mem_ptr) cinfo->mem; 934793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler small_pool_ptr shdr_ptr; 935793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler large_pool_ptr lhdr_ptr; 936793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t space_freed; 937793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 938793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) 939793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ 940793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 941793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#ifdef MEM_STATS 942793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (cinfo->err->trace_level > 1) 943793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */ 944793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#endif 945793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 946793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* If freeing IMAGE pool, close any virtual arrays first */ 947793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (pool_id == JPOOL_IMAGE) { 948793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_sarray_ptr sptr; 949793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jvirt_barray_ptr bptr; 950793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 951793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { 952793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (sptr->b_s_open) { /* there may be no backing store */ 953793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler sptr->b_s_open = FALSE; /* prevent recursive close if error */ 954793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info); 955793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 956793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 957793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->virt_sarray_list = NULL; 958793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { 959793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (bptr->b_s_open) { /* there may be no backing store */ 960793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler bptr->b_s_open = FALSE; /* prevent recursive close if error */ 961793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info); 962793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 963793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 964793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->virt_barray_list = NULL; 965793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 966793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 967793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Release large objects */ 968793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler lhdr_ptr = mem->large_list[pool_id]; 969793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->large_list[pool_id] = NULL; 970793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 971793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler while (lhdr_ptr != NULL) { 972793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next; 973793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler space_freed = lhdr_ptr->hdr.bytes_used + 974793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler lhdr_ptr->hdr.bytes_left + 975793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler SIZEOF(large_pool_hdr); 976793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed); 977793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->total_space_allocated -= space_freed; 978793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler lhdr_ptr = next_lhdr_ptr; 979793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 980793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 981793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Release small objects */ 982793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler shdr_ptr = mem->small_list[pool_id]; 983793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->small_list[pool_id] = NULL; 984793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 985793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler while (shdr_ptr != NULL) { 986793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next; 987793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler space_freed = shdr_ptr->hdr.bytes_used + 988793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler shdr_ptr->hdr.bytes_left + 989793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler SIZEOF(small_pool_hdr); 990793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed); 991793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->total_space_allocated -= space_freed; 992793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler shdr_ptr = next_shdr_ptr; 993793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 994793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 995793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 996793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 997793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 998793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Close up shop entirely. 999793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Note that this cannot be called unless cinfo->mem is non-NULL. 1000793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 1001793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1002793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerMETHODDEF(void) 1003793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerself_destruct (j_common_ptr cinfo) 1004793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 1005793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler int pool; 1006793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1007793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Close all backing store, release all memory. 1008793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Releasing pools in reverse order might help avoid fragmentation 1009793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * with some (brain-damaged) malloc libraries. 1010793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 1011793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { 1012793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler free_pool(cinfo, pool); 1013793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 1014793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1015793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Release the memory manager control block too. */ 1016793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr)); 1017793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler cinfo->mem = NULL; /* ensures I will be called only once */ 1018793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1019793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jpeg_mem_term(cinfo); /* system-dependent cleanup */ 1020793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 1021793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1022793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1023793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler/* 1024793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Memory manager initialization. 1025793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * When this is called, only the error manager pointer is valid in cinfo! 1026793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 1027793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1028793ee12c6df9cad3806238d32528c49a3ff9331dNoah PreslerGLOBAL(void) 1029793ee12c6df9cad3806238d32528c49a3ff9331dNoah Preslerjinit_memory_mgr (j_common_ptr cinfo) 1030793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler{ 1031793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler my_mem_ptr mem; 1032793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler long max_to_use; 1033793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler int pool; 1034793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler size_t test_mac; 1035793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1036793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler cinfo->mem = NULL; /* for safety if init fails */ 1037793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1038793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Check for configuration errors. 1039793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably 1040793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * doesn't reflect any real hardware alignment requirement. 1041793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * The test is a little tricky: for X>0, X and X-1 have no one-bits 1042793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * in common if and only if X is a power of 2, ie has only one one-bit. 1043793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Some compilers may give an "unreachable code" warning here; ignore it. 1044793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 1045793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0) 1046793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE); 1047793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be 1048793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * a multiple of SIZEOF(ALIGN_TYPE). 1049793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * Again, an "unreachable code" warning may be ignored here. 1050793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK. 1051793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 1052793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler test_mac = (size_t) MAX_ALLOC_CHUNK; 1053793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if ((long) test_mac != MAX_ALLOC_CHUNK || 1054793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0) 1055793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK); 1056793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1057793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */ 1058793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1059793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Attempt to allocate memory manager's control block */ 1060793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr)); 1061793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1062793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (mem == NULL) { 1063793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler jpeg_mem_term(cinfo); /* system-dependent cleanup */ 1064793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0); 1065793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 1066793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1067793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* OK, fill in the method pointers */ 1068793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.alloc_small = alloc_small; 1069793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.alloc_large = alloc_large; 1070793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.alloc_sarray = alloc_sarray; 1071793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.alloc_barray = alloc_barray; 1072793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.request_virt_sarray = request_virt_sarray; 1073793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.request_virt_barray = request_virt_barray; 1074793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.realize_virt_arrays = realize_virt_arrays; 1075793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.access_virt_sarray = access_virt_sarray; 1076793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.access_virt_barray = access_virt_barray; 1077793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.free_pool = free_pool; 1078793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.self_destruct = self_destruct; 1079793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1080793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Make MAX_ALLOC_CHUNK accessible to other modules */ 1081793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK; 1082793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1083793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Initialize working state */ 1084793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.max_memory_to_use = max_to_use; 1085793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1086793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { 1087793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->small_list[pool] = NULL; 1088793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->large_list[pool] = NULL; 1089793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 1090793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->virt_sarray_list = NULL; 1091793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->virt_barray_list = NULL; 1092793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1093793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->total_space_allocated = SIZEOF(my_memory_mgr); 1094793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1095793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Declare ourselves open for business */ 1096793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler cinfo->mem = & mem->pub; 1097793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1098793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler /* Check for an environment variable JPEGMEM; if found, override the 1099793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * default max_memory setting from jpeg_mem_init. Note that the 1100793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * surrounding application may again override this value. 1101793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * If your system doesn't support getenv(), define NO_GETENV to disable 1102793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler * this feature. 1103793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler */ 1104793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#ifndef NO_GETENV 1105793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler { char * memenv; 1106793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1107793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if ((memenv = getenv("JPEGMEM")) != NULL) { 1108793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler char ch = 'x'; 1109793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1110793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) { 1111793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler if (ch == 'm' || ch == 'M') 1112793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler max_to_use *= 1000L; 1113793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler mem->pub.max_memory_to_use = max_to_use * 1000L; 1114793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 1115793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 1116793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler } 1117793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler#endif 1118793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler 1119793ee12c6df9cad3806238d32528c49a3ff9331dNoah Presler} 1120