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

Go to the source code of this file.

Macros

#define JPEG_INTERNALS
 

Functions

 jpeg_abort (j_common_ptr cinfo)
 
 jpeg_destroy (j_common_ptr cinfo)
 
 jpeg_alloc_quant_table (j_common_ptr cinfo)
 
 jpeg_alloc_huff_table (j_common_ptr cinfo)
 
 jpeg_std_huff_table (j_common_ptr cinfo, boolean isDC, int tblno)
 

Macro Definition Documentation

◆ JPEG_INTERNALS

#define JPEG_INTERNALS

Definition at line 13 of file jcomapi.c.

Function Documentation

◆ jpeg_abort()

jpeg_abort ( j_common_ptr  cinfo)

Definition at line 30 of file jcomapi.c.

31 {
32  int pool;
33 
34  /* Do nothing if called on a not-initialized or destroyed JPEG object. */
35  if (cinfo->mem == NULL)
36  return;
37 
38  /* Releasing pools in reverse order might help avoid fragmentation
39  * with some (brain-damaged) malloc libraries.
40  */
41  for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
42  (*cinfo->mem->free_pool) (cinfo, pool);
43  }
44 
45  /* Reset overall state for possible reuse of object */
46  if (cinfo->is_decompressor) {
47  cinfo->global_state = DSTATE_START;
48  /* Try to keep application from accessing now-deleted marker list.
49  * A bit kludgy to do it here, but this is the most central place.
50  */
51  ((j_decompress_ptr) cinfo)->marker_list = NULL;
52  } else {
53  cinfo->global_state = CSTATE_START;
54  }
55 }
struct jpeg_decompress_struct * j_decompress_ptr
Definition: jpeglib.h:286
#define CSTATE_START
Definition: jpegint.h:26
smooth NULL
Definition: ftsmooth.c:416
#define DSTATE_START
Definition: jpegint.h:30
#define JPOOL_NUMPOOLS
Definition: jpeglib.h:809
#define JPOOL_PERMANENT
Definition: jpeglib.h:807

Referenced by jpeg_abort_compress(), jpeg_abort_decompress(), jpeg_finish_compress(), jpeg_finish_decompress(), and jpeg_read_header().

◆ jpeg_alloc_huff_table()

jpeg_alloc_huff_table ( j_common_ptr  cinfo)

Definition at line 99 of file jcomapi.c.

100 {
101  JHUFF_TBL *tbl;
102 
103  tbl = (JHUFF_TBL *)
104  (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL));
105  tbl->sent_table = FALSE; /* make sure this is false in any new table */
106  return tbl;
107 }
boolean sent_table
Definition: jpeglib.h:119
#define SIZEOF(_ar)
Definition: calc.h:97
#define FALSE
Definition: types.h:117
#define JPOOL_PERMANENT
Definition: jpeglib.h:807

Referenced by finish_pass_gather(), get_dht(), and jpeg_std_huff_table().

◆ jpeg_alloc_quant_table()

jpeg_alloc_quant_table ( j_common_ptr  cinfo)

Definition at line 87 of file jcomapi.c.

88 {
89  JQUANT_TBL *tbl;
90 
91  tbl = (JQUANT_TBL *)
92  (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL));
93  tbl->sent_table = FALSE; /* make sure this is false in any new table */
94  return tbl;
95 }
#define SIZEOF(_ar)
Definition: calc.h:97
#define FALSE
Definition: types.h:117
boolean sent_table
Definition: jpeglib.h:103
#define JPOOL_PERMANENT
Definition: jpeglib.h:807

Referenced by get_dqt(), jpeg_add_quant_table(), and jpeg_copy_critical_parameters().

◆ jpeg_destroy()

jpeg_destroy ( j_common_ptr  cinfo)

Definition at line 70 of file jcomapi.c.

71 {
72  /* We need only tell the memory manager to release everything. */
73  /* NB: mem pointer is NULL if memory mgr failed to initialize. */
74  if (cinfo->mem != NULL)
75  (*cinfo->mem->self_destruct) (cinfo);
76  cinfo->mem = NULL; /* be safe if jpeg_destroy is called twice */
77  cinfo->global_state = 0; /* mark it destroyed */
78 }
smooth NULL
Definition: ftsmooth.c:416

Referenced by error_exit(), jpeg_destroy_compress(), and jpeg_destroy_decompress().

◆ jpeg_std_huff_table()

jpeg_std_huff_table ( j_common_ptr  cinfo,
boolean  isDC,
int  tblno 
)

Definition at line 117 of file jcomapi.c.

118 {
119  JHUFF_TBL **htblptr, *htbl;
120  const UINT8 *bits, *val;
121  int nsymbols, len;
122 
123  static const UINT8 bits_dc_luminance[17] =
124  { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
125  static const UINT8 val_dc_luminance[] =
126  { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
127 
128  static const UINT8 bits_dc_chrominance[17] =
129  { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
130  static const UINT8 val_dc_chrominance[] =
131  { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
132 
133  static const UINT8 bits_ac_luminance[17] =
134  { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
135  static const UINT8 val_ac_luminance[] =
136  { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
137  0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
138  0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
139  0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
140  0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
141  0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
142  0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
143  0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
144  0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
145  0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
146  0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
147  0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
148  0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
149  0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
150  0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
151  0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
152  0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
153  0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
154  0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
155  0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
156  0xf9, 0xfa };
157 
158  static const UINT8 bits_ac_chrominance[17] =
159  { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
160  static const UINT8 val_ac_chrominance[] =
161  { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
162  0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
163  0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
164  0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
165  0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
166  0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
167  0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
168  0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
169  0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
170  0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
171  0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
172  0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
173  0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
174  0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
175  0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
176  0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
177  0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
178  0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
179  0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
180  0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
181  0xf9, 0xfa };
182 
183  if (cinfo->is_decompressor) {
184  if (isDC)
185  htblptr = ((j_decompress_ptr) cinfo)->dc_huff_tbl_ptrs;
186  else
187  htblptr = ((j_decompress_ptr) cinfo)->ac_huff_tbl_ptrs;
188  } else {
189  if (isDC)
190  htblptr = ((j_compress_ptr) cinfo)->dc_huff_tbl_ptrs;
191  else
192  htblptr = ((j_compress_ptr) cinfo)->ac_huff_tbl_ptrs;
193  }
194 
195  switch (tblno) {
196  case 0:
197  if (isDC) {
198  bits = bits_dc_luminance;
199  val = val_dc_luminance;
200  } else {
201  bits = bits_ac_luminance;
202  val = val_ac_luminance;
203  }
204  break;
205  case 1:
206  if (isDC) {
207  bits = bits_dc_chrominance;
208  val = val_dc_chrominance;
209  } else {
210  bits = bits_ac_chrominance;
211  val = val_ac_chrominance;
212  }
213  break;
214  default:
215  ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
216  return NULL; /* avoid compiler warnings for uninitialized variables */
217  }
218 
219  if (htblptr[tblno] == NULL)
220  htblptr[tblno] = jpeg_alloc_huff_table(cinfo);
221 
222  htbl = htblptr[tblno];
223 
224  /* Copy the number-of-symbols-of-each-code-length counts */
225  MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
226 
227  /* Validate the counts. We do this here mainly so we can copy the right
228  * number of symbols from the val[] array, without risking marching off
229  * the end of memory. jxhuff.c will do a more thorough test later.
230  */
231  nsymbols = 0;
232  for (len = 1; len <= 16; len++)
233  nsymbols += bits[len];
234  if (nsymbols > 256)
235  ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
236 
237  if (nsymbols > 0)
238  MEMCOPY(htbl->huffval, val, nsymbols * SIZEOF(UINT8));
239 
240  /* Initialize sent_table FALSE so table will be written to JPEG file. */
241  htbl->sent_table = FALSE;
242 
243  return htbl;
244 }
struct jpeg_decompress_struct * j_decompress_ptr
Definition: jpeglib.h:286
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
UINT8 huffval[256]
Definition: jpeglib.h:113
boolean int tblno
Definition: jpeglib.h:1010
boolean sent_table
Definition: jpeglib.h:119
jpeg_alloc_huff_table(j_common_ptr cinfo)
Definition: jcomapi.c:99
struct jpeg_compress_struct * j_compress_ptr
Definition: jpeglib.h:285
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
UINT8 bits[17]
Definition: jpeglib.h:111
#define SIZEOF(_ar)
Definition: calc.h:97
#define FALSE
Definition: types.h:117
smooth NULL
Definition: ftsmooth.c:416
#define MEMCOPY(dest, src, size)
Definition: jinclude.h:69
GLuint GLfloat * val
Definition: glext.h:7180
boolean isDC
Definition: jpeglib.h:1010
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
GLenum GLsizei len
Definition: glext.h:6722
unsigned char UINT8

Referenced by jpeg_make_c_derived_tbl(), jpeg_make_d_derived_tbl(), and std_huff_tables().