ReactOS  0.4.15-dev-1197-g8081ba9
jmemmgr.c File Reference
#include "jinclude.h"
#include "jpeglib.h"
#include "jmemsys.h"
Include dependency graph for jmemmgr.c:

Go to the source code of this file.

Classes

union  small_pool_struct
 
union  large_pool_struct
 
struct  my_memory_mgr
 
struct  jvirt_sarray_control
 
struct  jvirt_barray_control
 

Macros

#define JPEG_INTERNALS
 
#define AM_MEMORY_MANAGER   /* we define jvirt_Xarray_control structs */
 
#define ALIGN_TYPE   double
 
#define MIN_SLOP   50 /* greater than 0 to avoid futile looping */
 

Typedefs

typedef union small_pool_structsmall_pool_ptr
 
typedef union small_pool_struct small_pool_hdr
 
typedef union large_pool_struct FARlarge_pool_ptr
 
typedef union large_pool_struct large_pool_hdr
 
typedef my_memory_mgrmy_mem_ptr
 

Functions

char *getenv JPP ((const char *name))
 
 out_of_memory (j_common_ptr cinfo, int which)
 
 alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
 
 alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
 
 alloc_sarray (j_common_ptr cinfo, int pool_id, JDIMENSION samplesperrow, JDIMENSION numrows)
 
 alloc_barray (j_common_ptr cinfo, int pool_id, JDIMENSION blocksperrow, JDIMENSION numrows)
 
 request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION samplesperrow, JDIMENSION numrows, JDIMENSION maxaccess)
 
 request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION blocksperrow, JDIMENSION numrows, JDIMENSION maxaccess)
 
 realize_virt_arrays (j_common_ptr cinfo)
 
 do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)
 
 do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
 
 access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable)
 
 access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable)
 
 free_pool (j_common_ptr cinfo, int pool_id)
 
 self_destruct (j_common_ptr cinfo)
 
 jinit_memory_mgr (j_common_ptr cinfo)
 

Variables

static const size_t first_pool_slop [JPOOL_NUMPOOLS]
 
static const size_t extra_pool_slop [JPOOL_NUMPOOLS]
 

Macro Definition Documentation

◆ ALIGN_TYPE

#define ALIGN_TYPE   double

Definition at line 74 of file jmemmgr.c.

◆ AM_MEMORY_MANAGER

#define AM_MEMORY_MANAGER   /* we define jvirt_Xarray_control structs */

Definition at line 29 of file jmemmgr.c.

◆ JPEG_INTERNALS

#define JPEG_INTERNALS

Definition at line 28 of file jmemmgr.c.

◆ MIN_SLOP

#define MIN_SLOP   50 /* greater than 0 to avoid futile looping */

Definition at line 254 of file jmemmgr.c.

Typedef Documentation

◆ large_pool_hdr

◆ large_pool_ptr

Definition at line 101 of file jmemmgr.c.

◆ my_mem_ptr

Definition at line 141 of file jmemmgr.c.

◆ small_pool_hdr

◆ small_pool_ptr

Definition at line 90 of file jmemmgr.c.

Function Documentation

◆ access_virt_barray()

access_virt_barray ( j_common_ptr  cinfo,
jvirt_barray_ptr  ptr,
JDIMENSION  start_row,
JDIMENSION  num_rows,
boolean  writable 
)

Definition at line 838 of file jmemmgr.c.

844 {
845  JDIMENSION end_row = start_row + num_rows;
846  JDIMENSION undef_row;
847 
848  /* debugging check */
849  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
850  ptr->mem_buffer == NULL)
851  ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
852 
853  /* Make the desired part of the virtual array accessible */
854  if (start_row < ptr->cur_start_row ||
855  end_row > ptr->cur_start_row + ptr->rows_in_mem) {
856  if (! ptr->b_s_open)
857  ERREXIT(cinfo, JERR_VIRTUAL_BUG);
858  /* Flush old buffer contents if necessary */
859  if (ptr->dirty) {
860  do_barray_io(cinfo, ptr, TRUE);
861  ptr->dirty = FALSE;
862  }
863  /* Decide what part of virtual array to access.
864  * Algorithm: if target address > current window, assume forward scan,
865  * load starting at target address. If target address < current window,
866  * assume backward scan, load so that target area is top of window.
867  * Note that when switching from forward write to forward read, will have
868  * start_row = 0, so the limiting case applies and we load from 0 anyway.
869  */
870  if (start_row > ptr->cur_start_row) {
871  ptr->cur_start_row = start_row;
872  } else {
873  /* use long arithmetic here to avoid overflow & unsigned problems */
874  long ltemp;
875 
876  ltemp = (long) end_row - (long) ptr->rows_in_mem;
877  if (ltemp < 0)
878  ltemp = 0; /* don't fall off front end of file */
879  ptr->cur_start_row = (JDIMENSION) ltemp;
880  }
881  /* Read in the selected part of the array.
882  * During the initial write pass, we will do no actual read
883  * because the selected part is all undefined.
884  */
885  do_barray_io(cinfo, ptr, FALSE);
886  }
887  /* Ensure the accessed part of the array is defined; prezero if needed.
888  * To improve locality of access, we only prezero the part of the array
889  * that the caller is about to access, not the entire in-memory array.
890  */
891  if (ptr->first_undef_row < end_row) {
892  if (ptr->first_undef_row < start_row) {
893  if (writable) /* writer skipped over a section of array */
894  ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
895  undef_row = start_row; /* but reader is allowed to read ahead */
896  } else {
897  undef_row = ptr->first_undef_row;
898  }
899  if (writable)
900  ptr->first_undef_row = end_row;
901  if (ptr->pre_zero) {
902  size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK);
903  undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
904  end_row -= ptr->cur_start_row;
905  while (undef_row < end_row) {
906  FMEMZERO((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
907  undef_row++;
908  }
909  } else {
910  if (! writable) /* reader looking at undefined data */
911  ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
912  }
913  }
914  /* Flag the buffer dirty if caller will write in it */
915  if (writable)
916  ptr->dirty = TRUE;
917  /* Return address of proper part of the buffer */
918  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
919 }
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define TRUE
Definition: types.h:120
do_barray_io(j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
Definition: jmemmgr.c:720
JCOEF JBLOCK[DCTSIZE2]
Definition: jpeglib.h:79
#define SIZEOF(_ar)
Definition: calc.h:97
#define FALSE
Definition: types.h:117
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
__kernel_size_t size_t
Definition: linux.h:237
int JSAMPARRAY int int num_rows
Definition: jpegint.h:419
#define long
Definition: qsort.c:33
unsigned int JDIMENSION
Definition: jmorecfg.h:229
#define FAR
Definition: zlib.h:34
#define FMEMZERO(target, size)
Definition: jpegint.h:368

Referenced by jinit_memory_mgr().

◆ access_virt_sarray()

access_virt_sarray ( j_common_ptr  cinfo,
jvirt_sarray_ptr  ptr,
JDIMENSION  start_row,
JDIMENSION  num_rows,
boolean  writable 
)

Definition at line 753 of file jmemmgr.c.

759 {
760  JDIMENSION end_row = start_row + num_rows;
761  JDIMENSION undef_row;
762 
763  /* debugging check */
764  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
765  ptr->mem_buffer == NULL)
766  ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
767 
768  /* Make the desired part of the virtual array accessible */
769  if (start_row < ptr->cur_start_row ||
770  end_row > ptr->cur_start_row + ptr->rows_in_mem) {
771  if (! ptr->b_s_open)
772  ERREXIT(cinfo, JERR_VIRTUAL_BUG);
773  /* Flush old buffer contents if necessary */
774  if (ptr->dirty) {
775  do_sarray_io(cinfo, ptr, TRUE);
776  ptr->dirty = FALSE;
777  }
778  /* Decide what part of virtual array to access.
779  * Algorithm: if target address > current window, assume forward scan,
780  * load starting at target address. If target address < current window,
781  * assume backward scan, load so that target area is top of window.
782  * Note that when switching from forward write to forward read, will have
783  * start_row = 0, so the limiting case applies and we load from 0 anyway.
784  */
785  if (start_row > ptr->cur_start_row) {
786  ptr->cur_start_row = start_row;
787  } else {
788  /* use long arithmetic here to avoid overflow & unsigned problems */
789  long ltemp;
790 
791  ltemp = (long) end_row - (long) ptr->rows_in_mem;
792  if (ltemp < 0)
793  ltemp = 0; /* don't fall off front end of file */
794  ptr->cur_start_row = (JDIMENSION) ltemp;
795  }
796  /* Read in the selected part of the array.
797  * During the initial write pass, we will do no actual read
798  * because the selected part is all undefined.
799  */
800  do_sarray_io(cinfo, ptr, FALSE);
801  }
802  /* Ensure the accessed part of the array is defined; prezero if needed.
803  * To improve locality of access, we only prezero the part of the array
804  * that the caller is about to access, not the entire in-memory array.
805  */
806  if (ptr->first_undef_row < end_row) {
807  if (ptr->first_undef_row < start_row) {
808  if (writable) /* writer skipped over a section of array */
809  ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
810  undef_row = start_row; /* but reader is allowed to read ahead */
811  } else {
812  undef_row = ptr->first_undef_row;
813  }
814  if (writable)
815  ptr->first_undef_row = end_row;
816  if (ptr->pre_zero) {
817  size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE);
818  undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
819  end_row -= ptr->cur_start_row;
820  while (undef_row < end_row) {
821  FMEMZERO((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
822  undef_row++;
823  }
824  } else {
825  if (! writable) /* reader looking at undefined data */
826  ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
827  }
828  }
829  /* Flag the buffer dirty if caller will write in it */
830  if (writable)
831  ptr->dirty = TRUE;
832  /* Return address of proper part of the buffer */
833  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
834 }
char JSAMPLE
Definition: jmorecfg.h:74
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define TRUE
Definition: types.h:120
#define SIZEOF(_ar)
Definition: calc.h:97
#define FALSE
Definition: types.h:117
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
do_sarray_io(j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)
Definition: jmemmgr.c:687
__kernel_size_t size_t
Definition: linux.h:237
int JSAMPARRAY int int num_rows
Definition: jpegint.h:419
#define long
Definition: qsort.c:33
unsigned int JDIMENSION
Definition: jmorecfg.h:229
#define FAR
Definition: zlib.h:34
#define FMEMZERO(target, size)
Definition: jpegint.h:368

Referenced by jinit_memory_mgr().

◆ alloc_barray()

alloc_barray ( j_common_ptr  cinfo,
int  pool_id,
JDIMENSION  blocksperrow,
JDIMENSION  numrows 
)

Definition at line 443 of file jmemmgr.c.

446 {
447  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
449  JBLOCKROW workspace;
450  JDIMENSION rowsperchunk, currow, i;
451  long ltemp;
452 
453  /* Calculate max # of rows allowed in one allocation chunk */
454  ltemp = (MAX_ALLOC_CHUNK - SIZEOF(large_pool_hdr)) /
455  ((long) blocksperrow * SIZEOF(JBLOCK));
456  if (ltemp <= 0)
457  ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
458  if (ltemp < (long) numrows)
459  rowsperchunk = (JDIMENSION) ltemp;
460  else
461  rowsperchunk = numrows;
462  mem->last_rowsperchunk = rowsperchunk;
463 
464  /* Get space for row pointers (small object) */
465  result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,
466  (size_t) numrows * SIZEOF(JBLOCKROW));
467 
468  /* Get the rows themselves (large objects) */
469  currow = 0;
470  while (currow < numrows) {
471  rowsperchunk = MIN(rowsperchunk, numrows - currow);
472  workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,
473  (size_t) rowsperchunk * (size_t) blocksperrow * SIZEOF(JBLOCK));
474  for (i = rowsperchunk; i > 0; i--) {
475  result[currow++] = workspace;
476  workspace += blocksperrow;
477  }
478  }
479 
480  return result;
481 }
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
alloc_small(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
Definition: jmemmgr.c:258
JCOEF JBLOCK[DCTSIZE2]
Definition: jpeglib.h:79
JBLOCKROW * JBLOCKARRAY
Definition: jpeglib.h:81
my_memory_mgr * my_mem_ptr
Definition: jmemmgr.c:141
alloc_large(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
Definition: jmemmgr.c:343
T MIN(T a, T b)
Definition: polytest.cpp:79
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SIZEOF(_ar)
Definition: calc.h:97
__kernel_size_t size_t
Definition: linux.h:237
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:80
Definition: mem.c:156
unsigned int JDIMENSION
Definition: jmorecfg.h:229
#define MAX_ALLOC_CHUNK
Definition: jmemsys.h:78
GLuint64EXT * result
Definition: glext.h:11304

Referenced by jinit_memory_mgr(), and realize_virt_arrays().

◆ alloc_large()

alloc_large ( j_common_ptr  cinfo,
int  pool_id,
size_t  sizeofobject 
)

Definition at line 343 of file jmemmgr.c.

345 {
346  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
347  large_pool_ptr hdr_ptr;
348  size_t odd_bytes;
349 
350  /* Check for unsatisfiable request (do now to ensure no overflow below) */
352  out_of_memory(cinfo, 3); /* request exceeds malloc's ability */
353 
354  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
355  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
356  if (odd_bytes > 0)
357  sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
358 
359  /* Always make a new pool */
360  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
361  ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
362 
363  hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject +
365  if (hdr_ptr == NULL)
366  out_of_memory(cinfo, 4); /* jpeg_get_large failed */
367  mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr);
368 
369  /* Success, initialize the new pool header and add to list */
370  hdr_ptr->hdr.next = mem->large_list[pool_id];
371  /* We maintain space counts in each pool header for statistical purposes,
372  * even though they are not needed for allocation.
373  */
374  hdr_ptr->hdr.bytes_used = sizeofobject;
375  hdr_ptr->hdr.bytes_left = 0;
376  mem->large_list[pool_id] = hdr_ptr;
377 
378  return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */
379 }
jpeg_get_large(j_common_ptr cinfo, size_t sizeofobject)
Definition: jmemansi.c:56
out_of_memory(j_common_ptr cinfo, int which)
Definition: jmemmgr.c:218
my_memory_mgr * my_mem_ptr
Definition: jmemmgr.c:141
#define ALIGN_TYPE
Definition: jmemmgr.c:74
size_t sizeofobject
Definition: jmemsys.h:47
#define SIZEOF(_ar)
Definition: calc.h:97
union large_pool_struct FAR * large_pool_ptr
Definition: jmemmgr.c:101
smooth NULL
Definition: ftsmooth.c:416
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
#define JPOOL_NUMPOOLS
Definition: jpeglib.h:809
Definition: mem.c:156
#define MAX_ALLOC_CHUNK
Definition: jmemsys.h:78
#define FAR
Definition: zlib.h:34

Referenced by alloc_barray(), alloc_sarray(), and jinit_memory_mgr().

◆ alloc_sarray()

alloc_sarray ( j_common_ptr  cinfo,
int  pool_id,
JDIMENSION  samplesperrow,
JDIMENSION  numrows 
)

Definition at line 396 of file jmemmgr.c.

399 {
400  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
402  JSAMPROW workspace;
403  JDIMENSION rowsperchunk, currow, i;
404  long ltemp;
405 
406  /* Calculate max # of rows allowed in one allocation chunk */
407  ltemp = (MAX_ALLOC_CHUNK - SIZEOF(large_pool_hdr)) /
408  ((long) samplesperrow * SIZEOF(JSAMPLE));
409  if (ltemp <= 0)
410  ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
411  if (ltemp < (long) numrows)
412  rowsperchunk = (JDIMENSION) ltemp;
413  else
414  rowsperchunk = numrows;
415  mem->last_rowsperchunk = rowsperchunk;
416 
417  /* Get space for row pointers (small object) */
418  result = (JSAMPARRAY) alloc_small(cinfo, pool_id,
419  (size_t) numrows * SIZEOF(JSAMPROW));
420 
421  /* Get the rows themselves (large objects) */
422  currow = 0;
423  while (currow < numrows) {
424  rowsperchunk = MIN(rowsperchunk, numrows - currow);
425  workspace = (JSAMPROW) alloc_large(cinfo, pool_id,
426  (size_t) rowsperchunk * (size_t) samplesperrow * SIZEOF(JSAMPLE));
427  for (i = rowsperchunk; i > 0; i--) {
428  result[currow++] = workspace;
429  workspace += samplesperrow;
430  }
431  }
432 
433  return result;
434 }
char JSAMPLE
Definition: jmorecfg.h:74
JSAMPLE FAR * JSAMPROW
Definition: jpeglib.h:75
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
alloc_small(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
Definition: jmemmgr.c:258
my_memory_mgr * my_mem_ptr
Definition: jmemmgr.c:141
alloc_large(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
Definition: jmemmgr.c:343
T MIN(T a, T b)
Definition: polytest.cpp:79
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SIZEOF(_ar)
Definition: calc.h:97
__kernel_size_t size_t
Definition: linux.h:237
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:76
Definition: mem.c:156
unsigned int JDIMENSION
Definition: jmorecfg.h:229
#define MAX_ALLOC_CHUNK
Definition: jmemsys.h:78
GLuint64EXT * result
Definition: glext.h:11304

Referenced by jinit_memory_mgr(), and realize_virt_arrays().

◆ alloc_small()

alloc_small ( j_common_ptr  cinfo,
int  pool_id,
size_t  sizeofobject 
)

Definition at line 258 of file jmemmgr.c.

260 {
261  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
262  small_pool_ptr hdr_ptr, prev_hdr_ptr;
263  size_t odd_bytes, min_request, slop;
264  char * data_ptr;
265 
266  /* Check for unsatisfiable request (do now to ensure no overflow below) */
268  out_of_memory(cinfo, 1); /* request exceeds malloc's ability */
269 
270  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
271  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
272  if (odd_bytes > 0)
273  sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
274 
275  /* See if space is available in any existing pool */
276  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
277  ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
278  prev_hdr_ptr = NULL;
279  hdr_ptr = mem->small_list[pool_id];
280  while (hdr_ptr != NULL) {
281  if (hdr_ptr->hdr.bytes_left >= sizeofobject)
282  break; /* found pool with enough space */
283  prev_hdr_ptr = hdr_ptr;
284  hdr_ptr = hdr_ptr->hdr.next;
285  }
286 
287  /* Time to make a new pool? */
288  if (hdr_ptr == NULL) {
289  /* min_request is what we need now, slop is what will be leftover */
290  min_request = sizeofobject + SIZEOF(small_pool_hdr);
291  if (prev_hdr_ptr == NULL) /* first pool in class? */
292  slop = first_pool_slop[pool_id];
293  else
294  slop = extra_pool_slop[pool_id];
295  /* Don't ask for more than MAX_ALLOC_CHUNK */
296  if (slop > (size_t) MAX_ALLOC_CHUNK - min_request)
297  slop = (size_t) MAX_ALLOC_CHUNK - min_request;
298  /* Try to get space, if fail reduce slop and try again */
299  for (;;) {
300  hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop);
301  if (hdr_ptr != NULL)
302  break;
303  slop /= 2;
304  if (slop < MIN_SLOP) /* give up when it gets real small */
305  out_of_memory(cinfo, 2); /* jpeg_get_small failed */
306  }
307  mem->total_space_allocated += min_request + slop;
308  /* Success, initialize the new pool header and add to end of list */
309  hdr_ptr->hdr.next = NULL;
310  hdr_ptr->hdr.bytes_used = 0;
311  hdr_ptr->hdr.bytes_left = sizeofobject + slop;
312  if (prev_hdr_ptr == NULL) /* first pool in class? */
313  mem->small_list[pool_id] = hdr_ptr;
314  else
315  prev_hdr_ptr->hdr.next = hdr_ptr;
316  }
317 
318  /* OK, allocate the object from the current pool */
319  data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */
320  data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */
321  hdr_ptr->hdr.bytes_used += sizeofobject;
322  hdr_ptr->hdr.bytes_left -= sizeofobject;
323 
324  return (void *) data_ptr;
325 }
jpeg_get_small(j_common_ptr cinfo, size_t sizeofobject)
Definition: jmemansi.c:36
out_of_memory(j_common_ptr cinfo, int which)
Definition: jmemmgr.c:218
my_memory_mgr * my_mem_ptr
Definition: jmemmgr.c:141
#define ALIGN_TYPE
Definition: jmemmgr.c:74
size_t sizeofobject
Definition: jmemsys.h:47
#define SIZEOF(_ar)
Definition: calc.h:97
smooth NULL
Definition: ftsmooth.c:416
union small_pool_struct * small_pool_ptr
Definition: jmemmgr.c:90
__kernel_size_t size_t
Definition: linux.h:237
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
static const size_t first_pool_slop[JPOOL_NUMPOOLS]
Definition: jmemmgr.c:242
#define JPOOL_NUMPOOLS
Definition: jpeglib.h:809
struct small_pool_struct::@172 hdr
static const size_t extra_pool_slop[JPOOL_NUMPOOLS]
Definition: jmemmgr.c:248
Definition: mem.c:156
#define MAX_ALLOC_CHUNK
Definition: jmemsys.h:78
#define MIN_SLOP
Definition: jmemmgr.c:254

Referenced by alloc_barray(), alloc_sarray(), jinit_memory_mgr(), request_virt_barray(), and request_virt_sarray().

◆ do_barray_io()

do_barray_io ( j_common_ptr  cinfo,
jvirt_barray_ptr  ptr,
boolean  writing 
)

Definition at line 720 of file jmemmgr.c.

722 {
723  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
724 
725  bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK);
726  file_offset = (long) ptr->cur_start_row * bytesperrow;
727  /* Loop to read or write each allocation chunk in mem_buffer */
728  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
729  /* One chunk, but check for short chunk at end of buffer */
730  rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
731  /* Transfer no more than is currently defined */
732  thisrow = (long) ptr->cur_start_row + i;
733  rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
734  /* Transfer no more than fits in file */
735  rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
736  if (rows <= 0) /* this chunk might be past end of file! */
737  break;
738  byte_count = rows * bytesperrow;
739  if (writing)
740  (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
741  (void FAR *) ptr->mem_buffer[i],
742  file_offset, byte_count);
743  else
744  (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
745  (void FAR *) ptr->mem_buffer[i],
746  file_offset, byte_count);
747  file_offset += byte_count;
748  }
749 }
JCOEF JBLOCK[DCTSIZE2]
Definition: jpeglib.h:79
T MIN(T a, T b)
Definition: polytest.cpp:79
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SIZEOF(_ar)
Definition: calc.h:97
static PVOID ptr
Definition: dispmode.c:27
#define for
Definition: utility.h:88
#define long
Definition: qsort.c:33
#define FAR
Definition: zlib.h:34

Referenced by access_virt_barray().

◆ do_sarray_io()

do_sarray_io ( j_common_ptr  cinfo,
jvirt_sarray_ptr  ptr,
boolean  writing 
)

Definition at line 687 of file jmemmgr.c.

689 {
690  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
691 
692  bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE);
693  file_offset = (long) ptr->cur_start_row * bytesperrow;
694  /* Loop to read or write each allocation chunk in mem_buffer */
695  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
696  /* One chunk, but check for short chunk at end of buffer */
697  rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
698  /* Transfer no more than is currently defined */
699  thisrow = (long) ptr->cur_start_row + i;
700  rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
701  /* Transfer no more than fits in file */
702  rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
703  if (rows <= 0) /* this chunk might be past end of file! */
704  break;
705  byte_count = rows * bytesperrow;
706  if (writing)
707  (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
708  (void FAR *) ptr->mem_buffer[i],
709  file_offset, byte_count);
710  else
711  (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
712  (void FAR *) ptr->mem_buffer[i],
713  file_offset, byte_count);
714  file_offset += byte_count;
715  }
716 }
char JSAMPLE
Definition: jmorecfg.h:74
T MIN(T a, T b)
Definition: polytest.cpp:79
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SIZEOF(_ar)
Definition: calc.h:97
static PVOID ptr
Definition: dispmode.c:27
#define for
Definition: utility.h:88
#define long
Definition: qsort.c:33
#define FAR
Definition: zlib.h:34

Referenced by access_virt_sarray().

◆ free_pool()

free_pool ( j_common_ptr  cinfo,
int  pool_id 
)

Definition at line 927 of file jmemmgr.c.

928 {
929  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
930  small_pool_ptr shdr_ptr;
931  large_pool_ptr lhdr_ptr;
932  size_t space_freed;
933 
934  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
935  ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
936 
937 #ifdef MEM_STATS
938  if (cinfo->err->trace_level > 1)
939  print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */
940 #endif
941 
942  /* If freeing IMAGE pool, close any virtual arrays first */
943  if (pool_id == JPOOL_IMAGE) {
944  jvirt_sarray_ptr sptr;
945  jvirt_barray_ptr bptr;
946 
947  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
948  if (sptr->b_s_open) { /* there may be no backing store */
949  sptr->b_s_open = FALSE; /* prevent recursive close if error */
950  (*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info);
951  }
952  }
953  mem->virt_sarray_list = NULL;
954  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
955  if (bptr->b_s_open) { /* there may be no backing store */
956  bptr->b_s_open = FALSE; /* prevent recursive close if error */
957  (*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info);
958  }
959  }
960  mem->virt_barray_list = NULL;
961  }
962 
963  /* Release large objects */
964  lhdr_ptr = mem->large_list[pool_id];
965  mem->large_list[pool_id] = NULL;
966 
967  while (lhdr_ptr != NULL) {
968  large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next;
969  space_freed = lhdr_ptr->hdr.bytes_used +
970  lhdr_ptr->hdr.bytes_left +
972  jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed);
973  mem->total_space_allocated -= space_freed;
974  lhdr_ptr = next_lhdr_ptr;
975  }
976 
977  /* Release small objects */
978  shdr_ptr = mem->small_list[pool_id];
979  mem->small_list[pool_id] = NULL;
980 
981  while (shdr_ptr != NULL) {
982  small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next;
983  space_freed = shdr_ptr->hdr.bytes_used +
984  shdr_ptr->hdr.bytes_left +
986  jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed);
987  mem->total_space_allocated -= space_freed;
988  shdr_ptr = next_shdr_ptr;
989  }
990 }
my_memory_mgr * my_mem_ptr
Definition: jmemmgr.c:141
jvirt_sarray_ptr next
Definition: jmemmgr.c:163
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define FALSE
Definition: types.h:117
union large_pool_struct FAR * large_pool_ptr
Definition: jmemmgr.c:101
smooth NULL
Definition: ftsmooth.c:416
jvirt_barray_ptr next
Definition: jmemmgr.c:179
jpeg_free_large(j_common_ptr cinfo, void FAR *object, size_t sizeofobject)
Definition: jmemansi.c:62
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
#define JPOOL_NUMPOOLS
Definition: jpeglib.h:809
backing_store_info b_s_info
Definition: jmemmgr.c:180
struct small_pool_struct::@172 hdr
jpeg_free_small(j_common_ptr cinfo, void *object, size_t sizeofobject)
Definition: jmemansi.c:42
backing_store_info b_s_info
Definition: jmemmgr.c:164
Definition: mem.c:156
#define FAR
Definition: zlib.h:34

Referenced by jinit_memory_mgr(), and self_destruct().

◆ jinit_memory_mgr()

jinit_memory_mgr ( j_common_ptr  cinfo)

Definition at line 1025 of file jmemmgr.c.

1026 {
1027  my_mem_ptr mem;
1028  long max_to_use;
1029  int pool;
1030  size_t test_mac;
1031 
1032  cinfo->mem = NULL; /* for safety if init fails */
1033 
1034  /* Check for configuration errors.
1035  * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably
1036  * doesn't reflect any real hardware alignment requirement.
1037  * The test is a little tricky: for X>0, X and X-1 have no one-bits
1038  * in common if and only if X is a power of 2, ie has only one one-bit.
1039  * Some compilers may give an "unreachable code" warning here; ignore it.
1040  */
1041  if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0)
1042  ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE);
1043  /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be
1044  * a multiple of SIZEOF(ALIGN_TYPE).
1045  * Again, an "unreachable code" warning may be ignored here.
1046  * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK.
1047  */
1049  if ((long) test_mac != MAX_ALLOC_CHUNK ||
1050  (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0)
1051  ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
1052 
1053  max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */
1054 
1055  /* Attempt to allocate memory manager's control block */
1057 
1058  if (mem == NULL) {
1059  jpeg_mem_term(cinfo); /* system-dependent cleanup */
1060  ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0);
1061  }
1062 
1063  /* OK, fill in the method pointers */
1064  mem->pub.alloc_small = alloc_small;
1065  mem->pub.alloc_large = alloc_large;
1066  mem->pub.alloc_sarray = alloc_sarray;
1067  mem->pub.alloc_barray = alloc_barray;
1068  mem->pub.request_virt_sarray = request_virt_sarray;
1069  mem->pub.request_virt_barray = request_virt_barray;
1070  mem->pub.realize_virt_arrays = realize_virt_arrays;
1071  mem->pub.access_virt_sarray = access_virt_sarray;
1072  mem->pub.access_virt_barray = access_virt_barray;
1073  mem->pub.free_pool = free_pool;
1074  mem->pub.self_destruct = self_destruct;
1075 
1076  /* Make MAX_ALLOC_CHUNK accessible to other modules */
1077  mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK;
1078 
1079  /* Initialize working state */
1080  mem->pub.max_memory_to_use = max_to_use;
1081 
1082  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
1083  mem->small_list[pool] = NULL;
1084  mem->large_list[pool] = NULL;
1085  }
1086  mem->virt_sarray_list = NULL;
1087  mem->virt_barray_list = NULL;
1088 
1089  mem->total_space_allocated = SIZEOF(my_memory_mgr);
1090 
1091  /* Declare ourselves open for business */
1092  cinfo->mem = &mem->pub;
1093 
1094  /* Check for an environment variable JPEGMEM; if found, override the
1095  * default max_memory setting from jpeg_mem_init. Note that the
1096  * surrounding application may again override this value.
1097  * If your system doesn't support getenv(), define NO_GETENV to disable
1098  * this feature.
1099  */
1100 #ifndef NO_GETENV
1101  { char * memenv;
1102 
1103  if ((memenv = getenv("JPEGMEM")) != NULL) {
1104  char ch = 'x';
1105 
1106  if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) {
1107  if (ch == 'm' || ch == 'M')
1108  max_to_use *= 1000L;
1109  mem->pub.max_memory_to_use = max_to_use * 1000L;
1110  }
1111  }
1112  }
1113 #endif
1114 
1115 }
request_virt_barray(j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION blocksperrow, JDIMENSION numrows, JDIMENSION maxaccess)
Definition: jmemmgr.c:552
jpeg_get_small(j_common_ptr cinfo, size_t sizeofobject)
Definition: jmemansi.c:36
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
alloc_small(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
Definition: jmemmgr.c:258
alloc_sarray(j_common_ptr cinfo, int pool_id, JDIMENSION samplesperrow, JDIMENSION numrows)
Definition: jmemmgr.c:396
jpeg_mem_term(j_common_ptr cinfo)
Definition: jmemansi.c:164
my_memory_mgr * my_mem_ptr
Definition: jmemmgr.c:141
alloc_large(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
Definition: jmemmgr.c:343
free_pool(j_common_ptr cinfo, int pool_id)
Definition: jmemmgr.c:927
#define ALIGN_TYPE
Definition: jmemmgr.c:74
self_destruct(j_common_ptr cinfo)
Definition: jmemmgr.c:999
#define SIZEOF(_ar)
Definition: calc.h:97
smooth NULL
Definition: ftsmooth.c:416
_Check_return_ _CRTIMP int __cdecl sscanf(_In_z_ const char *_Src, _In_z_ _Scanf_format_string_ const char *_Format,...)
__kernel_size_t size_t
Definition: linux.h:237
access_virt_sarray(j_common_ptr cinfo, jvirt_sarray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable)
Definition: jmemmgr.c:753
static const WCHAR L[]
Definition: oid.c:1250
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
#define JPOOL_NUMPOOLS
Definition: jpeglib.h:809
_Check_return_ char *__cdecl getenv(_In_z_ const char *_VarName)
jpeg_mem_init(j_common_ptr cinfo)
Definition: jmemansi.c:158
realize_virt_arrays(j_common_ptr cinfo)
Definition: jmemmgr.c:582
alloc_barray(j_common_ptr cinfo, int pool_id, JDIMENSION blocksperrow, JDIMENSION numrows)
Definition: jmemmgr.c:443
Definition: mem.c:156
request_virt_sarray(j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION samplesperrow, JDIMENSION numrows, JDIMENSION maxaccess)
Definition: jmemmgr.c:522
#define JPOOL_PERMANENT
Definition: jpeglib.h:807
#define MAX_ALLOC_CHUNK
Definition: jmemsys.h:78
static void test_mac(void)
Definition: rsaenh.c:1849
access_virt_barray(j_common_ptr cinfo, jvirt_barray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable)
Definition: jmemmgr.c:838

Referenced by jpeg_CreateCompress(), and jpeg_CreateDecompress().

◆ JPP()

char* getenv JPP ( (const char *name )

◆ out_of_memory()

out_of_memory ( j_common_ptr  cinfo,
int  which 
)

Definition at line 218 of file jmemmgr.c.

221 {
222 #ifdef MEM_STATS
223  cinfo->err->trace_level = 2; /* force self_destruct to report stats */
224 #endif
225  ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);
226 }
static GLenum which
Definition: wgl_font.c:159
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212

Referenced by alloc_large(), alloc_proxy_textures(), and alloc_small().

◆ realize_virt_arrays()

realize_virt_arrays ( j_common_ptr  cinfo)

Definition at line 582 of file jmemmgr.c.

584 {
585  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
586  long bytesperrow, space_per_minheight, maximum_space;
587  long avail_mem, minheights, max_minheights;
588  jvirt_sarray_ptr sptr;
589  jvirt_barray_ptr bptr;
590 
591  /* Compute the minimum space needed (maxaccess rows in each buffer)
592  * and the maximum space needed (full image height in each buffer).
593  * These may be of use to the system-dependent jpeg_mem_available routine.
594  */
595  space_per_minheight = 0;
596  maximum_space = 0;
597  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
598  if (sptr->mem_buffer == NULL) { /* if not realized yet */
599  bytesperrow = (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
600  space_per_minheight += (long) sptr->maxaccess * bytesperrow;
601  maximum_space += (long) sptr->rows_in_array * bytesperrow;
602  }
603  }
604  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
605  if (bptr->mem_buffer == NULL) { /* if not realized yet */
606  bytesperrow = (long) bptr->blocksperrow * SIZEOF(JBLOCK);
607  space_per_minheight += (long) bptr->maxaccess * bytesperrow;
608  maximum_space += (long) bptr->rows_in_array * bytesperrow;
609  }
610  }
611 
612  if (space_per_minheight <= 0)
613  return; /* no unrealized arrays, no work */
614 
615  /* Determine amount of memory to actually use; this is system-dependent. */
616  avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,
617  (long) mem->total_space_allocated);
618 
619  /* If the maximum space needed is available, make all the buffers full
620  * height; otherwise parcel it out with the same number of minheights
621  * in each buffer.
622  */
623  if (avail_mem >= maximum_space)
624  max_minheights = 1000000000L;
625  else {
626  max_minheights = avail_mem / space_per_minheight;
627  /* If there doesn't seem to be enough space, try to get the minimum
628  * anyway. This allows a "stub" implementation of jpeg_mem_available().
629  */
630  if (max_minheights <= 0)
631  max_minheights = 1;
632  }
633 
634  /* Allocate the in-memory buffers and initialize backing store as needed. */
635 
636  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
637  if (sptr->mem_buffer == NULL) { /* if not realized yet */
638  minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L;
639  if (minheights <= max_minheights) {
640  /* This buffer fits in memory */
641  sptr->rows_in_mem = sptr->rows_in_array;
642  } else {
643  /* It doesn't fit in memory, create backing store. */
644  sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess);
645  jpeg_open_backing_store(cinfo, & sptr->b_s_info,
646  (long) sptr->rows_in_array *
647  (long) sptr->samplesperrow *
648  (long) SIZEOF(JSAMPLE));
649  sptr->b_s_open = TRUE;
650  }
651  sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE,
652  sptr->samplesperrow, sptr->rows_in_mem);
653  sptr->rowsperchunk = mem->last_rowsperchunk;
654  sptr->cur_start_row = 0;
655  sptr->first_undef_row = 0;
656  sptr->dirty = FALSE;
657  }
658  }
659 
660  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
661  if (bptr->mem_buffer == NULL) { /* if not realized yet */
662  minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L;
663  if (minheights <= max_minheights) {
664  /* This buffer fits in memory */
665  bptr->rows_in_mem = bptr->rows_in_array;
666  } else {
667  /* It doesn't fit in memory, create backing store. */
668  bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess);
669  jpeg_open_backing_store(cinfo, & bptr->b_s_info,
670  (long) bptr->rows_in_array *
671  (long) bptr->blocksperrow *
672  (long) SIZEOF(JBLOCK));
673  bptr->b_s_open = TRUE;
674  }
675  bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE,
676  bptr->blocksperrow, bptr->rows_in_mem);
677  bptr->rowsperchunk = mem->last_rowsperchunk;
678  bptr->cur_start_row = 0;
679  bptr->first_undef_row = 0;
680  bptr->dirty = FALSE;
681  }
682  }
683 }
char JSAMPLE
Definition: jmorecfg.h:74
alloc_sarray(j_common_ptr cinfo, int pool_id, JDIMENSION samplesperrow, JDIMENSION numrows)
Definition: jmemmgr.c:396
#define TRUE
Definition: types.h:120
JCOEF JBLOCK[DCTSIZE2]
Definition: jpeglib.h:79
my_memory_mgr * my_mem_ptr
Definition: jmemmgr.c:141
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define FALSE
Definition: types.h:117
smooth NULL
Definition: ftsmooth.c:416
jpeg_open_backing_store(j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed)
Definition: jmemansi.c:141
#define for
Definition: utility.h:88
static const WCHAR L[]
Definition: oid.c:1250
jpeg_mem_available(j_common_ptr cinfo, long min_bytes_needed, long max_bytes_needed, long already_allocated)
Definition: jmemansi.c:81
#define long
Definition: qsort.c:33
alloc_barray(j_common_ptr cinfo, int pool_id, JDIMENSION blocksperrow, JDIMENSION numrows)
Definition: jmemmgr.c:443
Definition: mem.c:156
unsigned int JDIMENSION
Definition: jmorecfg.h:229

Referenced by jinit_memory_mgr().

◆ request_virt_barray()

request_virt_barray ( j_common_ptr  cinfo,
int  pool_id,
boolean  pre_zero,
JDIMENSION  blocksperrow,
JDIMENSION  numrows,
JDIMENSION  maxaccess 
)

Definition at line 552 of file jmemmgr.c.

556 {
557  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
559 
560  /* Only IMAGE-lifetime virtual arrays are currently supported */
561  if (pool_id != JPOOL_IMAGE)
562  ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
563 
564  /* get control block */
565  result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id,
566  SIZEOF(struct jvirt_barray_control));
567 
568  result->mem_buffer = NULL; /* marks array not yet realized */
569  result->rows_in_array = numrows;
570  result->blocksperrow = blocksperrow;
571  result->maxaccess = maxaccess;
572  result->pre_zero = pre_zero;
573  result->b_s_open = FALSE; /* no associated backing-store object */
574  result->next = mem->virt_barray_list; /* add to list of virtual arrays */
575  mem->virt_barray_list = result;
576 
577  return result;
578 }
alloc_small(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
Definition: jmemmgr.c:258
my_memory_mgr * my_mem_ptr
Definition: jmemmgr.c:141
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define FALSE
Definition: types.h:117
smooth NULL
Definition: ftsmooth.c:416
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
struct jvirt_barray_control * jvirt_barray_ptr
Definition: jpeglib.h:812
struct define * next
Definition: compiler.c:65
Definition: mem.c:156
GLuint64EXT * result
Definition: glext.h:11304

Referenced by jinit_memory_mgr().

◆ request_virt_sarray()

request_virt_sarray ( j_common_ptr  cinfo,
int  pool_id,
boolean  pre_zero,
JDIMENSION  samplesperrow,
JDIMENSION  numrows,
JDIMENSION  maxaccess 
)

Definition at line 522 of file jmemmgr.c.

526 {
527  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
529 
530  /* Only IMAGE-lifetime virtual arrays are currently supported */
531  if (pool_id != JPOOL_IMAGE)
532  ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
533 
534  /* get control block */
535  result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id,
536  SIZEOF(struct jvirt_sarray_control));
537 
538  result->mem_buffer = NULL; /* marks array not yet realized */
539  result->rows_in_array = numrows;
540  result->samplesperrow = samplesperrow;
541  result->maxaccess = maxaccess;
542  result->pre_zero = pre_zero;
543  result->b_s_open = FALSE; /* no associated backing-store object */
544  result->next = mem->virt_sarray_list; /* add to list of virtual arrays */
545  mem->virt_sarray_list = result;
546 
547  return result;
548 }
alloc_small(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
Definition: jmemmgr.c:258
my_memory_mgr * my_mem_ptr
Definition: jmemmgr.c:141
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define FALSE
Definition: types.h:117
smooth NULL
Definition: ftsmooth.c:416
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
struct define * next
Definition: compiler.c:65
Definition: mem.c:156
GLuint64EXT * result
Definition: glext.h:11304
struct jvirt_sarray_control * jvirt_sarray_ptr
Definition: jpeglib.h:811

Referenced by jinit_memory_mgr().

◆ self_destruct()

self_destruct ( j_common_ptr  cinfo)

Definition at line 999 of file jmemmgr.c.

1000 {
1001  int pool;
1002 
1003  /* Close all backing store, release all memory.
1004  * Releasing pools in reverse order might help avoid fragmentation
1005  * with some (brain-damaged) malloc libraries.
1006  */
1007  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
1008  free_pool(cinfo, pool);
1009  }
1010 
1011  /* Release the memory manager control block too. */
1012  jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr));
1013  cinfo->mem = NULL; /* ensures I will be called only once */
1014 
1015  jpeg_mem_term(cinfo); /* system-dependent cleanup */
1016 }
jpeg_mem_term(j_common_ptr cinfo)
Definition: jmemansi.c:164
free_pool(j_common_ptr cinfo, int pool_id)
Definition: jmemmgr.c:927
#define SIZEOF(_ar)
Definition: calc.h:97
smooth NULL
Definition: ftsmooth.c:416
#define JPOOL_NUMPOOLS
Definition: jpeglib.h:809
jpeg_free_small(j_common_ptr cinfo, void *object, size_t sizeofobject)
Definition: jmemansi.c:42
#define JPOOL_PERMANENT
Definition: jpeglib.h:807

Referenced by jinit_memory_mgr().

Variable Documentation

◆ extra_pool_slop

const size_t extra_pool_slop[JPOOL_NUMPOOLS]
static
Initial value:
=
{
0,
5000
}

Definition at line 248 of file jmemmgr.c.

Referenced by alloc_small().

◆ first_pool_slop

const size_t first_pool_slop[JPOOL_NUMPOOLS]
static
Initial value:
=
{
1600,
16000
}

Definition at line 242 of file jmemmgr.c.

Referenced by alloc_small().