1 /* libs/pixelflinger/raster.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 
20 #include <string.h>
21 
22 #include "raster.h"
23 #include "trap.h"
24 
25 namespace android {
26 
27 static void ggl_rasterPos2x(void* con, GGLfixed x, GGLfixed y);
28 static void ggl_rasterPos2i(void* con, GGLint x, GGLint y);
29 static void ggl_copyPixels(void* con, GGLint xs, GGLint ys,
30         GGLsizei width, GGLsizei height, GGLenum type);
31 
ggl_init_raster(context_t * c)32 void ggl_init_raster(context_t* c)
33 {
34     GGLContext& procs = *(GGLContext*)c;
35     GGL_INIT_PROC(procs, copyPixels);
36     GGL_INIT_PROC(procs, rasterPos2x);
37     GGL_INIT_PROC(procs, rasterPos2i);
38 }
39 
ggl_rasterPos2x(void * con,GGLfixed x,GGLfixed y)40 void ggl_rasterPos2x(void* con, GGLfixed x, GGLfixed y)
41 {
42     GGL_CONTEXT(c, con);
43     // raster pos should be processed just like glVertex
44     c->state.raster.x = x;
45     c->state.raster.y = y;
46 }
47 
ggl_rasterPos2i(void * con,GGLint x,GGLint y)48 void ggl_rasterPos2i(void* con, GGLint x, GGLint y)
49 {
50     ggl_rasterPos2x(con, gglIntToFixed(x), gglIntToFixed(y));
51 }
52 
ggl_copyPixels(void * con,GGLint xs,GGLint ys,GGLsizei width,GGLsizei height,GGLenum)53 void ggl_copyPixels(void* con, GGLint xs, GGLint ys,
54         GGLsizei width, GGLsizei height, GGLenum /*type*/)
55 {
56     GGL_CONTEXT(c, con);
57 
58     // color-buffer
59     surface_t* cb = &(c->state.buffers.color);
60 
61     // undefined behaviour if we try to copy from outside the surface
62     if (uint32_t(xs) > cb->width)
63         return;
64     if (uint32_t(ys) > cb->height)
65         return;
66     if (uint32_t(xs + width) > cb->width)
67         return;
68     if (uint32_t(ys + height) > cb->height)
69         return;
70 
71     // copy to current raster position
72     GGLint xd = gglFixedToIntRound(c->state.raster.x);
73     GGLint yd = gglFixedToIntRound(c->state.raster.y);
74 
75     // clip to scissor
76     if (xd < GGLint(c->state.scissor.left)) {
77         GGLint offset = GGLint(c->state.scissor.left) - xd;
78         xd = GGLint(c->state.scissor.left);
79         xs += offset;
80         width -= offset;
81     }
82     if (yd < GGLint(c->state.scissor.top)) {
83         GGLint offset = GGLint(c->state.scissor.top) - yd;
84         yd = GGLint(c->state.scissor.top);
85         ys += offset;
86         height -= offset;
87     }
88     if ((xd + width) > GGLint(c->state.scissor.right)) {
89         width = GGLint(c->state.scissor.right) - xd;
90     }
91     if ((yd + height) > GGLint(c->state.scissor.bottom)) {
92         height = GGLint(c->state.scissor.bottom) - yd;
93     }
94 
95     if (width<=0 || height<=0) {
96         return; // nothing to copy
97     }
98 
99     if (xs==xd && ys==yd) {
100         // nothing to do, but be careful, this might not be true when we support
101         // gglPixelTransfer, gglPixelMap and gglPixelZoom
102         return;
103     }
104 
105     const GGLFormat* fp = &(c->formats[cb->format]);
106     uint8_t* src = reinterpret_cast<uint8_t*>(cb->data)
107             + (xs + (cb->stride * ys)) * fp->size;
108     uint8_t* dst = reinterpret_cast<uint8_t*>(cb->data)
109             + (xd + (cb->stride * yd)) * fp->size;
110     const size_t bpr = cb->stride * fp->size;
111     const size_t rowsize = width * fp->size;
112     size_t yc = height;
113 
114     if (ys < yd) {
115         // bottom to top
116         src += height * bpr;
117         dst += height * bpr;
118         do {
119             dst -= bpr;
120             src -= bpr;
121             memcpy(dst, src, rowsize);
122         } while (--yc);
123     } else {
124         if (ys == yd) {
125             // might be right to left
126             do {
127                 memmove(dst, src, rowsize);
128                 dst += bpr;
129                 src += bpr;
130             } while (--yc);
131         } else {
132             // top to bottom
133             do {
134                 memcpy(dst, src, rowsize);
135                 dst += bpr;
136                 src += bpr;
137             } while (--yc);
138         }
139     }
140 }
141 
142 }; // namespace android
143 
144 using namespace android;
145 
gglBitBlit(GGLContext * con,int tmu,GGLint crop[4],GGLint where[4])146 GGLint gglBitBlit(GGLContext* con, int tmu, GGLint crop[4], GGLint where[4])
147 {
148     GGL_CONTEXT(c, (void*)con);
149 
150      GGLint x = where[0];
151      GGLint y = where[1];
152      GGLint w = where[2];
153      GGLint h = where[3];
154 
155     // exclsively enable this tmu
156     const GGLSurface& cbSurface = c->state.buffers.color.s;
157     c->procs.activeTexture(c, tmu);
158     c->procs.disable(c, GGL_W_LERP);
159 
160     uint32_t tmus = 1UL<<tmu;
161     if (c->state.enabled_tmu != tmus) {
162         c->activeTMU->enable = 1;
163         c->state.enabled_tmu = tmus;
164         c->state.enables |= GGL_ENABLE_TMUS;
165         ggl_state_changed(c, GGL_TMU_STATE);
166     }
167 
168     const GGLint Wcr = crop[2];
169     const GGLint Hcr = crop[3];
170     if ((w == Wcr) && (h == Hcr)) {
171         c->procs.texGeni(c, GGL_S, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
172         c->procs.texGeni(c, GGL_T, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
173         const GGLint Ucr = crop[0];
174         const GGLint Vcr = crop[1];
175         const GGLint s0  = Ucr - x;
176         const GGLint t0  = Vcr - y;
177         c->procs.texCoord2i(c, s0, t0);
178         c->procs.recti(c, x, y, x+w, y+h);
179     } else {
180         int32_t texcoords[8];
181         x = gglIntToFixed(x);
182         y = gglIntToFixed(y);
183 
184         // we CLAMP here, which works with premultiplied (s,t)
185         c->procs.texParameteri(c, GGL_TEXTURE_2D, GGL_TEXTURE_WRAP_S, GGL_CLAMP);
186         c->procs.texParameteri(c, GGL_TEXTURE_2D, GGL_TEXTURE_WRAP_T, GGL_CLAMP);
187         c->procs.texGeni(c, GGL_S, GGL_TEXTURE_GEN_MODE, GGL_AUTOMATIC);
188         c->procs.texGeni(c, GGL_T, GGL_TEXTURE_GEN_MODE, GGL_AUTOMATIC);
189 
190         const GGLint Ucr = crop[0] << 16;
191         const GGLint Vcr = crop[1] << 16;
192         const GGLint Wcr = crop[2] << 16;
193         const GGLint Hcr = crop[3] << 16;
194 
195         // computes texture coordinates (pre-multiplied)
196         int32_t dsdx = Wcr / w;   // dsdx = ((Wcr/w)/Wt)*Wt
197         int32_t dtdy = Hcr / h;   // dtdy = ((Hcr/h)/Ht)*Ht
198         int32_t s0   = Ucr - gglMulx(dsdx, x); // s0 = Ucr - x * dsdx
199         int32_t t0   = Vcr - gglMulx(dtdy, y); // t0 = Vcr - y * dtdy
200         texcoords[0] = s0;
201         texcoords[1] = dsdx;
202         texcoords[2] = 0;
203         texcoords[3] = t0;
204         texcoords[4] = 0;
205         texcoords[5] = dtdy;
206         texcoords[6] = 0;
207         texcoords[7] = 0;
208         c->procs.texCoordGradScale8xv(c, tmu, texcoords);
209         c->procs.recti(c,
210                 gglFixedToIntRound(x),
211                 gglFixedToIntRound(y),
212                 gglFixedToIntRound(x)+w,
213                 gglFixedToIntRound(y)+h);
214     }
215     return 0;
216 }
217 
218