1 /*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef ANDROID_GGL_CONTEXT_H
18 #define ANDROID_GGL_CONTEXT_H
19
20 #include <stdint.h>
21 #include <stddef.h>
22 #include <string.h>
23 #include <sys/types.h>
24 #include <endian.h>
25
26 #include <pixelflinger/pixelflinger.h>
27 #include <private/pixelflinger/ggl_fixed.h>
28
29 namespace android {
30
31 // ----------------------------------------------------------------------------
32
33 #if BYTE_ORDER == LITTLE_ENDIAN
34
GGL_RGBA_TO_HOST(uint32_t v)35 inline uint32_t GGL_RGBA_TO_HOST(uint32_t v) {
36 return v;
37 }
GGL_HOST_TO_RGBA(uint32_t v)38 inline uint32_t GGL_HOST_TO_RGBA(uint32_t v) {
39 return v;
40 }
41
42 #else
43
44 inline uint32_t GGL_RGBA_TO_HOST(uint32_t v) {
45 #if defined(__mips__) && __mips_isa_rev>=2
46 uint32_t r;
47 __asm__("wsbh %0, %1;"
48 "rotr %0, %0, 16"
49 : "=r" (r)
50 : "r" (v)
51 );
52 return r;
53 #else
54 return (v<<24) | (v>>24) | ((v<<8)&0xff0000) | ((v>>8)&0xff00);
55 #endif
56 }
57 inline uint32_t GGL_HOST_TO_RGBA(uint32_t v) {
58 #if defined(__mips__) && __mips_isa_rev>=2
59 uint32_t r;
60 __asm__("wsbh %0, %1;"
61 "rotr %0, %0, 16"
62 : "=r" (r)
63 : "r" (v)
64 );
65 return r;
66 #else
67 return (v<<24) | (v>>24) | ((v<<8)&0xff0000) | ((v>>8)&0xff00);
68 #endif
69 }
70
71 #endif
72
73 // ----------------------------------------------------------------------------
74
75 const int GGL_DITHER_BITS = 6; // dither weights stored on 6 bits
76 const int GGL_DITHER_ORDER_SHIFT= 3;
77 const int GGL_DITHER_ORDER = (1<<GGL_DITHER_ORDER_SHIFT);
78 const int GGL_DITHER_SIZE = GGL_DITHER_ORDER * GGL_DITHER_ORDER;
79 const int GGL_DITHER_MASK = GGL_DITHER_ORDER-1;
80
81 // ----------------------------------------------------------------------------
82
83 const int GGL_SUBPIXEL_BITS = 4;
84
85 // TRI_FRACTION_BITS defines the number of bits we want to use
86 // for the sub-pixel coordinates during the edge stepping, the
87 // value shouldn't be more than 7, or bad things are going to
88 // happen when drawing large triangles (8 doesn't work because
89 // 32 bit muls will loose the sign bit)
90
91 #define TRI_FRACTION_BITS (GGL_SUBPIXEL_BITS)
92 #define TRI_ONE (1 << TRI_FRACTION_BITS)
93 #define TRI_HALF (1 << (TRI_FRACTION_BITS-1))
94 #define TRI_FROM_INT(x) ((x) << TRI_FRACTION_BITS)
95 #define TRI_FRAC(x) ((x) & (TRI_ONE-1))
96 #define TRI_FLOOR(x) ((x) & ~(TRI_ONE-1))
97 #define TRI_CEIL(x) (((x) + (TRI_ONE-1)) & ~(TRI_ONE-1))
98 #define TRI_ROUND(x) (((x) + TRI_HALF ) & ~(TRI_ONE-1))
99
100 #define TRI_ROUDNING (1 << (16 - TRI_FRACTION_BITS - 1))
101 #define TRI_FROM_FIXED(x) (((x)+TRI_ROUDNING) >> (16-TRI_FRACTION_BITS))
102
103 #define TRI_SNAP_NEXT_HALF(x) (TRI_CEIL((x)+TRI_HALF) - TRI_HALF)
104 #define TRI_SNAP_PREV_HALF(x) (TRI_CEIL((x)-TRI_HALF) - TRI_HALF)
105
106 // ----------------------------------------------------------------------------
107
108 const int GGL_COLOR_BITS = 24;
109
110 // To maintain 8-bits color chanels, with a maximum GGLSurface
111 // size of 4096 and GGL_SUBPIXEL_BITS=4, we need 8 + 12 + 4 = 24 bits
112 // for encoding the color iterators
113
gglFixedToIteratedColor(GGLfixed c)114 inline GGLcolor gglFixedToIteratedColor(GGLfixed c) {
115 return (c << 8) - c;
116 }
117
118 // ----------------------------------------------------------------------------
119
120 template<bool> struct CTA;
121 template<> struct CTA<true> { };
122
123 #define GGL_CONTEXT(con, c) context_t *(con) = static_cast<context_t *>(c) /* NOLINT */
124 #define GGL_OFFSETOF(field) uintptr_t(&(((context_t*)0)->field))
125 #define GGL_INIT_PROC(p, f) p.f = ggl_ ## f;
126 #define GGL_BETWEEN(x, L, H) (uint32_t((x)-(L)) <= ((H)-(L)))
127
128 #define ggl_likely(x) __builtin_expect(!!(x), 1)
129 #define ggl_unlikely(x) __builtin_expect(!!(x), 0)
130
131 const int GGL_TEXTURE_UNIT_COUNT = 2;
132 const int GGL_TMU_STATE = 0x00000001;
133 const int GGL_CB_STATE = 0x00000002;
134 const int GGL_PIXEL_PIPELINE_STATE = 0x00000004;
135
136 // ----------------------------------------------------------------------------
137
138 #define GGL_RESERVE_NEEDS(name, l, s) \
139 const uint32_t GGL_NEEDS_##name##_MASK = (((1LU<<(s))-1)<<(l)); \
140 const uint32_t GGL_NEEDS_##name##_SHIFT = (l);
141
142 #define GGL_BUILD_NEEDS(val, name) \
143 (((val)<<(GGL_NEEDS_##name##_SHIFT)) & GGL_NEEDS_##name##_MASK)
144
145 #define GGL_READ_NEEDS(name, n) \
146 (uint32_t((n) & GGL_NEEDS_##name##_MASK) >> GGL_NEEDS_##name##_SHIFT)
147
148 #define GGL_NEED_MASK(name) (uint32_t(GGL_NEEDS_##name##_MASK))
149 #define GGL_NEED(name, val) GGL_BUILD_NEEDS(val, name)
150
151 GGL_RESERVE_NEEDS( CB_FORMAT, 0, 6 )
152 GGL_RESERVE_NEEDS( SHADE, 6, 1 )
153 GGL_RESERVE_NEEDS( W, 7, 1 )
154 GGL_RESERVE_NEEDS( BLEND_SRC, 8, 4 )
155 GGL_RESERVE_NEEDS( BLEND_DST, 12, 4 )
156 GGL_RESERVE_NEEDS( BLEND_SRCA, 16, 4 )
157 GGL_RESERVE_NEEDS( BLEND_DSTA, 20, 4 )
158 GGL_RESERVE_NEEDS( LOGIC_OP, 24, 4 )
159 GGL_RESERVE_NEEDS( MASK_ARGB, 28, 4 )
160
161 GGL_RESERVE_NEEDS( P_ALPHA_TEST, 0, 3 )
162 GGL_RESERVE_NEEDS( P_AA, 3, 1 )
163 GGL_RESERVE_NEEDS( P_DEPTH_TEST, 4, 3 )
164 GGL_RESERVE_NEEDS( P_MASK_Z, 7, 1 )
165 GGL_RESERVE_NEEDS( P_DITHER, 8, 1 )
166 GGL_RESERVE_NEEDS( P_FOG, 9, 1 )
167 GGL_RESERVE_NEEDS( P_RESERVED1, 10,22 )
168
169 GGL_RESERVE_NEEDS( T_FORMAT, 0, 6 )
170 GGL_RESERVE_NEEDS( T_RESERVED0, 6, 1 )
171 GGL_RESERVE_NEEDS( T_POT, 7, 1 )
172 GGL_RESERVE_NEEDS( T_S_WRAP, 8, 2 )
173 GGL_RESERVE_NEEDS( T_T_WRAP, 10, 2 )
174 GGL_RESERVE_NEEDS( T_ENV, 12, 3 )
175 GGL_RESERVE_NEEDS( T_LINEAR, 15, 1 )
176
177 const int GGL_NEEDS_WRAP_CLAMP_TO_EDGE = 0;
178 const int GGL_NEEDS_WRAP_REPEAT = 1;
179 const int GGL_NEEDS_WRAP_11 = 2;
180
181 inline uint32_t ggl_wrap_to_needs(uint32_t e) {
182 switch (e) {
183 case GGL_CLAMP: return GGL_NEEDS_WRAP_CLAMP_TO_EDGE;
184 case GGL_REPEAT: return GGL_NEEDS_WRAP_REPEAT;
185 }
186 return 0;
187 }
188
189 inline uint32_t ggl_blendfactor_to_needs(uint32_t b) {
190 if (b <= 1) return b;
191 return (b & 0xF)+2;
192 }
193
194 inline uint32_t ggl_needs_to_blendfactor(uint32_t n) {
195 if (n <= 1) return n;
196 return (n - 2) + 0x300;
197 }
198
199 inline uint32_t ggl_env_to_needs(uint32_t e) {
200 switch (e) {
201 case GGL_REPLACE: return 0;
202 case GGL_MODULATE: return 1;
203 case GGL_DECAL: return 2;
204 case GGL_BLEND: return 3;
205 case GGL_ADD: return 4;
206 }
207 return 0;
208 }
209
210 inline uint32_t ggl_needs_to_env(uint32_t n) {
211 const uint32_t envs[] = { GGL_REPLACE, GGL_MODULATE,
212 GGL_DECAL, GGL_BLEND, GGL_ADD };
213 return envs[n];
214
215 }
216
217 // ----------------------------------------------------------------------------
218
219 enum {
220 GGL_ENABLE_BLENDING = 0x00000001,
221 GGL_ENABLE_SMOOTH = 0x00000002,
222 GGL_ENABLE_AA = 0x00000004,
223 GGL_ENABLE_LOGIC_OP = 0x00000008,
224 GGL_ENABLE_ALPHA_TEST = 0x00000010,
225 GGL_ENABLE_SCISSOR_TEST = 0x00000020,
226 GGL_ENABLE_TMUS = 0x00000040,
227 GGL_ENABLE_DEPTH_TEST = 0x00000080,
228 GGL_ENABLE_STENCIL_TEST = 0x00000100,
229 GGL_ENABLE_W = 0x00000200,
230 GGL_ENABLE_DITHER = 0x00000400,
231 GGL_ENABLE_FOG = 0x00000800,
232 GGL_ENABLE_POINT_AA_NICE= 0x00001000
233 };
234
235 // ----------------------------------------------------------------------------
236
237 struct needs_filter_t;
238 struct needs_t {
239 inline int match(const needs_filter_t& filter);
240 inline bool operator == (const needs_t& rhs) const {
241 return (n==rhs.n) &&
242 (p==rhs.p) &&
243 (t[0]==rhs.t[0]) &&
244 (t[1]==rhs.t[1]);
245 }
246 inline bool operator != (const needs_t& rhs) const {
247 return !operator == (rhs);
248 }
249 uint32_t n;
250 uint32_t p;
251 uint32_t t[GGL_TEXTURE_UNIT_COUNT];
252 };
253
254 inline int compare_type(const needs_t& lhs, const needs_t& rhs) {
255 return memcmp(&lhs, &rhs, sizeof(needs_t));
256 }
257
258 struct needs_filter_t {
259 needs_t value;
260 needs_t mask;
261 };
262
263 int needs_t::match(const needs_filter_t& filter) {
264 uint32_t result =
265 ((filter.value.n ^ n) & filter.mask.n) |
266 ((filter.value.p ^ p) & filter.mask.p) |
267 ((filter.value.t[0] ^ t[0]) & filter.mask.t[0]) |
268 ((filter.value.t[1] ^ t[1]) & filter.mask.t[1]);
269 return (result == 0);
270 }
271
272 // ----------------------------------------------------------------------------
273
274 struct context_t;
275 class Assembly;
276
277 struct blend_state_t {
278 uint32_t src;
279 uint32_t dst;
280 uint32_t src_alpha;
281 uint32_t dst_alpha;
282 uint8_t reserved;
283 uint8_t alpha_separate;
284 uint8_t operation;
285 uint8_t equation;
286 };
287
288 struct mask_state_t {
289 uint8_t color;
290 uint8_t depth;
291 uint32_t stencil;
292 };
293
294 struct clear_state_t {
295 GGLclampx r;
296 GGLclampx g;
297 GGLclampx b;
298 GGLclampx a;
299 GGLclampx depth;
300 GGLint stencil;
301 uint32_t colorPacked;
302 uint32_t depthPacked;
303 uint32_t stencilPacked;
304 uint32_t dirty;
305 };
306
307 struct fog_state_t {
308 uint8_t color[4];
309 };
310
311 struct logic_op_state_t {
312 uint16_t opcode;
313 };
314
315 struct alpha_test_state_t {
316 uint16_t func;
317 GGLcolor ref;
318 };
319
320 struct depth_test_state_t {
321 uint16_t func;
322 GGLclampx clearValue;
323 };
324
325 struct scissor_t {
326 uint32_t user_left;
327 uint32_t user_right;
328 uint32_t user_top;
329 uint32_t user_bottom;
330 uint32_t left;
331 uint32_t right;
332 uint32_t top;
333 uint32_t bottom;
334 };
335
336 struct pixel_t {
337 uint32_t c[4];
338 uint8_t s[4];
339 };
340
341 struct surface_t {
342 union {
343 GGLSurface s;
344 // Keep the following struct field types in line with the corresponding
345 // GGLSurface fields to avoid mismatches leading to errors.
346 struct {
347 GGLsizei reserved;
348 GGLuint width;
349 GGLuint height;
350 GGLint stride;
351 GGLubyte* data;
352 GGLubyte format;
353 GGLubyte dirty;
354 GGLubyte pad[2];
355 };
356 };
357 void (*read) (const surface_t* s, context_t* c,
358 uint32_t x, uint32_t y, pixel_t* pixel);
359 void (*write)(const surface_t* s, context_t* c,
360 uint32_t x, uint32_t y, const pixel_t* pixel);
361 };
362
363 // ----------------------------------------------------------------------------
364
365 struct texture_shade_t {
366 union {
367 struct {
368 int32_t is0;
369 int32_t idsdx;
370 int32_t idsdy;
371 int sscale;
372 int32_t it0;
373 int32_t idtdx;
374 int32_t idtdy;
375 int tscale;
376 };
377 struct {
378 int32_t v;
379 int32_t dx;
380 int32_t dy;
381 int scale;
382 } st[2];
383 };
384 };
385
386 struct texture_iterators_t {
387 // these are not encoded in the same way than in the
388 // texture_shade_t structure
389 union {
390 struct {
391 GGLfixed ydsdy;
392 GGLfixed dsdx;
393 GGLfixed dsdy;
394 int sscale;
395 GGLfixed ydtdy;
396 GGLfixed dtdx;
397 GGLfixed dtdy;
398 int tscale;
399 };
400 struct {
401 GGLfixed ydvdy;
402 GGLfixed dvdx;
403 GGLfixed dvdy;
404 int scale;
405 } st[2];
406 };
407 };
408
409 struct texture_t {
410 surface_t surface;
411 texture_iterators_t iterators;
412 texture_shade_t shade;
413 uint32_t s_coord;
414 uint32_t t_coord;
415 uint16_t s_wrap;
416 uint16_t t_wrap;
417 uint16_t min_filter;
418 uint16_t mag_filter;
419 uint16_t env;
420 uint8_t env_color[4];
421 uint8_t enable;
422 uint8_t dirty;
423 };
424
425 struct raster_t {
426 GGLfixed x;
427 GGLfixed y;
428 };
429
430 struct framebuffer_t {
431 surface_t color;
432 surface_t read;
433 surface_t depth;
434 surface_t stencil;
435 int16_t *coverage;
436 size_t coverageBufferSize;
437 };
438
439 // ----------------------------------------------------------------------------
440
441 struct iterators_t {
442 int32_t xl;
443 int32_t xr;
444 int32_t y;
445 GGLcolor ydady;
446 GGLcolor ydrdy;
447 GGLcolor ydgdy;
448 GGLcolor ydbdy;
449 GGLfixed ydzdy;
450 GGLfixed ydwdy;
451 GGLfixed ydfdy;
452 };
453
454 struct shade_t {
455 GGLcolor a0;
456 GGLcolor dadx;
457 GGLcolor dady;
458 GGLcolor r0;
459 GGLcolor drdx;
460 GGLcolor drdy;
461 GGLcolor g0;
462 GGLcolor dgdx;
463 GGLcolor dgdy;
464 GGLcolor b0;
465 GGLcolor dbdx;
466 GGLcolor dbdy;
467 uint32_t z0;
468 GGLfixed32 dzdx;
469 GGLfixed32 dzdy;
470 GGLfixed w0;
471 GGLfixed dwdx;
472 GGLfixed dwdy;
473 uint32_t f0;
474 GGLfixed dfdx;
475 GGLfixed dfdy;
476 };
477
478 // these are used in the generated code
479 // we use this mirror structure to improve
480 // data locality in the pixel pipeline
481 struct generated_tex_vars_t {
482 uint32_t width;
483 uint32_t height;
484 uint32_t stride;
485 uintptr_t data;
486 int32_t dsdx;
487 int32_t dtdx;
488 int32_t spill[2];
489 };
490
491 struct generated_vars_t {
492 struct {
493 int32_t c;
494 int32_t dx;
495 } argb[4];
496 int32_t aref;
497 int32_t dzdx;
498 int32_t zbase;
499 int32_t f;
500 int32_t dfdx;
501 int32_t spill[3];
502 generated_tex_vars_t texture[GGL_TEXTURE_UNIT_COUNT];
503 int32_t rt;
504 int32_t lb;
505 };
506
507 // ----------------------------------------------------------------------------
508
509 struct state_t {
510 framebuffer_t buffers;
511 texture_t texture[GGL_TEXTURE_UNIT_COUNT];
512 scissor_t scissor;
513 raster_t raster;
514 blend_state_t blend;
515 alpha_test_state_t alpha_test;
516 depth_test_state_t depth_test;
517 mask_state_t mask;
518 clear_state_t clear;
519 fog_state_t fog;
520 logic_op_state_t logic_op;
521 uint32_t enables;
522 uint32_t enabled_tmu;
523 needs_t needs;
524 };
525
526 // ----------------------------------------------------------------------------
527
528 struct context_t {
529 GGLContext procs;
530 state_t state;
531 shade_t shade;
532 iterators_t iterators;
533 generated_vars_t generated_vars __attribute__((aligned(32)));
534 uint8_t ditherMatrix[GGL_DITHER_SIZE] __attribute__((aligned(32)));
535 uint32_t packed;
536 uint32_t packed8888;
537 const GGLFormat* formats;
538 uint32_t dirty;
539 texture_t* activeTMU;
540 uint32_t activeTMUIndex;
541
542 void (*init_y)(context_t* c, int32_t y);
543 void (*step_y)(context_t* c);
544 void (*scanline)(context_t* c);
545 void (*span)(context_t* c);
546 void (*rect)(context_t* c, size_t yc);
547
548 void* base;
549 Assembly* scanline_as;
550 GGLenum error;
551 };
552
553 // ----------------------------------------------------------------------------
554
555 void ggl_init_context(context_t* context);
556 void ggl_uninit_context(context_t* context);
557 void ggl_error(context_t* c, GGLenum error);
558 int64_t ggl_system_time();
559
560 // ----------------------------------------------------------------------------
561
562 };
563
564 #endif // ANDROID_GGL_CONTEXT_H
565
566