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 "gpu/command_buffer/tests/gl_test_utils.h" 6 #include <string> 7 #include <stdio.h> 8 #include "base/basictypes.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "testing/gmock/include/gmock/gmock.h" 11 #include "testing/gtest/include/gtest/gtest.h" 12 13 // GCC requires these declarations, but MSVC requires they not be present. 14 #ifndef COMPILER_MSVC 15 const uint8 GLTestHelper::kCheckClearValue; 16 #endif 17 18 bool GLTestHelper::HasExtension(const char* extension) { 19 std::string extensions( 20 reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS))); 21 return extensions.find(extension) != std::string::npos; 22 } 23 24 bool GLTestHelper::CheckGLError(const char* msg, int line) { 25 bool success = true; 26 GLenum error = GL_NO_ERROR; 27 while ((error = glGetError()) != GL_NO_ERROR) { 28 success = false; 29 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), error) 30 << "GL ERROR in " << msg << " at line " << line << " : " << error; 31 } 32 return success; 33 } 34 35 GLuint GLTestHelper::LoadShader(GLenum type, const char* shaderSrc) { 36 GLuint shader = glCreateShader(type); 37 // Load the shader source 38 glShaderSource(shader, 1, &shaderSrc, NULL); 39 // Compile the shader 40 glCompileShader(shader); 41 // Check the compile status 42 GLint value = 0; 43 glGetShaderiv(shader, GL_COMPILE_STATUS, &value); 44 if (value == 0) { 45 char buffer[1024]; 46 GLsizei length = 0; 47 glGetShaderInfoLog(shader, sizeof(buffer), &length, buffer); 48 std::string log(buffer, length); 49 EXPECT_EQ(1, value) << "Error compiling shader: " << log; 50 glDeleteShader(shader); 51 shader = 0; 52 } 53 return shader; 54 } 55 56 GLuint GLTestHelper::SetupProgram( 57 GLuint vertex_shader, GLuint fragment_shader) { 58 // Create the program object 59 GLuint program = glCreateProgram(); 60 glAttachShader(program, vertex_shader); 61 glAttachShader(program, fragment_shader); 62 // Link the program 63 glLinkProgram(program); 64 // Check the link status 65 GLint linked = 0; 66 glGetProgramiv(program, GL_LINK_STATUS, &linked); 67 if (linked == 0) { 68 char buffer[1024]; 69 GLsizei length = 0; 70 glGetProgramInfoLog(program, sizeof(buffer), &length, buffer); 71 std::string log(buffer, length); 72 EXPECT_EQ(1, linked) << "Error linking program: " << log; 73 glDeleteProgram(program); 74 program = 0; 75 } 76 return program; 77 } 78 79 GLuint GLTestHelper::LoadProgram( 80 const char* vertex_shader_source, 81 const char* fragment_shader_source) { 82 GLuint vertex_shader = LoadShader( 83 GL_VERTEX_SHADER, vertex_shader_source); 84 GLuint fragment_shader = LoadShader( 85 GL_FRAGMENT_SHADER, fragment_shader_source); 86 if (!vertex_shader || !fragment_shader) { 87 return 0; 88 } 89 return SetupProgram(vertex_shader, fragment_shader); 90 } 91 92 GLuint GLTestHelper::SetupUnitQuad(GLint position_location) { 93 GLuint vbo = 0; 94 glGenBuffers(1, &vbo); 95 glBindBuffer(GL_ARRAY_BUFFER, vbo); 96 static float vertices[] = { 97 1.0f, 1.0f, 98 -1.0f, 1.0f, 99 -1.0f, -1.0f, 100 1.0f, 1.0f, 101 -1.0f, -1.0f, 102 1.0f, -1.0f, 103 }; 104 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 105 glEnableVertexAttribArray(position_location); 106 glVertexAttribPointer(position_location, 2, GL_FLOAT, GL_FALSE, 0, 0); 107 108 return vbo; 109 } 110 111 GLuint GLTestHelper::SetupColorsForUnitQuad( 112 GLint location, const GLfloat color[4], GLenum usage) { 113 GLuint vbo = 0; 114 glGenBuffers(1, &vbo); 115 glBindBuffer(GL_ARRAY_BUFFER, vbo); 116 GLfloat vertices[6 * 4]; 117 for (int ii = 0; ii < 6; ++ii) { 118 for (int jj = 0; jj < 4; ++jj) { 119 vertices[ii * 4 + jj] = color[jj]; 120 } 121 } 122 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, usage); 123 glEnableVertexAttribArray(location); 124 glVertexAttribPointer(location, 4, GL_FLOAT, GL_FALSE, 0, 0); 125 126 return vbo; 127 } 128 129 bool GLTestHelper::CheckPixels( 130 GLint x, GLint y, GLsizei width, GLsizei height, GLint tolerance, 131 const uint8* color) { 132 GLsizei size = width * height * 4; 133 scoped_ptr<uint8[]> pixels(new uint8[size]); 134 memset(pixels.get(), kCheckClearValue, size); 135 glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get()); 136 int bad_count = 0; 137 for (GLint yy = 0; yy < height; ++yy) { 138 for (GLint xx = 0; xx < width; ++xx) { 139 int offset = yy * width * 4 + xx * 4; 140 for (int jj = 0; jj < 4; ++jj) { 141 uint8 actual = pixels[offset + jj]; 142 uint8 expected = color[jj]; 143 int diff = actual - expected; 144 diff = diff < 0 ? -diff: diff; 145 if (diff > tolerance) { 146 EXPECT_EQ(expected, actual) << " at " << (xx + x) << ", " << (yy + y) 147 << " channel " << jj; 148 ++bad_count; 149 // Exit early just so we don't spam the log but we print enough 150 // to hopefully make it easy to diagnose the issue. 151 if (bad_count > 16) { 152 return false; 153 } 154 } 155 } 156 } 157 } 158 return bad_count == 0; 159 } 160 161 namespace { 162 163 void Set16BitValue(uint8 dest[2], uint16 value) { 164 dest[0] = value & 0xFFu; 165 dest[1] = value >> 8; 166 } 167 168 void Set32BitValue(uint8 dest[4], uint32 value) { 169 dest[0] = (value >> 0) & 0xFFu; 170 dest[1] = (value >> 8) & 0xFFu; 171 dest[2] = (value >> 16) & 0xFFu; 172 dest[3] = (value >> 24) & 0xFFu; 173 } 174 175 struct BitmapHeaderFile { 176 uint8 magic[2]; 177 uint8 size[4]; 178 uint8 reserved[4]; 179 uint8 offset[4]; 180 }; 181 182 struct BitmapInfoHeader{ 183 uint8 size[4]; 184 uint8 width[4]; 185 uint8 height[4]; 186 uint8 planes[2]; 187 uint8 bit_count[2]; 188 uint8 compression[4]; 189 uint8 size_image[4]; 190 uint8 x_pels_per_meter[4]; 191 uint8 y_pels_per_meter[4]; 192 uint8 clr_used[4]; 193 uint8 clr_important[4]; 194 }; 195 196 } 197 198 bool GLTestHelper::SaveBackbufferAsBMP( 199 const char* filename, int width, int height) { 200 FILE* fp = fopen(filename, "wb"); 201 EXPECT_TRUE(fp != NULL); 202 glPixelStorei(GL_PACK_ALIGNMENT, 1); 203 int num_pixels = width * height; 204 int size = num_pixels * 4; 205 scoped_ptr<uint8[]> data(new uint8[size]); 206 uint8* pixels = data.get(); 207 glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 208 209 // RGBA to BGRA 210 for (int ii = 0; ii < num_pixels; ++ii) { 211 int offset = ii * 4; 212 uint8 t = pixels[offset + 0]; 213 pixels[offset + 0] = pixels[offset + 2]; 214 pixels[offset + 2] = t; 215 } 216 217 BitmapHeaderFile bhf; 218 BitmapInfoHeader bih; 219 220 bhf.magic[0] = 'B'; 221 bhf.magic[1] = 'M'; 222 Set32BitValue(bhf.size, 0); 223 Set32BitValue(bhf.reserved, 0); 224 Set32BitValue(bhf.offset, sizeof(bhf) + sizeof(bih)); 225 226 Set32BitValue(bih.size, sizeof(bih)); 227 Set32BitValue(bih.width, width); 228 Set32BitValue(bih.height, height); 229 Set16BitValue(bih.planes, 1); 230 Set16BitValue(bih.bit_count, 32); 231 Set32BitValue(bih.compression, 0); 232 Set32BitValue(bih.x_pels_per_meter, 0); 233 Set32BitValue(bih.y_pels_per_meter, 0); 234 Set32BitValue(bih.clr_used, 0); 235 Set32BitValue(bih.clr_important, 0); 236 237 fwrite(&bhf, sizeof(bhf), 1, fp); 238 fwrite(&bih, sizeof(bih), 1, fp); 239 fwrite(pixels, size, 1, fp); 240 fclose(fp); 241 return true; 242 } 243 244 int GLTestHelper::RunTests(int argc, char** argv) { 245 testing::InitGoogleMock(&argc, argv); 246 return RUN_ALL_TESTS(); 247 } 248
