jmemmgr.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

/*
 * 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, (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 */

#if 0  /*RS*/
  /* 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;
	}
  }
# else
  ERREXIT(cinfo, JERR_NO_BACKING_STORE);
#endif
}


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 FAR *) ptr->mem_buffer[i], file_offset, byte_count);
					}
					else
					{
						(*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, (void FAR *) ptr->mem_buffer[i], file_offset, byte_count);
					}
					file_offset += byte_count;
				}
}


/* Do backing store read or write of a virtual coefficient-block array */
LOCAL(void) do_barray_io(j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
{
				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 FAR *) ptr->mem_buffer[i], file_offset, byte_count);
					}
					else
					{
						(*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, (void FAR *) ptr->mem_buffer[i], file_offset, byte_count);
					}
					file_offset += byte_count;
				}
}


/* 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. */
METHODDEF(JSAMPARRAY) access_virt_sarray(j_common_ptr cinfo, jvirt_sarray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable)
{
						  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)