• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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