Previous 199869 Revisions Next

r34315 Saturday 10th January, 2015 at 11:50:58 UTC by Miodrag Milanović
Fixes for libjpeg compile (nw)
[3rdparty/libjpeg]jchuff.c jcmainct.c jconfig.h* jdatadst.c jdmainct.c jmorecfg.h jpeglib.h

trunk/3rdparty/libjpeg/jchuff.c
r242826r242827
302302 * between calls, so 24 bits are sufficient.
303303 */
304304
305INLINE
305/*INLINE*/
306306LOCAL(boolean)
307307emit_bits_s (working_state * state, unsigned int code, int size)
308308/* Emit some bits; return TRUE if successful, FALSE if must suspend */
r242826r242827
341341}
342342
343343
344INLINE
344/*INLINE*/
345345LOCAL(void)
346346emit_bits_e (huff_entropy_ptr entropy, unsigned int code, int size)
347347/* Emit some bits, unless we are in gather mode */
r242826r242827
406406 * Emit (or just count) a Huffman symbol.
407407 */
408408
409INLINE
409/*INLINE*/
410410LOCAL(void)
411411emit_dc_symbol (huff_entropy_ptr entropy, int tbl_no, int symbol)
412412{
r242826r242827
419419}
420420
421421
422INLINE
422/*INLINE*/
423423LOCAL(void)
424424emit_ac_symbol (huff_entropy_ptr entropy, int tbl_no, int symbol)
425425{
trunk/3rdparty/libjpeg/jcmainct.c
r242826r242827
6868METHODDEF(void)
6969start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
7070{
71  my_main_ptr main = (my_main_ptr) cinfo->main;
71  my_main_ptr mymain = (my_main_ptr) cinfo->main;
7272
7373  /* Do nothing in raw-data mode. */
7474  if (cinfo->raw_data_in)
7575    return;
7676
77  main->cur_iMCU_row = 0;   /* initialize counters */
78  main->rowgroup_ctr = 0;
79  main->suspended = FALSE;
80  main->pass_mode = pass_mode;   /* save mode for use by process_data */
77  mymain->cur_iMCU_row = 0;   /* initialize counters */
78  mymain->rowgroup_ctr = 0;
79  mymain->suspended = FALSE;
80  mymain->pass_mode = pass_mode;   /* save mode for use by process_data */
8181
8282  switch (pass_mode) {
8383  case JBUF_PASS_THRU:
8484#ifdef FULL_MAIN_BUFFER_SUPPORTED
85    if (main->whole_image[0] != NULL)
85    if (mymain->whole_image[0] != NULL)
8686      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
8787#endif
88    main->pub.process_data = process_data_simple_main;
88    mymain->pub.process_data = process_data_simple_main;
8989    break;
9090#ifdef FULL_MAIN_BUFFER_SUPPORTED
9191  case JBUF_SAVE_SOURCE:
9292  case JBUF_CRANK_DEST:
9393  case JBUF_SAVE_AND_PASS:
94    if (main->whole_image[0] == NULL)
94    if (mymain->whole_image[0] == NULL)
9595      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
96    main->pub.process_data = process_data_buffer_main;
96    mymain->pub.process_data = process_data_buffer_main;
9797    break;
9898#endif
9999  default:
r242826r242827
114114           JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
115115           JDIMENSION in_rows_avail)
116116{
117  my_main_ptr main = (my_main_ptr) cinfo->main;
117  my_main_ptr mymain = (my_main_ptr) cinfo->main;
118118
119  while (main->cur_iMCU_row < cinfo->total_iMCU_rows) {
119  while (mymain->cur_iMCU_row < cinfo->total_iMCU_rows) {
120120    /* Read input data if we haven't filled the main buffer yet */
121    if (main->rowgroup_ctr < (JDIMENSION) cinfo->min_DCT_v_scaled_size)
121    if (mymain->rowgroup_ctr < (JDIMENSION) cinfo->min_DCT_v_scaled_size)
122122      (*cinfo->prep->pre_process_data) (cinfo,
123123               input_buf, in_row_ctr, in_rows_avail,
124               main->buffer, &main->rowgroup_ctr,
124               mymain->buffer, &mymain->rowgroup_ctr,
125125               (JDIMENSION) cinfo->min_DCT_v_scaled_size);
126126
127127    /* If we don't have a full iMCU row buffered, return to application for
128128     * more data.  Note that preprocessor will always pad to fill the iMCU row
129129     * at the bottom of the image.
130130     */
131    if (main->rowgroup_ctr != (JDIMENSION) cinfo->min_DCT_v_scaled_size)
131    if (mymain->rowgroup_ctr != (JDIMENSION) cinfo->min_DCT_v_scaled_size)
132132      return;
133133
134134    /* Send the completed row to the compressor */
135    if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) {
135    if (! (*cinfo->coef->compress_data) (cinfo, mymain->buffer)) {
136136      /* If compressor did not consume the whole row, then we must need to
137137       * suspend processing and return to the application.  In this situation
138138       * we pretend we didn't yet consume the last input row; otherwise, if
139139       * it happened to be the last row of the image, the application would
140140       * think we were done.
141141       */
142      if (! main->suspended) {
142      if (! mymain->suspended) {
143143   (*in_row_ctr)--;
144   main->suspended = TRUE;
144   mymain->suspended = TRUE;
145145      }
146146      return;
147147    }
148148    /* We did finish the row.  Undo our little suspension hack if a previous
149149     * call suspended; then mark the main buffer empty.
150150     */
151    if (main->suspended) {
151    if (mymain->suspended) {
152152      (*in_row_ctr)++;
153      main->suspended = FALSE;
153      mymain->suspended = FALSE;
154154    }
155    main->rowgroup_ctr = 0;
156    main->cur_iMCU_row++;
155    mymain->rowgroup_ctr = 0;
156    mymain->cur_iMCU_row++;
157157  }
158158}
159159
r242826r242827
244244GLOBAL(void)
245245jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
246246{
247  my_main_ptr main;
247  my_main_ptr mymain;
248248  int ci;
249249  jpeg_component_info *compptr;
250250
251  main = (my_main_ptr)
251  mymain = (my_main_ptr)
252252    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
253253            SIZEOF(my_main_controller));
254  cinfo->main = (struct jpeg_c_main_controller *) main;
255  main->pub.start_pass = start_pass_main;
254  cinfo->main = (struct jpeg_c_main_controller *) mymain;
255  mymain->pub.start_pass = start_pass_main;
256256
257257  /* We don't need to create a buffer in raw-data mode. */
258258  if (cinfo->raw_data_in)
r242826r242827
267267    /* Note we pad the bottom to a multiple of the iMCU height */
268268    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
269269    ci++, compptr++) {
270      main->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
270      mymain->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
271271   ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
272272    compptr->width_in_blocks * compptr->DCT_h_scaled_size,
273273    (JDIMENSION) jround_up((long) compptr->height_in_blocks,
r242826r242827
279279#endif
280280  } else {
281281#ifdef FULL_MAIN_BUFFER_SUPPORTED
282    main->whole_image[0] = NULL; /* flag for no virtual arrays */
282    mymain->whole_image[0] = NULL; /* flag for no virtual arrays */
283283#endif
284284    /* Allocate a strip buffer for each component */
285285    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
286286    ci++, compptr++) {
287      main->buffer[ci] = (*cinfo->mem->alloc_sarray)
287      mymain->buffer[ci] = (*cinfo->mem->alloc_sarray)
288288   ((j_common_ptr) cinfo, JPOOL_IMAGE,
289289    compptr->width_in_blocks * compptr->DCT_h_scaled_size,
290290    (JDIMENSION) (compptr->v_samp_factor * compptr->DCT_v_scaled_size));
trunk/3rdparty/libjpeg/jconfig.h
r0r242827
1/* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */
2/* see jconfig.txt for explanations */
3
4#define HAVE_PROTOTYPES
5#define HAVE_UNSIGNED_CHAR
6#define HAVE_UNSIGNED_SHORT
7/* #define void char */
8/* #define const */
9#undef CHAR_IS_UNSIGNED
10#define HAVE_STDDEF_H
11#define HAVE_STDLIB_H
12#undef NEED_BSD_STRINGS
13#undef NEED_SYS_TYPES_H
14#undef NEED_FAR_POINTERS    /* we presume a 32-bit flat memory model */
15#undef NEED_SHORT_EXTERNAL_NAMES
16#undef INCOMPLETE_TYPES_BROKEN
17
18/* Define "boolean" as unsigned char, not int, per Windows custom */
19#ifndef __RPCNDR_H__        /* don't conflict if rpcndr.h already read */
20typedef unsigned char boolean;
21#endif
22#define HAVE_BOOLEAN        /* prevent jmorecfg.h from redefining it */
23
24
25#ifdef JPEG_INTERNALS
26
27#undef RIGHT_SHIFT_IS_UNSIGNED
28
29#endif /* JPEG_INTERNALS */
30
31#ifdef JPEG_CJPEG_DJPEG
32
33#define BMP_SUPPORTED       /* BMP image file format */
34#define GIF_SUPPORTED       /* GIF image file format */
35#define PPM_SUPPORTED       /* PBMPLUS PPM/PGM image file format */
36#undef RLE_SUPPORTED        /* Utah RLE image file format */
37#define TARGA_SUPPORTED     /* Targa image file format */
38
39#define TWO_FILE_COMMANDLINE    /* optional */
40#define USE_SETMODE     /* Microsoft has setmode() */
41#undef NEED_SIGNAL_CATCHER
42#undef DONT_USE_B_MODE
43#undef PROGRESS_REPORT      /* optional */
44
45#endif /* JPEG_CJPEG_DJPEG */
trunk/3rdparty/libjpeg/jdatadst.c
r242826r242827
128128
129129  /* Try to allocate new buffer with double size */
130130  nextsize = dest->bufsize * 2;
131  nextbuffer = malloc(nextsize);
131  nextbuffer = (JOCTET*)malloc(nextsize);
132132
133133  if (nextbuffer == NULL)
134134    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
r242826r242827
256256
257257  if (*outbuffer == NULL || *outsize == 0) {
258258    /* Allocate initial buffer */
259    dest->newbuffer = *outbuffer = malloc(OUTPUT_BUF_SIZE);
259    dest->newbuffer = *outbuffer = (unsigned char*)malloc(OUTPUT_BUF_SIZE);
260260    if (dest->newbuffer == NULL)
261261      ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
262262    *outsize = OUTPUT_BUF_SIZE;
trunk/3rdparty/libjpeg/jdmainct.c
r242826r242827
159159 * This is done only once, not once per pass.
160160 */
161161{
162  my_main_ptr main = (my_main_ptr) cinfo->main;
162  my_main_ptr mymain = (my_main_ptr) cinfo->main;
163163  int ci, rgroup;
164164  int M = cinfo->min_DCT_v_scaled_size;
165165  jpeg_component_info *compptr;
r242826r242827
168168  /* Get top-level space for component array pointers.
169169   * We alloc both arrays with one call to save a few cycles.
170170   */
171  main->xbuffer[0] = (JSAMPIMAGE)
171  mymain->xbuffer[0] = (JSAMPIMAGE)
172172    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
173173            cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
174  main->xbuffer[1] = main->xbuffer[0] + cinfo->num_components;
174  mymain->xbuffer[1] = mymain->xbuffer[0] + cinfo->num_components;
175175
176176  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
177177       ci++, compptr++) {
r242826r242827
184184      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
185185              2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
186186    xbuf += rgroup;      /* want one row group at negative offsets */
187    main->xbuffer[0][ci] = xbuf;
187    mymain->xbuffer[0][ci] = xbuf;
188188    xbuf += rgroup * (M + 4);
189    main->xbuffer[1][ci] = xbuf;
189    mymain->xbuffer[1][ci] = xbuf;
190190  }
191191}
192192
r242826r242827
200200 * This will be repeated at the beginning of each pass.
201201 */
202202{
203  my_main_ptr main = (my_main_ptr) cinfo->main;
203  my_main_ptr mymain = (my_main_ptr) cinfo->main;
204204  int ci, i, rgroup;
205205  int M = cinfo->min_DCT_v_scaled_size;
206206  jpeg_component_info *compptr;
r242826r242827
210210       ci++, compptr++) {
211211    rgroup = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) /
212212      cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
213    xbuf0 = main->xbuffer[0][ci];
214    xbuf1 = main->xbuffer[1][ci];
213    xbuf0 = mymain->xbuffer[0][ci];
214    xbuf1 = mymain->xbuffer[1][ci];
215215    /* First copy the workspace pointers as-is */
216    buf = main->buffer[ci];
216    buf = mymain->buffer[ci];
217217    for (i = 0; i < rgroup * (M + 2); i++) {
218218      xbuf0[i] = xbuf1[i] = buf[i];
219219    }
r242826r242827
240240 * This changes the pointer list state from top-of-image to the normal state.
241241 */
242242{
243  my_main_ptr main = (my_main_ptr) cinfo->main;
243  my_main_ptr mymain = (my_main_ptr) cinfo->main;
244244  int ci, i, rgroup;
245245  int M = cinfo->min_DCT_v_scaled_size;
246246  jpeg_component_info *compptr;
r242826r242827
250250       ci++, compptr++) {
251251    rgroup = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) /
252252      cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
253    xbuf0 = main->xbuffer[0][ci];
254    xbuf1 = main->xbuffer[1][ci];
253    xbuf0 = mymain->xbuffer[0][ci];
254    xbuf1 = mymain->xbuffer[1][ci];
255255    for (i = 0; i < rgroup; i++) {
256256      xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];
257257      xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];
r242826r242827
269269 * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
270270 */
271271{
272  my_main_ptr main = (my_main_ptr) cinfo->main;
272  my_main_ptr mymain = (my_main_ptr) cinfo->main;
273273  int ci, i, rgroup, iMCUheight, rows_left;
274274  jpeg_component_info *compptr;
275275  JSAMPARRAY xbuf;
r242826r242827
286286     * so we need only do it once.
287287     */
288288    if (ci == 0) {
289      main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
289      mymain->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
290290    }
291291    /* Duplicate the last real sample row rgroup*2 times; this pads out the
292292     * last partial rowgroup and ensures at least one full rowgroup of context.
293293     */
294    xbuf = main->xbuffer[main->whichptr][ci];
294    xbuf = mymain->xbuffer[mymain->whichptr][ci];
295295    for (i = 0; i < rgroup * 2; i++) {
296296      xbuf[rows_left + i] = xbuf[rows_left-1];
297297    }
r242826r242827
306306METHODDEF(void)
307307start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
308308{
309  my_main_ptr main = (my_main_ptr) cinfo->main;
309  my_main_ptr mymain = (my_main_ptr) cinfo->main;
310310
311311  switch (pass_mode) {
312312  case JBUF_PASS_THRU:
313313    if (cinfo->upsample->need_context_rows) {
314      main->pub.process_data = process_data_context_main;
314      mymain->pub.process_data = process_data_context_main;
315315      make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
316      main->whichptr = 0;   /* Read first iMCU row into xbuffer[0] */
317      main->context_state = CTX_PREPARE_FOR_IMCU;
318      main->iMCU_row_ctr = 0;
316      mymain->whichptr = 0;   /* Read first iMCU row into xbuffer[0] */
317      mymain->context_state = CTX_PREPARE_FOR_IMCU;
318      mymain->iMCU_row_ctr = 0;
319319    } else {
320320      /* Simple case with no context needed */
321      main->pub.process_data = process_data_simple_main;
321      mymain->pub.process_data = process_data_simple_main;
322322    }
323    main->buffer_full = FALSE;   /* Mark buffer empty */
324    main->rowgroup_ctr = 0;
323    mymain->buffer_full = FALSE;   /* Mark buffer empty */
324    mymain->rowgroup_ctr = 0;
325325    break;
326326#ifdef QUANT_2PASS_SUPPORTED
327327  case JBUF_CRANK_DEST:
328328    /* For last pass of 2-pass quantization, just crank the postprocessor */
329    main->pub.process_data = process_data_crank_post;
329    mymain->pub.process_data = process_data_crank_post;
330330    break;
331331#endif
332332  default:
r242826r242827
346346           JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
347347           JDIMENSION out_rows_avail)
348348{
349  my_main_ptr main = (my_main_ptr) cinfo->main;
349  my_main_ptr mymain = (my_main_ptr) cinfo->main;
350350  JDIMENSION rowgroups_avail;
351351
352352  /* Read input data if we haven't filled the main buffer yet */
353  if (! main->buffer_full) {
354    if (! (*cinfo->coef->decompress_data) (cinfo, main->buffer))
353  if (! mymain->buffer_full) {
354    if (! (*cinfo->coef->decompress_data) (cinfo, mymain->buffer))
355355      return;         /* suspension forced, can do nothing more */
356    main->buffer_full = TRUE;   /* OK, we have an iMCU row to work with */
356    mymain->buffer_full = TRUE;   /* OK, we have an iMCU row to work with */
357357  }
358358
359359  /* There are always min_DCT_scaled_size row groups in an iMCU row. */
r242826r242827
364364   */
365365
366366  /* Feed the postprocessor */
367  (*cinfo->post->post_process_data) (cinfo, main->buffer,
368                 &main->rowgroup_ctr, rowgroups_avail,
367  (*cinfo->post->post_process_data) (cinfo, mymain->buffer,
368                 &mymain->rowgroup_ctr, rowgroups_avail,
369369                 output_buf, out_row_ctr, out_rows_avail);
370370
371371  /* Has postprocessor consumed all the data yet? If so, mark buffer empty */
372  if (main->rowgroup_ctr >= rowgroups_avail) {
373    main->buffer_full = FALSE;
374    main->rowgroup_ctr = 0;
372  if (mymain->rowgroup_ctr >= rowgroups_avail) {
373    mymain->buffer_full = FALSE;
374    mymain->rowgroup_ctr = 0;
375375  }
376376}
377377
r242826r242827
386386            JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
387387            JDIMENSION out_rows_avail)
388388{
389  my_main_ptr main = (my_main_ptr) cinfo->main;
389  my_main_ptr mymain = (my_main_ptr) cinfo->main;
390390
391391  /* Read input data if we haven't filled the main buffer yet */
392  if (! main->buffer_full) {
392  if (! mymain->buffer_full) {
393393    if (! (*cinfo->coef->decompress_data) (cinfo,
394                  main->xbuffer[main->whichptr]))
394                  mymain->xbuffer[mymain->whichptr]))
395395      return;         /* suspension forced, can do nothing more */
396    main->buffer_full = TRUE;   /* OK, we have an iMCU row to work with */
397    main->iMCU_row_ctr++;   /* count rows received */
396    mymain->buffer_full = TRUE;   /* OK, we have an iMCU row to work with */
397    mymain->iMCU_row_ctr++;   /* count rows received */
398398  }
399399
400400  /* Postprocessor typically will not swallow all the input data it is handed
r242826r242827
402402   * to exit and restart.  This switch lets us keep track of how far we got.
403403   * Note that each case falls through to the next on successful completion.
404404   */
405  switch (main->context_state) {
405  switch (mymain->context_state) {
406406  case CTX_POSTPONED_ROW:
407407    /* Call postprocessor using previously set pointers for postponed row */
408    (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
409         &main->rowgroup_ctr, main->rowgroups_avail,
408    (*cinfo->post->post_process_data) (cinfo, mymain->xbuffer[mymain->whichptr],
409         &mymain->rowgroup_ctr, mymain->rowgroups_avail,
410410         output_buf, out_row_ctr, out_rows_avail);
411    if (main->rowgroup_ctr < main->rowgroups_avail)
411    if (mymain->rowgroup_ctr < mymain->rowgroups_avail)
412412      return;         /* Need to suspend */
413    main->context_state = CTX_PREPARE_FOR_IMCU;
413    mymain->context_state = CTX_PREPARE_FOR_IMCU;
414414    if (*out_row_ctr >= out_rows_avail)
415415      return;         /* Postprocessor exactly filled output buf */
416416    /*FALLTHROUGH*/
417417  case CTX_PREPARE_FOR_IMCU:
418418    /* Prepare to process first M-1 row groups of this iMCU row */
419    main->rowgroup_ctr = 0;
420    main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_v_scaled_size - 1);
419    mymain->rowgroup_ctr = 0;
420    mymain->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_v_scaled_size - 1);
421421    /* Check for bottom of image: if so, tweak pointers to "duplicate"
422422     * the last sample row, and adjust rowgroups_avail to ignore padding rows.
423423     */
424    if (main->iMCU_row_ctr == cinfo->total_iMCU_rows)
424    if (mymain->iMCU_row_ctr == cinfo->total_iMCU_rows)
425425      set_bottom_pointers(cinfo);
426    main->context_state = CTX_PROCESS_IMCU;
426    mymain->context_state = CTX_PROCESS_IMCU;
427427    /*FALLTHROUGH*/
428428  case CTX_PROCESS_IMCU:
429429    /* Call postprocessor using previously set pointers */
430    (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
431         &main->rowgroup_ctr, main->rowgroups_avail,
430    (*cinfo->post->post_process_data) (cinfo, mymain->xbuffer[mymain->whichptr],
431         &mymain->rowgroup_ctr, mymain->rowgroups_avail,
432432         output_buf, out_row_ctr, out_rows_avail);
433    if (main->rowgroup_ctr < main->rowgroups_avail)
433    if (mymain->rowgroup_ctr < mymain->rowgroups_avail)
434434      return;         /* Need to suspend */
435435    /* After the first iMCU, change wraparound pointers to normal state */
436    if (main->iMCU_row_ctr == 1)
436    if (mymain->iMCU_row_ctr == 1)
437437      set_wraparound_pointers(cinfo);
438438    /* Prepare to load new iMCU row using other xbuffer list */
439    main->whichptr ^= 1;   /* 0=>1 or 1=>0 */
440    main->buffer_full = FALSE;
439    mymain->whichptr ^= 1;   /* 0=>1 or 1=>0 */
440    mymain->buffer_full = FALSE;
441441    /* Still need to process last row group of this iMCU row, */
442442    /* which is saved at index M+1 of the other xbuffer */
443    main->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_v_scaled_size + 1);
444    main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_v_scaled_size + 2);
445    main->context_state = CTX_POSTPONED_ROW;
443    mymain->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_v_scaled_size + 1);
444    mymain->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_v_scaled_size + 2);
445    mymain->context_state = CTX_POSTPONED_ROW;
446446  }
447447}
448448
r242826r242827
475475GLOBAL(void)
476476jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
477477{
478  my_main_ptr main;
478  my_main_ptr mymain;
479479  int ci, rgroup, ngroups;
480480  jpeg_component_info *compptr;
481481
482  main = (my_main_ptr)
482  mymain = (my_main_ptr)
483483    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
484484            SIZEOF(my_main_controller));
485  cinfo->main = (struct jpeg_d_main_controller *) main;
486  main->pub.start_pass = start_pass_main;
485  cinfo->main = (struct jpeg_d_main_controller *) mymain;
486  mymain->pub.start_pass = start_pass_main;
487487
488488  if (need_full_buffer)      /* shouldn't happen */
489489    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
r242826r242827
504504       ci++, compptr++) {
505505    rgroup = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) /
506506      cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
507    main->buffer[ci] = (*cinfo->mem->alloc_sarray)
507    mymain->buffer[ci] = (*cinfo->mem->alloc_sarray)
508508         ((j_common_ptr) cinfo, JPOOL_IMAGE,
509509          compptr->width_in_blocks * compptr->DCT_h_scaled_size,
510510          (JDIMENSION) (rgroup * ngroups));
trunk/3rdparty/libjpeg/jmorecfg.h
r242826r242827
162162#ifndef _BASETSD_H_      /* Microsoft defines it in basetsd.h */
163163#ifndef _BASETSD_H      /* MinGW is slightly different */
164164#ifndef QGLOBAL_H      /* Qt defines it in qglobal.h */
165typedef long INT32;
165typedef int INT32;
166166#endif
167167#endif
168168#endif
trunk/3rdparty/libjpeg/jpeglib.h
r242826r242827
1111 * and perhaps jerror.h if they want to know the exact error codes.
1212 */
1313
14#ifdef USE_SYSTEM_JPEGLIB
15#ifndef XMD_H
16#define XMD_H
17#endif
18#include <jpeglib.h>
19#else
20
1421#ifndef JPEGLIB_H
1522#define JPEGLIB_H
1623
r242826r242827
11581165#endif
11591166
11601167#endif /* JPEGLIB_H */
1168#endif /* USE_SYSTEM_JPEGLIB */

https://github.com/mamedev/mame/commit/0404bdd34cb4779129f372ce735f316379644a84

Previous 199869 Revisions Next

© 1997-2024 The MAME Team