w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

jccoefct.c
Go to the documentation of this file.
1 /*
2  * jccoefct.c
3  *
4  * Copyright (C) 1994-1997, Thomas G. Lane.
5  * This file is part of the Independent JPEG Group's software.
6  * For conditions of distribution and use, see the accompanying README file.
7  *
8  * This file contains the coefficient buffer controller for compression.
9  * This controller is the top level of the JPEG compressor proper.
10  * The coefficient buffer lies between forward-DCT and entropy encoding steps.
11  */
12 
13 #define JPEG_INTERNALS
14 #include "jinclude.h"
15 #include "jpeglib.h"
16 
17 
18 /* We use a full-image coefficient buffer when doing Huffman optimization,
19  * and also for writing multiple-scan JPEG files. In all cases, the DCT
20  * step is run during the first pass, and subsequent passes need only read
21  * the buffered coefficients.
22  */
23 #ifdef ENTROPY_OPT_SUPPORTED
24 #define FULL_COEF_BUFFER_SUPPORTED
25 #else
26 #ifdef C_MULTISCAN_FILES_SUPPORTED
27 #define FULL_COEF_BUFFER_SUPPORTED
28 #endif
29 #endif
30 
31 
32 /* Private buffer controller object */
33 
34 typedef struct {
35  struct jpeg_c_coef_controller pub; /* public fields */
36 
37  JDIMENSION iMCU_row_num; /* iMCU row # within image */
38  JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
39  int MCU_vert_offset; /* counts MCU rows within iMCU row */
40  int MCU_rows_per_iMCU_row; /* number of such rows needed */
41 
42  /* For single-pass compression, it's sufficient to buffer just one MCU
43  * (although this may prove a bit slow in practice). We allocate a
44  * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
45  * MCU constructed and sent. (On 80x86, the workspace is FAR even though
46  * it's not really very big; this is to keep the module interfaces unchanged
47  * when a large coefficient buffer is necessary.)
48  * In multi-pass modes, this array points to the current MCU's blocks
49  * within the virtual arrays.
50  */
52 
53  /* In multi-pass modes, we need a virtual block array for each component. */
56 
58 
59 
60 /* Forward declarations */
61 METHODDEF(boolean) compress_data
63 #ifdef FULL_COEF_BUFFER_SUPPORTED
68 #endif
69 
70 
71 LOCAL(void)
73 /* Reset within-iMCU-row counters for a new row */
74 {
75  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
76 
77  /* In an interleaved scan, an MCU row is the same as an iMCU row.
78  * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
79  * But at the bottom of the image, process only what's left.
80  */
81  if (cinfo->comps_in_scan > 1) {
82  coef->MCU_rows_per_iMCU_row = 1;
83  } else {
84  if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
85  coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
86  else
87  coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
88  }
89 
90  coef->mcu_ctr = 0;
91  coef->MCU_vert_offset = 0;
92 }
93 
94 
95 /*
96  * Initialize for a processing pass.
97  */
98 
99 METHODDEF(void)
101 {
102  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
103 
104  coef->iMCU_row_num = 0;
105  start_iMCU_row(cinfo);
106 
107  switch (pass_mode) {
108  case JBUF_PASS_THRU:
109  if (coef->whole_image[0] != NULL)
111  coef->pub.compress_data = compress_data;
112  break;
113 #ifdef FULL_COEF_BUFFER_SUPPORTED
114  case JBUF_SAVE_AND_PASS:
115  if (coef->whole_image[0] == NULL)
117  coef->pub.compress_data = compress_first_pass;
118  break;
119  case JBUF_CRANK_DEST:
120  if (coef->whole_image[0] == NULL)
122  coef->pub.compress_data = compress_output;
123  break;
124 #endif
125  default:
127  break;
128  }
129 }
130 
131 
132 /*
133  * Process some data in the single-pass case.
134  * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
135  * per call, ie, v_samp_factor block rows for each component in the image.
136  * Returns TRUE if the iMCU row is completed, FALSE if suspended.
137  *
138  * NB: input_buf contains a plane for each component in image,
139  * which we index according to the component's SOF position.
140  */
141 
142 METHODDEF(boolean)
144 {
145  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
146  JDIMENSION MCU_col_num; /* index of current MCU within row */
147  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
148  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
149  int blkn, bi, ci, yindex, yoffset, blockcnt;
150  JDIMENSION ypos, xpos;
152 
153  /* Loop to write as much as one whole iMCU row */
154  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
155  yoffset++) {
156  for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
157  MCU_col_num++) {
158  /* Determine where data comes from in input_buf and do the DCT thing.
159  * Each call on forward_DCT processes a horizontal row of DCT blocks
160  * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
161  * sequentially. Dummy blocks at the right or bottom edge are filled in
162  * specially. The data in them does not matter for image reconstruction,
163  * so we fill them with values that will encode to the smallest amount of
164  * data, viz: all zeroes in the AC entries, DC entries equal to previous
165  * block's DC value. (Thanks to Thomas Kinsman for this idea.)
166  */
167  blkn = 0;
168  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
169  compptr = cinfo->cur_comp_info[ci];
170  blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
172  xpos = MCU_col_num * compptr->MCU_sample_width;
173  ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
174  for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
175  if (coef->iMCU_row_num < last_iMCU_row ||
176  yoffset+yindex < compptr->last_row_height) {
177  (*cinfo->fdct->forward_DCT) (cinfo, compptr,
179  coef->MCU_buffer[blkn],
180  ypos, xpos, (JDIMENSION) blockcnt);
181  if (blockcnt < compptr->MCU_width) {
182  /* Create some dummy blocks at the right edge of the image. */
183  jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
184  (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
185  for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
186  coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
187  }
188  }
189  } else {
190  /* Create a row of dummy blocks at the bottom of the image. */
191  jzero_far((void FAR *) coef->MCU_buffer[blkn],
193  for (bi = 0; bi < compptr->MCU_width; bi++) {
194  coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
195  }
196  }
197  blkn += compptr->MCU_width;
198  ypos += DCTSIZE;
199  }
200  }
201  /* Try to write the MCU. In event of a suspension failure, we will
202  * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
203  */
204  if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
205  /* Suspension forced; update state counters and exit */
206  coef->MCU_vert_offset = yoffset;
207  coef->mcu_ctr = MCU_col_num;
208  return FALSE;
209  }
210  }
211  /* Completed an MCU row, but perhaps not an iMCU row */
212  coef->mcu_ctr = 0;
213  }
214  /* Completed the iMCU row, advance counters for next one */
215  coef->iMCU_row_num++;
216  start_iMCU_row(cinfo);
217  return TRUE;
218 }
219 
220 
221 #ifdef FULL_COEF_BUFFER_SUPPORTED
222 
223 /*
224  * Process some data in the first pass of a multi-pass case.
225  * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
226  * per call, ie, v_samp_factor block rows for each component in the image.
227  * This amount of data is read from the source buffer, DCT'd and quantized,
228  * and saved into the virtual arrays. We also generate suitable dummy blocks
229  * as needed at the right and lower edges. (The dummy blocks are constructed
230  * in the virtual arrays, which have been padded appropriately.) This makes
231  * it possible for subsequent passes not to worry about real vs. dummy blocks.
232  *
233  * We must also emit the data to the entropy encoder. This is conveniently
234  * done by calling compress_output() after we've loaded the current strip
235  * of the virtual arrays.
236  *
237  * NB: input_buf contains a plane for each component in image. All
238  * components are DCT'd and loaded into the virtual arrays in this pass.
239  * However, it may be that only a subset of the components are emitted to
240  * the entropy encoder during this first pass; be careful about looking
241  * at the scan-dependent variables (MCU dimensions, etc).
242  */
243 
244 METHODDEF(boolean)
246 {
247  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
248  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
249  JDIMENSION blocks_across, MCUs_across, MCUindex;
250  int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
251  JCOEF lastDC;
254  JBLOCKROW thisblockrow, lastblockrow;
255 
256  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
257  ci++, compptr++) {
258  /* Align the virtual buffer for this component. */
259  buffer = (*cinfo->mem->access_virt_barray)
260  ((j_common_ptr) cinfo, coef->whole_image[ci],
263  /* Count non-dummy DCT block rows in this iMCU row. */
264  if (coef->iMCU_row_num < last_iMCU_row)
265  block_rows = compptr->v_samp_factor;
266  else {
267  /* NB: can't use last_row_height here, since may not be set! */
268  block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
269  if (block_rows == 0) block_rows = compptr->v_samp_factor;
270  }
271  blocks_across = compptr->width_in_blocks;
272  h_samp_factor = compptr->h_samp_factor;
273  /* Count number of dummy blocks to be added at the right margin. */
274  ndummy = (int) (blocks_across % h_samp_factor);
275  if (ndummy > 0)
276  ndummy = h_samp_factor - ndummy;
277  /* Perform DCT for all non-dummy blocks in this iMCU row. Each call
278  * on forward_DCT processes a complete horizontal row of DCT blocks.
279  */
280  for (block_row = 0; block_row < block_rows; block_row++) {
281  thisblockrow = buffer[block_row];
282  (*cinfo->fdct->forward_DCT) (cinfo, compptr,
283  input_buf[ci], thisblockrow,
284  (JDIMENSION) (block_row * DCTSIZE),
285  (JDIMENSION) 0, blocks_across);
286  if (ndummy > 0) {
287  /* Create dummy blocks at the right edge of the image. */
288  thisblockrow += blocks_across; /* => first dummy block */
289  jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
290  lastDC = thisblockrow[-1][0];
291  for (bi = 0; bi < ndummy; bi++) {
292  thisblockrow[bi][0] = lastDC;
293  }
294  }
295  }
296  /* If at end of image, create dummy block rows as needed.
297  * The tricky part here is that within each MCU, we want the DC values
298  * of the dummy blocks to match the last real block's DC value.
299  * This squeezes a few more bytes out of the resulting file...
300  */
301  if (coef->iMCU_row_num == last_iMCU_row) {
302  blocks_across += ndummy; /* include lower right corner */
303  MCUs_across = blocks_across / h_samp_factor;
304  for (block_row = block_rows; block_row < compptr->v_samp_factor;
305  block_row++) {
306  thisblockrow = buffer[block_row];
307  lastblockrow = buffer[block_row-1];
308  jzero_far((void FAR *) thisblockrow,
309  (size_t) (blocks_across * SIZEOF(JBLOCK)));
310  for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
311  lastDC = lastblockrow[h_samp_factor-1][0];
312  for (bi = 0; bi < h_samp_factor; bi++) {
313  thisblockrow[bi][0] = lastDC;
314  }
315  thisblockrow += h_samp_factor; /* advance to next MCU in row */
316  lastblockrow += h_samp_factor;
317  }
318  }
319  }
320  }
321  /* NB: compress_output will increment iMCU_row_num if successful.
322  * A suspension return will result in redoing all the work above next time.
323  */
324 
325  /* Emit data to the entropy encoder, sharing code with subsequent passes */
326  return compress_output(cinfo, input_buf);
327 }
328 
329 
330 /*
331  * Process some data in subsequent passes of a multi-pass case.
332  * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
333  * per call, ie, v_samp_factor block rows for each component in the scan.
334  * The data is obtained from the virtual arrays and fed to the entropy coder.
335  * Returns TRUE if the iMCU row is completed, FALSE if suspended.
336  *
337  * NB: input_buf is ignored; it is likely to be a NULL pointer.
338  */
339 
340 METHODDEF(boolean)
342 {
343  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
344  JDIMENSION MCU_col_num; /* index of current MCU within row */
345  int blkn, ci, xindex, yindex, yoffset;
346  JDIMENSION start_col;
348  JBLOCKROW buffer_ptr;
350 
351  /* Align the virtual buffers for the components used in this scan.
352  * NB: during first pass, this is safe only because the buffers will
353  * already be aligned properly, so jmemmgr.c won't need to do any I/O.
354  */
355  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
356  compptr = cinfo->cur_comp_info[ci];
357  buffer[ci] = (*cinfo->mem->access_virt_barray)
361  }
362 
363  /* Loop to process one whole iMCU row */
364  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
365  yoffset++) {
366  for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
367  MCU_col_num++) {
368  /* Construct list of pointers to DCT blocks belonging to this MCU */
369  blkn = 0; /* index of current DCT block within MCU */
370  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
371  compptr = cinfo->cur_comp_info[ci];
372  start_col = MCU_col_num * compptr->MCU_width;
373  for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
374  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
375  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
376  coef->MCU_buffer[blkn++] = buffer_ptr++;
377  }
378  }
379  }
380  /* Try to write the MCU. */
381  if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
382  /* Suspension forced; update state counters and exit */
383  coef->MCU_vert_offset = yoffset;
384  coef->mcu_ctr = MCU_col_num;
385  return FALSE;
386  }
387  }
388  /* Completed an MCU row, but perhaps not an iMCU row */
389  coef->mcu_ctr = 0;
390  }
391  /* Completed the iMCU row, advance counters for next one */
392  coef->iMCU_row_num++;
393  start_iMCU_row(cinfo);
394  return TRUE;
395 }
396 
397 #endif /* FULL_COEF_BUFFER_SUPPORTED */
398 
399 
400 /*
401  * Initialize coefficient buffer controller.
402  */
403 
404 GLOBAL(void)
406 {
407  my_coef_ptr coef;
408 
409  coef = (my_coef_ptr)
410  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
412  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
413  coef->pub.start_pass = start_pass_coef;
414 
415  /* Create the coefficient buffer. */
416  if (need_full_buffer) {
417 #ifdef FULL_COEF_BUFFER_SUPPORTED
418  /* Allocate a full-image virtual array for each component, */
419  /* padded to a multiple of samp_factor DCT blocks in each direction. */
420  int ci;
422 
423  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
424  ci++, compptr++) {
425  coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
426  ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
428  (long) compptr->h_samp_factor),
430  (long) compptr->v_samp_factor),
432  }
433 #else
435 #endif
436  } else {
437  /* We only need a single-MCU buffer. */
439  int i;
440 
441  buffer = (JBLOCKROW)
442  (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
444  for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
445  coef->MCU_buffer[i] = buffer + i;
446  }
447  coef->whole_image[0] = NULL; /* flag for no virtual arrays */
448  }
449 }
@ FALSE
Definition: dd.h:101
@ TRUE
Definition: dd.h:102
static boolean compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
Definition: jccoefct.c:143
static boolean compress_first_pass(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
Definition: jccoefct.c:245
static void start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
Definition: jccoefct.c:100
my_coef_controller * my_coef_ptr
Definition: jccoefct.c:57
void jinit_c_coef_controller(j_compress_ptr cinfo, boolean need_full_buffer)
Definition: jccoefct.c:405
static boolean compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
Definition: jccoefct.c:341
static void start_iMCU_row(j_compress_ptr cinfo)
Definition: jccoefct.c:72
jpeg_component_info * compptr
Definition: jdct.h:102
#define ERREXIT(cinfo, code)
Definition: jerror.h:205
@ JERR_BAD_BUFFER_MODE
Definition: jerror.h:46
#define SIZEOF(object)
Definition: jinclude.h:80
unsigned int JDIMENSION
Definition: jmorecfg.h:171
#define MAX_COMPONENTS
Definition: jmorecfg.h:35
#define LOCAL(type)
Definition: jmorecfg.h:186
#define METHODDEF(type)
Definition: jmorecfg.h:184
short JCOEF
Definition: jmorecfg.h:99
#define FAR
Definition: jmorecfg.h:217
#define GLOBAL(type)
Definition: jmorecfg.h:188
J_BUF_MODE
Definition: jpegint.h:16
@ JBUF_PASS_THRU
Definition: jpegint.h:17
@ JBUF_SAVE_AND_PASS
Definition: jpegint.h:21
@ JBUF_CRANK_DEST
Definition: jpegint.h:20
boolean need_full_buffer
Definition: jpegint.h:338
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:261
#define JPP(arglist)
Definition: jpeglib.h:818
#define DCTSIZE
Definition: jpeglib.h:41
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:68
#define C_MAX_BLOCKS_IN_MCU
Definition: jpeglib.h:55
JBLOCKROW * JBLOCKARRAY
Definition: jpeglib.h:72
JCOEF JBLOCK[64]
Definition: jpeglib.h:70
JBLOCK * JBLOCKROW
Definition: jpeglib.h:71
#define JPOOL_IMAGE
Definition: jpeglib.h:749
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:46
long jround_up(long a, long b)
Definition: jutils.c:81
void jzero_far(void *target, size_t bytestozero)
Definition: jutils.c:165
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific i
Definition: afcover.h:80
for(n=0;n< outline->n_points;n++)
Definition: ftbbox.c:494
#define JDIMENSION
Definition: gd_topal.c:67
#define input_buf
Definition: gd_topal.c:129
integer yoffset[256]
Definition: pbmtopk.c:49
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro pixld1_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl else error unsupported endif endm macro pixld2_s mem_operand if mov asr add asl add asl mov asr sub UNIT_X add asl mov asr add asl add asl mov asr add UNIT_X add asl else pixld1_s mem_operand pixld1_s mem_operand endif endm macro pixld0_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl endif endm macro pixld_s_internal mem_operand if mem_operand pixld2_s mem_operand pixdeinterleave basereg elseif mem_operand elseif mem_operand elseif mem_operand elseif mem_operand pixld0_s mem_operand else pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else error unsupported mem_operand if bpp mem_operand endif endm macro vuzp8 reg2 vuzp d d &reg2 endm macro vzip8 reg2 vzip d d &reg2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld[DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld if[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro fetch_mask_pixblock pixld mask_basereg pixblock_size MASK endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp skip1(dst_w_bpp<=(lowbit *8)) &&((lowbit *8)<(pixblock_size *dst_w_bpp)) .if lowbit< 16 tst DST_R
static void yindex(LexState *ls, expdesc *v)
Definition: lparser.c:622
Definition: utils.c:300
JDIMENSION width_in_blocks
Definition: jpeglib.h:139
JDIMENSION height_in_blocks
Definition: jpeglib.h:140
struct jpeg_c_coef_controller pub
Definition: jccoefct.c:35
JBLOCKROW MCU_buffer[10]
Definition: jccoefct.c:51
int MCU_rows_per_iMCU_row
Definition: jccoefct.c:40
jvirt_barray_ptr whole_image[10]
Definition: jccoefct.c:54
JDIMENSION mcu_ctr
Definition: jccoefct.c:38
JDIMENSION iMCU_row_num
Definition: jccoefct.c:37
return() int(((double) *(font_tbl[cur_fnt].wtbl+(int)(*(font_tbl[cur_fnt].char_wi+(int)(ch - font_tbl[cur_fnt].char_f)% 256)))/(double)(1L<< 20)) *(double) font_tbl[cur_fnt].scale)
#define buffer
Definition: xmlparse.c:611