← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/libjpeg/jdsample.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/libjpeg/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
  /* Fill the conversion buffer, if it's empty */
 
101
  if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
 
102
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
 
103
         ci++, compptr++) {
 
104
      /* Invoke per-component upsample method.  Notice we pass a POINTER
 
105
       * to color_buf[ci], so that fullsize_upsample can change it.
 
106
       */
 
107
      (*upsample->methods[ci]) (cinfo, compptr,
 
108
        input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
 
109
        upsample->color_buf + ci);
 
110
    }
 
111
    upsample->next_row_out = 0;
 
112
  }
 
113
 
 
114
  /* Color-convert and emit rows */
 
115
 
 
116
  /* How many we have in the buffer: */
 
117
  num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out);
 
118
  /* Not more than the distance to the end of the image.  Need this test
 
119
   * in case the image height is not a multiple of max_v_samp_factor:
 
120
   */
 
121
  if (num_rows > upsample->rows_to_go) 
 
122
    num_rows = upsample->rows_to_go;
 
123
  /* And not more than what the client can accept: */
 
124
  out_rows_avail -= *out_row_ctr;
 
125
  if (num_rows > out_rows_avail)
 
126
    num_rows = out_rows_avail;
 
127
 
 
128
  (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
 
129
                                     (JDIMENSION) upsample->next_row_out,
 
130
                                     output_buf + *out_row_ctr,
 
131
                                     (int) num_rows);
 
132
 
 
133
  /* Adjust counts */
 
134
  *out_row_ctr += num_rows;
 
135
  upsample->rows_to_go -= num_rows;
 
136
  upsample->next_row_out += num_rows;
 
137
  /* When the buffer is emptied, declare this input row group consumed */
 
138
  if (upsample->next_row_out >= cinfo->max_v_samp_factor)
 
139
    (*in_row_group_ctr)++;
 
140
}
 
141
 
 
142
 
 
143
/*
 
144
 * These are the routines invoked by sep_upsample to upsample pixel values
 
145
 * of a single component.  One row group is processed per call.
 
146
 */
 
147
 
 
148
 
 
149
/*
 
150
 * For full-size components, we just make color_buf[ci] point at the
 
151
 * input buffer, and thus avoid copying any data.  Note that this is
 
152
 * safe only because sep_upsample doesn't declare the input row group
 
153
 * "consumed" until we are done color converting and emitting it.
 
154
 */
 
155
 
 
156
METHODDEF(void)
 
157
fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
158
                   JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 
159
{
 
160
  *output_data_ptr = input_data;
 
161
}
 
162
 
 
163
 
 
164
/*
 
165
 * This is a no-op version used for "uninteresting" components.
 
166
 * These components will not be referenced by color conversion.
 
167
 */
 
168
 
 
169
METHODDEF(void)
 
170
noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
171
               JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 
172
{
 
173
  *output_data_ptr = NULL;      /* safety check */
 
174
}
 
175
 
 
176
 
 
177
/*
 
178
 * This version handles any integral sampling ratios.
 
179
 * This is not used for typical JPEG files, so it need not be fast.
 
180
 * Nor, for that matter, is it particularly accurate: the algorithm is
 
181
 * simple replication of the input pixel onto the corresponding output
 
182
 * pixels.  The hi-falutin sampling literature refers to this as a
 
183
 * "box filter".  A box filter tends to introduce visible artifacts,
 
184
 * so if you are actually going to use 3:1 or 4:1 sampling ratios
 
185
 * you would be well advised to improve this code.
 
186
 */
 
187
 
 
188
METHODDEF(void)
 
189
int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
190
              JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 
191
{
 
192
  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
 
193
  JSAMPARRAY output_data = *output_data_ptr;
 
194
  register JSAMPROW inptr, outptr;
 
195
  register JSAMPLE invalue;
 
196
  register int h;
 
197
  JSAMPROW outend;
 
198
  int h_expand, v_expand;
 
199
  int inrow, outrow;
 
200
 
 
201
  h_expand = upsample->h_expand[compptr->component_index];
 
202
  v_expand = upsample->v_expand[compptr->component_index];
 
203
 
 
204
  inrow = outrow = 0;
 
205
  while (outrow < cinfo->max_v_samp_factor) {
 
206
    /* Generate one output row with proper horizontal expansion */
 
207
    inptr = input_data[inrow];
 
208
    outptr = output_data[outrow];
 
209
    outend = outptr + cinfo->output_width;
 
210
    while (outptr < outend) {
 
211
      invalue = *inptr++;       /* don't need GETJSAMPLE() here */
 
212
      for (h = h_expand; h > 0; h--) {
 
213
        *outptr++ = invalue;
 
214
      }
 
215
    }
 
216
    /* Generate any additional output rows by duplicating the first one */
 
217
    if (v_expand > 1) {
 
218
      jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
 
219
                        v_expand-1, cinfo->output_width);
 
220
    }
 
221
    inrow++;
 
222
    outrow += v_expand;
 
223
  }
 
224
}
 
225
 
 
226
 
 
227
/*
 
228
 * Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
 
229
 * It's still a box filter.
 
230
 */
 
231
 
 
232
METHODDEF(void)
 
233
h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
234
               JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 
235
{
 
236
  JSAMPARRAY output_data = *output_data_ptr;
 
237
  register JSAMPROW inptr, outptr;
 
238
  register JSAMPLE invalue;
 
239
  JSAMPROW outend;
 
240
  int inrow;
 
241
 
 
242
  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
 
243
    inptr = input_data[inrow];
 
244
    outptr = output_data[inrow];
 
245
    outend = outptr + cinfo->output_width;
 
246
    while (outptr < outend) {
 
247
      invalue = *inptr++;       /* don't need GETJSAMPLE() here */
 
248
      *outptr++ = invalue;
 
249
      *outptr++ = invalue;
 
250
    }
 
251
  }
 
252
}
 
253
 
 
254
 
 
255
/*
 
256
 * Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
 
257
 * It's still a box filter.
 
258
 */
 
259
 
 
260
METHODDEF(void)
 
261
h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
262
               JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 
263
{
 
264
  JSAMPARRAY output_data = *output_data_ptr;
 
265
  register JSAMPROW inptr, outptr;
 
266
  register JSAMPLE invalue;
 
267
  JSAMPROW outend;
 
268
  int inrow, outrow;
 
269
 
 
270
  inrow = outrow = 0;
 
271
  while (outrow < cinfo->max_v_samp_factor) {
 
272
    inptr = input_data[inrow];
 
273
    outptr = output_data[outrow];
 
274
    outend = outptr + cinfo->output_width;
 
275
    while (outptr < outend) {
 
276
      invalue = *inptr++;       /* don't need GETJSAMPLE() here */
 
277
      *outptr++ = invalue;
 
278
      *outptr++ = invalue;
 
279
    }
 
280
    jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
 
281
                      1, cinfo->output_width);
 
282
    inrow++;
 
283
    outrow += 2;
 
284
  }
 
285
}
 
286
 
 
287
 
 
288
/*
 
289
 * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
 
290
 *
 
291
 * The upsampling algorithm is linear interpolation between pixel centers,
 
292
 * also known as a "triangle filter".  This is a good compromise between
 
293
 * speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
 
294
 * of the way between input pixel centers.
 
295
 *
 
296
 * A note about the "bias" calculations: when rounding fractional values to
 
297
 * integer, we do not want to always round 0.5 up to the next integer.
 
298
 * If we did that, we'd introduce a noticeable bias towards larger values.
 
299
 * Instead, this code is arranged so that 0.5 will be rounded up or down at
 
300
 * alternate pixel locations (a simple ordered dither pattern).
 
301
 */
 
302
 
 
303
METHODDEF(void)
 
304
h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
305
                     JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 
306
{
 
307
  JSAMPARRAY output_data = *output_data_ptr;
 
308
  register JSAMPROW inptr, outptr;
 
309
  register int invalue;
 
310
  register JDIMENSION colctr;
 
311
  int inrow;
 
312
 
 
313
  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
 
314
    inptr = input_data[inrow];
 
315
    outptr = output_data[inrow];
 
316
    /* Special case for first column */
 
317
    invalue = GETJSAMPLE(*inptr++);
 
318
    *outptr++ = (JSAMPLE) invalue;
 
319
    *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2);
 
320
 
 
321
    for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
 
322
      /* General case: 3/4 * nearer pixel + 1/4 * further pixel */
 
323
      invalue = GETJSAMPLE(*inptr++) * 3;
 
324
      *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2);
 
325
      *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2);
 
326
    }
 
327
 
 
328
    /* Special case for last column */
 
329
    invalue = GETJSAMPLE(*inptr);
 
330
    *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2);
 
331
    *outptr++ = (JSAMPLE) invalue;
 
332
  }
 
333
}
 
334
 
 
335
 
 
336
/*
 
337
 * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
 
338
 * Again a triangle filter; see comments for h2v1 case, above.
 
339
 *
 
340
 * It is OK for us to reference the adjacent input rows because we demanded
 
341
 * context from the main buffer controller (see initialization code).
 
342
 */
 
343
 
 
344
METHODDEF(void)
 
345
h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
346
                     JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 
347
{
 
348
  JSAMPARRAY output_data = *output_data_ptr;
 
349
  register JSAMPROW inptr0, inptr1, outptr;
 
350
#if BITS_IN_JSAMPLE == 8
 
351
  register int thiscolsum, lastcolsum, nextcolsum;
 
352
#else
 
353
  register INT32 thiscolsum, lastcolsum, nextcolsum;
 
354
#endif
 
355
  register JDIMENSION colctr;
 
356
  int inrow, outrow, v;
 
357
 
 
358
  inrow = outrow = 0;
 
359
  while (outrow < cinfo->max_v_samp_factor) {
 
360
    for (v = 0; v < 2; v++) {
 
361
      /* inptr0 points to nearest input row, inptr1 points to next nearest */
 
362
      inptr0 = input_data[inrow];
 
363
      if (v == 0)               /* next nearest is row above */
 
364
        inptr1 = input_data[inrow-1];
 
365
      else                      /* next nearest is row below */
 
366
        inptr1 = input_data[inrow+1];
 
367
      outptr = output_data[outrow++];
 
368
 
 
369
      /* Special case for first column */
 
370
      thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
 
371
      nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
 
372
      *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4);
 
373
      *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
 
374
      lastcolsum = thiscolsum; thiscolsum = nextcolsum;
 
375
 
 
376
      for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
 
377
        /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
 
378
        /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
 
379
        nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
 
380
        *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
 
381
        *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
 
382
        lastcolsum = thiscolsum; thiscolsum = nextcolsum;
 
383
      }
 
384
 
 
385
      /* Special case for last column */
 
386
      *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
 
387
      *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4);
 
388
    }
 
389
    inrow++;
 
390
  }
 
391
}
 
392
 
 
393
 
 
394
/*
 
395
 * Module initialization routine for upsampling.
 
396
 */
 
397
 
 
398
GLOBAL(void)
 
399
jinit_upsampler (j_decompress_ptr cinfo)
 
400
{
 
401
  my_upsample_ptr upsample;
 
402
  int ci;
 
403
  jpeg_component_info * compptr;
 
404
  boolean need_buffer, do_fancy;
 
405
  int h_in_group, v_in_group, h_out_group, v_out_group;
 
406
 
 
407
  upsample = (my_upsample_ptr)
 
408
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 
409
                                SIZEOF(my_upsampler));
 
410
  cinfo->upsample = (struct jpeg_upsampler *) upsample;
 
411
  upsample->pub.start_pass = start_pass_upsample;
 
412
  upsample->pub.upsample = sep_upsample;
 
413
  upsample->pub.need_context_rows = FALSE; /* until we find out differently */
 
414
 
 
415
  if (cinfo->CCIR601_sampling)  /* this isn't supported */
 
416
    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
 
417
 
 
418
  /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
 
419
   * so don't ask for it.
 
420
   */
 
421
  do_fancy = cinfo->do_fancy_upsampling && cinfo->min_DCT_scaled_size > 1;
 
422
 
 
423
  /* Verify we can handle the sampling factors, select per-component methods,
 
424
   * and create storage as needed.
 
425
   */
 
426
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
 
427
       ci++, compptr++) {
 
428
    /* Compute size of an "input group" after IDCT scaling.  This many samples
 
429
     * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
 
430
     */
 
431
    h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) /
 
432
                 cinfo->min_DCT_scaled_size;
 
433
    v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
 
434
                 cinfo->min_DCT_scaled_size;
 
435
    h_out_group = cinfo->max_h_samp_factor;
 
436
    v_out_group = cinfo->max_v_samp_factor;
 
437
    upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
 
438
    need_buffer = TRUE;
 
439
    if (! compptr->component_needed) {
 
440
      /* Don't bother to upsample an uninteresting component. */
 
441
      upsample->methods[ci] = noop_upsample;
 
442
      need_buffer = FALSE;
 
443
    } else if (h_in_group == h_out_group && v_in_group == v_out_group) {
 
444
      /* Fullsize components can be processed without any work. */
 
445
      upsample->methods[ci] = fullsize_upsample;
 
446
      need_buffer = FALSE;
 
447
    } else if (h_in_group * 2 == h_out_group &&
 
448
               v_in_group == v_out_group) {
 
449
      /* Special cases for 2h1v upsampling */
 
450
      if (do_fancy && compptr->downsampled_width > 2)
 
451
        upsample->methods[ci] = h2v1_fancy_upsample;
 
452
      else
 
453
        upsample->methods[ci] = h2v1_upsample;
 
454
    } else if (h_in_group * 2 == h_out_group &&
 
455
               v_in_group * 2 == v_out_group) {
 
456
      /* Special cases for 2h2v upsampling */
 
457
      if (do_fancy && compptr->downsampled_width > 2) {
 
458
        upsample->methods[ci] = h2v2_fancy_upsample;
 
459
        upsample->pub.need_context_rows = TRUE;
 
460
      } else
 
461
        upsample->methods[ci] = h2v2_upsample;
 
462
    } else if ((h_out_group % h_in_group) == 0 &&
 
463
               (v_out_group % v_in_group) == 0) {
 
464
      /* Generic integral-factors upsampling method */
 
465
      upsample->methods[ci] = int_upsample;
 
466
      upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
 
467
      upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group);
 
468
    } else
 
469
      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
 
470
    if (need_buffer) {
 
471
      upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
 
472
        ((j_common_ptr) cinfo, JPOOL_IMAGE,
 
473
         (JDIMENSION) jround_up((long) cinfo->output_width,
 
474
                                (long) cinfo->max_h_samp_factor),
 
475
         (JDIMENSION) cinfo->max_v_samp_factor);
 
476
    }
 
477
  }
 
478
}