Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(333)

Side by Side Diff: third_party/libjpeg_turbo/jdcolor.c

Issue 7554002: Updates libjpeg-turbo to 1.1.90 (r677) (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/
Patch Set: '' Created 9 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « third_party/libjpeg_turbo/jdcoefct.c ('k') | third_party/libjpeg_turbo/jddctmgr.c » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * jdcolor.c 2 * jdcolor.c
3 * 3 *
4 * Copyright (C) 1991-1997, Thomas G. Lane. 4 * Copyright (C) 1991-1997, Thomas G. Lane.
5 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB 5 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
6 * Copyright (C) 2009, D. R. Commander. 6 * Copyright (C) 2009, D. R. Commander.
7 * This file is part of the Independent JPEG Group's software. 7 * This file is part of the Independent JPEG Group's software.
8 * For conditions of distribution and use, see the accompanying README file. 8 * For conditions of distribution and use, see the accompanying README file.
9 * 9 *
10 * This file contains output colorspace conversion routines. 10 * This file contains output colorspace conversion routines.
11 */ 11 */
12 12
13 #define JPEG_INTERNALS 13 #define JPEG_INTERNALS
14 #include "jinclude.h" 14 #include "jinclude.h"
15 #include "jpeglib.h" 15 #include "jpeglib.h"
16 #include "jsimd.h" 16 #include "jsimd.h"
17 17
18 18
19 /* Private subobject */ 19 /* Private subobject */
20 20
21 typedef struct { 21 typedef struct {
22 struct jpeg_color_deconverter pub; /* public fields */ 22 struct jpeg_color_deconverter pub; /* public fields */
23 23
24 /* Private state for YCC->RGB conversion */ 24 /* Private state for YCC->RGB conversion */
25 int * Cr_r_tab; /* => table for Cr to R conversion */ 25 int * Cr_r_tab;» » /* => table for Cr to R conversion */
26 int * Cb_b_tab; /* => table for Cb to B conversion */ 26 int * Cb_b_tab;» » /* => table for Cb to B conversion */
27 INT32 * Cr_g_tab; /* => table for Cr to G conversion */ 27 INT32 * Cr_g_tab;» » /* => table for Cr to G conversion */
28 INT32 * Cb_g_tab; /* => table for Cb to G conversion */ 28 INT32 * Cb_g_tab;» » /* => table for Cb to G conversion */
29 } my_color_deconverter; 29 } my_color_deconverter;
30 30
31 typedef my_color_deconverter * my_cconvert_ptr; 31 typedef my_color_deconverter * my_cconvert_ptr;
32 32
33 33
34 /**************** YCbCr -> RGB conversion: most common case **************/ 34 /**************** YCbCr -> RGB conversion: most common case **************/
35 35
36 /* 36 /*
37 * YCbCr is defined per CCIR 601-1, except that Cb and Cr are 37 * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
38 * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5. 38 * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
39 * The conversion equations to be implemented are therefore 39 * The conversion equations to be implemented are therefore
40 * R = Y + 1.40200 * Cr 40 *» R = Y + 1.40200 * Cr
41 * G = Y - 0.34414 * Cb - 0.71414 * Cr 41 *» G = Y - 0.34414 * Cb - 0.71414 * Cr
42 * B = Y + 1.77200 * Cb 42 *» B = Y + 1.77200 * Cb
43 * where Cb and Cr represent the incoming values less CENTERJSAMPLE. 43 * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
44 * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.) 44 * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
45 * 45 *
46 * To avoid floating-point arithmetic, we represent the fractional constants 46 * To avoid floating-point arithmetic, we represent the fractional constants
47 * as integers scaled up by 2^16 (about 4 digits precision); we have to divide 47 * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
48 * the products by 2^16, with appropriate rounding, to get the correct answer. 48 * the products by 2^16, with appropriate rounding, to get the correct answer.
49 * Notice that Y, being an integral input, does not contribute any fraction 49 * Notice that Y, being an integral input, does not contribute any fraction
50 * so it need not participate in the rounding. 50 * so it need not participate in the rounding.
51 * 51 *
52 * For even more speed, we avoid doing any multiplications in the inner loop 52 * For even more speed, we avoid doing any multiplications in the inner loop
53 * by precalculating the constants times Cb and Cr for all possible values. 53 * by precalculating the constants times Cb and Cr for all possible values.
54 * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table); 54 * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
55 * for 12-bit samples it is still acceptable. It's not very reasonable for 55 * for 12-bit samples it is still acceptable. It's not very reasonable for
56 * 16-bit samples, but if you want lossless storage you shouldn't be changing 56 * 16-bit samples, but if you want lossless storage you shouldn't be changing
57 * colorspace anyway. 57 * colorspace anyway.
58 * The Cr=>R and Cb=>B values can be rounded to integers in advance; the 58 * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
59 * values for the G calculation are left scaled up, since we must add them 59 * values for the G calculation are left scaled up, since we must add them
60 * together before rounding. 60 * together before rounding.
61 */ 61 */
62 62
63 #define SCALEBITS 16 /* speediest right-shift on some machines */ 63 #define SCALEBITS» 16» /* speediest right-shift on some machines */
64 #define ONE_HALF ((INT32) 1 << (SCALEBITS-1)) 64 #define ONE_HALF» ((INT32) 1 << (SCALEBITS-1))
65 #define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5)) 65 #define FIX(x)» » ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
66 66
67 67
68 /* 68 /*
69 * Initialize tables for YCC->RGB colorspace conversion. 69 * Initialize tables for YCC->RGB colorspace conversion.
70 */ 70 */
71 71
72 LOCAL(void) 72 LOCAL(void)
73 build_ycc_rgb_table (j_decompress_ptr cinfo) 73 build_ycc_rgb_table (j_decompress_ptr cinfo)
74 { 74 {
75 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; 75 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
76 int i; 76 int i;
77 INT32 x; 77 INT32 x;
78 SHIFT_TEMPS 78 SHIFT_TEMPS
79 79
80 cconvert->Cr_r_tab = (int *) 80 cconvert->Cr_r_tab = (int *)
81 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 81 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
82 (MAXJSAMPLE+1) * SIZEOF(int)); 82 » » » » (MAXJSAMPLE+1) * SIZEOF(int));
83 cconvert->Cb_b_tab = (int *) 83 cconvert->Cb_b_tab = (int *)
84 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 84 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
85 (MAXJSAMPLE+1) * SIZEOF(int)); 85 » » » » (MAXJSAMPLE+1) * SIZEOF(int));
86 cconvert->Cr_g_tab = (INT32 *) 86 cconvert->Cr_g_tab = (INT32 *)
87 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 87 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
88 (MAXJSAMPLE+1) * SIZEOF(INT32)); 88 » » » » (MAXJSAMPLE+1) * SIZEOF(INT32));
89 cconvert->Cb_g_tab = (INT32 *) 89 cconvert->Cb_g_tab = (INT32 *)
90 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 90 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
91 (MAXJSAMPLE+1) * SIZEOF(INT32)); 91 » » » » (MAXJSAMPLE+1) * SIZEOF(INT32));
92 92
93 for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) { 93 for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
94 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */ 94 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
95 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */ 95 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
96 /* Cr=>R value is nearest int to 1.40200 * x */ 96 /* Cr=>R value is nearest int to 1.40200 * x */
97 cconvert->Cr_r_tab[i] = (int) 97 cconvert->Cr_r_tab[i] = (int)
98 RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS); 98 » » RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
99 /* Cb=>B value is nearest int to 1.77200 * x */ 99 /* Cb=>B value is nearest int to 1.77200 * x */
100 cconvert->Cb_b_tab[i] = (int) 100 cconvert->Cb_b_tab[i] = (int)
101 RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS); 101 » » RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
102 /* Cr=>G value is scaled-up -0.71414 * x */ 102 /* Cr=>G value is scaled-up -0.71414 * x */
103 cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x; 103 cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
104 /* Cb=>G value is scaled-up -0.34414 * x */ 104 /* Cb=>G value is scaled-up -0.34414 * x */
105 /* We also add in ONE_HALF so that need not do it in inner loop */ 105 /* We also add in ONE_HALF so that need not do it in inner loop */
106 cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF; 106 cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
107 } 107 }
108 } 108 }
109 109
110 110
111 /* 111 /*
112 * Convert some rows of samples to the output colorspace. 112 * Convert some rows of samples to the output colorspace.
113 * 113 *
114 * Note that we change from noninterleaved, one-plane-per-component format 114 * Note that we change from noninterleaved, one-plane-per-component format
115 * to interleaved-pixel format. The output buffer is therefore three times 115 * to interleaved-pixel format. The output buffer is therefore three times
116 * as wide as the input buffer. 116 * as wide as the input buffer.
117 * A starting row offset is provided only for the input buffer. The caller 117 * A starting row offset is provided only for the input buffer. The caller
118 * can easily adjust the passed output_buf value to accommodate any row 118 * can easily adjust the passed output_buf value to accommodate any row
119 * offset required on that side. 119 * offset required on that side.
120 */ 120 */
121 121
122 METHODDEF(void) 122 METHODDEF(void)
123 ycc_rgb_convert (j_decompress_ptr cinfo, 123 ycc_rgb_convert (j_decompress_ptr cinfo,
124 JSAMPIMAGE input_buf, JDIMENSION input_row, 124 » » JSAMPIMAGE input_buf, JDIMENSION input_row,
125 JSAMPARRAY output_buf, int num_rows) 125 » » JSAMPARRAY output_buf, int num_rows)
126 { 126 {
127 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; 127 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
128 register int y, cb, cr; 128 register int y, cb, cr;
129 register JSAMPROW outptr; 129 register JSAMPROW outptr;
130 register JSAMPROW inptr0, inptr1, inptr2; 130 register JSAMPROW inptr0, inptr1, inptr2;
131 register JDIMENSION col; 131 register JDIMENSION col;
132 JDIMENSION num_cols = cinfo->output_width; 132 JDIMENSION num_cols = cinfo->output_width;
133 int rindex = rgb_red[cinfo->out_color_space];
134 int gindex = rgb_green[cinfo->out_color_space];
135 int bindex = rgb_blue[cinfo->out_color_space];
136 int rgbstride = rgb_pixelsize[cinfo->out_color_space];
133 /* copy these pointers into registers if possible */ 137 /* copy these pointers into registers if possible */
134 register JSAMPLE * range_limit = cinfo->sample_range_limit; 138 register JSAMPLE * range_limit = cinfo->sample_range_limit;
135 register int * Crrtab = cconvert->Cr_r_tab; 139 register int * Crrtab = cconvert->Cr_r_tab;
136 register int * Cbbtab = cconvert->Cb_b_tab; 140 register int * Cbbtab = cconvert->Cb_b_tab;
137 register INT32 * Crgtab = cconvert->Cr_g_tab; 141 register INT32 * Crgtab = cconvert->Cr_g_tab;
138 register INT32 * Cbgtab = cconvert->Cb_g_tab; 142 register INT32 * Cbgtab = cconvert->Cb_g_tab;
139 SHIFT_TEMPS 143 SHIFT_TEMPS
140 144
141 while (--num_rows >= 0) { 145 while (--num_rows >= 0) {
142 inptr0 = input_buf[0][input_row]; 146 inptr0 = input_buf[0][input_row];
143 inptr1 = input_buf[1][input_row]; 147 inptr1 = input_buf[1][input_row];
144 inptr2 = input_buf[2][input_row]; 148 inptr2 = input_buf[2][input_row];
145 input_row++; 149 input_row++;
146 outptr = *output_buf++; 150 outptr = *output_buf++;
147 for (col = 0; col < num_cols; col++) { 151 for (col = 0; col < num_cols; col++) {
148 y = GETJSAMPLE(inptr0[col]); 152 y = GETJSAMPLE(inptr0[col]);
149 cb = GETJSAMPLE(inptr1[col]); 153 cb = GETJSAMPLE(inptr1[col]);
150 cr = GETJSAMPLE(inptr2[col]); 154 cr = GETJSAMPLE(inptr2[col]);
151 /* Range-limiting is essential due to noise introduced by DCT losses. */ 155 /* Range-limiting is essential due to noise introduced by DCT losses. */
152 outptr[rgb_red[cinfo->out_color_space]] = range_limit[y + Crrtab[cr]]; 156 outptr[rindex] = range_limit[y + Crrtab[cr]];
153 outptr[rgb_green[cinfo->out_color_space]] = range_limit[y + 157 outptr[gindex] = range_limit[y +
154 ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], 158 » » » ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
155 SCALEBITS))]; 159 » » » » » » SCALEBITS))];
156 outptr[rgb_blue[cinfo->out_color_space]] = range_limit[y + Cbbtab[cb]]; 160 outptr[bindex] = range_limit[y + Cbbtab[cb]];
157 outptr += rgb_pixelsize[cinfo->out_color_space]; 161 outptr += rgbstride;
158 } 162 }
159 } 163 }
160 } 164 }
161 165
162 166
163 /**************** Cases other than YCbCr -> RGB **************/ 167 /**************** Cases other than YCbCr -> RGB **************/
164 168
165 169
166 /* 170 /*
167 * Color conversion for no colorspace change: just copy the data, 171 * Color conversion for no colorspace change: just copy the data,
168 * converting from separate-planes to interleaved representation. 172 * converting from separate-planes to interleaved representation.
169 */ 173 */
170 174
171 METHODDEF(void) 175 METHODDEF(void)
172 null_convert (j_decompress_ptr cinfo, 176 null_convert (j_decompress_ptr cinfo,
173 JSAMPIMAGE input_buf, JDIMENSION input_row, 177 » JSAMPIMAGE input_buf, JDIMENSION input_row,
174 JSAMPARRAY output_buf, int num_rows) 178 » JSAMPARRAY output_buf, int num_rows)
175 { 179 {
176 register JSAMPROW inptr, outptr; 180 register JSAMPROW inptr, outptr;
177 register JDIMENSION count; 181 register JDIMENSION count;
178 register int num_components = cinfo->num_components; 182 register int num_components = cinfo->num_components;
179 JDIMENSION num_cols = cinfo->output_width; 183 JDIMENSION num_cols = cinfo->output_width;
180 int ci; 184 int ci;
181 185
182 while (--num_rows >= 0) { 186 while (--num_rows >= 0) {
183 for (ci = 0; ci < num_components; ci++) { 187 for (ci = 0; ci < num_components; ci++) {
184 inptr = input_buf[ci][input_row]; 188 inptr = input_buf[ci][input_row];
185 outptr = output_buf[0] + ci; 189 outptr = output_buf[0] + ci;
186 for (count = num_cols; count > 0; count--) { 190 for (count = num_cols; count > 0; count--) {
187 *outptr = *inptr++; /* needn't bother with GETJSAMPLE() here */ 191 » *outptr = *inptr++;» /* needn't bother with GETJSAMPLE() here */
188 outptr += num_components; 192 » outptr += num_components;
189 } 193 }
190 } 194 }
191 input_row++; 195 input_row++;
192 output_buf++; 196 output_buf++;
193 } 197 }
194 } 198 }
195 199
196 200
197 /* 201 /*
198 * Color conversion for grayscale: just copy the data. 202 * Color conversion for grayscale: just copy the data.
199 * This also works for YCbCr -> grayscale conversion, in which 203 * This also works for YCbCr -> grayscale conversion, in which
200 * we just copy the Y (luminance) component and ignore chrominance. 204 * we just copy the Y (luminance) component and ignore chrominance.
201 */ 205 */
202 206
203 METHODDEF(void) 207 METHODDEF(void)
204 grayscale_convert (j_decompress_ptr cinfo, 208 grayscale_convert (j_decompress_ptr cinfo,
205 JSAMPIMAGE input_buf, JDIMENSION input_row, 209 » » JSAMPIMAGE input_buf, JDIMENSION input_row,
206 JSAMPARRAY output_buf, int num_rows) 210 » » JSAMPARRAY output_buf, int num_rows)
207 { 211 {
208 jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0, 212 jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
209 num_rows, cinfo->output_width); 213 » » num_rows, cinfo->output_width);
210 } 214 }
211 215
212 216
213 /* 217 /*
214 * Convert grayscale to RGB: just duplicate the graylevel three times. 218 * Convert grayscale to RGB: just duplicate the graylevel three times.
215 * This is provided to support applications that don't want to cope 219 * This is provided to support applications that don't want to cope
216 * with grayscale as a separate case. 220 * with grayscale as a separate case.
217 */ 221 */
218 222
219 METHODDEF(void) 223 METHODDEF(void)
220 gray_rgb_convert (j_decompress_ptr cinfo, 224 gray_rgb_convert (j_decompress_ptr cinfo,
221 JSAMPIMAGE input_buf, JDIMENSION input_row, 225 » » JSAMPIMAGE input_buf, JDIMENSION input_row,
222 JSAMPARRAY output_buf, int num_rows) 226 » » JSAMPARRAY output_buf, int num_rows)
223 { 227 {
224 register JSAMPROW inptr, outptr; 228 register JSAMPROW inptr, outptr;
225 JSAMPLE *maxinptr; 229 JSAMPLE *maxinptr;
226 JDIMENSION num_cols = cinfo->output_width; 230 JDIMENSION num_cols = cinfo->output_width;
227 int rindex = rgb_red[cinfo->out_color_space]; 231 int rindex = rgb_red[cinfo->out_color_space];
228 int gindex = rgb_green[cinfo->out_color_space]; 232 int gindex = rgb_green[cinfo->out_color_space];
229 int bindex = rgb_blue[cinfo->out_color_space]; 233 int bindex = rgb_blue[cinfo->out_color_space];
230 int rgbstride = rgb_pixelsize[cinfo->out_color_space]; 234 int rgbstride = rgb_pixelsize[cinfo->out_color_space];
231 235
232 while (--num_rows >= 0) { 236 while (--num_rows >= 0) {
(...skipping 10 matching lines...) Expand all
243 247
244 /* 248 /*
245 * Adobe-style YCCK->CMYK conversion. 249 * Adobe-style YCCK->CMYK conversion.
246 * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same 250 * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
247 * conversion as above, while passing K (black) unchanged. 251 * conversion as above, while passing K (black) unchanged.
248 * We assume build_ycc_rgb_table has been called. 252 * We assume build_ycc_rgb_table has been called.
249 */ 253 */
250 254
251 METHODDEF(void) 255 METHODDEF(void)
252 ycck_cmyk_convert (j_decompress_ptr cinfo, 256 ycck_cmyk_convert (j_decompress_ptr cinfo,
253 JSAMPIMAGE input_buf, JDIMENSION input_row, 257 » » JSAMPIMAGE input_buf, JDIMENSION input_row,
254 JSAMPARRAY output_buf, int num_rows) 258 » » JSAMPARRAY output_buf, int num_rows)
255 { 259 {
256 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; 260 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
257 register int y, cb, cr; 261 register int y, cb, cr;
258 register JSAMPROW outptr; 262 register JSAMPROW outptr;
259 register JSAMPROW inptr0, inptr1, inptr2, inptr3; 263 register JSAMPROW inptr0, inptr1, inptr2, inptr3;
260 register JDIMENSION col; 264 register JDIMENSION col;
261 JDIMENSION num_cols = cinfo->output_width; 265 JDIMENSION num_cols = cinfo->output_width;
262 /* copy these pointers into registers if possible */ 266 /* copy these pointers into registers if possible */
263 register JSAMPLE * range_limit = cinfo->sample_range_limit; 267 register JSAMPLE * range_limit = cinfo->sample_range_limit;
264 register int * Crrtab = cconvert->Cr_r_tab; 268 register int * Crrtab = cconvert->Cr_r_tab;
265 register int * Cbbtab = cconvert->Cb_b_tab; 269 register int * Cbbtab = cconvert->Cb_b_tab;
266 register INT32 * Crgtab = cconvert->Cr_g_tab; 270 register INT32 * Crgtab = cconvert->Cr_g_tab;
267 register INT32 * Cbgtab = cconvert->Cb_g_tab; 271 register INT32 * Cbgtab = cconvert->Cb_g_tab;
268 SHIFT_TEMPS 272 SHIFT_TEMPS
269 273
270 while (--num_rows >= 0) { 274 while (--num_rows >= 0) {
271 inptr0 = input_buf[0][input_row]; 275 inptr0 = input_buf[0][input_row];
272 inptr1 = input_buf[1][input_row]; 276 inptr1 = input_buf[1][input_row];
273 inptr2 = input_buf[2][input_row]; 277 inptr2 = input_buf[2][input_row];
274 inptr3 = input_buf[3][input_row]; 278 inptr3 = input_buf[3][input_row];
275 input_row++; 279 input_row++;
276 outptr = *output_buf++; 280 outptr = *output_buf++;
277 for (col = 0; col < num_cols; col++) { 281 for (col = 0; col < num_cols; col++) {
278 y = GETJSAMPLE(inptr0[col]); 282 y = GETJSAMPLE(inptr0[col]);
279 cb = GETJSAMPLE(inptr1[col]); 283 cb = GETJSAMPLE(inptr1[col]);
280 cr = GETJSAMPLE(inptr2[col]); 284 cr = GETJSAMPLE(inptr2[col]);
281 /* Range-limiting is essential due to noise introduced by DCT losses. */ 285 /* Range-limiting is essential due to noise introduced by DCT losses. */
282 outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */ 286 outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];» /* red */
283 outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */ 287 outptr[1] = range_limit[MAXJSAMPLE - (y +»» » /* green */
284 ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], 288 » » » ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
285 SCALEBITS)))]; 289 » » » » » » SCALEBITS)))];
286 outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */ 290 outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];» /* blue */
287 /* K passes through unchanged */ 291 /* K passes through unchanged */
288 outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */ 292 outptr[3] = inptr3[col];» /* don't need GETJSAMPLE here */
289 outptr += 4; 293 outptr += 4;
290 } 294 }
291 } 295 }
292 } 296 }
293 297
294 298
295 /* 299 /*
296 * Empty method for start_pass. 300 * Empty method for start_pass.
297 */ 301 */
298 302
299 METHODDEF(void) 303 METHODDEF(void)
300 start_pass_dcolor (j_decompress_ptr cinfo) 304 start_pass_dcolor (j_decompress_ptr cinfo)
301 { 305 {
302 /* no work needed */ 306 /* no work needed */
303 } 307 }
304 308
305 309
306 /* 310 /*
307 * Module initialization routine for output colorspace conversion. 311 * Module initialization routine for output colorspace conversion.
308 */ 312 */
309 313
310 GLOBAL(void) 314 GLOBAL(void)
311 jinit_color_deconverter (j_decompress_ptr cinfo) 315 jinit_color_deconverter (j_decompress_ptr cinfo)
312 { 316 {
313 my_cconvert_ptr cconvert; 317 my_cconvert_ptr cconvert;
314 int ci; 318 int ci;
315 319
316 cconvert = (my_cconvert_ptr) 320 cconvert = (my_cconvert_ptr)
317 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 321 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
318 SIZEOF(my_color_deconverter)); 322 » » » » SIZEOF(my_color_deconverter));
319 cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert; 323 cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
320 cconvert->pub.start_pass = start_pass_dcolor; 324 cconvert->pub.start_pass = start_pass_dcolor;
321 325
322 /* Make sure num_components agrees with jpeg_color_space */ 326 /* Make sure num_components agrees with jpeg_color_space */
323 switch (cinfo->jpeg_color_space) { 327 switch (cinfo->jpeg_color_space) {
324 case JCS_GRAYSCALE: 328 case JCS_GRAYSCALE:
325 if (cinfo->num_components != 1) 329 if (cinfo->num_components != 1)
326 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); 330 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
327 break; 331 break;
328 332
329 case JCS_RGB: 333 case JCS_RGB:
330 case JCS_YCbCr: 334 case JCS_YCbCr:
331 if (cinfo->num_components != 3) 335 if (cinfo->num_components != 3)
332 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); 336 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
333 break; 337 break;
334 338
335 case JCS_CMYK: 339 case JCS_CMYK:
336 case JCS_YCCK: 340 case JCS_YCCK:
337 if (cinfo->num_components != 4) 341 if (cinfo->num_components != 4)
338 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); 342 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
339 break; 343 break;
340 344
341 default: /* JCS_UNKNOWN can be anything */ 345 default:» » » /* JCS_UNKNOWN can be anything */
342 if (cinfo->num_components < 1) 346 if (cinfo->num_components < 1)
343 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); 347 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
344 break; 348 break;
345 } 349 }
346 350
347 /* Set out_color_components and conversion method based on requested space. 351 /* Set out_color_components and conversion method based on requested space.
348 * Also clear the component_needed flags for any unused components, 352 * Also clear the component_needed flags for any unused components,
349 * so that earlier pipeline stages can avoid useless computation. 353 * so that earlier pipeline stages can avoid useless computation.
350 */ 354 */
351 355
352 switch (cinfo->out_color_space) { 356 switch (cinfo->out_color_space) {
353 case JCS_GRAYSCALE: 357 case JCS_GRAYSCALE:
354 cinfo->out_color_components = 1; 358 cinfo->out_color_components = 1;
355 if (cinfo->jpeg_color_space == JCS_GRAYSCALE || 359 if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
356 cinfo->jpeg_color_space == JCS_YCbCr) { 360 » cinfo->jpeg_color_space == JCS_YCbCr) {
357 cconvert->pub.color_convert = grayscale_convert; 361 cconvert->pub.color_convert = grayscale_convert;
358 /* For color->grayscale conversion, only the Y (0) component is needed */ 362 /* For color->grayscale conversion, only the Y (0) component is needed */
359 for (ci = 1; ci < cinfo->num_components; ci++) 363 for (ci = 1; ci < cinfo->num_components; ci++)
360 cinfo->comp_info[ci].component_needed = FALSE; 364 » cinfo->comp_info[ci].component_needed = FALSE;
361 } else 365 } else
362 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); 366 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
363 break; 367 break;
364 368
365 case JCS_RGB: 369 case JCS_RGB:
366 case JCS_EXT_RGB: 370 case JCS_EXT_RGB:
367 case JCS_EXT_RGBX: 371 case JCS_EXT_RGBX:
368 case JCS_EXT_BGR: 372 case JCS_EXT_BGR:
369 case JCS_EXT_BGRX: 373 case JCS_EXT_BGRX:
370 case JCS_EXT_XBGR: 374 case JCS_EXT_XBGR:
(...skipping 24 matching lines...) Expand all
395 cconvert->pub.color_convert = null_convert; 399 cconvert->pub.color_convert = null_convert;
396 } else 400 } else
397 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); 401 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
398 break; 402 break;
399 403
400 default: 404 default:
401 /* Permit null conversion to same output space */ 405 /* Permit null conversion to same output space */
402 if (cinfo->out_color_space == cinfo->jpeg_color_space) { 406 if (cinfo->out_color_space == cinfo->jpeg_color_space) {
403 cinfo->out_color_components = cinfo->num_components; 407 cinfo->out_color_components = cinfo->num_components;
404 cconvert->pub.color_convert = null_convert; 408 cconvert->pub.color_convert = null_convert;
405 } else /* unsupported non-null conversion */ 409 } else» » » /* unsupported non-null conversion */
406 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); 410 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
407 break; 411 break;
408 } 412 }
409 413
410 if (cinfo->quantize_colors) 414 if (cinfo->quantize_colors)
411 cinfo->output_components = 1; /* single colormapped output component */ 415 cinfo->output_components = 1; /* single colormapped output component */
412 else 416 else
413 cinfo->output_components = cinfo->out_color_components; 417 cinfo->output_components = cinfo->out_color_components;
414 } 418 }
OLDNEW
« no previous file with comments | « third_party/libjpeg_turbo/jdcoefct.c ('k') | third_party/libjpeg_turbo/jddctmgr.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698