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