Home | History | Annotate | Download | only in filter
      1 #include <stdlib.h>
      2 #include <stdio.h>
      3 
      4 #include <EGL/egl.h>
      5 #include <GLES/gl.h>
      6 #include <GLES/glext.h>
      7 
      8 #include <ui/FramebufferNativeWindow.h>
      9 #include "EGLUtils.h"
     10 
     11 using namespace android;
     12 
     13 #define USE_DRAW_TEXTURE 1
     14 
     15 int main(int argc, char** argv)
     16 {
     17     if (argc!=2 && argc!=3) {
     18         printf("usage: %s <0-6> [pbuffer]\n", argv[0]);
     19         return 0;
     20     }
     21 
     22     const int test = atoi(argv[1]);
     23     int usePbuffer = argc==3 && !strcmp(argv[2], "pbuffer");
     24     EGLint s_configAttribs[] = {
     25          EGL_SURFACE_TYPE, EGL_PBUFFER_BIT|EGL_WINDOW_BIT,
     26          EGL_RED_SIZE,       5,
     27          EGL_GREEN_SIZE,     6,
     28          EGL_BLUE_SIZE,      5,
     29          EGL_NONE
     30      };
     31 
     32      EGLint numConfigs = -1;
     33      EGLint majorVersion;
     34      EGLint minorVersion;
     35      EGLConfig config;
     36      EGLContext context;
     37      EGLSurface surface;
     38      EGLint w, h;
     39 
     40      EGLDisplay dpy;
     41 
     42      EGLNativeWindowType window = 0;
     43      if (!usePbuffer) {
     44          window = android_createDisplaySurface();
     45      }
     46 
     47      dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
     48      eglInitialize(dpy, &majorVersion, &minorVersion);
     49      if (!usePbuffer) {
     50          EGLUtils::selectConfigForNativeWindow(
     51                  dpy, s_configAttribs, window, &config);
     52          surface = eglCreateWindowSurface(dpy, config, window, NULL);
     53      } else {
     54          printf("using pbuffer\n");
     55          eglChooseConfig(dpy, s_configAttribs, &config, 1, &numConfigs);
     56          EGLint attribs[] = { EGL_WIDTH, 320, EGL_HEIGHT, 480, EGL_NONE };
     57          surface = eglCreatePbufferSurface(dpy, config, attribs);
     58          if (surface == EGL_NO_SURFACE) {
     59              printf("eglCreatePbufferSurface error %x\n", eglGetError());
     60          }
     61      }
     62      context = eglCreateContext(dpy, config, NULL, NULL);
     63      eglMakeCurrent(dpy, surface, surface, context);
     64      eglQuerySurface(dpy, surface, EGL_WIDTH, &w);
     65      eglQuerySurface(dpy, surface, EGL_HEIGHT, &h);
     66      GLint dim = w<h ? w : h;
     67 
     68      glViewport(0, 0, w, h);
     69      glMatrixMode(GL_PROJECTION);
     70      glLoadIdentity();
     71      glOrthof(0, w, 0, h, 0, 1);
     72 
     73      glClearColor(0,0,0,0);
     74      glClear(GL_COLOR_BUFFER_BIT);
     75 
     76      GLint crop[4] = { 0, 4, 4, -4 };
     77      glBindTexture(GL_TEXTURE_2D, 0);
     78      glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
     79      glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     80      glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     81      glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
     82      glEnable(GL_TEXTURE_2D);
     83      glColor4f(1,1,1,1);
     84 
     85      // packing is always 4
     86      uint8_t t8[]  = {
     87              0x00, 0x55, 0x00, 0x55,
     88              0xAA, 0xFF, 0xAA, 0xFF,
     89              0x00, 0x55, 0x00, 0x55,
     90              0xAA, 0xFF, 0xAA, 0xFF  };
     91 
     92      uint16_t t16[]  = {
     93              0x0000, 0x5555, 0x0000, 0x5555,
     94              0xAAAA, 0xFFFF, 0xAAAA, 0xFFFF,
     95              0x0000, 0x5555, 0x0000, 0x5555,
     96              0xAAAA, 0xFFFF, 0xAAAA, 0xFFFF  };
     97 
     98      uint16_t t5551[]  = {
     99              0x0000, 0xFFFF, 0x0000, 0xFFFF,
    100              0xFFFF, 0x0000, 0xFFFF, 0x0000,
    101              0x0000, 0xFFFF, 0x0000, 0xFFFF,
    102              0xFFFF, 0x0000, 0xFFFF, 0x0000  };
    103 
    104      uint32_t t32[]  = {
    105              0xFF000000, 0xFF0000FF, 0xFF00FF00, 0xFFFF0000,
    106              0xFF00FF00, 0xFFFF0000, 0xFF000000, 0xFF0000FF,
    107              0xFF00FFFF, 0xFF00FF00, 0x00FF00FF, 0xFFFFFF00,
    108              0xFF000000, 0xFFFF00FF, 0xFF00FFFF, 0xFFFFFFFF
    109      };
    110 
    111      switch(test)
    112      {
    113      case 1:
    114          glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE,
    115                  4, 4, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, t8);
    116          break;
    117      case 2:
    118          glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
    119                  4, 4, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, t16);
    120          break;
    121      case 3:
    122          glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
    123                  4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, t16);
    124          break;
    125      case 4:
    126          glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,
    127                  4, 4, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, t16);
    128          break;
    129      case 5:
    130          glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
    131                  4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, t5551);
    132          break;
    133      case 6:
    134          glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
    135                  4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, t32);
    136          break;
    137      }
    138 
    139      //glDrawTexiOES(0, 0, 0, dim, dim);
    140 
    141      const GLfloat vertices[4][2] = {
    142              { 0,    0   },
    143              { 0,    dim },
    144              { dim,  dim },
    145              { dim,  0   }
    146      };
    147 
    148      const GLfloat texCoords[4][2] = {
    149              { 0,  0 },
    150              { 0,  1 },
    151              { 1,  1 },
    152              { 1,  0 }
    153      };
    154 
    155      if (!usePbuffer) {
    156          eglSwapBuffers(dpy, surface);
    157      }
    158 
    159      glMatrixMode(GL_MODELVIEW);
    160      glScissor(0,dim,dim,h-dim);
    161      glDisable(GL_SCISSOR_TEST);
    162 
    163      for (int y=0 ; y<dim ; y++) {
    164          //glDisable(GL_SCISSOR_TEST);
    165          glClear(GL_COLOR_BUFFER_BIT);
    166 
    167          //glEnable(GL_SCISSOR_TEST);
    168 
    169 #if USE_DRAW_TEXTURE && GL_OES_draw_texture
    170          glDrawTexiOES(0, y, 1, dim, dim);
    171 #else
    172          glLoadIdentity();
    173          glTranslatef(0, y, 0);
    174          glEnableClientState(GL_VERTEX_ARRAY);
    175          glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    176          glVertexPointer(2, GL_FLOAT, 0, vertices);
    177          glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
    178          glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
    179 #endif
    180 
    181          if (!usePbuffer) {
    182              eglSwapBuffers(dpy, surface);
    183          } else {
    184              glFinish();
    185          }
    186      }
    187 
    188      eglTerminate(dpy);
    189      return 0;
    190 }
    191