]> Creatis software - gdcm.git/blob - src/jpeg/libijg/jdsample.c
ENH: I am a moron. Fix compilation of gdcm in static mode, I had to add some new...
[gdcm.git] / src / jpeg / libijg / jdsample.c
1 /*
2  * jdsample.c
3  *
4  * Copyright (C) 1991-1996, 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 upsampling routines.
9  *
10  * Upsampling input data is counted in "row groups".  A row group
11  * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
12  * sample rows of each component.  Upsampling will normally produce
13  * max_v_samp_factor pixel rows from each row group (but this could vary
14  * if the upsampler is applying a scale factor of its own).
15  *
16  * An excellent reference for image resampling is
17  *   Digital Image Warping, George Wolberg, 1990.
18  *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
19  */
20
21 #define JPEG_INTERNALS
22 #include "jinclude.h"
23 #include "jpeglib.h"
24
25
26 /* Pointer to routine to upsample a single component */
27 typedef JMETHOD(void, upsample1_ptr,
28     (j_decompress_ptr cinfo, jpeg_component_info * compptr,
29      JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
30
31 /* Private subobject */
32
33 typedef struct {
34   struct jpeg_upsampler pub;  /* public fields */
35
36   /* Color conversion buffer.  When using separate upsampling and color
37    * conversion steps, this buffer holds one upsampled row group until it
38    * has been color converted and output.
39    * Note: we do not allocate any storage for component(s) which are full-size,
40    * ie do not need rescaling.  The corresponding entry of color_buf[] is
41    * simply set to point to the input data array, thereby avoiding copying.
42    */
43   JSAMPARRAY color_buf[MAX_COMPONENTS];
44
45   /* Per-component upsampling method pointers */
46   upsample1_ptr methods[MAX_COMPONENTS];
47
48   int next_row_out;    /* counts rows emitted from color_buf */
49   JDIMENSION rows_to_go;  /* counts rows remaining in image */
50
51   /* Height of an input row group for each component. */
52   int rowgroup_height[MAX_COMPONENTS];
53
54   /* These arrays save pixel expansion factors so that int_expand need not
55    * recompute them each time.  They are unused for other upsampling methods.
56    */
57   UINT8 h_expand[MAX_COMPONENTS];
58   UINT8 v_expand[MAX_COMPONENTS];
59 } my_upsampler;
60
61 typedef my_upsampler * my_upsample_ptr;
62
63
64 /*
65  * Initialize for an upsampling pass.
66  */
67
68 METHODDEF(void)
69 start_pass_upsample (j_decompress_ptr cinfo)
70 {
71   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
72
73   /* Mark the conversion buffer empty */
74   upsample->next_row_out = cinfo->max_v_samp_factor;
75   /* Initialize total-height counter for detecting bottom of image */
76   upsample->rows_to_go = cinfo->output_height;
77 }
78
79
80 /*
81  * Control routine to do upsampling (and color conversion).
82  *
83  * In this version we upsample each component independently.
84  * We upsample one row group into the conversion buffer, then apply
85  * color conversion a row at a time.
86  */
87
88 METHODDEF(void)
89 sep_upsample (j_decompress_ptr cinfo,
90         JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
91         JDIMENSION in_row_groups_avail,
92         JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
93         JDIMENSION out_rows_avail)
94 {
95   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
96   int ci;
97   jpeg_component_info * compptr;
98   JDIMENSION num_rows;
99
100   in_row_groups_avail = 0;
101   /* Fill the conversion buffer, if it's empty */
102   if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
103     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
104    ci++, compptr++) {
105       /* Invoke per-component upsample method.  Notice we pass a POINTER
106        * to color_buf[ci], so that fullsize_upsample can change it.
107        */
108       (*upsample->methods[ci]) (cinfo, compptr,
109   input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
110   upsample->color_buf + ci);
111     }
112     upsample->next_row_out = 0;
113   }
114
115   /* Color-convert and emit rows */
116
117   /* How many we have in the buffer: */
118   num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out);
119   /* Not more than the distance to the end of the image.  Need this test
120    * in case the image height is not a multiple of max_v_samp_factor:
121    */
122   if (num_rows > upsample->rows_to_go) 
123     num_rows = upsample->rows_to_go;
124   /* And not more than what the client can accept: */
125   out_rows_avail -= *out_row_ctr;
126   if (num_rows > out_rows_avail)
127     num_rows = out_rows_avail;
128
129   (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
130              (JDIMENSION) upsample->next_row_out,
131              output_buf + *out_row_ctr,
132              (int) num_rows);
133
134   /* Adjust counts */
135   *out_row_ctr += num_rows;
136   upsample->rows_to_go -= num_rows;
137   upsample->next_row_out += num_rows;
138   /* When the buffer is emptied, declare this input row group consumed */
139   if (upsample->next_row_out >= cinfo->max_v_samp_factor)
140     (*in_row_group_ctr)++;
141 }
142
143
144 /*
145  * These are the routines invoked by sep_upsample to upsample pixel values
146  * of a single component.  One row group is processed per call.
147  */
148
149
150 /*
151  * For full-size components, we just make color_buf[ci] point at the
152  * input buffer, and thus avoid copying any data.  Note that this is
153  * safe only because sep_upsample doesn't declare the input row group
154  * "consumed" until we are done color converting and emitting it.
155  */
156
157 METHODDEF(void)
158 fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
159        JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
160 {
161   cinfo = 0;
162   compptr = 0;
163   *output_data_ptr = input_data;
164 }
165
166
167 /*
168  * This is a no-op version used for "uninteresting" components.
169  * These components will not be referenced by color conversion.
170  */
171
172 METHODDEF(void)
173 noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
174          JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
175 {
176   cinfo = 0;
177   compptr = 0;
178   input_data = 0;
179   *output_data_ptr = NULL;  /* safety check */
180 }
181
182
183 /*
184  * This version handles any integral sampling ratios.
185  * This is not used for typical JPEG files, so it need not be fast.
186  * Nor, for that matter, is it particularly accurate: the algorithm is
187  * simple replication of the input pixel onto the corresponding output
188  * pixels.  The hi-falutin sampling literature refers to this as a
189  * "box filter".  A box filter tends to introduce visible artifacts,
190  * so if you are actually going to use 3:1 or 4:1 sampling ratios
191  * you would be well advised to improve this code.
192  */
193
194 METHODDEF(void)
195 int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
196         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
197 {
198   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
199   JSAMPARRAY output_data = *output_data_ptr;
200   register JSAMPROW inptr, outptr;
201   register JSAMPLE invalue;
202   register int h;
203   JSAMPROW outend;
204   int h_expand, v_expand;
205   int inrow, outrow;
206
207   h_expand = upsample->h_expand[compptr->component_index];
208   v_expand = upsample->v_expand[compptr->component_index];
209
210   inrow = outrow = 0;
211   while (outrow < cinfo->max_v_samp_factor) {
212     /* Generate one output row with proper horizontal expansion */
213     inptr = input_data[inrow];
214     outptr = output_data[outrow];
215     outend = outptr + cinfo->output_width;
216     while (outptr < outend) {
217       invalue = *inptr++;  /* don't need GETJSAMPLE() here */
218       for (h = h_expand; h > 0; h--) {
219   *outptr++ = invalue;
220       }
221     }
222     /* Generate any additional output rows by duplicating the first one */
223     if (v_expand > 1) {
224       jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
225       v_expand-1, cinfo->output_width);
226     }
227     inrow++;
228     outrow += v_expand;
229   }
230 }
231
232
233 /*
234  * Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
235  * It's still a box filter.
236  */
237
238 METHODDEF(void)
239 h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
240          JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
241 {
242   JSAMPARRAY output_data = *output_data_ptr;
243   register JSAMPROW inptr, outptr;
244   register JSAMPLE invalue;
245   JSAMPROW outend;
246   int inrow;
247
248   compptr = 0;
249   for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
250     inptr = input_data[inrow];
251     outptr = output_data[inrow];
252     outend = outptr + cinfo->output_width;
253     while (outptr < outend) {
254       invalue = *inptr++;  /* don't need GETJSAMPLE() here */
255       *outptr++ = invalue;
256       *outptr++ = invalue;
257     }
258   }
259 }
260
261
262 /*
263  * Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
264  * It's still a box filter.
265  */
266
267 METHODDEF(void)
268 h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
269          JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
270 {
271   JSAMPARRAY output_data = *output_data_ptr;
272   register JSAMPROW inptr, outptr;
273   register JSAMPLE invalue;
274   JSAMPROW outend;
275   int inrow, outrow;
276
277   compptr = 0;
278   inrow = outrow = 0;
279   while (outrow < cinfo->max_v_samp_factor) {
280     inptr = input_data[inrow];
281     outptr = output_data[outrow];
282     outend = outptr + cinfo->output_width;
283     while (outptr < outend) {
284       invalue = *inptr++;  /* don't need GETJSAMPLE() here */
285       *outptr++ = invalue;
286       *outptr++ = invalue;
287     }
288     jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
289           1, cinfo->output_width);
290     inrow++;
291     outrow += 2;
292   }
293 }
294
295
296 /*
297  * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
298  *
299  * The upsampling algorithm is linear interpolation between pixel centers,
300  * also known as a "triangle filter".  This is a good compromise between
301  * speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
302  * of the way between input pixel centers.
303  *
304  * A note about the "bias" calculations: when rounding fractional values to
305  * integer, we do not want to always round 0.5 up to the next integer.
306  * If we did that, we'd introduce a noticeable bias towards larger values.
307  * Instead, this code is arranged so that 0.5 will be rounded up or down at
308  * alternate pixel locations (a simple ordered dither pattern).
309  */
310
311 METHODDEF(void)
312 h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
313          JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
314 {
315   JSAMPARRAY output_data = *output_data_ptr;
316   register JSAMPROW inptr, outptr;
317   register int invalue;
318   register JDIMENSION colctr;
319   int inrow;
320
321   for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
322     inptr = input_data[inrow];
323     outptr = output_data[inrow];
324     /* Special case for first column */
325     invalue = GETJSAMPLE(*inptr++);
326     *outptr++ = (JSAMPLE) invalue;
327     *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2);
328
329     for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
330       /* General case: 3/4 * nearer pixel + 1/4 * further pixel */
331       invalue = GETJSAMPLE(*inptr++) * 3;
332       *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2);
333       *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2);
334     }
335
336     /* Special case for last column */
337     invalue = GETJSAMPLE(*inptr);
338     *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2);
339     *outptr++ = (JSAMPLE) invalue;
340   }
341 }
342
343
344 /*
345  * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
346  * Again a triangle filter; see comments for h2v1 case, above.
347  *
348  * It is OK for us to reference the adjacent input rows because we demanded
349  * context from the main buffer controller (see initialization code).
350  */
351
352 METHODDEF(void)
353 h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
354          JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
355 {
356   JSAMPARRAY output_data = *output_data_ptr;
357   register JSAMPROW inptr0, inptr1, outptr;
358 #if BITS_IN_JSAMPLE == 8
359   register int thiscolsum, lastcolsum, nextcolsum;
360 #else
361   register INT32 thiscolsum, lastcolsum, nextcolsum;
362 #endif
363   register JDIMENSION colctr;
364   int inrow, outrow, v;
365
366   inrow = outrow = 0;
367   while (outrow < cinfo->max_v_samp_factor) {
368     for (v = 0; v < 2; v++) {
369       /* inptr0 points to nearest input row, inptr1 points to next nearest */
370       inptr0 = input_data[inrow];
371       if (v == 0)    /* next nearest is row above */
372   inptr1 = input_data[inrow-1];
373       else      /* next nearest is row below */
374   inptr1 = input_data[inrow+1];
375       outptr = output_data[outrow++];
376
377       /* Special case for first column */
378       thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
379       nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
380       *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4);
381       *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
382       lastcolsum = thiscolsum; thiscolsum = nextcolsum;
383
384       for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
385   /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
386   /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
387   nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
388   *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
389   *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
390   lastcolsum = thiscolsum; thiscolsum = nextcolsum;
391       }
392
393       /* Special case for last column */
394       *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
395       *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4);
396     }
397     inrow++;
398   }
399 }
400
401
402 /*
403  * Module initialization routine for upsampling.
404  */
405
406 GLOBAL(void)
407 jinit_upsampler (j_decompress_ptr cinfo)
408 {
409   my_upsample_ptr upsample;
410   int ci;
411   jpeg_component_info * compptr;
412   boolean need_buffer, do_fancy;
413   int h_in_group, v_in_group, h_out_group, v_out_group;
414
415   upsample = (my_upsample_ptr)
416     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
417         SIZEOF(my_upsampler));
418   cinfo->upsample = (struct jpeg_upsampler *) upsample;
419   upsample->pub.start_pass = start_pass_upsample;
420   upsample->pub.upsample = sep_upsample;
421   upsample->pub.need_context_rows = FALSE; /* until we find out differently */
422
423   if (cinfo->CCIR601_sampling)  /* this isn't supported */
424     ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
425
426   /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
427    * so don't ask for it.
428    */
429   do_fancy = cinfo->do_fancy_upsampling && cinfo->min_DCT_scaled_size > 1;
430
431   /* Verify we can handle the sampling factors, select per-component methods,
432    * and create storage as needed.
433    */
434   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
435        ci++, compptr++) {
436     /* Compute size of an "input group" after IDCT scaling.  This many samples
437      * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
438      */
439     h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) /
440      cinfo->min_DCT_scaled_size;
441     v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
442      cinfo->min_DCT_scaled_size;
443     h_out_group = cinfo->max_h_samp_factor;
444     v_out_group = cinfo->max_v_samp_factor;
445     upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
446     need_buffer = TRUE;
447     if (! compptr->component_needed) {
448       /* Don't bother to upsample an uninteresting component. */
449       upsample->methods[ci] = noop_upsample;
450       need_buffer = FALSE;
451     } else if (h_in_group == h_out_group && v_in_group == v_out_group) {
452       /* Fullsize components can be processed without any work. */
453       upsample->methods[ci] = fullsize_upsample;
454       need_buffer = FALSE;
455     } else if (h_in_group * 2 == h_out_group &&
456          v_in_group == v_out_group) {
457       /* Special cases for 2h1v upsampling */
458       if (do_fancy && compptr->downsampled_width > 2)
459   upsample->methods[ci] = h2v1_fancy_upsample;
460       else
461   upsample->methods[ci] = h2v1_upsample;
462     } else if (h_in_group * 2 == h_out_group &&
463          v_in_group * 2 == v_out_group) {
464       /* Special cases for 2h2v upsampling */
465       if (do_fancy && compptr->downsampled_width > 2) {
466   upsample->methods[ci] = h2v2_fancy_upsample;
467   upsample->pub.need_context_rows = TRUE;
468       } else
469   upsample->methods[ci] = h2v2_upsample;
470     } else if ((h_out_group % h_in_group) == 0 &&
471          (v_out_group % v_in_group) == 0) {
472       /* Generic integral-factors upsampling method */
473       upsample->methods[ci] = int_upsample;
474       upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
475       upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group);
476     } else
477       ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
478     if (need_buffer) {
479       upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
480   ((j_common_ptr) cinfo, JPOOL_IMAGE,
481    (JDIMENSION) jround_up((long) cinfo->output_width,
482         (long) cinfo->max_h_samp_factor),
483    (JDIMENSION) cinfo->max_v_samp_factor);
484     }
485   }
486 }