7b4c2559ec15d3de19d528b6aa10c55c4d7eac31
[xonotic/netradiant.git] / libs / jpeg6 / jdmainct.cpp
1 /*\r
2 \r
3  * jdmainct.c\r
4 \r
5  *\r
6 \r
7  * Copyright (C) 1994-1995, Thomas G. Lane.\r
8 \r
9  * This file is part of the Independent JPEG Group's software.\r
10 \r
11  * For conditions of distribution and use, see the accompanying README file.\r
12 \r
13  *\r
14 \r
15  * This file contains the main buffer controller for decompression.\r
16 \r
17  * The main buffer lies between the JPEG decompressor proper and the\r
18 \r
19  * post-processor; it holds downsampled data in the JPEG colorspace.\r
20 \r
21  *\r
22 \r
23  * Note that this code is bypassed in raw-data mode, since the application\r
24 \r
25  * supplies the equivalent of the main buffer in that case.\r
26 \r
27  */\r
28 \r
29 \r
30 \r
31 #define JPEG_INTERNALS\r
32 \r
33 #include "jinclude.h"\r
34 \r
35 #include "radiant_jpeglib.h"\r
36 \r
37 \r
38 \r
39 \r
40 \r
41 /*\r
42 \r
43  * In the current system design, the main buffer need never be a full-image\r
44 \r
45  * buffer; any full-height buffers will be found inside the coefficient or\r
46 \r
47  * postprocessing controllers.  Nonetheless, the main controller is not\r
48 \r
49  * trivial.  Its responsibility is to provide context rows for upsampling/\r
50 \r
51  * rescaling, and doing this in an efficient fashion is a bit tricky.\r
52 \r
53  *\r
54 \r
55  * Postprocessor input data is counted in "row groups".  A row group\r
56 \r
57  * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)\r
58 \r
59  * sample rows of each component.  (We require DCT_scaled_size values to be\r
60 \r
61  * chosen such that these numbers are integers.  In practice DCT_scaled_size\r
62 \r
63  * values will likely be powers of two, so we actually have the stronger\r
64 \r
65  * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)\r
66 \r
67  * Upsampling will typically produce max_v_samp_factor pixel rows from each\r
68 \r
69  * row group (times any additional scale factor that the upsampler is\r
70 \r
71  * applying).\r
72 \r
73  *\r
74 \r
75  * The coefficient controller will deliver data to us one iMCU row at a time;\r
76 \r
77  * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or\r
78 \r
79  * exactly min_DCT_scaled_size row groups.  (This amount of data corresponds\r
80 \r
81  * to one row of MCUs when the image is fully interleaved.)  Note that the\r
82 \r
83  * number of sample rows varies across components, but the number of row\r
84 \r
85  * groups does not.  Some garbage sample rows may be included in the last iMCU\r
86 \r
87  * row at the bottom of the image.\r
88 \r
89  *\r
90 \r
91  * Depending on the vertical scaling algorithm used, the upsampler may need\r
92 \r
93  * access to the sample row(s) above and below its current input row group.\r
94 \r
95  * The upsampler is required to set need_context_rows TRUE at global selection\r
96 \r
97  * time if so.  When need_context_rows is FALSE, this controller can simply\r
98 \r
99  * obtain one iMCU row at a time from the coefficient controller and dole it\r
100 \r
101  * out as row groups to the postprocessor.\r
102 \r
103  *\r
104 \r
105  * When need_context_rows is TRUE, this controller guarantees that the buffer\r
106 \r
107  * passed to postprocessing contains at least one row group's worth of samples\r
108 \r
109  * above and below the row group(s) being processed.  Note that the context\r
110 \r
111  * rows "above" the first passed row group appear at negative row offsets in\r
112 \r
113  * the passed buffer.  At the top and bottom of the image, the required\r
114 \r
115  * context rows are manufactured by duplicating the first or last real sample\r
116 \r
117  * row; this avoids having special cases in the upsampling inner loops.\r
118 \r
119  *\r
120 \r
121  * The amount of context is fixed at one row group just because that's a\r
122 \r
123  * convenient number for this controller to work with.  The existing\r
124 \r
125  * upsamplers really only need one sample row of context.  An upsampler\r
126 \r
127  * supporting arbitrary output rescaling might wish for more than one row\r
128 \r
129  * group of context when shrinking the image; tough, we don't handle that.\r
130 \r
131  * (This is justified by the assumption that downsizing will be handled mostly\r
132 \r
133  * by adjusting the DCT_scaled_size values, so that the actual scale factor at\r
134 \r
135  * the upsample step needn't be much less than one.)\r
136 \r
137  *\r
138 \r
139  * To provide the desired context, we have to retain the last two row groups\r
140 \r
141  * of one iMCU row while reading in the next iMCU row.  (The last row group\r
142 \r
143  * can't be processed until we have another row group for its below-context,\r
144 \r
145  * and so we have to save the next-to-last group too for its above-context.)\r
146 \r
147  * We could do this most simply by copying data around in our buffer, but\r
148 \r
149  * that'd be very slow.  We can avoid copying any data by creating a rather\r
150 \r
151  * strange pointer structure.  Here's how it works.  We allocate a workspace\r
152 \r
153  * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number\r
154 \r
155  * of row groups per iMCU row).  We create two sets of redundant pointers to\r
156 \r
157  * the workspace.  Labeling the physical row groups 0 to M+1, the synthesized\r
158 \r
159  * pointer lists look like this:\r
160 \r
161  *                   M+1                          M-1\r
162 \r
163  * master pointer --> 0         master pointer --> 0\r
164 \r
165  *                    1                            1\r
166 \r
167  *                   ...                          ...\r
168 \r
169  *                   M-3                          M-3\r
170 \r
171  *                   M-2                           M\r
172 \r
173  *                   M-1                          M+1\r
174 \r
175  *                    M                           M-2\r
176 \r
177  *                   M+1                          M-1\r
178 \r
179  *                    0                            0\r
180 \r
181  * We read alternate iMCU rows using each master pointer; thus the last two\r
182 \r
183  * row groups of the previous iMCU row remain un-overwritten in the workspace.\r
184 \r
185  * The pointer lists are set up so that the required context rows appear to\r
186 \r
187  * be adjacent to the proper places when we pass the pointer lists to the\r
188 \r
189  * upsampler.\r
190 \r
191  *\r
192 \r
193  * The above pictures describe the normal state of the pointer lists.\r
194 \r
195  * At top and bottom of the image, we diddle the pointer lists to duplicate\r
196 \r
197  * the first or last sample row as necessary (this is cheaper than copying\r
198 \r
199  * sample rows around).\r
200 \r
201  *\r
202 \r
203  * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1.  In that\r
204 \r
205  * situation each iMCU row provides only one row group so the buffering logic\r
206 \r
207  * must be different (eg, we must read two iMCU rows before we can emit the\r
208 \r
209  * first row group).  For now, we simply do not support providing context\r
210 \r
211  * rows when min_DCT_scaled_size is 1.  That combination seems unlikely to\r
212 \r
213  * be worth providing --- if someone wants a 1/8th-size preview, they probably\r
214 \r
215  * want it quick and dirty, so a context-free upsampler is sufficient.\r
216 \r
217  */\r
218 \r
219 \r
220 \r
221 \r
222 \r
223 /* Private buffer controller object */\r
224 \r
225 \r
226 \r
227 typedef struct {\r
228 \r
229   struct jpeg_d_main_controller pub; /* public fields */\r
230 \r
231 \r
232 \r
233   /* Pointer to allocated workspace (M or M+2 row groups). */\r
234 \r
235   JSAMPARRAY buffer[MAX_COMPONENTS];\r
236 \r
237 \r
238 \r
239   boolean buffer_full;          /* Have we gotten an iMCU row from decoder? */\r
240 \r
241   JDIMENSION rowgroup_ctr;      /* counts row groups output to postprocessor */\r
242 \r
243 \r
244 \r
245   /* Remaining fields are only used in the context case. */\r
246 \r
247 \r
248 \r
249   /* These are the master pointers to the funny-order pointer lists. */\r
250 \r
251   JSAMPIMAGE xbuffer[2];        /* pointers to weird pointer lists */\r
252 \r
253 \r
254 \r
255   int whichptr;                 /* indicates which pointer set is now in use */\r
256 \r
257   int context_state;            /* process_data state machine status */\r
258 \r
259   JDIMENSION rowgroups_avail;   /* row groups available to postprocessor */\r
260 \r
261   JDIMENSION iMCU_row_ctr;      /* counts iMCU rows to detect image top/bot */\r
262 \r
263 } my_main_controller;\r
264 \r
265 \r
266 \r
267 typedef my_main_controller * my_main_ptr;\r
268 \r
269 \r
270 \r
271 /* context_state values: */\r
272 \r
273 #define CTX_PREPARE_FOR_IMCU    0       /* need to prepare for MCU row */\r
274 \r
275 #define CTX_PROCESS_IMCU        1       /* feeding iMCU to postprocessor */\r
276 \r
277 #define CTX_POSTPONED_ROW       2       /* feeding postponed row group */\r
278 \r
279 \r
280 \r
281 \r
282 \r
283 /* Forward declarations */\r
284 \r
285 METHODDEF void process_data_simple_main\r
286 \r
287         JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,\r
288 \r
289              JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));\r
290 \r
291 METHODDEF void process_data_context_main\r
292 \r
293         JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,\r
294 \r
295              JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));\r
296 \r
297 #ifdef QUANT_2PASS_SUPPORTED\r
298 \r
299 METHODDEF void process_data_crank_post\r
300 \r
301         JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,\r
302 \r
303              JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));\r
304 \r
305 #endif\r
306 \r
307 \r
308 \r
309 \r
310 \r
311 LOCAL void\r
312 \r
313 alloc_funny_pointers (j_decompress_ptr cinfo)\r
314 \r
315 /* Allocate space for the funny pointer lists.\r
316 \r
317  * This is done only once, not once per pass.\r
318 \r
319  */\r
320 \r
321 {\r
322 \r
323   my_main_ptr main = (my_main_ptr) cinfo->main;\r
324 \r
325   int ci, rgroup;\r
326 \r
327   int M = cinfo->min_DCT_scaled_size;\r
328 \r
329   jpeg_component_info *compptr;\r
330 \r
331   JSAMPARRAY xbuf;\r
332 \r
333 \r
334 \r
335   /* Get top-level space for component array pointers.\r
336 \r
337    * We alloc both arrays with one call to save a few cycles.\r
338 \r
339    */\r
340 \r
341   main->xbuffer[0] = (JSAMPIMAGE)\r
342 \r
343     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,\r
344 \r
345                                 cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));\r
346 \r
347   main->xbuffer[1] = main->xbuffer[0] + cinfo->num_components;\r
348 \r
349 \r
350 \r
351   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;\r
352 \r
353        ci++, compptr++) {\r
354 \r
355     rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /\r
356 \r
357       cinfo->min_DCT_scaled_size; /* height of a row group of component */\r
358 \r
359     /* Get space for pointer lists --- M+4 row groups in each list.\r
360 \r
361      * We alloc both pointer lists with one call to save a few cycles.\r
362 \r
363      */\r
364 \r
365     xbuf = (JSAMPARRAY)\r
366 \r
367       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,\r
368 \r
369                                   2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));\r
370 \r
371     xbuf += rgroup;             /* want one row group at negative offsets */\r
372 \r
373     main->xbuffer[0][ci] = xbuf;\r
374 \r
375     xbuf += rgroup * (M + 4);\r
376 \r
377     main->xbuffer[1][ci] = xbuf;\r
378 \r
379   }\r
380 \r
381 }\r
382 \r
383 \r
384 \r
385 \r
386 \r
387 LOCAL void\r
388 \r
389 make_funny_pointers (j_decompress_ptr cinfo)\r
390 \r
391 /* Create the funny pointer lists discussed in the comments above.\r
392 \r
393  * The actual workspace is already allocated (in main->buffer),\r
394 \r
395  * and the space for the pointer lists is allocated too.\r
396 \r
397  * This routine just fills in the curiously ordered lists.\r
398 \r
399  * This will be repeated at the beginning of each pass.\r
400 \r
401  */\r
402 \r
403 {\r
404 \r
405   my_main_ptr main = (my_main_ptr) cinfo->main;\r
406 \r
407   int ci, i, rgroup;\r
408 \r
409   int M = cinfo->min_DCT_scaled_size;\r
410 \r
411   jpeg_component_info *compptr;\r
412 \r
413   JSAMPARRAY buf, xbuf0, xbuf1;\r
414 \r
415 \r
416 \r
417   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;\r
418 \r
419        ci++, compptr++) {\r
420 \r
421     rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /\r
422 \r
423       cinfo->min_DCT_scaled_size; /* height of a row group of component */\r
424 \r
425     xbuf0 = main->xbuffer[0][ci];\r
426 \r
427     xbuf1 = main->xbuffer[1][ci];\r
428 \r
429     /* First copy the workspace pointers as-is */\r
430 \r
431     buf = main->buffer[ci];\r
432 \r
433     for (i = 0; i < rgroup * (M + 2); i++) {\r
434 \r
435       xbuf0[i] = xbuf1[i] = buf[i];\r
436 \r
437     }\r
438 \r
439     /* In the second list, put the last four row groups in swapped order */\r
440 \r
441     for (i = 0; i < rgroup * 2; i++) {\r
442 \r
443       xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i];\r
444 \r
445       xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i];\r
446 \r
447     }\r
448 \r
449     /* The wraparound pointers at top and bottom will be filled later\r
450 \r
451      * (see set_wraparound_pointers, below).  Initially we want the "above"\r
452 \r
453      * pointers to duplicate the first actual data line.  This only needs\r
454 \r
455      * to happen in xbuffer[0].\r
456 \r
457      */\r
458 \r
459     for (i = 0; i < rgroup; i++) {\r
460 \r
461       xbuf0[i - rgroup] = xbuf0[0];\r
462 \r
463     }\r
464 \r
465   }\r
466 \r
467 }\r
468 \r
469 \r
470 \r
471 \r
472 \r
473 LOCAL void\r
474 \r
475 set_wraparound_pointers (j_decompress_ptr cinfo)\r
476 \r
477 /* Set up the "wraparound" pointers at top and bottom of the pointer lists.\r
478 \r
479  * This changes the pointer list state from top-of-image to the normal state.\r
480 \r
481  */\r
482 \r
483 {\r
484 \r
485   my_main_ptr main = (my_main_ptr) cinfo->main;\r
486 \r
487   int ci, i, rgroup;\r
488 \r
489   int M = cinfo->min_DCT_scaled_size;\r
490 \r
491   jpeg_component_info *compptr;\r
492 \r
493   JSAMPARRAY xbuf0, xbuf1;\r
494 \r
495 \r
496 \r
497   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;\r
498 \r
499        ci++, compptr++) {\r
500 \r
501     rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /\r
502 \r
503       cinfo->min_DCT_scaled_size; /* height of a row group of component */\r
504 \r
505     xbuf0 = main->xbuffer[0][ci];\r
506 \r
507     xbuf1 = main->xbuffer[1][ci];\r
508 \r
509     for (i = 0; i < rgroup; i++) {\r
510 \r
511       xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];\r
512 \r
513       xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];\r
514 \r
515       xbuf0[rgroup*(M+2) + i] = xbuf0[i];\r
516 \r
517       xbuf1[rgroup*(M+2) + i] = xbuf1[i];\r
518 \r
519     }\r
520 \r
521   }\r
522 \r
523 }\r
524 \r
525 \r
526 \r
527 \r
528 \r
529 LOCAL void\r
530 \r
531 set_bottom_pointers (j_decompress_ptr cinfo)\r
532 \r
533 /* Change the pointer lists to duplicate the last sample row at the bottom\r
534 \r
535  * of the image.  whichptr indicates which xbuffer holds the final iMCU row.\r
536 \r
537  * Also sets rowgroups_avail to indicate number of nondummy row groups in row.\r
538 \r
539  */\r
540 \r
541 {\r
542 \r
543   my_main_ptr main = (my_main_ptr) cinfo->main;\r
544 \r
545   int ci, i, rgroup, iMCUheight, rows_left;\r
546 \r
547   jpeg_component_info *compptr;\r
548 \r
549   JSAMPARRAY xbuf;\r
550 \r
551 \r
552 \r
553   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;\r
554 \r
555        ci++, compptr++) {\r
556 \r
557     /* Count sample rows in one iMCU row and in one row group */\r
558 \r
559     iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size;\r
560 \r
561     rgroup = iMCUheight / cinfo->min_DCT_scaled_size;\r
562 \r
563     /* Count nondummy sample rows remaining for this component */\r
564 \r
565     rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);\r
566 \r
567     if (rows_left == 0) rows_left = iMCUheight;\r
568 \r
569     /* Count nondummy row groups.  Should get same answer for each component,\r
570 \r
571      * so we need only do it once.\r
572 \r
573      */\r
574 \r
575     if (ci == 0) {\r
576 \r
577       main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);\r
578 \r
579     }\r
580 \r
581     /* Duplicate the last real sample row rgroup*2 times; this pads out the\r
582 \r
583      * last partial rowgroup and ensures at least one full rowgroup of context.\r
584 \r
585      */\r
586 \r
587     xbuf = main->xbuffer[main->whichptr][ci];\r
588 \r
589     for (i = 0; i < rgroup * 2; i++) {\r
590 \r
591       xbuf[rows_left + i] = xbuf[rows_left-1];\r
592 \r
593     }\r
594 \r
595   }\r
596 \r
597 }\r
598 \r
599 \r
600 \r
601 \r
602 \r
603 /*\r
604 \r
605  * Initialize for a processing pass.\r
606 \r
607  */\r
608 \r
609 \r
610 \r
611 METHODDEF void\r
612 \r
613 start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)\r
614 \r
615 {\r
616 \r
617   my_main_ptr main = (my_main_ptr) cinfo->main;\r
618 \r
619 \r
620 \r
621   switch (pass_mode) {\r
622 \r
623   case JBUF_PASS_THRU:\r
624 \r
625     if (cinfo->upsample->need_context_rows) {\r
626 \r
627       main->pub.process_data = process_data_context_main;\r
628 \r
629       make_funny_pointers(cinfo); /* Create the xbuffer[] lists */\r
630 \r
631       main->whichptr = 0;       /* Read first iMCU row into xbuffer[0] */\r
632 \r
633       main->context_state = CTX_PREPARE_FOR_IMCU;\r
634 \r
635       main->iMCU_row_ctr = 0;\r
636 \r
637     } else {\r
638 \r
639       /* Simple case with no context needed */\r
640 \r
641       main->pub.process_data = process_data_simple_main;\r
642 \r
643     }\r
644 \r
645     main->buffer_full = FALSE;  /* Mark buffer empty */\r
646 \r
647     main->rowgroup_ctr = 0;\r
648 \r
649     break;\r
650 \r
651 #ifdef QUANT_2PASS_SUPPORTED\r
652 \r
653   case JBUF_CRANK_DEST:\r
654 \r
655     /* For last pass of 2-pass quantization, just crank the postprocessor */\r
656 \r
657     main->pub.process_data = process_data_crank_post;\r
658 \r
659     break;\r
660 \r
661 #endif\r
662 \r
663   default:\r
664 \r
665     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);\r
666 \r
667     break;\r
668 \r
669   }\r
670 \r
671 }\r
672 \r
673 \r
674 \r
675 \r
676 \r
677 /*\r
678 \r
679  * Process some data.\r
680 \r
681  * This handles the simple case where no context is required.\r
682 \r
683  */\r
684 \r
685 \r
686 \r
687 METHODDEF void\r
688 \r
689 process_data_simple_main (j_decompress_ptr cinfo,\r
690 \r
691                           JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,\r
692 \r
693                           JDIMENSION out_rows_avail)\r
694 \r
695 {\r
696 \r
697   my_main_ptr main = (my_main_ptr) cinfo->main;\r
698 \r
699   JDIMENSION rowgroups_avail;\r
700 \r
701 \r
702 \r
703   /* Read input data if we haven't filled the main buffer yet */\r
704 \r
705   if (! main->buffer_full) {\r
706 \r
707     if (! (*cinfo->coef->decompress_data) (cinfo, main->buffer))\r
708 \r
709       return;                   /* suspension forced, can do nothing more */\r
710 \r
711     main->buffer_full = TRUE;   /* OK, we have an iMCU row to work with */\r
712 \r
713   }\r
714 \r
715 \r
716 \r
717   /* There are always min_DCT_scaled_size row groups in an iMCU row. */\r
718 \r
719   rowgroups_avail = (JDIMENSION) cinfo->min_DCT_scaled_size;\r
720 \r
721   /* Note: at the bottom of the image, we may pass extra garbage row groups\r
722 \r
723    * to the postprocessor.  The postprocessor has to check for bottom\r
724 \r
725    * of image anyway (at row resolution), so no point in us doing it too.\r
726 \r
727    */\r
728 \r
729 \r
730 \r
731   /* Feed the postprocessor */\r
732 \r
733   (*cinfo->post->post_process_data) (cinfo, main->buffer,\r
734 \r
735                                      &main->rowgroup_ctr, rowgroups_avail,\r
736 \r
737                                      output_buf, out_row_ctr, out_rows_avail);\r
738 \r
739 \r
740 \r
741   /* Has postprocessor consumed all the data yet? If so, mark buffer empty */\r
742 \r
743   if (main->rowgroup_ctr >= rowgroups_avail) {\r
744 \r
745     main->buffer_full = FALSE;\r
746 \r
747     main->rowgroup_ctr = 0;\r
748 \r
749   }\r
750 \r
751 }\r
752 \r
753 \r
754 \r
755 \r
756 \r
757 /*\r
758 \r
759  * Process some data.\r
760 \r
761  * This handles the case where context rows must be provided.\r
762 \r
763  */\r
764 \r
765 \r
766 \r
767 METHODDEF void\r
768 \r
769 process_data_context_main (j_decompress_ptr cinfo,\r
770 \r
771                            JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,\r
772 \r
773                            JDIMENSION out_rows_avail)\r
774 \r
775 {\r
776 \r
777   my_main_ptr main = (my_main_ptr) cinfo->main;\r
778 \r
779 \r
780 \r
781   /* Read input data if we haven't filled the main buffer yet */\r
782 \r
783   if (! main->buffer_full) {\r
784 \r
785     if (! (*cinfo->coef->decompress_data) (cinfo,\r
786 \r
787                                            main->xbuffer[main->whichptr]))\r
788 \r
789       return;                   /* suspension forced, can do nothing more */\r
790 \r
791     main->buffer_full = TRUE;   /* OK, we have an iMCU row to work with */\r
792 \r
793     main->iMCU_row_ctr++;       /* count rows received */\r
794 \r
795   }\r
796 \r
797 \r
798 \r
799   /* Postprocessor typically will not swallow all the input data it is handed\r
800 \r
801    * in one call (due to filling the output buffer first).  Must be prepared\r
802 \r
803    * to exit and restart.  This switch lets us keep track of how far we got.\r
804 \r
805    * Note that each case falls through to the next on successful completion.\r
806 \r
807    */\r
808 \r
809   switch (main->context_state) {\r
810 \r
811   case CTX_POSTPONED_ROW:\r
812 \r
813     /* Call postprocessor using previously set pointers for postponed row */\r
814 \r
815     (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],\r
816 \r
817                         &main->rowgroup_ctr, main->rowgroups_avail,\r
818 \r
819                         output_buf, out_row_ctr, out_rows_avail);\r
820 \r
821     if (main->rowgroup_ctr < main->rowgroups_avail)\r
822 \r
823       return;                   /* Need to suspend */\r
824 \r
825     main->context_state = CTX_PREPARE_FOR_IMCU;\r
826 \r
827     if (*out_row_ctr >= out_rows_avail)\r
828 \r
829       return;                   /* Postprocessor exactly filled output buf */\r
830 \r
831     /*FALLTHROUGH*/\r
832 \r
833   case CTX_PREPARE_FOR_IMCU:\r
834 \r
835     /* Prepare to process first M-1 row groups of this iMCU row */\r
836 \r
837     main->rowgroup_ctr = 0;\r
838 \r
839     main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size - 1);\r
840 \r
841     /* Check for bottom of image: if so, tweak pointers to "duplicate"\r
842 \r
843      * the last sample row, and adjust rowgroups_avail to ignore padding rows.\r
844 \r
845      */\r
846 \r
847     if (main->iMCU_row_ctr == cinfo->total_iMCU_rows)\r
848 \r
849       set_bottom_pointers(cinfo);\r
850 \r
851     main->context_state = CTX_PROCESS_IMCU;\r
852 \r
853     /*FALLTHROUGH*/\r
854 \r
855   case CTX_PROCESS_IMCU:\r
856 \r
857     /* Call postprocessor using previously set pointers */\r
858 \r
859     (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],\r
860 \r
861                         &main->rowgroup_ctr, main->rowgroups_avail,\r
862 \r
863                         output_buf, out_row_ctr, out_rows_avail);\r
864 \r
865     if (main->rowgroup_ctr < main->rowgroups_avail)\r
866 \r
867       return;                   /* Need to suspend */\r
868 \r
869     /* After the first iMCU, change wraparound pointers to normal state */\r
870 \r
871     if (main->iMCU_row_ctr == 1)\r
872 \r
873       set_wraparound_pointers(cinfo);\r
874 \r
875     /* Prepare to load new iMCU row using other xbuffer list */\r
876 \r
877     main->whichptr ^= 1;        /* 0=>1 or 1=>0 */\r
878 \r
879     main->buffer_full = FALSE;\r
880 \r
881     /* Still need to process last row group of this iMCU row, */\r
882 \r
883     /* which is saved at index M+1 of the other xbuffer */\r
884 \r
885     main->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_scaled_size + 1);\r
886 \r
887     main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size + 2);\r
888 \r
889     main->context_state = CTX_POSTPONED_ROW;\r
890 \r
891   }\r
892 \r
893 }\r
894 \r
895 \r
896 \r
897 \r
898 \r
899 /*\r
900 \r
901  * Process some data.\r
902 \r
903  * Final pass of two-pass quantization: just call the postprocessor.\r
904 \r
905  * Source data will be the postprocessor controller's internal buffer.\r
906 \r
907  */\r
908 \r
909 \r
910 \r
911 #ifdef QUANT_2PASS_SUPPORTED\r
912 \r
913 \r
914 \r
915 METHODDEF void\r
916 \r
917 process_data_crank_post (j_decompress_ptr cinfo,\r
918 \r
919                          JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,\r
920 \r
921                          JDIMENSION out_rows_avail)\r
922 \r
923 {\r
924 \r
925   (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,\r
926 \r
927                                      (JDIMENSION *) NULL, (JDIMENSION) 0,\r
928 \r
929                                      output_buf, out_row_ctr, out_rows_avail);\r
930 \r
931 }\r
932 \r
933 \r
934 \r
935 #endif /* QUANT_2PASS_SUPPORTED */\r
936 \r
937 \r
938 \r
939 \r
940 \r
941 /*\r
942 \r
943  * Initialize main buffer controller.\r
944 \r
945  */\r
946 \r
947 \r
948 \r
949 GLOBAL void\r
950 \r
951 jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)\r
952 \r
953 {\r
954 \r
955   my_main_ptr main;\r
956 \r
957   int ci, rgroup, ngroups;\r
958 \r
959   jpeg_component_info *compptr;\r
960 \r
961 \r
962 \r
963   main = (my_main_ptr)\r
964 \r
965     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,\r
966 \r
967                                 SIZEOF(my_main_controller));\r
968 \r
969   cinfo->main = (struct jpeg_d_main_controller *) main;\r
970 \r
971   main->pub.start_pass = start_pass_main;\r
972 \r
973 \r
974 \r
975   if (need_full_buffer)         /* shouldn't happen */\r
976 \r
977     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);\r
978 \r
979 \r
980 \r
981   /* Allocate the workspace.\r
982 \r
983    * ngroups is the number of row groups we need.\r
984 \r
985    */\r
986 \r
987   if (cinfo->upsample->need_context_rows) {\r
988 \r
989     if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */\r
990 \r
991       ERREXIT(cinfo, JERR_NOTIMPL);\r
992 \r
993     alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */\r
994 \r
995     ngroups = cinfo->min_DCT_scaled_size + 2;\r
996 \r
997   } else {\r
998 \r
999     ngroups = cinfo->min_DCT_scaled_size;\r
1000 \r
1001   }\r
1002 \r
1003 \r
1004 \r
1005   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;\r
1006 \r
1007        ci++, compptr++) {\r
1008 \r
1009     rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /\r
1010 \r
1011       cinfo->min_DCT_scaled_size; /* height of a row group of component */\r
1012 \r
1013     main->buffer[ci] = (*cinfo->mem->alloc_sarray)\r
1014 \r
1015                         ((j_common_ptr) cinfo, JPOOL_IMAGE,\r
1016 \r
1017                          compptr->width_in_blocks * compptr->DCT_scaled_size,\r
1018 \r
1019                          (JDIMENSION) (rgroup * ngroups));\r
1020 \r
1021   }\r
1022 \r
1023 }\r
1024 \r