blob: cbdab5a7d396d2f69be258f16a630591cd1def80 [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/* libs/pixelflinger/buffer.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18
19#include <assert.h>
20
21#include "buffer.h"
22
23namespace android {
24// ----------------------------------------------------------------------------
25
26static void read_pixel(const surface_t* s, context_t* c,
27 uint32_t x, uint32_t y, pixel_t* pixel);
28static void write_pixel(const surface_t* s, context_t* c,
29 uint32_t x, uint32_t y, const pixel_t* pixel);
30static void readRGB565(const surface_t* s, context_t* c,
31 uint32_t x, uint32_t y, pixel_t* pixel);
32static void readABGR8888(const surface_t* s, context_t* c,
33 uint32_t x, uint32_t y, pixel_t* pixel);
34
35static uint32_t logic_op(int op, uint32_t s, uint32_t d);
36static uint32_t extract(uint32_t v, int h, int l, int bits);
37static uint32_t expand(uint32_t v, int sbits, int dbits);
38static uint32_t downshift_component(uint32_t in, uint32_t v,
39 int sh, int sl, int dh, int dl, int ch, int cl, int dither);
40
41// ----------------------------------------------------------------------------
42
43void ggl_init_texture(context_t* c)
44{
45 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
46 texture_t& t = c->state.texture[i];
47 t.s_coord = GGL_ONE_TO_ONE;
48 t.t_coord = GGL_ONE_TO_ONE;
49 t.s_wrap = GGL_REPEAT;
50 t.t_wrap = GGL_REPEAT;
51 t.min_filter = GGL_NEAREST;
52 t.mag_filter = GGL_NEAREST;
53 t.env = GGL_MODULATE;
54 }
55 c->activeTMU = &(c->state.texture[0]);
56}
57
58void ggl_set_surface(context_t* c, surface_t* dst, const GGLSurface* src)
59{
60 dst->width = src->width;
61 dst->height = src->height;
62 dst->stride = src->stride;
63 dst->data = src->data;
64 dst->format = src->format;
65 dst->dirty = 1;
66 if (__builtin_expect(dst->stride < 0, false)) {
67 const GGLFormat& pixelFormat(c->formats[dst->format]);
68 const int32_t bpr = -dst->stride * pixelFormat.size;
69 dst->data += bpr * (dst->height-1);
70 }
71}
72
73static void pick_read_write(surface_t* s)
74{
75 // Choose best reader/writers.
76 switch (s->format) {
77 case GGL_PIXEL_FORMAT_RGBA_8888: s->read = readABGR8888; break;
78 case GGL_PIXEL_FORMAT_RGB_565: s->read = readRGB565; break;
79 default: s->read = read_pixel; break;
80 }
81 s->write = write_pixel;
82}
83
84void ggl_pick_texture(context_t* c)
85{
86 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; ++i) {
87 surface_t& s = c->state.texture[i].surface;
88 if ((!c->state.texture[i].enable) || (!s.dirty))
89 continue;
90 s.dirty = 0;
91 pick_read_write(&s);
92 generated_tex_vars_t& gen = c->generated_vars.texture[i];
93 gen.width = s.width;
94 gen.height = s.height;
95 gen.stride = s.stride;
Ashok Bhatd10afb12013-11-14 11:13:41 +000096 gen.data = uintptr_t(s.data);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080097 }
98}
99
100void ggl_pick_cb(context_t* c)
101{
102 surface_t& s = c->state.buffers.color;
103 if (s.dirty) {
104 s.dirty = 0;
105 pick_read_write(&s);
106 }
107}
108
109// ----------------------------------------------------------------------------
110
111void read_pixel(const surface_t* s, context_t* c,
112 uint32_t x, uint32_t y, pixel_t* pixel)
113{
114 assert((x < s->width) && (y < s->height));
115
116 const GGLFormat* f = &(c->formats[s->format]);
117 int32_t index = x + (s->stride * y);
118 uint8_t* const data = s->data + index * f->size;
119 uint32_t v = 0;
120 switch (f->size) {
121 case 1: v = *data; break;
122 case 2: v = *(uint16_t*)data; break;
123 case 3: v = (data[2]<<16)|(data[1]<<8)|data[0]; break;
124 case 4: v = GGL_RGBA_TO_HOST(*(uint32_t*)data); break;
125 }
126 for (int i=0 ; i<4 ; i++) {
127 pixel->s[i] = f->c[i].h - f->c[i].l;
128 if (pixel->s[i])
129 pixel->c[i] = extract(v, f->c[i].h, f->c[i].l, f->size*8);
130 }
131}
132
133void readRGB565(const surface_t* s, context_t* c,
134 uint32_t x, uint32_t y, pixel_t* pixel)
135{
136 uint16_t v = *(reinterpret_cast<uint16_t*>(s->data) + (x + (s->stride * y)));
137 pixel->c[0] = 0;
138 pixel->c[1] = v>>11;
139 pixel->c[2] = (v>>5)&0x3F;
140 pixel->c[3] = v&0x1F;
141 pixel->s[0] = 0;
142 pixel->s[1] = 5;
143 pixel->s[2] = 6;
144 pixel->s[3] = 5;
145}
146
147void readABGR8888(const surface_t* s, context_t* c,
148 uint32_t x, uint32_t y, pixel_t* pixel)
149{
150 uint32_t v = *(reinterpret_cast<uint32_t*>(s->data) + (x + (s->stride * y)));
151 v = GGL_RGBA_TO_HOST(v);
152 pixel->c[0] = v>>24; // A
153 pixel->c[1] = v&0xFF; // R
154 pixel->c[2] = (v>>8)&0xFF; // G
155 pixel->c[3] = (v>>16)&0xFF; // B
156 pixel->s[0] =
157 pixel->s[1] =
158 pixel->s[2] =
159 pixel->s[3] = 8;
160}
161
162void write_pixel(const surface_t* s, context_t* c,
163 uint32_t x, uint32_t y, const pixel_t* pixel)
164{
165 assert((x < s->width) && (y < s->height));
166
167 int dither = -1;
168 if (c->state.enables & GGL_ENABLE_DITHER) {
169 dither = c->ditherMatrix[ (x & GGL_DITHER_MASK) +
170 ((y & GGL_DITHER_MASK)<<GGL_DITHER_ORDER_SHIFT) ];
171 }
172
173 const GGLFormat* f = &(c->formats[s->format]);
174 int32_t index = x + (s->stride * y);
175 uint8_t* const data = s->data + index * f->size;
176
177 uint32_t mask = 0;
178 uint32_t v = 0;
179 for (int i=0 ; i<4 ; i++) {
180 const int component_mask = 1 << i;
181 if (f->components>=GGL_LUMINANCE &&
182 (i==GGLFormat::GREEN || i==GGLFormat::BLUE)) {
183 // destinations L formats don't have G or B
184 continue;
185 }
186 const int l = f->c[i].l;
187 const int h = f->c[i].h;
188 if (h && (c->state.mask.color & component_mask)) {
189 mask |= (((1<<(h-l))-1)<<l);
190 uint32_t u = pixel->c[i];
191 int32_t pixelSize = pixel->s[i];
192 if (pixelSize < (h-l)) {
193 u = expand(u, pixelSize, h-l);
194 pixelSize = h-l;
195 }
196 v = downshift_component(v, u, pixelSize, 0, h, l, 0, 0, dither);
197 }
198 }
199
200 if ((c->state.mask.color != 0xF) ||
201 (c->state.enables & GGL_ENABLE_LOGIC_OP)) {
202 uint32_t d = 0;
203 switch (f->size) {
204 case 1: d = *data; break;
205 case 2: d = *(uint16_t*)data; break;
206 case 3: d = (data[2]<<16)|(data[1]<<8)|data[0]; break;
207 case 4: d = GGL_RGBA_TO_HOST(*(uint32_t*)data); break;
208 }
209 if (c->state.enables & GGL_ENABLE_LOGIC_OP) {
210 v = logic_op(c->state.logic_op.opcode, v, d);
211 v &= mask;
212 }
213 v |= (d & ~mask);
214 }
215
216 switch (f->size) {
217 case 1: *data = v; break;
218 case 2: *(uint16_t*)data = v; break;
219 case 3:
220 data[0] = v;
221 data[1] = v>>8;
222 data[2] = v>>16;
223 break;
224 case 4: *(uint32_t*)data = GGL_HOST_TO_RGBA(v); break;
225 }
226}
227
228static uint32_t logic_op(int op, uint32_t s, uint32_t d)
229{
230 switch(op) {
231 case GGL_CLEAR: return 0;
232 case GGL_AND: return s & d;
233 case GGL_AND_REVERSE: return s & ~d;
234 case GGL_COPY: return s;
235 case GGL_AND_INVERTED: return ~s & d;
236 case GGL_NOOP: return d;
237 case GGL_XOR: return s ^ d;
238 case GGL_OR: return s | d;
239 case GGL_NOR: return ~(s | d);
240 case GGL_EQUIV: return ~(s ^ d);
241 case GGL_INVERT: return ~d;
242 case GGL_OR_REVERSE: return s | ~d;
243 case GGL_COPY_INVERTED: return ~s;
244 case GGL_OR_INVERTED: return ~s | d;
245 case GGL_NAND: return ~(s & d);
246 case GGL_SET: return ~0;
247 };
248 return s;
249}
250
251
252uint32_t ggl_expand(uint32_t v, int sbits, int dbits)
253{
254 return expand(v, sbits, dbits);
255}
256
257uint32_t ggl_pack_color(context_t* c, int32_t format,
258 GGLcolor r, GGLcolor g, GGLcolor b, GGLcolor a)
259{
260 const GGLFormat* f = &(c->formats[format]);
261 uint32_t p = 0;
262 const int32_t hbits = GGL_COLOR_BITS;
263 const int32_t lbits = GGL_COLOR_BITS - 8;
264 p = downshift_component(p, r, hbits, lbits, f->rh, f->rl, 0, 1, -1);
265 p = downshift_component(p, g, hbits, lbits, f->gh, f->gl, 0, 1, -1);
266 p = downshift_component(p, b, hbits, lbits, f->bh, f->bl, 0, 1, -1);
267 p = downshift_component(p, a, hbits, lbits, f->ah, f->al, 0, 1, -1);
268 switch (f->size) {
269 case 1: p |= p << 8; // fallthrough
270 case 2: p |= p << 16;
271 }
272 return p;
273}
274
275// ----------------------------------------------------------------------------
276
277// extract a component from a word
278uint32_t extract(uint32_t v, int h, int l, int bits)
279{
280 assert(h);
281 if (l) {
282 v >>= l;
283 }
284 if (h != bits) {
285 v &= (1<<(h-l))-1;
286 }
287 return v;
288}
289
290// expand a component from sbits to dbits
291uint32_t expand(uint32_t v, int sbits, int dbits)
292{
293 if (dbits > sbits) {
294 assert(sbits);
295 if (sbits==1) {
296 v = (v<<dbits) - v;
297 } else {
298 if (dbits % sbits) {
299 v <<= (dbits-sbits);
300 dbits -= sbits;
301 do {
302 v |= v>>sbits;
303 dbits -= sbits;
304 sbits *= 2;
305 } while (dbits>0);
306 } else {
307 dbits -= sbits;
308 do {
309 v |= v<<sbits;
310 dbits -= sbits;
311 if (sbits*2 < dbits) {
312 sbits *= 2;
313 }
314 } while (dbits > 0);
315 }
316 }
317 }
318 return v;
319}
320
321// downsample a component from sbits to dbits
322// and shift / construct the pixel
323uint32_t downshift_component( uint32_t in, uint32_t v,
324 int sh, int sl, // src
325 int dh, int dl, // dst
326 int ch, int cl, // clear
327 int dither)
328{
329 const int sbits = sh-sl;
330 const int dbits = dh-dl;
331
332 assert(sbits>=dbits);
333
334
335 if (sbits>dbits) {
336 if (dither>=0) {
337 v -= (v>>dbits); // fix up
338 const int shift = (GGL_DITHER_BITS - (sbits-dbits));
339 if (shift >= 0) v += (dither >> shift) << sl;
340 else v += (dither << (-shift)) << sl;
341 } else {
342 // don't do that right now, so we can reproduce the same
343 // artifacts we get on ARM (Where we don't do this)
344 // -> this is not really needed if we don't dither
345 //if (dBits > 1) { // result already OK if dBits==1
346 // v -= (v>>dbits); // fix up
347 // v += 1 << ((sbits-dbits)-1); // rounding
348 //}
349 }
350 }
351
352
353 // we need to clear the high bits of the source
354 if (ch) {
355 v <<= 32-sh;
356 sl += 32-sh;
357 sh = 32;
358 }
359
360 if (dl) {
361 if (cl || (sbits>dbits)) {
362 v >>= sh-dbits;
363 sl = 0;
364 sh = dbits;
365 in |= v<<dl;
366 } else {
367 // sbits==dbits and we don't need to clean the lower bits
368 // so we just have to shift the component to the right location
369 int shift = dh-sh;
370 in |= v<<shift;
371 }
372 } else {
373 // destination starts at bit 0
374 // ie: sh-dh == sh-dbits
375 int shift = sh-dh;
376 if (shift > 0) in |= v>>shift;
377 else if (shift < 0) in |= v<<shift;
378 else in |= v;
379 }
380 return in;
381}
382
383// ----------------------------------------------------------------------------
384}; // namespace android