opengl/tests/filter/filter.cpp

   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 }