Home | History | Annotate | Download | only in pixelflinger
      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 
     35 inline uint32_t GGL_RGBA_TO_HOST(uint32_t v) {
     36     return v;
     37 }
     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 
    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)
    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