Home | History | Annotate | Download | only in libagl
      1 /* libs/opengles/mipmap.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 
     21 #include "context.h"
     22 #include "state.h"
     23 #include "texture.h"
     24 #include "TextureObjectManager.h"
     25 
     26 namespace android {
     27 
     28 // ----------------------------------------------------------------------------
     29 
     30 status_t buildAPyramid(ogles_context_t* c, EGLTextureObject* tex)
     31 {
     32     int level = 0;
     33     const GGLSurface* base = &tex->surface;
     34     const GGLFormat& pixelFormat(c->rasterizer.formats[base->format]);
     35 
     36     int w = base->width;
     37     int h = base->height;
     38     if ((w&h) == 1)
     39         return NO_ERROR;
     40 
     41     w = (w>>1) ? : 1;
     42     h = (h>>1) ? : 1;
     43 
     44     while(true) {
     45         ++level;
     46         const int bpr = w * pixelFormat.size;
     47         if (tex->reallocate(level, w, h, w,
     48                 base->format, base->compressedFormat, bpr) != NO_ERROR) {
     49             return NO_MEMORY;
     50         }
     51 
     52         int stride = w;
     53         int bs = base->stride;
     54         GGLSurface& cur = tex->editMip(level);
     55 
     56         if (base->format == GGL_PIXEL_FORMAT_RGB_565)
     57         {
     58             uint16_t const * src = (uint16_t const *)base->data;
     59             uint16_t* dst = (uint16_t*)cur.data;
     60             const uint32_t mask = 0x07E0F81F;
     61             for (int y=0 ; y<h ; y++) {
     62                 size_t offset = (y*2) * bs;
     63                 for (int x=0 ; x<w ; x++) {
     64                     uint32_t p00 = src[offset];
     65                     uint32_t p10 = src[offset+1];
     66                     uint32_t p01 = src[offset+bs];
     67                     uint32_t p11 = src[offset+bs+1];
     68                     p00 = (p00 | (p00 << 16)) & mask;
     69                     p01 = (p01 | (p01 << 16)) & mask;
     70                     p10 = (p10 | (p10 << 16)) & mask;
     71                     p11 = (p11 | (p11 << 16)) & mask;
     72                     uint32_t grb = ((p00 + p10 + p01 + p11) >> 2) & mask;
     73                     uint32_t rgb = (grb & 0xFFFF) | (grb >> 16);
     74                     dst[x + y*stride] = rgb;
     75                     offset += 2;
     76                 }
     77             }
     78         }
     79         else if (base->format == GGL_PIXEL_FORMAT_RGBA_5551)
     80         {
     81             uint16_t const * src = (uint16_t const *)base->data;
     82             uint16_t* dst = (uint16_t*)cur.data;
     83             for (int y=0 ; y<h ; y++) {
     84                 size_t offset = (y*2) * bs;
     85                 for (int x=0 ; x<w ; x++) {
     86                     uint32_t p00 = src[offset];
     87                     uint32_t p10 = src[offset+1];
     88                     uint32_t p01 = src[offset+bs];
     89                     uint32_t p11 = src[offset+bs+1];
     90                     uint32_t r = ((p00>>11)+(p10>>11)+(p01>>11)+(p11>>11)+2)>>2;
     91                     uint32_t g = (((p00>>6)+(p10>>6)+(p01>>6)+(p11>>6)+2)>>2)&0x3F;
     92                     uint32_t b = ((p00&0x3E)+(p10&0x3E)+(p01&0x3E)+(p11&0x3E)+4)>>3;
     93                     uint32_t a = ((p00&1)+(p10&1)+(p01&1)+(p11&1)+2)>>2;
     94                     dst[x + y*stride] = (r<<11)|(g<<6)|(b<<1)|a;
     95                     offset += 2;
     96                 }
     97             }
     98         }
     99         else if (base->format == GGL_PIXEL_FORMAT_RGBA_8888)
    100         {
    101             uint32_t const * src = (uint32_t const *)base->data;
    102             uint32_t* dst = (uint32_t*)cur.data;
    103             for (int y=0 ; y<h ; y++) {
    104                 size_t offset = (y*2) * bs;
    105                 for (int x=0 ; x<w ; x++) {
    106                     uint32_t p00 = src[offset];
    107                     uint32_t p10 = src[offset+1];
    108                     uint32_t p01 = src[offset+bs];
    109                     uint32_t p11 = src[offset+bs+1];
    110                     uint32_t rb00 = p00 & 0x00FF00FF;
    111                     uint32_t rb01 = p01 & 0x00FF00FF;
    112                     uint32_t rb10 = p10 & 0x00FF00FF;
    113                     uint32_t rb11 = p11 & 0x00FF00FF;
    114                     uint32_t ga00 = (p00 >> 8) & 0x00FF00FF;
    115                     uint32_t ga01 = (p01 >> 8) & 0x00FF00FF;
    116                     uint32_t ga10 = (p10 >> 8) & 0x00FF00FF;
    117                     uint32_t ga11 = (p11 >> 8) & 0x00FF00FF;
    118                     uint32_t rb = (rb00 + rb01 + rb10 + rb11)>>2;
    119                     uint32_t ga = (ga00 + ga01 + ga10 + ga11)>>2;
    120                     uint32_t rgba = (rb & 0x00FF00FF) | ((ga & 0x00FF00FF)<<8);
    121                     dst[x + y*stride] = rgba;
    122                     offset += 2;
    123                 }
    124             }
    125         }
    126         else if ((base->format == GGL_PIXEL_FORMAT_RGB_888) ||
    127                  (base->format == GGL_PIXEL_FORMAT_LA_88) ||
    128                  (base->format == GGL_PIXEL_FORMAT_A_8) ||
    129                  (base->format == GGL_PIXEL_FORMAT_L_8))
    130         {
    131             int skip;
    132             switch (base->format) {
    133             case GGL_PIXEL_FORMAT_RGB_888:  skip = 3;   break;
    134             case GGL_PIXEL_FORMAT_LA_88:    skip = 2;   break;
    135             default:                        skip = 1;   break;
    136             }
    137             uint8_t const * src = (uint8_t const *)base->data;
    138             uint8_t* dst = (uint8_t*)cur.data;
    139             bs *= skip;
    140             stride *= skip;
    141             for (int y=0 ; y<h ; y++) {
    142                 size_t offset = (y*2) * bs;
    143                 for (int x=0 ; x<w ; x++) {
    144                     for (int c=0 ; c<skip ; c++) {
    145                         uint32_t p00 = src[c+offset];
    146                         uint32_t p10 = src[c+offset+skip];
    147                         uint32_t p01 = src[c+offset+bs];
    148                         uint32_t p11 = src[c+offset+bs+skip];
    149                         dst[x + y*stride + c] = (p00 + p10 + p01 + p11) >> 2;
    150                     }
    151                     offset += 2*skip;
    152                 }
    153             }
    154         }
    155         else if (base->format == GGL_PIXEL_FORMAT_RGBA_4444)
    156         {
    157             uint16_t const * src = (uint16_t const *)base->data;
    158             uint16_t* dst = (uint16_t*)cur.data;
    159             for (int y=0 ; y<h ; y++) {
    160                 size_t offset = (y*2) * bs;
    161                 for (int x=0 ; x<w ; x++) {
    162                     uint32_t p00 = src[offset];
    163                     uint32_t p10 = src[offset+1];
    164                     uint32_t p01 = src[offset+bs];
    165                     uint32_t p11 = src[offset+bs+1];
    166                     p00 = ((p00 << 12) & 0x0F0F0000) | (p00 & 0x0F0F);
    167                     p10 = ((p10 << 12) & 0x0F0F0000) | (p10 & 0x0F0F);
    168                     p01 = ((p01 << 12) & 0x0F0F0000) | (p01 & 0x0F0F);
    169                     p11 = ((p11 << 12) & 0x0F0F0000) | (p11 & 0x0F0F);
    170                     uint32_t rbga = (p00 + p10 + p01 + p11) >> 2;
    171                     uint32_t rgba = (rbga & 0x0F0F) | ((rbga>>12) & 0xF0F0);
    172                     dst[x + y*stride] = rgba;
    173                     offset += 2;
    174                 }
    175             }
    176         } else {
    177             LOGE("Unsupported format (%d)", base->format);
    178             return BAD_TYPE;
    179         }
    180 
    181         // exit condition: we just processed the 1x1 LODs
    182         if ((w&h) == 1)
    183             break;
    184 
    185         base = &cur;
    186         w = (w>>1) ? : 1;
    187         h = (h>>1) ? : 1;
    188     }
    189     return NO_ERROR;
    190 }
    191 
    192 }; // namespace android
    193