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