(size_t) ((size_t) rowsperchunk * (size_t) blocksperrow		  * SIZEOF(JBLOCK)));    for (i = rowsperchunk; i > 0; i--) {      result[currow++] = workspace;      workspace += blocksperrow;    }  }  return result;}/* * About virtual array management: * * The above "normal" array routines are only used to allocate strip buffers * (as wide as the image, but just a few rows high).  Full-image-sized buffers * are handled as "virtual" arrays.  The array is still accessed a strip at a * time, but the memory manager must save the whole array for repeated * accesses.  The intended implementation is that there is a strip buffer in * memory (as high as is possible given the desired memory limit), plus a * backing file that holds the rest of the array. * * The request_virt_array routines are told the total size of the image and * the maximum number of rows that will be accessed at once.  The in-memory * buffer must be at least as large as the maxaccess value. * * The request routines create control blocks but not the in-memory buffers. * That is postponed until realize_virt_arrays is called.  At that time the * total amount of space needed is known (approximately, anyway), so free * memory can be divided up fairly. * * The access_virt_array routines are responsible for making a specific strip * area accessible (after reading or writing the backing file, if necessary). * Note that the access routines are told whether the caller intends to modify * the accessed strip; during a read-only pass this saves having to rewrite * data to disk.  The access routines are also responsible for pre-zeroing * any newly accessed rows, if pre-zeroing was requested. * * In current usage, the access requests are usually for nonoverlapping * strips; that is, successive access start_row numbers differ by exactly * num_rows = maxaccess.  This means we can get good performance with simple * buffer dump/reload logic, by making the in-memory buffer be a multiple * of the access height; then there will never be accesses across bufferload * boundaries.  The code will still work with overlapping access requests, * but it doesn't handle bufferload overlaps very efficiently. */METHODDEF(jvirt_sarray_ptr)request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero,		     JDIMENSION samplesperrow, JDIMENSION numrows,		     JDIMENSION maxaccess)/* Request a virtual 2-D sample array */{  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  jvirt_sarray_ptr result;  /* Only IMAGE-lifetime virtual arrays are currently supported */  if (pool_id != JPOOL_IMAGE)    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */  /* get control block */  result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id,					  SIZEOF(struct jvirt_sarray_control));  result->mem_buffer = NULL;	/* marks array not yet realized */  result->rows_in_array = numrows;  result->samplesperrow = samplesperrow;  result->maxaccess = maxaccess;  result->pre_zero = pre_zero;  result->b_s_open = FALSE;	/* no associated backing-store object */  result->next = mem->virt_sarray_list; /* add to list of virtual arrays */  mem->virt_sarray_list = result;  return result;}METHODDEF(jvirt_barray_ptr)request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero,		     JDIMENSION blocksperrow, JDIMENSION numrows,		     JDIMENSION maxaccess)/* Request a virtual 2-D coefficient-block array */{  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  jvirt_barray_ptr result;  /* Only IMAGE-lifetime virtual arrays are currently supported */  if (pool_id != JPOOL_IMAGE)    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */  /* get control block */  result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id,					  SIZEOF(struct jvirt_barray_control));  result->mem_buffer = NULL;	/* marks array not yet realized */  result->rows_in_array = numrows;  result->blocksperrow = blocksperrow;  result->maxaccess = maxaccess;  result->pre_zero = pre_zero;  result->b_s_open = FALSE;	/* no associated backing-store object */  result->next = mem->virt_barray_list; /* add to list of virtual arrays */  mem->virt_barray_list = result;  return result;}METHODDEF(void)realize_virt_arrays (j_common_ptr cinfo)/* Allocate the in-memory buffers for any unrealized virtual arrays */{  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  long space_per_minheight, maximum_space, avail_mem;  long minheights, max_minheights;  jvirt_sarray_ptr sptr;  jvirt_barray_ptr bptr;  /* Compute the minimum space needed (maxaccess rows in each buffer)   * and the maximum space needed (full image height in each buffer).   * These may be of use to the system-dependent jpeg_mem_available routine.   */  space_per_minheight = 0;  maximum_space = 0;  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {    if (sptr->mem_buffer == NULL) { /* if not realized yet */      space_per_minheight += (long) sptr->maxaccess *			     (long) sptr->samplesperrow * SIZEOF(JSAMPLE);      maximum_space += (long) sptr->rows_in_array *		       (long) sptr->samplesperrow * SIZEOF(JSAMPLE);    }  }  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {    if (bptr->mem_buffer == NULL) { /* if not realized yet */      space_per_minheight += (long) bptr->maxaccess *			     (long) bptr->blocksperrow * SIZEOF(JBLOCK);      maximum_space += (long) bptr->rows_in_array *		       (long) bptr->blocksperrow * SIZEOF(JBLOCK);    }  }  if (space_per_minheight <= 0)    return;			/* no unrealized arrays, no work */  /* Determine amount of memory to actually use; this is system-dependent. */  avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,				 mem->total_space_allocated);  /* If the maximum space needed is available, make all the buffers full   * height; otherwise parcel it out with the same number of minheights   * in each buffer.   */  if (avail_mem >= maximum_space)    max_minheights = 1000000000L;  else {    max_minheights = avail_mem / space_per_minheight;    /* If there doesn't seem to be enough space, try to get the minimum     * anyway.  This allows a "stub" implementation of jpeg_mem_available().     */    if (max_minheights <= 0)      max_minheights = 1;  }  /* Allocate the in-memory buffers and initialize backing store as needed. */  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {    if (sptr->mem_buffer == NULL) { /* if not realized yet */      minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L;      if (minheights <= max_minheights) {	/* This buffer fits in memory */	sptr->rows_in_mem = sptr->rows_in_array;      } else {	/* It doesn't fit in memory, create backing store. */	sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess);	jpeg_open_backing_store(cinfo, & sptr->b_s_info,				(long) sptr->rows_in_array *				(long) sptr->samplesperrow *				(long) SIZEOF(JSAMPLE));	sptr->b_s_open = TRUE;      }      sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE,				      sptr->samplesperrow, sptr->rows_in_mem);      sptr->rowsperchunk = mem->last_rowsperchunk;      sptr->cur_start_row = 0;      sptr->first_undef_row = 0;      sptr->dirty = FALSE;    }  }  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {    if (bptr->mem_buffer == NULL) { /* if not realized yet */      minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L;      if (minheights <= max_minheights) {	/* This buffer fits in memory */	bptr->rows_in_mem = bptr->rows_in_array;      } else {	/* It doesn't fit in memory, create backing store. */	bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess);	jpeg_open_backing_store(cinfo, & bptr->b_s_info,				(long) bptr->rows_in_array *				(long) bptr->blocksperrow *				(long) SIZEOF(JBLOCK));	bptr->b_s_open = TRUE;      }      bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE,				      bptr->blocksperrow, bptr->rows_in_mem);      bptr->rowsperchunk = mem->last_rowsperchunk;      bptr->cur_start_row = 0;      bptr->first_undef_row = 0;      bptr->dirty = FALSE;    }  }}LOCAL(void)do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)/* Do backing store read or write of a virtual sample array */{  long bytesperrow, file_offset, byte_count, rows, thisrow, i;  bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE);  file_offset = ptr->cur_start_row * bytesperrow;  /* Loop to read or write each allocation chunk in mem_buffer */  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {    /* One chunk, but check for short chunk at end of buffer */    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);    /* Transfer no more than is currently defined */    thisrow = (long) ptr->cur_start_row + i;    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);    /* Transfer no more than fits in file */    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);    if (rows <= 0)		/* this chunk might be past end of file! */      break;    byte_count = rows * bytesperrow;    if (writing)      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,					    (void *) ptr->mem_buffer[i],					    file_offset, byte_count);    else      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,					   (void *) ptr->mem_buffer[i],					   file_offset, byte_count);    file_offset += byte_count;  }}LOCAL(void)do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)/* Do backing store read or write of a virtual coefficient-block array */{  long bytesperrow, file_offset, byte_count, rows, thisrow, i;  bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK);  file_offset = ptr->cur_start_row * bytesperrow;  /* Loop to read or write each allocation chunk in mem_buffer */  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {    /* One chunk, but check for short chunk at end of buffer */    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);    /* Transfer no more than is currently defined */    thisrow = (long) ptr->cur_start_row + i;    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);    /* Transfer no more than fits in file */    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);    if (rows <= 0)		/* this chunk might be past end of file! */      break;    byte_count = rows * bytesperrow;    if (writing)      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,					    (void *) ptr->mem_buffer[i],					    file_offset, byte_count);    else      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,					   (void *) ptr->mem_buffer[i],					   file_offset, byte_count);    file_offset += byte_count;  }}METHODDEF(JSAMPARRAY)access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr,		    JDIMENSION start_row, JDIMENSION num_rows,		    boolean writable)/* Access the part of a virtual sample array starting at start_row *//* and extending for num_rows rows.  writable is true if  *//* caller intends to modify the accessed area. */{  JDIMENSION end_row = start_row + num_rows;  JDIMENSION undef_row;  /* debugging check */  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||      ptr->mem_buffer == NULL)    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);  /* Make the desired part of the virtual array accessible */  if (start_row < ptr->cur_start_row ||      end_row > ptr->cur_start_row+ptr->rows_in_mem) {    if (! ptr->b_s_open)      ERREXIT(cinfo, JERR_VIRTUAL_BUG);    /* Flush old buffer contents if necessary */    if (ptr->dirty) {      do_sarray_io(cinfo, ptr, TRUE);      ptr->dirty = FALSE;    }    /* Decide what part of virtual array to access.     * Algorithm: if target address > current window, assume forward scan,     * load starting at target address.  If target address < current window,     * assume backward scan, load so that target area is top of window.     * Note that when switching from forward write to forward read, will have     * start_row = 0, so the limiting case applies and we load from 0 anyway.     */    if (start_row > ptr->cur_start_row) {      ptr->cur_start_row = start_row;    } else {      /* use long arithmetic here to avoid overflow & unsigned problems */      long ltemp;      ltemp = (long) end_row - (long) ptr->rows_in_mem;      if (ltemp < 0)	ltemp = 0;		/* don't fall off front end of file */      ptr->cur_start_row = (JDIMENSION) ltemp;    }    /* Read in the selected part of the array.     * During the initial write pass, we will do no actual read     * because the selected part is all undefined.     */    do_sarray_io(cinfo, ptr, FALSE);  }  /* Ensure the accessed part of the array is defined; prezero if needed.   * To improve locality of access, we only prezero the part of the array   * that the caller is about to access, not the entire in-memory array.   */  if (ptr->first_undef_row < end_row) {    if (ptr->first_undef_row < start_row) {      if (writable)		/* writer skipped over a section of array */	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);      undef_row = start_row;	/* but reader is allowed to read ahead */    } else {      undef_row = ptr->first_undef_row;    }    if (writable)      ptr->first_undef_row = end_row;    if (ptr->pre_zero) {      size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE);      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */      end_row -= ptr->cur_start_row;      while (undef_row < end_row) {	jzero_far((void *) ptr->mem_buffer[undef_row], bytesperrow);	undef_row++;      }    } else {      if (! writable)		/* reader looking at undefined data */	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);    }  }  /* Flag the buffer dirty if caller will write in it */  if (writable)    ptr->dirty = TRUE;  /* Return address of proper part of the buffer */  return ptr->mem_buffer + (start_row - ptr->cur_start_row);}METHODDEF(JBLOCKARRAY)