transform-sse1.c revision 5821806d5e7f356e8fa4b058a389a808ea183019 
1//  qcms
2//  Copyright (C) 2009 Mozilla Foundation
3//
4// Permission is hereby granted, free of charge, to any person obtaining
5// a copy of this software and associated documentation files (the "Software"),
6// to deal in the Software without restriction, including without limitation
7// the rights to use, copy, modify, merge, publish, distribute, sublicense,
8// and/or sell copies of the Software, and to permit persons to whom the Software
9// is furnished to do so, subject to the following conditions:
10//
11// The above copyright notice and this permission notice shall be included in
12// all copies or substantial portions of the Software.
13//
14// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
16// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22#include <xmmintrin.h>
23
24#include "qcmsint.h"
25
26/* pre-shuffled: just load these into XMM reg instead of load-scalar/shufps sequence */
27#define FLOATSCALE  (float)(PRECACHE_OUTPUT_SIZE)
28#define CLAMPMAXVAL ( ((float) (PRECACHE_OUTPUT_SIZE - 1)) / PRECACHE_OUTPUT_SIZE )
29static const ALIGN float floatScaleX4[4] =
30    { FLOATSCALE, FLOATSCALE, FLOATSCALE, FLOATSCALE};
31static const ALIGN float clampMaxValueX4[4] =
32    { CLAMPMAXVAL, CLAMPMAXVAL, CLAMPMAXVAL, CLAMPMAXVAL};
33
34void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform,
35                                          unsigned char *src,
36                                          unsigned char *dest,
37                                          size_t length,
38                                          qcms_format_type output_format)
39{
40    unsigned int i;
41    float (*mat)[4] = transform->matrix;
42    char input_back[32];
43    /* Ensure we have a buffer that's 16 byte aligned regardless of the original
44     * stack alignment. We can't use __attribute__((aligned(16))) or __declspec(align(32))
45     * because they don't work on stack variables. gcc 4.4 does do the right thing
46     * on x86 but that's too new for us right now. For more info: gcc bug #16660 */
47    float const * input = (float*)(((uintptr_t)&input_back[16]) & ~0xf);
48    /* share input and output locations to save having to keep the
49     * locations in separate registers */
50    uint32_t const * output = (uint32_t*)input;
51
52    /* deref *transform now to avoid it in loop */
53    const float *igtbl_r = transform->input_gamma_table_r;
54    const float *igtbl_g = transform->input_gamma_table_g;
55    const float *igtbl_b = transform->input_gamma_table_b;
56
57    /* deref *transform now to avoid it in loop */
58    const uint8_t *otdata_r = &transform->output_table_r->data[0];
59    const uint8_t *otdata_g = &transform->output_table_g->data[0];
60    const uint8_t *otdata_b = &transform->output_table_b->data[0];
61
62    /* input matrix values never change */
63    const __m128 mat0  = _mm_load_ps(mat[0]);
64    const __m128 mat1  = _mm_load_ps(mat[1]);
65    const __m128 mat2  = _mm_load_ps(mat[2]);
66
67    /* these values don't change, either */
68    const __m128 max   = _mm_load_ps(clampMaxValueX4);
69    const __m128 min   = _mm_setzero_ps();
70    const __m128 scale = _mm_load_ps(floatScaleX4);
71
72    /* working variables */
73    __m128 vec_r, vec_g, vec_b, result;
74    const int r_out = output_format.r;
75    const int b_out = output_format.b;
76
77    /* CYA */
78    if (!length)
79        return;
80
81    /* one pixel is handled outside of the loop */
82    length--;
83
84    /* setup for transforming 1st pixel */
85    vec_r = _mm_load_ss(&igtbl_r[src[0]]);
86    vec_g = _mm_load_ss(&igtbl_g[src[1]]);
87    vec_b = _mm_load_ss(&igtbl_b[src[2]]);
88    src += 3;
89
90    /* transform all but final pixel */
91
92    for (i=0; i<length; i++)
93    {
94        /* position values from gamma tables */
95        vec_r = _mm_shuffle_ps(vec_r, vec_r, 0);
96        vec_g = _mm_shuffle_ps(vec_g, vec_g, 0);
97        vec_b = _mm_shuffle_ps(vec_b, vec_b, 0);
98
99        /* gamma * matrix */
100        vec_r = _mm_mul_ps(vec_r, mat0);
101        vec_g = _mm_mul_ps(vec_g, mat1);
102        vec_b = _mm_mul_ps(vec_b, mat2);
103
104        /* crunch, crunch, crunch */
105        vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
106        vec_r  = _mm_max_ps(min, vec_r);
107        vec_r  = _mm_min_ps(max, vec_r);
108        result = _mm_mul_ps(vec_r, scale);
109
110        /* store calc'd output tables indices */
111        *((__m64 *)&output[0]) = _mm_cvtps_pi32(result);
112        result = _mm_movehl_ps(result, result);
113        *((__m64 *)&output[2]) = _mm_cvtps_pi32(result) ;
114
115        /* load for next loop while store completes */
116        vec_r = _mm_load_ss(&igtbl_r[src[0]]);
117        vec_g = _mm_load_ss(&igtbl_g[src[1]]);
118        vec_b = _mm_load_ss(&igtbl_b[src[2]]);
119        src += 3;
120
121        /* use calc'd indices to output RGB values */
122        dest[r_out] = otdata_r[output[0]];
123        dest[1]     = otdata_g[output[1]];
124        dest[b_out] = otdata_b[output[2]];
125        dest += 3;
126    }
127
128    /* handle final (maybe only) pixel */
129
130    vec_r = _mm_shuffle_ps(vec_r, vec_r, 0);
131    vec_g = _mm_shuffle_ps(vec_g, vec_g, 0);
132    vec_b = _mm_shuffle_ps(vec_b, vec_b, 0);
133
134    vec_r = _mm_mul_ps(vec_r, mat0);
135    vec_g = _mm_mul_ps(vec_g, mat1);
136    vec_b = _mm_mul_ps(vec_b, mat2);
137
138    vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
139    vec_r  = _mm_max_ps(min, vec_r);
140    vec_r  = _mm_min_ps(max, vec_r);
141    result = _mm_mul_ps(vec_r, scale);
142
143    *((__m64 *)&output[0]) = _mm_cvtps_pi32(result);
144    result = _mm_movehl_ps(result, result);
145    *((__m64 *)&output[2]) = _mm_cvtps_pi32(result);
146
147    dest[r_out] = otdata_r[output[0]];
148    dest[1]     = otdata_g[output[1]];
149    dest[b_out] = otdata_b[output[2]];
150
151    _mm_empty();
152}
153
154void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform,
155                                           unsigned char *src,
156                                           unsigned char *dest,
157                                           size_t length,
158                                           qcms_format_type output_format)
159{
160    unsigned int i;
161    float (*mat)[4] = transform->matrix;
162    char input_back[32];
163    /* Ensure we have a buffer that's 16 byte aligned regardless of the original
164     * stack alignment. We can't use __attribute__((aligned(16))) or __declspec(align(32))
165     * because they don't work on stack variables. gcc 4.4 does do the right thing
166     * on x86 but that's too new for us right now. For more info: gcc bug #16660 */
167    float const * input = (float*)(((uintptr_t)&input_back[16]) & ~0xf);
168    /* share input and output locations to save having to keep the
169     * locations in separate registers */
170    uint32_t const * output = (uint32_t*)input;
171
172    /* deref *transform now to avoid it in loop */
173    const float *igtbl_r = transform->input_gamma_table_r;
174    const float *igtbl_g = transform->input_gamma_table_g;
175    const float *igtbl_b = transform->input_gamma_table_b;
176
177    /* deref *transform now to avoid it in loop */
178    const uint8_t *otdata_r = &transform->output_table_r->data[0];
179    const uint8_t *otdata_g = &transform->output_table_g->data[0];
180    const uint8_t *otdata_b = &transform->output_table_b->data[0];
181
182    /* input matrix values never change */
183    const __m128 mat0  = _mm_load_ps(mat[0]);
184    const __m128 mat1  = _mm_load_ps(mat[1]);
185    const __m128 mat2  = _mm_load_ps(mat[2]);
186
187    /* these values don't change, either */
188    const __m128 max   = _mm_load_ps(clampMaxValueX4);
189    const __m128 min   = _mm_setzero_ps();
190    const __m128 scale = _mm_load_ps(floatScaleX4);
191
192    /* working variables */
193    __m128 vec_r, vec_g, vec_b, result;
194    const int r_out = output_format.r;
195    const int b_out = output_format.b;
196    unsigned char alpha;
197
198    /* CYA */
199    if (!length)
200        return;
201
202    /* one pixel is handled outside of the loop */
203    length--;
204
205    /* setup for transforming 1st pixel */
206    vec_r = _mm_load_ss(&igtbl_r[src[0]]);
207    vec_g = _mm_load_ss(&igtbl_g[src[1]]);
208    vec_b = _mm_load_ss(&igtbl_b[src[2]]);
209    alpha = src[3];
210    src += 4;
211
212    /* transform all but final pixel */
213
214    for (i=0; i<length; i++)
215    {
216        /* position values from gamma tables */
217        vec_r = _mm_shuffle_ps(vec_r, vec_r, 0);
218        vec_g = _mm_shuffle_ps(vec_g, vec_g, 0);
219        vec_b = _mm_shuffle_ps(vec_b, vec_b, 0);
220
221        /* gamma * matrix */
222        vec_r = _mm_mul_ps(vec_r, mat0);
223        vec_g = _mm_mul_ps(vec_g, mat1);
224        vec_b = _mm_mul_ps(vec_b, mat2);
225
226        /* store alpha for this pixel; load alpha for next */
227        dest[3] = alpha;
228        alpha   = src[3];
229
230        /* crunch, crunch, crunch */
231        vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
232        vec_r  = _mm_max_ps(min, vec_r);
233        vec_r  = _mm_min_ps(max, vec_r);
234        result = _mm_mul_ps(vec_r, scale);
235
236        /* store calc'd output tables indices */
237        *((__m64 *)&output[0]) = _mm_cvtps_pi32(result);
238        result = _mm_movehl_ps(result, result);
239        *((__m64 *)&output[2]) = _mm_cvtps_pi32(result);
240
241        /* load gamma values for next loop while store completes */
242        vec_r = _mm_load_ss(&igtbl_r[src[0]]);
243        vec_g = _mm_load_ss(&igtbl_g[src[1]]);
244        vec_b = _mm_load_ss(&igtbl_b[src[2]]);
245        src += 4;
246
247        /* use calc'd indices to output RGB values */
248        dest[r_out] = otdata_r[output[0]];
249        dest[1]     = otdata_g[output[1]];
250        dest[b_out] = otdata_b[output[2]];
251        dest += 4;
252    }
253
254    /* handle final (maybe only) pixel */
255
256    vec_r = _mm_shuffle_ps(vec_r, vec_r, 0);
257    vec_g = _mm_shuffle_ps(vec_g, vec_g, 0);
258    vec_b = _mm_shuffle_ps(vec_b, vec_b, 0);
259
260    vec_r = _mm_mul_ps(vec_r, mat0);
261    vec_g = _mm_mul_ps(vec_g, mat1);
262    vec_b = _mm_mul_ps(vec_b, mat2);
263
264    dest[3] = alpha;
265
266    vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
267    vec_r  = _mm_max_ps(min, vec_r);
268    vec_r  = _mm_min_ps(max, vec_r);
269    result = _mm_mul_ps(vec_r, scale);
270
271    *((__m64 *)&output[0]) = _mm_cvtps_pi32(result);
272    result = _mm_movehl_ps(result, result);
273    *((__m64 *)&output[2]) = _mm_cvtps_pi32(result);
274
275    dest[r_out] = otdata_r[output[0]];
276    dest[1]     = otdata_g[output[1]];
277    dest[b_out] = otdata_b[output[2]];
278
279    _mm_empty();
280}
281