Home | History | Annotate | Download | only in tests 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <GLES2/gl2.h>
      6 #include <GLES2/gl2ext.h>
      7 #include <GLES2/gl2extchromium.h>
      8 
      9 #include <cmath>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/bind.h"
     13 #include "base/message_loop/message_loop.h"
     14 #include "base/run_loop.h"
     15 #include "gpu/command_buffer/tests/gl_manager.h"
     16 #include "gpu/command_buffer/tests/gl_test_utils.h"
     17 #include "testing/gmock/include/gmock/gmock.h"
     18 #include "testing/gtest/include/gtest/gtest.h"
     19 
     20 namespace gpu {
     21 
     22 class GLReadbackTest : public testing::Test {
     23  protected:
     24   virtual void SetUp() {
     25     gl_.Initialize(GLManager::Options());
     26   }
     27 
     28   virtual void TearDown() {
     29     gl_.Destroy();
     30   }
     31 
     32   static void WaitForQueryCallback(int q, base::Closure cb) {
     33     unsigned int done = 0;
     34     glGetQueryObjectuivEXT(q, GL_QUERY_RESULT_AVAILABLE_EXT, &done);
     35     if (done) {
     36       cb.Run();
     37     } else {
     38       base::MessageLoop::current()->PostDelayedTask(
     39           FROM_HERE,
     40           base::Bind(&WaitForQueryCallback, q, cb),
     41           base::TimeDelta::FromMilliseconds(3));
     42     }
     43   }
     44 
     45   void WaitForQuery(int q) {
     46     base::RunLoop run_loop;
     47     WaitForQueryCallback(q, run_loop.QuitClosure());
     48     run_loop.Run();
     49   }
     50 
     51   GLManager gl_;
     52 };
     53 
     54 
     55 TEST_F(GLReadbackTest, ReadPixelsWithPBOAndQuery) {
     56   const GLint kBytesPerPixel = 4;
     57   const GLint kWidth = 2;
     58   const GLint kHeight = 2;
     59 
     60   GLuint b, q;
     61   glClearColor(0.0, 0.0, 1.0, 1.0);
     62   glClear(GL_COLOR_BUFFER_BIT);
     63   glGenBuffers(1, &b);
     64   glGenQueriesEXT(1, &q);
     65   glBindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, b);
     66   glBufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
     67                kWidth * kHeight * kBytesPerPixel,
     68                NULL,
     69                GL_STREAM_READ);
     70   glBeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, q);
     71   glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, 0);
     72   glEndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM);
     73   glFlush();
     74   WaitForQuery(q);
     75 
     76   // TODO(hubbe): Check that glMapBufferCHROMIUM does not block here.
     77   unsigned char *data = static_cast<unsigned char *>(
     78       glMapBufferCHROMIUM(
     79           GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
     80           GL_READ_ONLY));
     81   EXPECT_TRUE(data);
     82   EXPECT_EQ(data[0], 0);   // red
     83   EXPECT_EQ(data[1], 0);   // green
     84   EXPECT_EQ(data[2], 255); // blue
     85   glUnmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM);
     86   glBindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
     87   glDeleteBuffers(1, &b);
     88   glDeleteQueriesEXT(1, &q);
     89   GLTestHelper::CheckGLError("no errors", __LINE__);
     90 }
     91 
     92 static float HalfToFloat32(uint16 value) {
     93   int32 s = (value >> 15) & 0x00000001;
     94   int32 e = (value >> 10) & 0x0000001f;
     95   int32 m =  value        & 0x000003ff;
     96 
     97   if (e == 0) {
     98     if (m == 0) {
     99       uint32 result = s << 31;
    100       return bit_cast<float>(result);
    101     } else {
    102       while (!(m & 0x00000400)) {
    103         m <<= 1;
    104         e -=  1;
    105       }
    106 
    107       e += 1;
    108       m &= ~0x00000400;
    109     }
    110   } else if (e == 31) {
    111     if (m == 0) {
    112       uint32 result = (s << 31) | 0x7f800000;
    113       return bit_cast<float>(result);
    114     } else {
    115       uint32 result = (s << 31) | 0x7f800000 | (m << 13);
    116       return bit_cast<float>(result);
    117     }
    118   }
    119 
    120   e = e + (127 - 15);
    121   m = m << 13;
    122 
    123   uint32 result = (s << 31) | (e << 23) | m;
    124   return bit_cast<float>(result);
    125 }
    126 
    127 static GLuint CompileShader(GLenum type, const char *data) {
    128   const char *shaderStrings[1] = { data };
    129 
    130   GLuint shader = glCreateShader(type);
    131   glShaderSource(shader, 1, shaderStrings, NULL);
    132   glCompileShader(shader);
    133 
    134   GLint compile_status = 0;
    135   glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
    136   if (compile_status != GL_TRUE) {
    137     glDeleteShader(shader);
    138     shader = 0;
    139   }
    140 
    141   return shader;
    142 }
    143 
    144 TEST_F(GLReadbackTest, ReadPixelsFloat) {
    145   const GLsizei kTextureSize = 4;
    146   const GLfloat kDrawColor[4] = { -10.9f, 0.5f, 10.5f, 100.12f };
    147   const GLfloat kEpsilon = 0.01f;
    148 
    149   struct TestFormat {
    150     GLint format;
    151     GLint type;
    152     uint32 comp_count;
    153   };
    154   TestFormat test_formats[4];
    155   size_t test_count = 0;
    156   const char *extensions = reinterpret_cast<const char*>(
    157       glGetString(GL_EXTENSIONS));
    158   if (strstr(extensions, "GL_OES_texture_half_float") != NULL) {
    159       TestFormat rgb16f = { GL_RGB, GL_HALF_FLOAT_OES, 3 };
    160       test_formats[test_count++] = rgb16f;
    161 
    162       TestFormat rgba16f = { GL_RGBA, GL_HALF_FLOAT_OES, 4 };
    163       test_formats[test_count++] = rgba16f;
    164   }
    165   if (strstr(extensions, "GL_OES_texture_float") != NULL) {
    166       TestFormat rgb32f = { GL_RGB, GL_FLOAT, 3 };
    167       test_formats[test_count++] = rgb32f;
    168 
    169       TestFormat rgba32f = { GL_RGBA, GL_FLOAT, 4 };
    170       test_formats[test_count++] = rgba32f;
    171   }
    172 
    173   const char *vs_source =
    174       "precision mediump float;\n"
    175       "attribute vec4 a_position;\n"
    176       "void main() {\n"
    177       "  gl_Position =  a_position;\n"
    178       "}\n";
    179 
    180   GLuint vertex_shader = CompileShader(GL_VERTEX_SHADER, vs_source);
    181   ASSERT_NE(vertex_shader, GLuint(0));
    182 
    183   const char *fs_source =
    184       "precision mediump float;\n"
    185       "uniform vec4 u_color;\n"
    186       "void main() {\n"
    187       "  gl_FragColor = u_color;\n"
    188       "}\n";
    189 
    190   GLuint fragment_shader = CompileShader(GL_FRAGMENT_SHADER, fs_source);
    191   ASSERT_NE(fragment_shader, GLuint(0));
    192 
    193   GLuint program = glCreateProgram();
    194   glAttachShader(program, vertex_shader);
    195   glDeleteShader(vertex_shader);
    196   glAttachShader(program, fragment_shader);
    197   glDeleteShader(fragment_shader);
    198   glLinkProgram(program);
    199 
    200   GLint link_status = 0;
    201   glGetProgramiv(program, GL_LINK_STATUS, &link_status);
    202   if (link_status != GL_TRUE) {
    203     glDeleteProgram(program);
    204     program = 0;
    205   }
    206   ASSERT_NE(program, GLuint(0));
    207 
    208   EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
    209 
    210   float quad_vertices[] = {
    211       -1.0, -1.0,
    212       1.0, -1.0,
    213       1.0, 1.0,
    214       -1.0, 1.0
    215   };
    216 
    217   GLuint vertex_buffer;
    218   glGenBuffers(1, &vertex_buffer);
    219   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
    220   glBufferData(
    221       GL_ARRAY_BUFFER, sizeof(quad_vertices),
    222       reinterpret_cast<void*>(quad_vertices), GL_STATIC_DRAW);
    223 
    224   GLint position_location = glGetAttribLocation(program, "a_position");
    225   glVertexAttribPointer(
    226       position_location, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), NULL);
    227   glEnableVertexAttribArray(position_location);
    228 
    229   glUseProgram(program);
    230   glUniform4fv(glGetUniformLocation(program, "u_color"), 1, kDrawColor);
    231 
    232   EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
    233 
    234   for (size_t ii = 0; ii < test_count; ++ii) {
    235     GLuint texture_id = 0;
    236     glGenTextures(1, &texture_id);
    237     glBindTexture(GL_TEXTURE_2D, texture_id);
    238     glTexImage2D(
    239         GL_TEXTURE_2D, 0, test_formats[ii].format, kTextureSize, kTextureSize,
    240         0, test_formats[ii].format, test_formats[ii].type, NULL);
    241 
    242     GLuint framebuffer = 0;
    243     glGenFramebuffers(1, &framebuffer);
    244     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
    245     glFramebufferTexture2D(
    246         GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_id, 0);
    247 
    248     EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
    249 
    250     // Make sure this floating point framebuffer is supported
    251     if (glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) {
    252       // Check if this implementation supports reading floats back from this
    253       // framebuffer
    254       GLint read_format = 0;
    255       glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &read_format);
    256       GLint read_type = 0;
    257       glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &read_type);
    258 
    259       EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
    260 
    261       if ((read_format == GL_RGB || read_format == GL_RGBA) &&
    262           read_type == test_formats[ii].type) {
    263         glClear(GL_COLOR_BUFFER_BIT);
    264         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
    265 
    266         uint32 read_comp_count = 0;
    267         switch (read_format) {
    268           case GL_RGB:
    269             read_comp_count = 3;
    270             break;
    271           case GL_RGBA:
    272             read_comp_count = 4;
    273             break;
    274         }
    275 
    276         switch (read_type) {
    277           case GL_HALF_FLOAT_OES: {
    278             scoped_ptr<GLushort[]> buf(
    279                 new GLushort[kTextureSize * kTextureSize * read_comp_count]);
    280             glReadPixels(
    281                 0, 0, kTextureSize, kTextureSize, read_format, read_type,
    282                 buf.get());
    283             EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
    284             for (uint32 jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
    285               for (uint32 kk = 0; kk < test_formats[ii].comp_count; ++kk) {
    286                 EXPECT_LE(
    287                     std::abs(HalfToFloat32(buf[jj * read_comp_count + kk]) -
    288                         kDrawColor[kk]),
    289                     std::abs(kDrawColor[kk] * kEpsilon));
    290               }
    291             }
    292             break;
    293           }
    294           case GL_FLOAT: {
    295             scoped_ptr<GLfloat[]> buf(
    296                 new GLfloat[kTextureSize * kTextureSize * read_comp_count]);
    297             glReadPixels(
    298                 0, 0, kTextureSize, kTextureSize, read_format, read_type,
    299                 buf.get());
    300             EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
    301             for (uint32 jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
    302               for (uint32 kk = 0; kk < test_formats[ii].comp_count; ++kk) {
    303                 EXPECT_LE(
    304                     std::abs(buf[jj * read_comp_count + kk] - kDrawColor[kk]),
    305                     std::abs(kDrawColor[kk] * kEpsilon));
    306               }
    307             }
    308             break;
    309           }
    310         }
    311       }
    312     }
    313 
    314     glDeleteFramebuffers(1, &framebuffer);
    315     glDeleteTextures(1, &texture_id);
    316   }
    317 
    318   glDeleteBuffers(1, &vertex_buffer);
    319   glDeleteProgram(program);
    320 }
    321 
    322 }  // namespace gpu
    323