OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [jpeg-6b/] [jdpostct.c] - Blame information for rev 174

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 27 unneback 
/*
2 
 * jdpostct.c
3 
 *
4 
 * Copyright (C) 1994-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 the decompression postprocessing controller.
9 
 * This controller manages the upsampling, color conversion, and color
10 
 * quantization/reduction steps; specifically, it controls the buffering
11 
 * between upsample/color conversion and color quantization/reduction.
12 
 *
13 
 * If no color quantization/reduction is required, then this module has no
14 
 * work to do, and it just hands off to the upsample/color conversion code.
15 
 * An integrated upsample/convert/quantize process would replace this module
16 
 * entirely.
17 
 */
18 
 
19 
#define JPEG_INTERNALS
20 
#include "jinclude.h"
21 
#include "jpeglib.h"
22 
 
23 
 
24 
/* Private buffer controller object */
25 
 
26 
typedef struct {
27 
  struct jpeg_d_post_controller pub; /* public fields */
28 
 
29 
  /* Color quantization source buffer: this holds output data from
30 
   * the upsample/color conversion step to be passed to the quantizer.
31 
   * For two-pass color quantization, we need a full-image buffer;
32 
   * for one-pass operation, a strip buffer is sufficient.
33 
   */
34 
  jvirt_sarray_ptr whole_image; /* virtual array, or NULL if one-pass */
35 
  JSAMPARRAY buffer;            /* strip buffer, or current strip of virtual */
36 
  JDIMENSION strip_height;      /* buffer size in rows */
37 
  /* for two-pass mode only: */
38 
  JDIMENSION starting_row;      /* row # of first row in current strip */
39 
  JDIMENSION next_row;          /* index of next row to fill/empty in strip */
40 
} my_post_controller;
41 
 
42 
typedef my_post_controller * my_post_ptr;
43 
 
44 
 
45 
/* Forward declarations */
46 
METHODDEF(void) post_process_1pass
47 
        JPP((j_decompress_ptr cinfo,
48 
             JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
49 
             JDIMENSION in_row_groups_avail,
50 
             JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
51 
             JDIMENSION out_rows_avail));
52 
#ifdef QUANT_2PASS_SUPPORTED
53 
METHODDEF(void) post_process_prepass
54 
        JPP((j_decompress_ptr cinfo,
55 
             JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
56 
             JDIMENSION in_row_groups_avail,
57 
             JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
58 
             JDIMENSION out_rows_avail));
59 
METHODDEF(void) post_process_2pass
60 
        JPP((j_decompress_ptr cinfo,
61 
             JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
62 
             JDIMENSION in_row_groups_avail,
63 
             JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
64 
             JDIMENSION out_rows_avail));
65 
#endif
66 
 
67 
 
68 
/*
69 
 * Initialize for a processing pass.
70 
 */
71 
 
72 
METHODDEF(void)
73 
start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
74 
{
75 
  my_post_ptr post = (my_post_ptr) cinfo->post;
76 
 
77 
  switch (pass_mode) {
78 
  case JBUF_PASS_THRU:
79 
    if (cinfo->quantize_colors) {
80 
      /* Single-pass processing with color quantization. */
81 
      post->pub.post_process_data = post_process_1pass;
82 
      /* We could be doing buffered-image output before starting a 2-pass
83 
       * color quantization; in that case, jinit_d_post_controller did not
84 
       * allocate a strip buffer.  Use the virtual-array buffer as workspace.
85 
       */
86 
      if (post->buffer == NULL) {
87 
        post->buffer = (*cinfo->mem->access_virt_sarray)
88 
          ((j_common_ptr) cinfo, post->whole_image,
89 
           (JDIMENSION) 0, post->strip_height, TRUE);
90 
      }
91 
    } else {
92 
      /* For single-pass processing without color quantization,
93 
       * I have no work to do; just call the upsampler directly.
94 
       */
95 
      post->pub.post_process_data = cinfo->upsample->upsample;
96 
    }
97 
    break;
98 
#ifdef QUANT_2PASS_SUPPORTED
99 
  case JBUF_SAVE_AND_PASS:
100 
    /* First pass of 2-pass quantization */
101 
    if (post->whole_image == NULL)
102 
      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
103 
    post->pub.post_process_data = post_process_prepass;
104 
    break;
105 
  case JBUF_CRANK_DEST:
106 
    /* Second pass of 2-pass quantization */
107 
    if (post->whole_image == NULL)
108 
      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
109 
    post->pub.post_process_data = post_process_2pass;
110 
    break;
111 
#endif /* QUANT_2PASS_SUPPORTED */
112 
  default:
113 
    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
114 
    break;
115 
  }
116 
  post->starting_row = post->next_row = 0;
117 
}
118 
 
119 
 
120 
/*
121 
 * Process some data in the one-pass (strip buffer) case.
122 
 * This is used for color precision reduction as well as one-pass quantization.
123 
 */
124 
 
125 
METHODDEF(void)
126 
post_process_1pass (j_decompress_ptr cinfo,
127 
                    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
128 
                    JDIMENSION in_row_groups_avail,
129 
                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
130 
                    JDIMENSION out_rows_avail)
131 
{
132 
  my_post_ptr post = (my_post_ptr) cinfo->post;
133 
  JDIMENSION num_rows, max_rows;
134 
 
135 
  /* Fill the buffer, but not more than what we can dump out in one go. */
136 
  /* Note we rely on the upsampler to detect bottom of image. */
137 
  max_rows = out_rows_avail - *out_row_ctr;
138 
  if (max_rows > post->strip_height)
139 
    max_rows = post->strip_height;
140 
  num_rows = 0;
141 
  (*cinfo->upsample->upsample) (cinfo,
142 
                input_buf, in_row_group_ctr, in_row_groups_avail,
143 
                post->buffer, &num_rows, max_rows);
144 
  /* Quantize and emit data. */
145 
  (*cinfo->cquantize->color_quantize) (cinfo,
146 
                post->buffer, output_buf + *out_row_ctr, (int) num_rows);
147 
  *out_row_ctr += num_rows;
148 
}
149 
 
150 
 
151 
#ifdef QUANT_2PASS_SUPPORTED
152 
 
153 
/*
154 
 * Process some data in the first pass of 2-pass quantization.
155 
 */
156 
 
157 
METHODDEF(void)
158 
post_process_prepass (j_decompress_ptr cinfo,
159 
                      JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
160 
                      JDIMENSION in_row_groups_avail,
161 
                      JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
162 
                      JDIMENSION out_rows_avail)
163 
{
164 
  my_post_ptr post = (my_post_ptr) cinfo->post;
165 
  JDIMENSION old_next_row, num_rows;
166 
 
167 
  /* Reposition virtual buffer if at start of strip. */
168 
  if (post->next_row == 0) {
169 
    post->buffer = (*cinfo->mem->access_virt_sarray)
170 
        ((j_common_ptr) cinfo, post->whole_image,
171 
         post->starting_row, post->strip_height, TRUE);
172 
  }
173 
 
174 
  /* Upsample some data (up to a strip height's worth). */
175 
  old_next_row = post->next_row;
176 
  (*cinfo->upsample->upsample) (cinfo,
177 
                input_buf, in_row_group_ctr, in_row_groups_avail,
178 
                post->buffer, &post->next_row, post->strip_height);
179 
 
180 
  /* Allow quantizer to scan new data.  No data is emitted, */
181 
  /* but we advance out_row_ctr so outer loop can tell when we're done. */
182 
  if (post->next_row > old_next_row) {
183 
    num_rows = post->next_row - old_next_row;
184 
    (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
185 
                                         (JSAMPARRAY) NULL, (int) num_rows);
186 
    *out_row_ctr += num_rows;
187 
  }
188 
 
189 
  /* Advance if we filled the strip. */
190 
  if (post->next_row >= post->strip_height) {
191 
    post->starting_row += post->strip_height;
192 
    post->next_row = 0;
193 
  }
194 
}
195 
 
196 
 
197 
/*
198 
 * Process some data in the second pass of 2-pass quantization.
199 
 */
200 
 
201 
METHODDEF(void)
202 
post_process_2pass (j_decompress_ptr cinfo,
203 
                    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
204 
                    JDIMENSION in_row_groups_avail,
205 
                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
206 
                    JDIMENSION out_rows_avail)
207 
{
208 
  my_post_ptr post = (my_post_ptr) cinfo->post;
209 
  JDIMENSION num_rows, max_rows;
210 
 
211 
  /* Reposition virtual buffer if at start of strip. */
212 
  if (post->next_row == 0) {
213 
    post->buffer = (*cinfo->mem->access_virt_sarray)
214 
        ((j_common_ptr) cinfo, post->whole_image,
215 
         post->starting_row, post->strip_height, FALSE);
216 
  }
217 
 
218 
  /* Determine number of rows to emit. */
219 
  num_rows = post->strip_height - post->next_row; /* available in strip */
220 
  max_rows = out_rows_avail - *out_row_ctr; /* available in output area */
221 
  if (num_rows > max_rows)
222 
    num_rows = max_rows;
223 
  /* We have to check bottom of image here, can't depend on upsampler. */
224 
  max_rows = cinfo->output_height - post->starting_row;
225 
  if (num_rows > max_rows)
226 
    num_rows = max_rows;
227 
 
228 
  /* Quantize and emit data. */
229 
  (*cinfo->cquantize->color_quantize) (cinfo,
230 
                post->buffer + post->next_row, output_buf + *out_row_ctr,
231 
                (int) num_rows);
232 
  *out_row_ctr += num_rows;
233 
 
234 
  /* Advance if we filled the strip. */
235 
  post->next_row += num_rows;
236 
  if (post->next_row >= post->strip_height) {
237 
    post->starting_row += post->strip_height;
238 
    post->next_row = 0;
239 
  }
240 
}
241 
 
242 
#endif /* QUANT_2PASS_SUPPORTED */
243 
 
244 
 
245 
/*
246 
 * Initialize postprocessing controller.
247 
 */
248 
 
249 
GLOBAL(void)
250 
jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
251 
{
252 
  my_post_ptr post;
253 
 
254 
  post = (my_post_ptr)
255 
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
256 
                                SIZEOF(my_post_controller));
257 
  cinfo->post = (struct jpeg_d_post_controller *) post;
258 
  post->pub.start_pass = start_pass_dpost;
259 
  post->whole_image = NULL;     /* flag for no virtual arrays */
260 
  post->buffer = NULL;          /* flag for no strip buffer */
261 
 
262 
  /* Create the quantization buffer, if needed */
263 
  if (cinfo->quantize_colors) {
264 
    /* The buffer strip height is max_v_samp_factor, which is typically
265 
     * an efficient number of rows for upsampling to return.
266 
     * (In the presence of output rescaling, we might want to be smarter?)
267 
     */
268 
    post->strip_height = (JDIMENSION) cinfo->max_v_samp_factor;
269 
    if (need_full_buffer) {
270 
      /* Two-pass color quantization: need full-image storage. */
271 
      /* We round up the number of rows to a multiple of the strip height. */
272 
#ifdef QUANT_2PASS_SUPPORTED
273 
      post->whole_image = (*cinfo->mem->request_virt_sarray)
274 
        ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
275 
         cinfo->output_width * cinfo->out_color_components,
276 
         (JDIMENSION) jround_up((long) cinfo->output_height,
277 
                                (long) post->strip_height),
278 
         post->strip_height);
279 
#else
280 
      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
281 
#endif /* QUANT_2PASS_SUPPORTED */
282 
    } else {
283 
      /* One-pass color quantization: just make a strip buffer. */
284 
      post->buffer = (*cinfo->mem->alloc_sarray)
285 
        ((j_common_ptr) cinfo, JPOOL_IMAGE,
286 
         cinfo->output_width * cinfo->out_color_components,
287 
         post->strip_height);
288 
    }
289 
  }
290 
}

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.