size_t bytes_used;		/* how many bytes already used within pool */    size_t bytes_left;		/* bytes still available in this pool */  } hdr;  ALIGN_TYPE dummy;		/* included in union to ensure alignment */} large_pool_hdr;/* * Here is the full definition of a memory manager object. */typedef struct {  struct jpeg_memory_mgr pub;	/* public fields */  /* Each pool identifier (lifetime class) names a linked list of pools. */  small_pool_ptr small_list[JPOOL_NUMPOOLS];  large_pool_ptr large_list[JPOOL_NUMPOOLS];  /* Since we only have one lifetime class of virtual arrays, only one   * linked list is necessary (for each datatype).  Note that the virtual   * array control blocks being linked together are actually stored somewhere   * in the small-pool list.   */  jvirt_sarray_ptr virt_sarray_list;  jvirt_barray_ptr virt_barray_list;  /* This counts total space obtained from jpeg_get_small/large */  long total_space_allocated;  /* alloc_sarray and alloc_barray set this value for use by virtual   * array routines.   */  JDIMENSION last_rowsperchunk;	/* from most recent alloc_sarray/barray */} my_memory_mgr;typedef my_memory_mgr * my_mem_ptr;/* * The control blocks for virtual arrays. * Note that these blocks are allocated in the "small" pool area. * System-dependent info for the associated backing store (if any) is hidden * inside the backing_store_info struct. */struct jvirt_sarray_control {  JSAMPARRAY mem_buffer;	/* => the in-memory buffer */  JDIMENSION rows_in_array;	/* total virtual array height */  JDIMENSION samplesperrow;	/* width of array (and of memory buffer) */  JDIMENSION maxaccess;		/* max rows accessed by access_virt_sarray */  JDIMENSION rows_in_mem;	/* height of memory buffer */  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */  JDIMENSION cur_start_row;	/* first logical row # in the buffer */  JDIMENSION first_undef_row;	/* row # of first uninitialized row */  boolean pre_zero;		/* pre-zero mode requested? */  boolean dirty;		/* do current buffer contents need written? */  boolean b_s_open;		/* is backing-store data valid? */  jvirt_sarray_ptr next;	/* link to next virtual sarray control block */  backing_store_info b_s_info;	/* System-dependent control info */};struct jvirt_barray_control {  JBLOCKARRAY mem_buffer;	/* => the in-memory buffer */  JDIMENSION rows_in_array;	/* total virtual array height */  JDIMENSION blocksperrow;	/* width of array (and of memory buffer) */  JDIMENSION maxaccess;		/* max rows accessed by access_virt_barray */  JDIMENSION rows_in_mem;	/* height of memory buffer */  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */  JDIMENSION cur_start_row;	/* first logical row # in the buffer */  JDIMENSION first_undef_row;	/* row # of first uninitialized row */  boolean pre_zero;		/* pre-zero mode requested? */  boolean dirty;		/* do current buffer contents need written? */  boolean b_s_open;		/* is backing-store data valid? */  jvirt_barray_ptr next;	/* link to next virtual barray control block */  backing_store_info b_s_info;	/* System-dependent control info */};#ifdef MEM_STATS		/* optional extra stuff for statistics */LOCAL(void)print_mem_stats (j_common_ptr cinfo, int pool_id){  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  small_pool_ptr shdr_ptr;  large_pool_ptr lhdr_ptr;  /* Since this is only a debugging stub, we can cheat a little by using   * fprintf directly rather than going through the trace message code.   * This is helpful because message parm array can't handle longs.   */  fprintf(stderr, "Freeing pool %d, total space = %ld\n",	  pool_id, mem->total_space_allocated);  for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;       lhdr_ptr = lhdr_ptr->hdr.next) {    fprintf(stderr, "  Large chunk used %ld\n",	    (long) lhdr_ptr->hdr.bytes_used);  }  for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL;       shdr_ptr = shdr_ptr->hdr.next) {    fprintf(stderr, "  Small chunk used %ld free %ld\n",	    (long) shdr_ptr->hdr.bytes_used,	    (long) shdr_ptr->hdr.bytes_left);  }}#endif /* MEM_STATS */LOCAL(void)out_of_memory (j_common_ptr cinfo, int which)/* Report an out-of-memory error and stop execution *//* If we compiled MEM_STATS support, report alloc requests before dying */{#ifdef MEM_STATS  cinfo->err->trace_level = 2;	/* force self_destruct to report stats */#endif  ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);}/* * Allocation of "small" objects. * * For these, we use pooled storage.  When a new pool must be created, * we try to get enough space for the current request plus a "slop" factor, * where the slop will be the amount of leftover space in the new pool. * The speed vs. space tradeoff is largely determined by the slop values. * A different slop value is provided for each pool class (lifetime), * and we also distinguish the first pool of a class from later ones. * NOTE: the values given work fairly well on both 16- and 32-bit-int * machines, but may be too small if longs are 64 bits or more. */static const size_t first_pool_slop[JPOOL_NUMPOOLS] = {	1600,			/* first PERMANENT pool */	16000			/* first IMAGE pool */};static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = {	0,			/* additional PERMANENT pools */	5000			/* additional IMAGE pools */};#define MIN_SLOP  50		/* greater than 0 to avoid futile looping */METHODDEF(void *)alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)/* Allocate a "small" object */{  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  small_pool_ptr hdr_ptr, prev_hdr_ptr;  char * data_ptr;  size_t odd_bytes, min_request, slop;  /* Check for unsatisfiable request (do now to ensure no overflow below) */  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr)))    out_of_memory(cinfo, 1);	/* request exceeds malloc's ability */  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);  if (odd_bytes > 0)    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;  /* See if space is available in any existing pool */  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */  prev_hdr_ptr = NULL;  hdr_ptr = mem->small_list[pool_id];  while (hdr_ptr != NULL) {    if (hdr_ptr->hdr.bytes_left >= sizeofobject)      break;			/* found pool with enough space */    prev_hdr_ptr = hdr_ptr;    hdr_ptr = hdr_ptr->hdr.next;  }  /* Time to make a new pool? */  if (hdr_ptr == NULL) {    /* min_request is what we need now, slop is what will be leftover */    min_request = sizeofobject + SIZEOF(small_pool_hdr);    if (prev_hdr_ptr == NULL)	/* first pool in class? */      slop = first_pool_slop[pool_id];    else      slop = extra_pool_slop[pool_id];    /* Don't ask for more than MAX_ALLOC_CHUNK */    if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request))      slop = (size_t) (MAX_ALLOC_CHUNK-min_request);    /* Try to get space, if fail reduce slop and try again */    for (;;) {      hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop);      if (hdr_ptr != NULL)	break;      slop /= 2;      if (slop < MIN_SLOP)	/* give up when it gets real small */	out_of_memory(cinfo, 2); /* jpeg_get_small failed */    }    mem->total_space_allocated += min_request + slop;    /* Success, initialize the new pool header and add to end of list */    hdr_ptr->hdr.next = NULL;    hdr_ptr->hdr.bytes_used = 0;    hdr_ptr->hdr.bytes_left = sizeofobject + slop;    if (prev_hdr_ptr == NULL)	/* first pool in class? */      mem->small_list[pool_id] = hdr_ptr;    else      prev_hdr_ptr->hdr.next = hdr_ptr;  }  /* OK, allocate the object from the current pool */  data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */  data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */  hdr_ptr->hdr.bytes_used += sizeofobject;  hdr_ptr->hdr.bytes_left -= sizeofobject;  return (void *) data_ptr;}/* * Allocation of "large" objects. * * The external semantics of these are the same as "small" objects, * except that FAR pointers are used on 80x86.  However the pool * management heuristics are quite different.  We assume that each * request is large enough that it may as well be passed directly to * jpeg_get_large; the pool management just links everything together * so that we can free it all on demand. * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY * structures.  The routines that create these structures (see below) * deliberately bunch rows together to ensure a large request size. */METHODDEF(void *)alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)/* Allocate a "large" object */{  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  large_pool_ptr hdr_ptr;  size_t odd_bytes;  /* Check for unsatisfiable request (do now to ensure no overflow below) */  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)))    out_of_memory(cinfo, 3);	/* request exceeds malloc's ability */  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);  if (odd_bytes > 0)    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;  /* Always make a new pool */  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */  hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject +					    SIZEOF(large_pool_hdr));  if (hdr_ptr == NULL)    out_of_memory(cinfo, 4);	/* jpeg_get_large failed */  mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr);  /* Success, initialize the new pool header and add to list */  hdr_ptr->hdr.next = mem->large_list[pool_id];  /* We maintain space counts in each pool header for statistical purposes,   * even though they are not needed for allocation.   */  hdr_ptr->hdr.bytes_used = sizeofobject;  hdr_ptr->hdr.bytes_left = 0;  mem->large_list[pool_id] = hdr_ptr;  return (void *) (hdr_ptr + 1); /* point to first data byte in pool */}/* * Creation of 2-D sample arrays. * The pointers are in near heap, the samples themselves in FAR heap. * * To minimize allocation overhead and to allow I/O of large contiguous * blocks, we allocate the sample rows in groups of as many rows as possible * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request. * NB: the virtual array control routines, later in this file, know about * this chunking of rows.  The rowsperchunk value is left in the mem manager * object so that it can be saved away if this sarray is the workspace for * a virtual array. */METHODDEF(JSAMPARRAY)alloc_sarray (j_common_ptr cinfo, int pool_id,	      JDIMENSION samplesperrow, JDIMENSION numrows)/* Allocate a 2-D sample array */{  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  JSAMPARRAY result;  JSAMPROW workspace;  JDIMENSION rowsperchunk, currow, i;  long ltemp;  /* Calculate max # of rows allowed in one allocation chunk */  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /	  ((long) samplesperrow * SIZEOF(JSAMPLE));  if (ltemp <= 0)    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);  if (ltemp < (long) numrows)    rowsperchunk = (JDIMENSION) ltemp;  else    rowsperchunk = numrows;  mem->last_rowsperchunk = rowsperchunk;  /* Get space for row pointers (small object) */  result = (JSAMPARRAY) alloc_small(cinfo, pool_id,				    (size_t) (numrows * SIZEOF(JSAMPROW)));  /* Get the rows themselves (large objects) */  currow = 0;  while (currow < numrows) {    rowsperchunk = MIN(rowsperchunk, numrows - currow);    workspace = (JSAMPROW) alloc_large(cinfo, pool_id,	(size_t) ((size_t) rowsperchunk * (size_t) samplesperrow		  * SIZEOF(JSAMPLE)));    for (i = rowsperchunk; i > 0; i--) {      result[currow++] = workspace;      workspace += samplesperrow;    }  }  return result;}/* * Creation of 2-D coefficient-block arrays. * This is essentially the same as the code for sample arrays, above. */METHODDEF(JBLOCKARRAY)alloc_barray (j_common_ptr cinfo, int pool_id,	      JDIMENSION blocksperrow, JDIMENSION numrows)/* Allocate a 2-D coefficient-block array */{  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  JBLOCKARRAY result;  JBLOCKROW workspace;  JDIMENSION rowsperchunk, currow, i;  long ltemp;  /* Calculate max # of rows allowed in one allocation chunk */  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /	  ((long) blocksperrow * SIZEOF(JBLOCK));  if (ltemp <= 0)    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);  if (ltemp < (long) numrows)    rowsperchunk = (JDIMENSION) ltemp;  else    rowsperchunk = numrows;  mem->last_rowsperchunk = rowsperchunk;  /* Get space for row pointers (small object) */  result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,				     (size_t) (numrows * SIZEOF(JBLOCKROW)));  /* Get the rows themselves (large objects) */  currow = 0;  while (currow < numrows) {    rowsperchunk = MIN(rowsperchunk, numrows - currow);    workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,