[go: nahoru, domu]

1/* libs/opengles/texture.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#include <stdio.h>
19#include <stdlib.h>
20#include "context.h"
21#include "fp.h"
22#include "state.h"
23#include "texture.h"
24#include "TextureObjectManager.h"
25
26#include <ETC1/etc1.h>
27
28namespace android {
29
30// ----------------------------------------------------------------------------
31
32static void bindTextureTmu(
33    ogles_context_t* c, int tmu, GLuint texture, const sp<EGLTextureObject>& tex);
34
35static __attribute__((noinline))
36void generateMipmap(ogles_context_t* c, GLint level);
37
38// ----------------------------------------------------------------------------
39
40#if 0
41#pragma mark -
42#pragma mark Init
43#endif
44
45void ogles_init_texture(ogles_context_t* c)
46{
47    c->textures.packAlignment   = 4;
48    c->textures.unpackAlignment = 4;
49
50    // each context has a default named (0) texture (not shared)
51    c->textures.defaultTexture = new EGLTextureObject();
52    c->textures.defaultTexture->incStrong(c);
53
54    // bind the default texture to each texture unit
55    for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
56        bindTextureTmu(c, i, 0, c->textures.defaultTexture);
57        memset(c->current.texture[i].v, 0, sizeof(vec4_t));
58        c->current.texture[i].Q = 0x10000;
59    }
60}
61
62void ogles_uninit_texture(ogles_context_t* c)
63{
64    if (c->textures.ggl)
65        gglUninit(c->textures.ggl);
66    c->textures.defaultTexture->decStrong(c);
67    for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
68        if (c->textures.tmu[i].texture)
69            c->textures.tmu[i].texture->decStrong(c);
70    }
71}
72
73static __attribute__((noinline))
74void validate_tmu(ogles_context_t* c, int i)
75{
76    texture_unit_t& u(c->textures.tmu[i]);
77    if (u.dirty) {
78        u.dirty = 0;
79        c->rasterizer.procs.activeTexture(c, i);
80        c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
81        c->rasterizer.procs.texGeni(c, GGL_S,
82                GGL_TEXTURE_GEN_MODE, GGL_AUTOMATIC);
83        c->rasterizer.procs.texGeni(c, GGL_T,
84                GGL_TEXTURE_GEN_MODE, GGL_AUTOMATIC);
85        c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
86                GGL_TEXTURE_WRAP_S, u.texture->wraps);
87        c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
88                GGL_TEXTURE_WRAP_T, u.texture->wrapt);
89        c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
90                GGL_TEXTURE_MIN_FILTER, u.texture->min_filter);
91        c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
92                GGL_TEXTURE_MAG_FILTER, u.texture->mag_filter);
93
94        // disable this texture unit if it's not complete
95        if (!u.texture->isComplete()) {
96            c->rasterizer.procs.disable(c, GGL_TEXTURE_2D);
97        }
98    }
99}
100
101void ogles_validate_texture(ogles_context_t* c)
102{
103    for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
104        if (c->rasterizer.state.texture[i].enable)
105            validate_tmu(c, i);
106    }
107    c->rasterizer.procs.activeTexture(c, c->textures.active);
108}
109
110static
111void invalidate_texture(ogles_context_t* c, int tmu, uint8_t flags = 0xFF) {
112    c->textures.tmu[tmu].dirty = flags;
113}
114
115/*
116 * If the active textures are EGLImage, they need to be locked before
117 * they can be used.
118 *
119 * FIXME: code below is far from being optimal
120 *
121 */
122
123void ogles_lock_textures(ogles_context_t* c)
124{
125    for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
126        if (c->rasterizer.state.texture[i].enable) {
127            texture_unit_t& u(c->textures.tmu[i]);
128            ANativeWindowBuffer* native_buffer = u.texture->buffer;
129            if (native_buffer) {
130                c->rasterizer.procs.activeTexture(c, i);
131                hw_module_t const* pModule;
132                if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &pModule))
133                    continue;
134
135                gralloc_module_t const* module =
136                    reinterpret_cast<gralloc_module_t const*>(pModule);
137
138                void* vaddr;
139                int err = module->lock(module, native_buffer->handle,
140                        GRALLOC_USAGE_SW_READ_OFTEN,
141                        0, 0, native_buffer->width, native_buffer->height,
142                        &vaddr);
143
144                u.texture->setImageBits(vaddr);
145                c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
146            }
147        }
148    }
149}
150
151void ogles_unlock_textures(ogles_context_t* c)
152{
153    for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
154        if (c->rasterizer.state.texture[i].enable) {
155            texture_unit_t& u(c->textures.tmu[i]);
156            ANativeWindowBuffer* native_buffer = u.texture->buffer;
157            if (native_buffer) {
158                c->rasterizer.procs.activeTexture(c, i);
159                hw_module_t const* pModule;
160                if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &pModule))
161                    continue;
162
163                gralloc_module_t const* module =
164                    reinterpret_cast<gralloc_module_t const*>(pModule);
165
166                module->unlock(module, native_buffer->handle);
167                u.texture->setImageBits(NULL);
168                c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
169            }
170        }
171    }
172    c->rasterizer.procs.activeTexture(c, c->textures.active);
173}
174
175// ----------------------------------------------------------------------------
176#if 0
177#pragma mark -
178#pragma mark Format conversion
179#endif
180
181static uint32_t gl2format_table[6][4] = {
182    // BYTE, 565, 4444, 5551
183    { GGL_PIXEL_FORMAT_A_8,
184      0, 0, 0 },                        // GL_ALPHA
185    { GGL_PIXEL_FORMAT_RGB_888,
186      GGL_PIXEL_FORMAT_RGB_565,
187      0, 0 },                           // GL_RGB
188    { GGL_PIXEL_FORMAT_RGBA_8888,
189      0,
190      GGL_PIXEL_FORMAT_RGBA_4444,
191      GGL_PIXEL_FORMAT_RGBA_5551 },     // GL_RGBA
192    { GGL_PIXEL_FORMAT_L_8,
193      0, 0, 0 },                        // GL_LUMINANCE
194    { GGL_PIXEL_FORMAT_LA_88,
195      0, 0, 0 },                        // GL_LUMINANCE_ALPHA
196};
197
198static int32_t convertGLPixelFormat(GLint format, GLenum type)
199{
200    int32_t fi = -1;
201    int32_t ti = -1;
202    switch (format) {
203    case GL_ALPHA:              fi = 0;     break;
204    case GL_RGB:                fi = 1;     break;
205    case GL_RGBA:               fi = 2;     break;
206    case GL_LUMINANCE:          fi = 3;     break;
207    case GL_LUMINANCE_ALPHA:    fi = 4;     break;
208    }
209    switch (type) {
210    case GL_UNSIGNED_BYTE:          ti = 0; break;
211    case GL_UNSIGNED_SHORT_5_6_5:   ti = 1; break;
212    case GL_UNSIGNED_SHORT_4_4_4_4: ti = 2; break;
213    case GL_UNSIGNED_SHORT_5_5_5_1: ti = 3; break;
214    }
215    if (fi==-1 || ti==-1)
216        return 0;
217    return gl2format_table[fi][ti];
218}
219
220// ----------------------------------------------------------------------------
221
222static GLenum validFormatType(ogles_context_t* c, GLenum format, GLenum type)
223{
224    GLenum error = 0;
225    if (format<GL_ALPHA || format>GL_LUMINANCE_ALPHA) {
226        error = GL_INVALID_ENUM;
227    }
228    if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 &&
229        type != GL_UNSIGNED_SHORT_5_5_5_1 && type != GL_UNSIGNED_SHORT_5_6_5) {
230        error = GL_INVALID_ENUM;
231    }
232    if (type == GL_UNSIGNED_SHORT_5_6_5 && format != GL_RGB) {
233        error = GL_INVALID_OPERATION;
234    }
235    if ((type == GL_UNSIGNED_SHORT_4_4_4_4 ||
236         type == GL_UNSIGNED_SHORT_5_5_5_1)  && format != GL_RGBA) {
237        error = GL_INVALID_OPERATION;
238    }
239    if (error) {
240        ogles_error(c, error);
241    }
242    return error;
243}
244
245// ----------------------------------------------------------------------------
246
247GGLContext* getRasterizer(ogles_context_t* c)
248{
249    GGLContext* ggl = c->textures.ggl;
250    if (ggl_unlikely(!ggl)) {
251        // this is quite heavy the first time...
252        gglInit(&ggl);
253        if (!ggl) {
254            return 0;
255        }
256        GGLfixed colors[4] = { 0, 0, 0, 0x10000 };
257        c->textures.ggl = ggl;
258        ggl->activeTexture(ggl, 0);
259        ggl->enable(ggl, GGL_TEXTURE_2D);
260        ggl->texEnvi(ggl, GGL_TEXTURE_ENV, GGL_TEXTURE_ENV_MODE, GGL_REPLACE);
261        ggl->disable(ggl, GGL_DITHER);
262        ggl->shadeModel(ggl, GGL_FLAT);
263        ggl->color4xv(ggl, colors);
264    }
265    return ggl;
266}
267
268static __attribute__((noinline))
269int copyPixels(
270        ogles_context_t* c,
271        const GGLSurface& dst,
272        GLint xoffset, GLint yoffset,
273        const GGLSurface& src,
274        GLint x, GLint y, GLsizei w, GLsizei h)
275{
276    if ((dst.format == src.format) &&
277        (dst.stride == src.stride) &&
278        (dst.width == src.width) &&
279        (dst.height == src.height) &&
280        (dst.stride > 0) &&
281        ((x|y) == 0) &&
282        ((xoffset|yoffset) == 0))
283    {
284        // this is a common case...
285        const GGLFormat& pixelFormat(c->rasterizer.formats[src.format]);
286        const size_t size = src.height * src.stride * pixelFormat.size;
287        memcpy(dst.data, src.data, size);
288        return 0;
289    }
290
291    // use pixel-flinger to handle all the conversions
292    GGLContext* ggl = getRasterizer(c);
293    if (!ggl) {
294        // the only reason this would fail is because we ran out of memory
295        return GL_OUT_OF_MEMORY;
296    }
297
298    ggl->colorBuffer(ggl, &dst);
299    ggl->bindTexture(ggl, &src);
300    ggl->texCoord2i(ggl, x-xoffset, y-yoffset);
301    ggl->recti(ggl, xoffset, yoffset, xoffset+w, yoffset+h);
302    return 0;
303}
304
305// ----------------------------------------------------------------------------
306
307static __attribute__((noinline))
308sp<EGLTextureObject> getAndBindActiveTextureObject(ogles_context_t* c)
309{
310    sp<EGLTextureObject> tex;
311    const int active = c->textures.active;
312    const GLuint name = c->textures.tmu[active].name;
313
314    // free the reference to the previously bound object
315    texture_unit_t& u(c->textures.tmu[active]);
316    if (u.texture)
317        u.texture->decStrong(c);
318
319    if (name == 0) {
320        // 0 is our local texture object, not shared with anyone.
321        // But it affects all bound TMUs immediately.
322        // (we need to invalidate all units bound to this texture object)
323        tex = c->textures.defaultTexture;
324        for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
325            if (c->textures.tmu[i].texture == tex.get())
326                invalidate_texture(c, i);
327        }
328    } else {
329        // get a new texture object for that name
330        tex = c->surfaceManager->replaceTexture(name);
331    }
332
333    // bind this texture to the current active texture unit
334    // and add a reference to this texture object
335    u.texture = tex.get();
336    u.texture->incStrong(c);
337    u.name = name;
338    invalidate_texture(c, active);
339    return tex;
340}
341
342void bindTextureTmu(
343    ogles_context_t* c, int tmu, GLuint texture, const sp<EGLTextureObject>& tex)
344{
345    if (tex.get() == c->textures.tmu[tmu].texture)
346        return;
347
348    // free the reference to the previously bound object
349    texture_unit_t& u(c->textures.tmu[tmu]);
350    if (u.texture)
351        u.texture->decStrong(c);
352
353    // bind this texture to the current active texture unit
354    // and add a reference to this texture object
355    u.texture = tex.get();
356    u.texture->incStrong(c);
357    u.name = texture;
358    invalidate_texture(c, tmu);
359}
360
361int createTextureSurface(ogles_context_t* c,
362        GGLSurface** outSurface, int32_t* outSize, GLint level,
363        GLenum format, GLenum type, GLsizei width, GLsizei height,
364        GLenum compressedFormat = 0)
365{
366    // find out which texture is bound to the current unit
367    const int active = c->textures.active;
368    const GLuint name = c->textures.tmu[active].name;
369
370    // convert the pixelformat to one we can handle
371    const int32_t formatIdx = convertGLPixelFormat(format, type);
372    if (formatIdx == 0) { // we don't know what to do with this
373        return GL_INVALID_OPERATION;
374    }
375
376    // figure out the size we need as well as the stride
377    const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
378    const int32_t align = c->textures.unpackAlignment-1;
379    const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
380    const size_t size = bpr * height;
381    const int32_t stride = bpr / pixelFormat.size;
382
383    if (level > 0) {
384        const int active = c->textures.active;
385        EGLTextureObject* tex = c->textures.tmu[active].texture;
386        status_t err = tex->reallocate(level,
387                width, height, stride, formatIdx, compressedFormat, bpr);
388        if (err != NO_ERROR)
389            return GL_OUT_OF_MEMORY;
390        GGLSurface& surface = tex->editMip(level);
391        *outSurface = &surface;
392        *outSize = size;
393        return 0;
394    }
395
396    sp<EGLTextureObject> tex = getAndBindActiveTextureObject(c);
397    status_t err = tex->reallocate(level,
398            width, height, stride, formatIdx, compressedFormat, bpr);
399    if (err != NO_ERROR)
400        return GL_OUT_OF_MEMORY;
401
402    tex->internalformat = format;
403    *outSurface = &tex->surface;
404    *outSize = size;
405    return 0;
406}
407
408static size_t dataSizePalette4(int numLevels, int width, int height, int format)
409{
410    int indexBits = 8;
411    int entrySize = 0;
412    switch (format) {
413    case GL_PALETTE4_RGB8_OES:
414        indexBits = 4;
415        /* FALLTHROUGH */
416    case GL_PALETTE8_RGB8_OES:
417        entrySize = 3;
418        break;
419
420    case GL_PALETTE4_RGBA8_OES:
421        indexBits = 4;
422        /* FALLTHROUGH */
423    case GL_PALETTE8_RGBA8_OES:
424        entrySize = 4;
425        break;
426
427    case GL_PALETTE4_R5_G6_B5_OES:
428    case GL_PALETTE4_RGBA4_OES:
429    case GL_PALETTE4_RGB5_A1_OES:
430        indexBits = 4;
431        /* FALLTHROUGH */
432    case GL_PALETTE8_R5_G6_B5_OES:
433    case GL_PALETTE8_RGBA4_OES:
434    case GL_PALETTE8_RGB5_A1_OES:
435        entrySize = 2;
436        break;
437    }
438
439    size_t size = (1 << indexBits) * entrySize; // palette size
440
441    for (int i=0 ; i< numLevels ; i++) {
442        int w = (width  >> i) ? : 1;
443        int h = (height >> i) ? : 1;
444        int levelSize = h * ((w * indexBits) / 8) ? : 1;
445        size += levelSize;
446    }
447
448    return size;
449}
450
451static void decodePalette4(const GLvoid *data, int level, int width, int height,
452                           void *surface, int stride, int format)
453
454{
455    int indexBits = 8;
456    int entrySize = 0;
457    switch (format) {
458    case GL_PALETTE4_RGB8_OES:
459        indexBits = 4;
460        /* FALLTHROUGH */
461    case GL_PALETTE8_RGB8_OES:
462        entrySize = 3;
463        break;
464
465    case GL_PALETTE4_RGBA8_OES:
466        indexBits = 4;
467        /* FALLTHROUGH */
468    case GL_PALETTE8_RGBA8_OES:
469        entrySize = 4;
470        break;
471
472    case GL_PALETTE4_R5_G6_B5_OES:
473    case GL_PALETTE4_RGBA4_OES:
474    case GL_PALETTE4_RGB5_A1_OES:
475        indexBits = 4;
476        /* FALLTHROUGH */
477    case GL_PALETTE8_R5_G6_B5_OES:
478    case GL_PALETTE8_RGBA4_OES:
479    case GL_PALETTE8_RGB5_A1_OES:
480        entrySize = 2;
481        break;
482    }
483
484    const int paletteSize = (1 << indexBits) * entrySize;
485
486    uint8_t const* pixels = (uint8_t *)data + paletteSize;
487    for (int i=0 ; i<level ; i++) {
488        int w = (width  >> i) ? : 1;
489        int h = (height >> i) ? : 1;
490        pixels += h * ((w * indexBits) / 8);
491    }
492    width  = (width  >> level) ? : 1;
493    height = (height >> level) ? : 1;
494
495    if (entrySize == 2) {
496        uint8_t const* const palette = (uint8_t*)data;
497        for (int y=0 ; y<height ; y++) {
498            uint8_t* p = (uint8_t*)surface + y*stride*2;
499            if (indexBits == 8) {
500                for (int x=0 ; x<width ; x++) {
501                    int index = 2 * (*pixels++);
502                    *p++ = palette[index + 0];
503                    *p++ = palette[index + 1];
504                }
505            } else {
506                for (int x=0 ; x<width ; x+=2) {
507                    int v = *pixels++;
508                    int index = 2 * (v >> 4);
509                    *p++ = palette[index + 0];
510                    *p++ = palette[index + 1];
511                    if (x+1 < width) {
512                        index = 2 * (v & 0xF);
513                        *p++ = palette[index + 0];
514                        *p++ = palette[index + 1];
515                    }
516                }
517            }
518        }
519    } else if (entrySize == 3) {
520        uint8_t const* const palette = (uint8_t*)data;
521        for (int y=0 ; y<height ; y++) {
522            uint8_t* p = (uint8_t*)surface + y*stride*3;
523            if (indexBits == 8) {
524                for (int x=0 ; x<width ; x++) {
525                    int index = 3 * (*pixels++);
526                    *p++ = palette[index + 0];
527                    *p++ = palette[index + 1];
528                    *p++ = palette[index + 2];
529                }
530            } else {
531                for (int x=0 ; x<width ; x+=2) {
532                    int v = *pixels++;
533                    int index = 3 * (v >> 4);
534                    *p++ = palette[index + 0];
535                    *p++ = palette[index + 1];
536                    *p++ = palette[index + 2];
537                    if (x+1 < width) {
538                        index = 3 * (v & 0xF);
539                        *p++ = palette[index + 0];
540                        *p++ = palette[index + 1];
541                        *p++ = palette[index + 2];
542                    }
543                }
544            }
545        }
546    } else if (entrySize == 4) {
547        uint8_t const* const palette = (uint8_t*)data;
548        for (int y=0 ; y<height ; y++) {
549            uint8_t* p = (uint8_t*)surface + y*stride*4;
550            if (indexBits == 8) {
551                for (int x=0 ; x<width ; x++) {
552                    int index = 4 * (*pixels++);
553                    *p++ = palette[index + 0];
554                    *p++ = palette[index + 1];
555                    *p++ = palette[index + 2];
556                    *p++ = palette[index + 3];
557                }
558            } else {
559                for (int x=0 ; x<width ; x+=2) {
560                    int v = *pixels++;
561                    int index = 4 * (v >> 4);
562                    *p++ = palette[index + 0];
563                    *p++ = palette[index + 1];
564                    *p++ = palette[index + 2];
565                    *p++ = palette[index + 3];
566                    if (x+1 < width) {
567                        index = 4 * (v & 0xF);
568                        *p++ = palette[index + 0];
569                        *p++ = palette[index + 1];
570                        *p++ = palette[index + 2];
571                        *p++ = palette[index + 3];
572                    }
573                }
574            }
575        }
576    }
577}
578
579
580
581static __attribute__((noinline))
582void set_depth_and_fog(ogles_context_t* c, GGLfixed z)
583{
584    const uint32_t enables = c->rasterizer.state.enables;
585    // we need to compute Zw
586    int32_t iterators[3];
587    iterators[1] = iterators[2] = 0;
588    GGLfixed Zw;
589    GGLfixed n = gglFloatToFixed(c->transforms.vpt.zNear);
590    GGLfixed f = gglFloatToFixed(c->transforms.vpt.zFar);
591    if (z<=0)               Zw = n;
592    else if (z>=0x10000)    Zw = f;
593    else            Zw = gglMulAddx(z, (f-n), n);
594    if (enables & GGL_ENABLE_FOG) {
595        // set up fog if needed...
596        iterators[0] = c->fog.fog(c, Zw);
597        c->rasterizer.procs.fogGrad3xv(c, iterators);
598    }
599    if (enables & GGL_ENABLE_DEPTH_TEST) {
600        // set up z-test if needed...
601        int32_t z = (Zw & ~(Zw>>31));
602        if (z >= 0x10000)
603            z = 0xFFFF;
604        iterators[0] = (z << 16) | z;
605        c->rasterizer.procs.zGrad3xv(c, iterators);
606    }
607}
608
609// ----------------------------------------------------------------------------
610#if 0
611#pragma mark -
612#pragma mark Generate mimaps
613#endif
614
615extern status_t buildAPyramid(ogles_context_t* c, EGLTextureObject* tex);
616
617void generateMipmap(ogles_context_t* c, GLint level)
618{
619    if (level == 0) {
620        const int active = c->textures.active;
621        EGLTextureObject* tex = c->textures.tmu[active].texture;
622        if (tex->generate_mipmap) {
623            if (buildAPyramid(c, tex) != NO_ERROR) {
624                ogles_error(c, GL_OUT_OF_MEMORY);
625                return;
626            }
627        }
628    }
629}
630
631
632static void texParameterx(
633        GLenum target, GLenum pname, GLfixed param, ogles_context_t* c)
634{
635    if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) {
636        ogles_error(c, GL_INVALID_ENUM);
637        return;
638    }
639
640    EGLTextureObject* textureObject = c->textures.tmu[c->textures.active].texture;
641    switch (pname) {
642    case GL_TEXTURE_WRAP_S:
643        if ((param == GL_REPEAT) ||
644            (param == GL_CLAMP_TO_EDGE)) {
645            textureObject->wraps = param;
646        } else {
647            goto invalid_enum;
648        }
649        break;
650    case GL_TEXTURE_WRAP_T:
651        if ((param == GL_REPEAT) ||
652            (param == GL_CLAMP_TO_EDGE)) {
653            textureObject->wrapt = param;
654        } else {
655            goto invalid_enum;
656        }
657        break;
658    case GL_TEXTURE_MIN_FILTER:
659        if ((param == GL_NEAREST) ||
660            (param == GL_LINEAR) ||
661            (param == GL_NEAREST_MIPMAP_NEAREST) ||
662            (param == GL_LINEAR_MIPMAP_NEAREST) ||
663            (param == GL_NEAREST_MIPMAP_LINEAR) ||
664            (param == GL_LINEAR_MIPMAP_LINEAR)) {
665            textureObject->min_filter = param;
666        } else {
667            goto invalid_enum;
668        }
669        break;
670    case GL_TEXTURE_MAG_FILTER:
671        if ((param == GL_NEAREST) ||
672            (param == GL_LINEAR)) {
673            textureObject->mag_filter = param;
674        } else {
675            goto invalid_enum;
676        }
677        break;
678    case GL_GENERATE_MIPMAP:
679        textureObject->generate_mipmap = param;
680        break;
681    default:
682invalid_enum:
683        ogles_error(c, GL_INVALID_ENUM);
684        return;
685    }
686    invalidate_texture(c, c->textures.active);
687}
688
689
690
691static void drawTexxOESImp(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h,
692        ogles_context_t* c)
693{
694    ogles_lock_textures(c);
695
696    const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
697    y = gglIntToFixed(cbSurface.height) - (y + h);
698    w >>= FIXED_BITS;
699    h >>= FIXED_BITS;
700
701    // set up all texture units
702    for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
703        if (!c->rasterizer.state.texture[i].enable)
704            continue;
705
706        int32_t texcoords[8];
707        texture_unit_t& u(c->textures.tmu[i]);
708
709        // validate this tmu (bind, wrap, filter)
710        validate_tmu(c, i);
711        // we CLAMP here, which works with premultiplied (s,t)
712        c->rasterizer.procs.texParameteri(c,
713                GGL_TEXTURE_2D, GGL_TEXTURE_WRAP_S, GGL_CLAMP);
714        c->rasterizer.procs.texParameteri(c,
715                GGL_TEXTURE_2D, GGL_TEXTURE_WRAP_T, GGL_CLAMP);
716        u.dirty = 0xFF; // XXX: should be more subtle
717
718        EGLTextureObject* textureObject = u.texture;
719        const GLint Ucr = textureObject->crop_rect[0] << 16;
720        const GLint Vcr = textureObject->crop_rect[1] << 16;
721        const GLint Wcr = textureObject->crop_rect[2] << 16;
722        const GLint Hcr = textureObject->crop_rect[3] << 16;
723
724        // computes texture coordinates (pre-multiplied)
725        int32_t dsdx = Wcr / w;   // dsdx =  ((Wcr/w)/Wt)*Wt
726        int32_t dtdy =-Hcr / h;   // dtdy = -((Hcr/h)/Ht)*Ht
727        int32_t s0   = Ucr       - gglMulx(dsdx, x); // s0 = Ucr - x * dsdx
728        int32_t t0   = (Vcr+Hcr) - gglMulx(dtdy, y); // t0 = (Vcr+Hcr) - y*dtdy
729        texcoords[0] = s0;
730        texcoords[1] = dsdx;
731        texcoords[2] = 0;
732        texcoords[3] = t0;
733        texcoords[4] = 0;
734        texcoords[5] = dtdy;
735        texcoords[6] = 0;
736        texcoords[7] = 0;
737        c->rasterizer.procs.texCoordGradScale8xv(c, i, texcoords);
738    }
739
740    const uint32_t enables = c->rasterizer.state.enables;
741    if (ggl_unlikely(enables & (GGL_ENABLE_DEPTH_TEST|GGL_ENABLE_FOG)))
742        set_depth_and_fog(c, z);
743
744    c->rasterizer.procs.activeTexture(c, c->textures.active);
745    c->rasterizer.procs.color4xv(c, c->currentColorClamped.v);
746    c->rasterizer.procs.disable(c, GGL_W_LERP);
747    c->rasterizer.procs.disable(c, GGL_AA);
748    c->rasterizer.procs.shadeModel(c, GL_FLAT);
749    c->rasterizer.procs.recti(c,
750            gglFixedToIntRound(x),
751            gglFixedToIntRound(y),
752            gglFixedToIntRound(x)+w,
753            gglFixedToIntRound(y)+h);
754
755    ogles_unlock_textures(c);
756}
757
758static void drawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h,
759        ogles_context_t* c)
760{
761    // quickly reject empty rects
762    if ((w|h) <= 0)
763        return;
764
765    drawTexxOESImp(x, y, z, w, h, c);
766}
767
768static void drawTexiOES(GLint x, GLint y, GLint z, GLint w, GLint h, ogles_context_t* c)
769{
770    // All coordinates are integer, so if we have only one
771    // texture unit active and no scaling is required
772    // THEN, we can use our special 1:1 mapping
773    // which is a lot faster.
774
775    if (ggl_likely(c->rasterizer.state.enabled_tmu == 1)) {
776        const int tmu = 0;
777        texture_unit_t& u(c->textures.tmu[tmu]);
778        EGLTextureObject* textureObject = u.texture;
779        const GLint Wcr = textureObject->crop_rect[2];
780        const GLint Hcr = textureObject->crop_rect[3];
781
782        if ((w == Wcr) && (h == -Hcr)) {
783            if ((w|h) <= 0) return; // quickly reject empty rects
784
785            if (u.dirty) {
786                c->rasterizer.procs.activeTexture(c, tmu);
787                c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
788                c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
789                        GGL_TEXTURE_MIN_FILTER, u.texture->min_filter);
790                c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
791                        GGL_TEXTURE_MAG_FILTER, u.texture->mag_filter);
792            }
793            c->rasterizer.procs.texGeni(c, GGL_S,
794                    GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
795            c->rasterizer.procs.texGeni(c, GGL_T,
796                    GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
797            u.dirty = 0xFF; // XXX: should be more subtle
798            c->rasterizer.procs.activeTexture(c, c->textures.active);
799
800            const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
801            y = cbSurface.height - (y + h);
802            const GLint Ucr = textureObject->crop_rect[0];
803            const GLint Vcr = textureObject->crop_rect[1];
804            const GLint s0  = Ucr - x;
805            const GLint t0  = (Vcr + Hcr) - y;
806
807            const GLuint tw = textureObject->surface.width;
808            const GLuint th = textureObject->surface.height;
809            if ((uint32_t(s0+x+w) > tw) || (uint32_t(t0+y+h) > th)) {
810                // The GL spec is unclear about what should happen
811                // in this case, so we just use the slow case, which
812                // at least won't crash
813                goto slow_case;
814            }
815
816            ogles_lock_textures(c);
817
818            c->rasterizer.procs.texCoord2i(c, s0, t0);
819            const uint32_t enables = c->rasterizer.state.enables;
820            if (ggl_unlikely(enables & (GGL_ENABLE_DEPTH_TEST|GGL_ENABLE_FOG)))
821                set_depth_and_fog(c, gglIntToFixed(z));
822
823            c->rasterizer.procs.color4xv(c, c->currentColorClamped.v);
824            c->rasterizer.procs.disable(c, GGL_W_LERP);
825            c->rasterizer.procs.disable(c, GGL_AA);
826            c->rasterizer.procs.shadeModel(c, GL_FLAT);
827            c->rasterizer.procs.recti(c, x, y, x+w, y+h);
828
829            ogles_unlock_textures(c);
830
831            return;
832        }
833    }
834
835slow_case:
836    drawTexxOESImp(
837            gglIntToFixed(x), gglIntToFixed(y), gglIntToFixed(z),
838            gglIntToFixed(w), gglIntToFixed(h),
839            c);
840}
841
842
843}; // namespace android
844// ----------------------------------------------------------------------------
845
846using namespace android;
847
848
849#if 0
850#pragma mark -
851#pragma mark Texture API
852#endif
853
854void glActiveTexture(GLenum texture)
855{
856    ogles_context_t* c = ogles_context_t::get();
857    if (uint32_t(texture-GL_TEXTURE0) > uint32_t(GGL_TEXTURE_UNIT_COUNT)) {
858        ogles_error(c, GL_INVALID_ENUM);
859        return;
860    }
861    c->textures.active = texture - GL_TEXTURE0;
862    c->rasterizer.procs.activeTexture(c, c->textures.active);
863}
864
865void glBindTexture(GLenum target, GLuint texture)
866{
867    ogles_context_t* c = ogles_context_t::get();
868    if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) {
869        ogles_error(c, GL_INVALID_ENUM);
870        return;
871    }
872
873    // Bind or create a texture
874    sp<EGLTextureObject> tex;
875    if (texture == 0) {
876        // 0 is our local texture object
877        tex = c->textures.defaultTexture;
878    } else {
879        tex = c->surfaceManager->texture(texture);
880        if (ggl_unlikely(tex == 0)) {
881            tex = c->surfaceManager->createTexture(texture);
882            if (tex == 0) {
883                ogles_error(c, GL_OUT_OF_MEMORY);
884                return;
885            }
886        }
887    }
888    bindTextureTmu(c, c->textures.active, texture, tex);
889}
890
891void glGenTextures(GLsizei n, GLuint *textures)
892{
893    ogles_context_t* c = ogles_context_t::get();
894    if (n<0) {
895        ogles_error(c, GL_INVALID_VALUE);
896        return;
897    }
898    // generate unique (shared) texture names
899    c->surfaceManager->getToken(n, textures);
900}
901
902void glDeleteTextures(GLsizei n, const GLuint *textures)
903{
904    ogles_context_t* c = ogles_context_t::get();
905    if (n<0) {
906        ogles_error(c, GL_INVALID_VALUE);
907        return;
908    }
909
910    // If deleting a bound texture, bind this unit to 0
911    for (int t=0 ; t<GGL_TEXTURE_UNIT_COUNT ; t++) {
912        if (c->textures.tmu[t].name == 0)
913            continue;
914        for (int i=0 ; i<n ; i++) {
915            if (textures[i] && (textures[i] == c->textures.tmu[t].name)) {
916                // bind this tmu to texture 0
917                sp<EGLTextureObject> tex(c->textures.defaultTexture);
918                bindTextureTmu(c, t, 0, tex);
919            }
920        }
921    }
922    c->surfaceManager->deleteTextures(n, textures);
923    c->surfaceManager->recycleTokens(n, textures);
924}
925
926void glMultiTexCoord4f(
927        GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
928{
929    ogles_context_t* c = ogles_context_t::get();
930    if (uint32_t(target-GL_TEXTURE0) > uint32_t(GGL_TEXTURE_UNIT_COUNT)) {
931        ogles_error(c, GL_INVALID_ENUM);
932        return;
933    }
934    const int tmu = target-GL_TEXTURE0;
935    c->current.texture[tmu].S = gglFloatToFixed(s);
936    c->current.texture[tmu].T = gglFloatToFixed(t);
937    c->current.texture[tmu].R = gglFloatToFixed(r);
938    c->current.texture[tmu].Q = gglFloatToFixed(q);
939}
940
941void glMultiTexCoord4x(
942        GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
943{
944    ogles_context_t* c = ogles_context_t::get();
945    if (uint32_t(target-GL_TEXTURE0) > uint32_t(GGL_TEXTURE_UNIT_COUNT)) {
946        ogles_error(c, GL_INVALID_ENUM);
947        return;
948    }
949    const int tmu = target-GL_TEXTURE0;
950    c->current.texture[tmu].S = s;
951    c->current.texture[tmu].T = t;
952    c->current.texture[tmu].R = r;
953    c->current.texture[tmu].Q = q;
954}
955
956void glPixelStorei(GLenum pname, GLint param)
957{
958    ogles_context_t* c = ogles_context_t::get();
959    if ((pname != GL_PACK_ALIGNMENT) && (pname != GL_UNPACK_ALIGNMENT)) {
960        ogles_error(c, GL_INVALID_ENUM);
961        return;
962    }
963    if ((param<=0 || param>8) || (param & (param-1))) {
964        ogles_error(c, GL_INVALID_VALUE);
965        return;
966    }
967    if (pname == GL_PACK_ALIGNMENT)
968        c->textures.packAlignment = param;
969    if (pname == GL_UNPACK_ALIGNMENT)
970        c->textures.unpackAlignment = param;
971}
972
973void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
974{
975    ogles_context_t* c = ogles_context_t::get();
976    c->rasterizer.procs.texEnvi(c, target, pname, GLint(param));
977}
978
979void glTexEnvfv(
980        GLenum target, GLenum pname, const GLfloat *params)
981{
982    ogles_context_t* c = ogles_context_t::get();
983    if (pname == GL_TEXTURE_ENV_MODE) {
984        c->rasterizer.procs.texEnvi(c, target, pname, GLint(*params));
985        return;
986    }
987    if (pname == GL_TEXTURE_ENV_COLOR) {
988        GGLfixed fixed[4];
989        for (int i=0 ; i<4 ; i++)
990            fixed[i] = gglFloatToFixed(params[i]);
991        c->rasterizer.procs.texEnvxv(c, target, pname, fixed);
992        return;
993    }
994    ogles_error(c, GL_INVALID_ENUM);
995}
996
997void glTexEnvx(GLenum target, GLenum pname, GLfixed param)
998{
999    ogles_context_t* c = ogles_context_t::get();
1000    c->rasterizer.procs.texEnvi(c, target, pname, param);
1001}
1002
1003void glTexEnvxv(
1004        GLenum target, GLenum pname, const GLfixed *params)
1005{
1006    ogles_context_t* c = ogles_context_t::get();
1007    c->rasterizer.procs.texEnvxv(c, target, pname, params);
1008}
1009
1010void glTexParameteriv(
1011        GLenum target, GLenum pname, const GLint* params)
1012{
1013    ogles_context_t* c = ogles_context_t::get();
1014    if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) {
1015        ogles_error(c, GL_INVALID_ENUM);
1016        return;
1017    }
1018
1019    EGLTextureObject* textureObject = c->textures.tmu[c->textures.active].texture;
1020    switch (pname) {
1021    case GL_TEXTURE_CROP_RECT_OES:
1022        memcpy(textureObject->crop_rect, params, 4*sizeof(GLint));
1023        break;
1024    default:
1025        texParameterx(target, pname, GLfixed(params[0]), c);
1026        return;
1027    }
1028}
1029
1030void glTexParameterf(
1031        GLenum target, GLenum pname, GLfloat param)
1032{
1033    ogles_context_t* c = ogles_context_t::get();
1034    texParameterx(target, pname, GLfixed(param), c);
1035}
1036
1037void glTexParameterx(
1038        GLenum target, GLenum pname, GLfixed param)
1039{
1040    ogles_context_t* c = ogles_context_t::get();
1041    texParameterx(target, pname, param, c);
1042}
1043
1044void glTexParameteri(
1045        GLenum target, GLenum pname, GLint param)
1046{
1047    ogles_context_t* c = ogles_context_t::get();
1048    texParameterx(target, pname, GLfixed(param), c);
1049}
1050
1051// ----------------------------------------------------------------------------
1052#if 0
1053#pragma mark -
1054#endif
1055
1056void glCompressedTexImage2D(
1057        GLenum target, GLint level, GLenum internalformat,
1058        GLsizei width, GLsizei height, GLint border,
1059        GLsizei imageSize, const GLvoid *data)
1060{
1061    ogles_context_t* c = ogles_context_t::get();
1062    if (target != GL_TEXTURE_2D) {
1063        ogles_error(c, GL_INVALID_ENUM);
1064        return;
1065    }
1066    if (width<0 || height<0 || border!=0) {
1067        ogles_error(c, GL_INVALID_VALUE);
1068        return;
1069    }
1070
1071    // "uncompress" the texture since pixelflinger doesn't support
1072    // any compressed texture format natively.
1073    GLenum format;
1074    GLenum type;
1075    switch (internalformat) {
1076    case GL_PALETTE8_RGB8_OES:
1077    case GL_PALETTE4_RGB8_OES:
1078        format      = GL_RGB;
1079        type        = GL_UNSIGNED_BYTE;
1080        break;
1081    case GL_PALETTE8_RGBA8_OES:
1082    case GL_PALETTE4_RGBA8_OES:
1083        format      = GL_RGBA;
1084        type        = GL_UNSIGNED_BYTE;
1085        break;
1086    case GL_PALETTE8_R5_G6_B5_OES:
1087    case GL_PALETTE4_R5_G6_B5_OES:
1088        format      = GL_RGB;
1089        type        = GL_UNSIGNED_SHORT_5_6_5;
1090        break;
1091    case GL_PALETTE8_RGBA4_OES:
1092    case GL_PALETTE4_RGBA4_OES:
1093        format      = GL_RGBA;
1094        type        = GL_UNSIGNED_SHORT_4_4_4_4;
1095        break;
1096    case GL_PALETTE8_RGB5_A1_OES:
1097    case GL_PALETTE4_RGB5_A1_OES:
1098        format      = GL_RGBA;
1099        type        = GL_UNSIGNED_SHORT_5_5_5_1;
1100        break;
1101#ifdef GL_OES_compressed_ETC1_RGB8_texture
1102    case GL_ETC1_RGB8_OES:
1103        format      = GL_RGB;
1104        type        = GL_UNSIGNED_BYTE;
1105        break;
1106#endif
1107    default:
1108        ogles_error(c, GL_INVALID_ENUM);
1109        return;
1110    }
1111
1112    if (!data || !width || !height) {
1113        // unclear if this is an error or not...
1114        return;
1115    }
1116
1117    int32_t size;
1118    GGLSurface* surface;
1119
1120#ifdef GL_OES_compressed_ETC1_RGB8_texture
1121    if (internalformat == GL_ETC1_RGB8_OES) {
1122        GLsizei compressedSize = etc1_get_encoded_data_size(width, height);
1123        if (compressedSize > imageSize) {
1124            ogles_error(c, GL_INVALID_VALUE);
1125            return;
1126        }
1127        int error = createTextureSurface(c, &surface, &size,
1128                level, format, type, width, height);
1129        if (error) {
1130            ogles_error(c, error);
1131            return;
1132        }
1133        if (etc1_decode_image(
1134                (const etc1_byte*)data,
1135                (etc1_byte*)surface->data,
1136                width, height, 3, surface->stride*3) != 0) {
1137            ogles_error(c, GL_INVALID_OPERATION);
1138        }
1139        return;
1140    }
1141#endif
1142
1143    // all mipmap levels are specified at once.
1144    const int numLevels = level<0 ? -level : 1;
1145
1146    if (dataSizePalette4(numLevels, width, height, format) > imageSize) {
1147        ogles_error(c, GL_INVALID_VALUE);
1148        return;
1149    }
1150
1151    for (int i=0 ; i<numLevels ; i++) {
1152        int lod_w = (width  >> i) ? : 1;
1153        int lod_h = (height >> i) ? : 1;
1154        int error = createTextureSurface(c, &surface, &size,
1155                i, format, type, lod_w, lod_h);
1156        if (error) {
1157            ogles_error(c, error);
1158            return;
1159        }
1160        decodePalette4(data, i, width, height,
1161                surface->data, surface->stride, internalformat);
1162    }
1163}
1164
1165
1166void glTexImage2D(
1167        GLenum target, GLint level, GLint internalformat,
1168        GLsizei width, GLsizei height, GLint border,
1169        GLenum format, GLenum type, const GLvoid *pixels)
1170{
1171    ogles_context_t* c = ogles_context_t::get();
1172    if (target != GL_TEXTURE_2D) {
1173        ogles_error(c, GL_INVALID_ENUM);
1174        return;
1175    }
1176    if (width<0 || height<0 || border!=0 || level < 0) {
1177        ogles_error(c, GL_INVALID_VALUE);
1178        return;
1179    }
1180    if (format != (GLenum)internalformat) {
1181        ogles_error(c, GL_INVALID_OPERATION);
1182        return;
1183    }
1184    if (validFormatType(c, format, type)) {
1185        return;
1186    }
1187
1188    int32_t size = 0;
1189    GGLSurface* surface = 0;
1190    int error = createTextureSurface(c, &surface, &size,
1191            level, format, type, width, height);
1192    if (error) {
1193        ogles_error(c, error);
1194        return;
1195    }
1196
1197    if (pixels) {
1198        const int32_t formatIdx = convertGLPixelFormat(format, type);
1199        const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
1200        const int32_t align = c->textures.unpackAlignment-1;
1201        const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
1202        const size_t size = bpr * height;
1203        const int32_t stride = bpr / pixelFormat.size;
1204
1205        GGLSurface userSurface;
1206        userSurface.version = sizeof(userSurface);
1207        userSurface.width  = width;
1208        userSurface.height = height;
1209        userSurface.stride = stride;
1210        userSurface.format = formatIdx;
1211        userSurface.compressedFormat = 0;
1212        userSurface.data = (GLubyte*)pixels;
1213
1214        int err = copyPixels(c, *surface, 0, 0, userSurface, 0, 0, width, height);
1215        if (err) {
1216            ogles_error(c, err);
1217            return;
1218        }
1219        generateMipmap(c, level);
1220    }
1221}
1222
1223// ----------------------------------------------------------------------------
1224
1225void glCompressedTexSubImage2D(
1226        GLenum /*target*/, GLint /*level*/, GLint /*xoffset*/,
1227        GLint /*yoffset*/, GLsizei /*width*/, GLsizei /*height*/,
1228        GLenum /*format*/, GLsizei /*imageSize*/,
1229        const GLvoid* /*data*/)
1230{
1231    ogles_context_t* c = ogles_context_t::get();
1232    ogles_error(c, GL_INVALID_ENUM);
1233}
1234
1235void glTexSubImage2D(
1236        GLenum target, GLint level, GLint xoffset,
1237        GLint yoffset, GLsizei width, GLsizei height,
1238        GLenum format, GLenum type, const GLvoid *pixels)
1239{
1240    ogles_context_t* c = ogles_context_t::get();
1241    if (target != GL_TEXTURE_2D) {
1242        ogles_error(c, GL_INVALID_ENUM);
1243        return;
1244    }
1245    if (xoffset<0 || yoffset<0 || width<0 || height<0 || level<0) {
1246        ogles_error(c, GL_INVALID_VALUE);
1247        return;
1248    }
1249    if (validFormatType(c, format, type)) {
1250        return;
1251    }
1252
1253    // find out which texture is bound to the current unit
1254    const int active = c->textures.active;
1255    EGLTextureObject* tex = c->textures.tmu[active].texture;
1256    const GGLSurface& surface(tex->mip(level));
1257
1258    if (!tex->internalformat || tex->direct) {
1259        ogles_error(c, GL_INVALID_OPERATION);
1260        return;
1261    }
1262
1263    if (format != tex->internalformat) {
1264        ogles_error(c, GL_INVALID_OPERATION);
1265        return;
1266    }
1267    if ((xoffset + width  > GLsizei(surface.width)) ||
1268        (yoffset + height > GLsizei(surface.height))) {
1269        ogles_error(c, GL_INVALID_VALUE);
1270        return;
1271    }
1272    if (!width || !height) {
1273        return; // okay, but no-op.
1274    }
1275
1276    // figure out the size we need as well as the stride
1277    const int32_t formatIdx = convertGLPixelFormat(format, type);
1278    if (formatIdx == 0) { // we don't know what to do with this
1279        ogles_error(c, GL_INVALID_OPERATION);
1280        return;
1281    }
1282
1283    const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
1284    const int32_t align = c->textures.unpackAlignment-1;
1285    const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
1286    const size_t size = bpr * height;
1287    const int32_t stride = bpr / pixelFormat.size;
1288    GGLSurface userSurface;
1289    userSurface.version = sizeof(userSurface);
1290    userSurface.width  = width;
1291    userSurface.height = height;
1292    userSurface.stride = stride;
1293    userSurface.format = formatIdx;
1294    userSurface.compressedFormat = 0;
1295    userSurface.data = (GLubyte*)pixels;
1296
1297    int err = copyPixels(c,
1298            surface, xoffset, yoffset,
1299            userSurface, 0, 0, width, height);
1300    if (err) {
1301        ogles_error(c, err);
1302        return;
1303    }
1304
1305    generateMipmap(c, level);
1306
1307    // since we only changed the content of the texture, we don't need
1308    // to call bindTexture on the main rasterizer.
1309}
1310
1311// ----------------------------------------------------------------------------
1312
1313void glCopyTexImage2D(
1314        GLenum target, GLint level, GLenum internalformat,
1315        GLint x, GLint y, GLsizei width, GLsizei height,
1316        GLint border)
1317{
1318    ogles_context_t* c = ogles_context_t::get();
1319    if (target != GL_TEXTURE_2D) {
1320        ogles_error(c, GL_INVALID_ENUM);
1321        return;
1322    }
1323    if (internalformat<GL_ALPHA || internalformat>GL_LUMINANCE_ALPHA) {
1324        ogles_error(c, GL_INVALID_ENUM);
1325        return;
1326    }
1327    if (width<0 || height<0 || border!=0 || level<0) {
1328        ogles_error(c, GL_INVALID_VALUE);
1329        return;
1330    }
1331
1332    GLenum format = 0;
1333    GLenum type = GL_UNSIGNED_BYTE;
1334    const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
1335    const int cbFormatIdx = cbSurface.format;
1336    switch (cbFormatIdx) {
1337    case GGL_PIXEL_FORMAT_RGB_565:
1338        type = GL_UNSIGNED_SHORT_5_6_5;
1339        break;
1340    case GGL_PIXEL_FORMAT_RGBA_5551:
1341        type = GL_UNSIGNED_SHORT_5_5_5_1;
1342        break;
1343    case GGL_PIXEL_FORMAT_RGBA_4444:
1344        type = GL_UNSIGNED_SHORT_4_4_4_4;
1345        break;
1346    }
1347    switch (internalformat) {
1348    case GL_ALPHA:
1349    case GL_LUMINANCE_ALPHA:
1350    case GL_LUMINANCE:
1351        type = GL_UNSIGNED_BYTE;
1352        break;
1353    }
1354
1355    // figure out the format to use for the new texture
1356    switch (cbFormatIdx) {
1357    case GGL_PIXEL_FORMAT_RGBA_8888:
1358    case GGL_PIXEL_FORMAT_A_8:
1359    case GGL_PIXEL_FORMAT_RGBA_5551:
1360    case GGL_PIXEL_FORMAT_RGBA_4444:
1361        format = internalformat;
1362        break;
1363    case GGL_PIXEL_FORMAT_RGBX_8888:
1364    case GGL_PIXEL_FORMAT_RGB_888:
1365    case GGL_PIXEL_FORMAT_RGB_565:
1366    case GGL_PIXEL_FORMAT_L_8:
1367        switch (internalformat) {
1368        case GL_LUMINANCE:
1369        case GL_RGB:
1370            format = internalformat;
1371            break;
1372        }
1373        break;
1374    }
1375
1376    if (format == 0) {
1377        // invalid combination
1378        ogles_error(c, GL_INVALID_ENUM);
1379        return;
1380    }
1381
1382    // create the new texture...
1383    int32_t size;
1384    GGLSurface* surface;
1385    int error = createTextureSurface(c, &surface, &size,
1386            level, format, type, width, height);
1387    if (error) {
1388        ogles_error(c, error);
1389        return;
1390    }
1391
1392    // The bottom row is stored first in textures
1393    GGLSurface txSurface(*surface);
1394    txSurface.stride = -txSurface.stride;
1395
1396    // (x,y) is the lower-left corner of colorBuffer
1397    y = cbSurface.height - (y + height);
1398
1399    /* The GLES spec says:
1400     * If any of the pixels within the specified rectangle are outside
1401     * the framebuffer associated with the current rendering context,
1402     * then the values obtained for those pixels are undefined.
1403     */
1404    if (x+width > GLint(cbSurface.width))
1405        width = cbSurface.width - x;
1406
1407    if (y+height > GLint(cbSurface.height))
1408        height = cbSurface.height - y;
1409
1410    int err = copyPixels(c,
1411            txSurface, 0, 0,
1412            cbSurface, x, y, width, height);
1413    if (err) {
1414        ogles_error(c, err);
1415    }
1416
1417    generateMipmap(c, level);
1418}
1419
1420void glCopyTexSubImage2D(
1421        GLenum target, GLint level, GLint xoffset, GLint yoffset,
1422        GLint x, GLint y, GLsizei width, GLsizei height)
1423{
1424    ogles_context_t* c = ogles_context_t::get();
1425    if (target != GL_TEXTURE_2D) {
1426        ogles_error(c, GL_INVALID_ENUM);
1427        return;
1428    }
1429    if (xoffset<0 || yoffset<0 || width<0 || height<0 || level<0) {
1430        ogles_error(c, GL_INVALID_VALUE);
1431        return;
1432    }
1433    if (!width || !height) {
1434        return; // okay, but no-op.
1435    }
1436
1437    // find out which texture is bound to the current unit
1438    const int active = c->textures.active;
1439    EGLTextureObject* tex = c->textures.tmu[active].texture;
1440    const GGLSurface& surface(tex->mip(level));
1441
1442    if (!tex->internalformat) {
1443        ogles_error(c, GL_INVALID_OPERATION);
1444        return;
1445    }
1446    if ((xoffset + width  > GLsizei(surface.width)) ||
1447        (yoffset + height > GLsizei(surface.height))) {
1448        ogles_error(c, GL_INVALID_VALUE);
1449        return;
1450    }
1451
1452    // The bottom row is stored first in textures
1453    GGLSurface txSurface(surface);
1454    txSurface.stride = -txSurface.stride;
1455
1456    // (x,y) is the lower-left corner of colorBuffer
1457    const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
1458    y = cbSurface.height - (y + height);
1459
1460    /* The GLES spec says:
1461     * If any of the pixels within the specified rectangle are outside
1462     * the framebuffer associated with the current rendering context,
1463     * then the values obtained for those pixels are undefined.
1464     */
1465    if (x+width > GLint(cbSurface.width))
1466        width = cbSurface.width - x;
1467
1468    if (y+height > GLint(cbSurface.height))
1469        height = cbSurface.height - y;
1470
1471    int err = copyPixels(c,
1472            txSurface, xoffset, yoffset,
1473            cbSurface, x, y, width, height);
1474    if (err) {
1475        ogles_error(c, err);
1476        return;
1477    }
1478
1479    generateMipmap(c, level);
1480}
1481
1482void glReadPixels(
1483        GLint x, GLint y, GLsizei width, GLsizei height,
1484        GLenum format, GLenum type, GLvoid *pixels)
1485{
1486    ogles_context_t* c = ogles_context_t::get();
1487    if ((format != GL_RGBA) && (format != GL_RGB)) {
1488        ogles_error(c, GL_INVALID_ENUM);
1489        return;
1490    }
1491    if ((type != GL_UNSIGNED_BYTE) && (type != GL_UNSIGNED_SHORT_5_6_5)) {
1492        ogles_error(c, GL_INVALID_ENUM);
1493        return;
1494    }
1495    if (width<0 || height<0) {
1496        ogles_error(c, GL_INVALID_VALUE);
1497        return;
1498    }
1499    if (x<0 || y<0) {
1500        ogles_error(c, GL_INVALID_VALUE);
1501        return;
1502    }
1503
1504    int32_t formatIdx = GGL_PIXEL_FORMAT_NONE;
1505    if ((format == GL_RGBA) && (type == GL_UNSIGNED_BYTE)) {
1506        formatIdx = GGL_PIXEL_FORMAT_RGBA_8888;
1507    } else if ((format == GL_RGB) && (type == GL_UNSIGNED_SHORT_5_6_5)) {
1508        formatIdx = GGL_PIXEL_FORMAT_RGB_565;
1509    } else {
1510        ogles_error(c, GL_INVALID_OPERATION);
1511        return;
1512    }
1513
1514    const GGLSurface& readSurface = c->rasterizer.state.buffers.read.s;
1515    if ((x+width > GLint(readSurface.width)) ||
1516            (y+height > GLint(readSurface.height))) {
1517        ogles_error(c, GL_INVALID_VALUE);
1518        return;
1519    }
1520
1521    const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
1522    const int32_t align = c->textures.packAlignment-1;
1523    const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
1524    const int32_t stride = bpr / pixelFormat.size;
1525
1526    GGLSurface userSurface;
1527    userSurface.version = sizeof(userSurface);
1528    userSurface.width  = width;
1529    userSurface.height = height;
1530    userSurface.stride = -stride; // bottom row is transfered first
1531    userSurface.format = formatIdx;
1532    userSurface.compressedFormat = 0;
1533    userSurface.data = (GLubyte*)pixels;
1534
1535    // use pixel-flinger to handle all the conversions
1536    GGLContext* ggl = getRasterizer(c);
1537    if (!ggl) {
1538        // the only reason this would fail is because we ran out of memory
1539        ogles_error(c, GL_OUT_OF_MEMORY);
1540        return;
1541    }
1542
1543    ggl->colorBuffer(ggl, &userSurface);  // destination is user buffer
1544    ggl->bindTexture(ggl, &readSurface);  // source is read-buffer
1545    ggl->texCoord2i(ggl, x, readSurface.height - (y + height));
1546    ggl->recti(ggl, 0, 0, width, height);
1547}
1548
1549// ----------------------------------------------------------------------------
1550#if 0
1551#pragma mark -
1552#pragma mark DrawTexture Extension
1553#endif
1554
1555void glDrawTexsvOES(const GLshort* coords) {
1556    ogles_context_t* c = ogles_context_t::get();
1557    drawTexiOES(coords[0], coords[1], coords[2], coords[3], coords[4], c);
1558}
1559void glDrawTexivOES(const GLint* coords) {
1560    ogles_context_t* c = ogles_context_t::get();
1561    drawTexiOES(coords[0], coords[1], coords[2], coords[3], coords[4], c);
1562}
1563void glDrawTexsOES(GLshort x , GLshort y, GLshort z, GLshort w, GLshort h) {
1564    ogles_context_t* c = ogles_context_t::get();
1565    drawTexiOES(x, y, z, w, h, c);
1566}
1567void glDrawTexiOES(GLint x, GLint y, GLint z, GLint w, GLint h) {
1568    ogles_context_t* c = ogles_context_t::get();
1569    drawTexiOES(x, y, z, w, h, c);
1570}
1571
1572void glDrawTexfvOES(const GLfloat* coords) {
1573    ogles_context_t* c = ogles_context_t::get();
1574    drawTexxOES(
1575            gglFloatToFixed(coords[0]),
1576            gglFloatToFixed(coords[1]),
1577            gglFloatToFixed(coords[2]),
1578            gglFloatToFixed(coords[3]),
1579            gglFloatToFixed(coords[4]),
1580            c);
1581}
1582void glDrawTexxvOES(const GLfixed* coords) {
1583    ogles_context_t* c = ogles_context_t::get();
1584    drawTexxOES(coords[0], coords[1], coords[2], coords[3], coords[4], c);
1585}
1586void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLfloat h){
1587    ogles_context_t* c = ogles_context_t::get();
1588    drawTexxOES(
1589            gglFloatToFixed(x), gglFloatToFixed(y), gglFloatToFixed(z),
1590            gglFloatToFixed(w), gglFloatToFixed(h),
1591            c);
1592}
1593void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h) {
1594    ogles_context_t* c = ogles_context_t::get();
1595    drawTexxOES(x, y, z, w, h, c);
1596}
1597
1598// ----------------------------------------------------------------------------
1599#if 0
1600#pragma mark -
1601#pragma mark EGL Image Extension
1602#endif
1603
1604void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
1605{
1606    ogles_context_t* c = ogles_context_t::get();
1607    if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) {
1608        ogles_error(c, GL_INVALID_ENUM);
1609        return;
1610    }
1611
1612    if (image == EGL_NO_IMAGE_KHR) {
1613        ogles_error(c, GL_INVALID_VALUE);
1614        return;
1615    }
1616
1617    ANativeWindowBuffer* native_buffer = (ANativeWindowBuffer*)image;
1618    if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) {
1619        ogles_error(c, GL_INVALID_VALUE);
1620        return;
1621    }
1622    if (native_buffer->common.version != sizeof(ANativeWindowBuffer)) {
1623        ogles_error(c, GL_INVALID_VALUE);
1624        return;
1625    }
1626
1627    // bind it to the texture unit
1628    sp<EGLTextureObject> tex = getAndBindActiveTextureObject(c);
1629    tex->setImage(native_buffer);
1630}
1631
1632void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
1633{
1634    ogles_context_t* c = ogles_context_t::get();
1635    if (target != GL_RENDERBUFFER_OES) {
1636        ogles_error(c, GL_INVALID_ENUM);
1637        return;
1638    }
1639
1640    if (image == EGL_NO_IMAGE_KHR) {
1641        ogles_error(c, GL_INVALID_VALUE);
1642        return;
1643    }
1644
1645    ANativeWindowBuffer* native_buffer = (ANativeWindowBuffer*)image;
1646    if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) {
1647        ogles_error(c, GL_INVALID_VALUE);
1648        return;
1649    }
1650    if (native_buffer->common.version != sizeof(ANativeWindowBuffer)) {
1651        ogles_error(c, GL_INVALID_VALUE);
1652        return;
1653    }
1654
1655    // well, we're not supporting this extension anyways
1656}
1657