git.sesse.net Git - movit/blob - flat_input_test.cpp

   1 // Unit tests for FlatInput.
   2
   3 #include <epoxy/gl.h>
   4 #include <stddef.h>
   5
   6 #include "effect_chain.h"
   7 #include "flat_input.h"
   8 #include "gtest/gtest.h"
   9 #include "resource_pool.h"
  10 #include "test_util.h"
  11 #include "util.h"
  12
  13 using namespace std;
  14
  15 namespace movit {
  16
  17 TEST(FlatInput, SimpleGrayscale) {
  18         const int size = 4;
  19
  20         float data[size] = {
  21                 0.0,
  22                 0.5,
  23                 0.7,
  24                 1.0,
  25         };
  26         float expected_data[4 * size] = {
  27                 0.0, 0.0, 0.0, 1.0,
  28                 0.5, 0.5, 0.5, 1.0,
  29                 0.7, 0.7, 0.7, 1.0,
  30                 1.0, 1.0, 1.0, 1.0,
  31         };
  32         float out_data[4 * size];
  33
  34         EffectChainTester tester(data, 1, size, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
  35         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
  36
  37         expect_equal(expected_data, out_data, 4, size);
  38 }
  39
  40 TEST(FlatInput, RGB) {
  41         const int size = 5;
  42
  43         float data[3 * size] = {
  44                 0.0, 0.0, 0.0,
  45                 0.5, 0.0, 0.0,
  46                 0.0, 0.5, 0.0,
  47                 0.0, 0.0, 0.7,
  48                 0.0, 0.3, 0.7,
  49         };
  50         float expected_data[4 * size] = {
  51                 0.0, 0.0, 0.0, 1.0,
  52                 0.5, 0.0, 0.0, 1.0,
  53                 0.0, 0.5, 0.0, 1.0,
  54                 0.0, 0.0, 0.7, 1.0,
  55                 0.0, 0.3, 0.7, 1.0,
  56         };
  57         float out_data[4 * size];
  58
  59         EffectChainTester tester(data, 1, size, FORMAT_RGB, COLORSPACE_sRGB, GAMMA_LINEAR);
  60         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
  61
  62         expect_equal(expected_data, out_data, 4, size);
  63 }
  64
  65 TEST(FlatInput, RGBA) {
  66         const int size = 5;
  67
  68         float data[4 * size] = {
  69                 0.0, 0.0, 0.0, 1.0,
  70                 0.5, 0.0, 0.0, 0.3,
  71                 0.0, 0.5, 0.0, 0.7,
  72                 0.0, 0.0, 0.7, 1.0,
  73                 0.0, 0.3, 0.7, 0.2,
  74         };
  75         float expected_data[4 * size] = {
  76                 0.0, 0.0, 0.0, 1.0,
  77                 0.5, 0.0, 0.0, 0.3,
  78                 0.0, 0.5, 0.0, 0.7,
  79                 0.0, 0.0, 0.7, 1.0,
  80                 0.0, 0.3, 0.7, 0.2,
  81         };
  82         float out_data[4 * size];
  83
  84         EffectChainTester tester(data, 1, size, FORMAT_RGBA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, GAMMA_LINEAR);
  85         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
  86
  87         expect_equal(expected_data, out_data, 4, size);
  88 }
  89
  90 // Note: The sRGB conversion itself is tested in EffectChainTester,
  91 // since it also wants to test the chain building itself.
  92 // Here, we merely test that alpha is left alone; the test will usually
  93 // run using the sRGB OpenGL extension, but might be run with a
  94 // GammaExpansionEffect if the card/driver happens not to support that.
  95 TEST(FlatInput, AlphaIsNotModifiedBySRGBConversion) {
  96         const int size = 5;
  97
  98         unsigned char data[4 * size] = {
  99                 0, 0, 0, 0,
 100                 0, 0, 0, 63,
 101                 0, 0, 0, 127,
 102                 0, 0, 0, 191,
 103                 0, 0, 0, 255,
 104         };
 105         float expected_data[4 * size] = {
 106                 0, 0, 0, 0.0 / 255.0,
 107                 0, 0, 0, 63.0 / 255.0,
 108                 0, 0, 0, 127.0 / 255.0,
 109                 0, 0, 0, 191.0 / 255.0,
 110                 0, 0, 0, 255.0 / 255.0,
 111         };
 112         float out_data[4 * size];
 113
 114         EffectChainTester tester(nullptr, 1, size);
 115         tester.add_input(data, FORMAT_RGBA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, GAMMA_sRGB);
 116         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
 117
 118         expect_equal(expected_data, out_data, 4, size);
 119 }
 120
 121 TEST(FlatInput, BGR) {
 122         const int size = 5;
 123
 124         float data[3 * size] = {
 125                 0.0, 0.0, 0.0,
 126                 0.5, 0.0, 0.0,
 127                 0.0, 0.5, 0.0,
 128                 0.0, 0.0, 0.7,
 129                 0.0, 0.3, 0.7,
 130         };
 131         float expected_data[4 * size] = {
 132                 0.0, 0.0, 0.0, 1.0,
 133                 0.0, 0.0, 0.5, 1.0,
 134                 0.0, 0.5, 0.0, 1.0,
 135                 0.7, 0.0, 0.0, 1.0,
 136                 0.7, 0.3, 0.0, 1.0,
 137         };
 138         float out_data[4 * size];
 139
 140         EffectChainTester tester(data, 1, size, FORMAT_BGR, COLORSPACE_sRGB, GAMMA_LINEAR);
 141         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
 142
 143         expect_equal(expected_data, out_data, 4, size);
 144 }
 145
 146 TEST(FlatInput, BGRA) {
 147         const int size = 5;
 148
 149         float data[4 * size] = {
 150                 0.0, 0.0, 0.0, 1.0,
 151                 0.5, 0.0, 0.0, 0.3,
 152                 0.0, 0.5, 0.0, 0.7,
 153                 0.0, 0.0, 0.7, 1.0,
 154                 0.0, 0.3, 0.7, 0.2,
 155         };
 156         float expected_data[4 * size] = {
 157                 0.0, 0.0, 0.0, 1.0,
 158                 0.0, 0.0, 0.5, 0.3,
 159                 0.0, 0.5, 0.0, 0.7,
 160                 0.7, 0.0, 0.0, 1.0,
 161                 0.7, 0.3, 0.0, 0.2,
 162         };
 163         float out_data[4 * size];
 164
 165         EffectChainTester tester(data, 1, size, FORMAT_BGRA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, GAMMA_LINEAR);
 166         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
 167
 168         expect_equal(expected_data, out_data, 4, size);
 169 }
 170
 171 TEST(FlatInput, Pitch) {
 172         const int pitch = 3;
 173         const int width = 2;
 174         const int height = 4;
 175
 176         float data[pitch * height] = {
 177                 0.0, 1.0, 999.0f,
 178                 0.5, 0.5, 999.0f,
 179                 0.7, 0.2, 999.0f,
 180                 1.0, 0.6, 999.0f,
 181         };
 182         float expected_data[4 * width * height] = {
 183                 0.0, 0.0, 0.0, 1.0,  1.0, 1.0, 1.0, 1.0,
 184                 0.5, 0.5, 0.5, 1.0,  0.5, 0.5, 0.5, 1.0,
 185                 0.7, 0.7, 0.7, 1.0,  0.2, 0.2, 0.2, 1.0,
 186                 1.0, 1.0, 1.0, 1.0,  0.6, 0.6, 0.6, 1.0,
 187         };
 188         float out_data[4 * width * height];
 189
 190         EffectChainTester tester(nullptr, width, height);
 191
 192         ImageFormat format;
 193         format.color_space = COLORSPACE_sRGB;
 194         format.gamma_curve = GAMMA_LINEAR;
 195
 196         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, width, height);
 197         input->set_pitch(pitch);
 198         input->set_pixel_data(data);
 199         tester.get_chain()->add_input(input);
 200
 201         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
 202         expect_equal(expected_data, out_data, 4 * width, height);
 203 }
 204
 205 TEST(FlatInput, UpdatedData) {
 206         const int width = 2;
 207         const int height = 4;
 208
 209         float data[width * height] = {
 210                 0.0, 1.0,
 211                 0.5, 0.5,
 212                 0.7, 0.2,
 213                 1.0, 0.6,
 214         };
 215         float out_data[width * height];
 216
 217         EffectChainTester tester(nullptr, width, height);
 218
 219         ImageFormat format;
 220         format.color_space = COLORSPACE_sRGB;
 221         format.gamma_curve = GAMMA_LINEAR;
 222
 223         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, width, height);
 224         input->set_pixel_data(data);
 225         tester.get_chain()->add_input(input);
 226
 227         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 228         expect_equal(data, out_data, width, height);
 229
 230         data[6] = 0.3;
 231         input->invalidate_pixel_data();
 232
 233         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 234         expect_equal(data, out_data, width, height);
 235 }
 236
 237 TEST(FlatInput, PBO) {
 238         const int width = 3;
 239         const int height = 2;
 240
 241         float data[width * height] = {
 242                 0.0, 1.0, 0.5,
 243                 0.5, 0.5, 0.2,
 244         };
 245         float expected_data[4 * width * height] = {
 246                 0.0, 0.0, 0.0, 1.0,  1.0, 1.0, 1.0, 1.0,  0.5, 0.5, 0.5, 1.0,
 247                 0.5, 0.5, 0.5, 1.0,  0.5, 0.5, 0.5, 1.0,  0.2, 0.2, 0.2, 1.0,
 248         };
 249         float out_data[4 * width * height];
 250
 251         GLuint pbo;
 252         glGenBuffers(1, &pbo);
 253         glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
 254         glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * sizeof(float), data, GL_STREAM_DRAW);
 255         glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
 256
 257         EffectChainTester tester(nullptr, width, height);
 258
 259         ImageFormat format;
 260         format.color_space = COLORSPACE_sRGB;
 261         format.gamma_curve = GAMMA_LINEAR;
 262
 263         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, width, height);
 264         input->set_pixel_data((float *)BUFFER_OFFSET(0), pbo);
 265         tester.get_chain()->add_input(input);
 266
 267         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
 268         expect_equal(expected_data, out_data, 4 * width, height);
 269
 270         glDeleteBuffers(1, &pbo);
 271 }
 272
 273 TEST(FlatInput, ExternalTexture) {
 274         const int size = 5;
 275
 276         float data[3 * size] = {
 277                 0.0, 0.0, 0.0,
 278                 0.5, 0.0, 0.0,
 279                 0.0, 0.5, 0.0,
 280                 0.0, 0.0, 0.7,
 281                 0.0, 0.3, 0.7,
 282         };
 283         float expected_data[4 * size] = {
 284                 0.0, 0.0, 0.0, 1.0,
 285                 0.5, 0.0, 0.0, 1.0,
 286                 0.0, 0.5, 0.0, 1.0,
 287                 0.0, 0.0, 0.7, 1.0,
 288                 0.0, 0.3, 0.7, 1.0,
 289         };
 290         float out_data[4 * size];
 291
 292         EffectChainTester tester(nullptr, 1, size, FORMAT_RGB, COLORSPACE_sRGB, GAMMA_LINEAR);
 293
 294         ImageFormat format;
 295         format.color_space = COLORSPACE_sRGB;
 296         format.gamma_curve = GAMMA_LINEAR;
 297
 298         ResourcePool pool;
 299         GLuint tex = pool.create_2d_texture(GL_RGB8, 1, size);
 300         check_error();
 301         glBindTexture(GL_TEXTURE_2D, tex);
 302         check_error();
 303         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 304         check_error();
 305         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 306         check_error();
 307         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, size, GL_RGB, GL_FLOAT, data);
 308         check_error();
 309         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 310         check_error();
 311         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 312         check_error();
 313
 314         FlatInput *input = new FlatInput(format, FORMAT_RGB, GL_FLOAT, 1, size);
 315         input->set_texture_num(tex);
 316         tester.get_chain()->add_input(input);
 317
 318         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
 319
 320         pool.release_2d_texture(tex);
 321
 322         expect_equal(expected_data, out_data, 4, size);
 323 }
 324
 325 // Just an IdentityEffect, but marks as needing mipmaps, so that we can use it
 326 // for downscaling to verify mipmaps were used.
 327 class MipmapNeedingEffect : public Effect {
 328 public:
 329         MipmapNeedingEffect() {}
 330         MipmapRequirements needs_mipmaps() const override { return NEEDS_MIPMAPS; }
 331
 332         string effect_type_id() const override { return "MipmapNeedingEffect"; }
 333         string output_fragment_shader() override { return read_file("identity.frag"); }
 334 };
 335
 336 TEST(FlatInput, ExternalTextureMipmapState) {
 337         const int width = 4;
 338         const int height = 4;
 339
 340         float data[width * height] = {
 341                 1.0, 0.0, 0.0, 0.0,
 342                 0.0, 0.0, 0.0, 0.0,
 343                 0.0, 0.0, 0.0, 0.0,
 344                 0.0, 0.0, 0.0, 0.0,
 345         };
 346         float expected_data[] = {
 347                 0.0625,
 348         };
 349         float out_data[1];
 350
 351         EffectChainTester tester(nullptr, 1, 1, FORMAT_RGB, COLORSPACE_sRGB, GAMMA_LINEAR);
 352
 353         ImageFormat format;
 354         format.color_space = COLORSPACE_sRGB;
 355         format.gamma_curve = GAMMA_LINEAR;
 356
 357         ResourcePool pool;
 358         GLuint tex = pool.create_2d_texture(GL_R8, width, height);
 359         check_error();
 360         glBindTexture(GL_TEXTURE_2D, tex);
 361         check_error();
 362         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
 363         check_error();
 364         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 365         check_error();
 366         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RED, GL_FLOAT, data);
 367         check_error();
 368         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 369         check_error();
 370         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 371         check_error();
 372         glGenerateMipmap(GL_TEXTURE_2D);
 373         check_error();
 374
 375         // Turn off mipmaps, so that we verify that Movit turns it back on.
 376         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 377         check_error();
 378
 379         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, width, height);
 380         input->set_texture_num(tex);
 381         tester.get_chain()->add_input(input);
 382         tester.get_chain()->add_effect(new MipmapNeedingEffect);
 383
 384         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 385
 386         pool.release_2d_texture(tex);
 387
 388         expect_equal(expected_data, out_data, 1, 1);
 389 }
 390
 391 TEST(FlatInput, NoData) {
 392         const int width = 2;
 393         const int height = 4;
 394
 395         float out_data[width * height];
 396
 397         EffectChainTester tester(nullptr, width, height);
 398
 399         ImageFormat format;
 400         format.color_space = COLORSPACE_sRGB;
 401         format.gamma_curve = GAMMA_LINEAR;
 402
 403         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, width, height);
 404         tester.get_chain()->add_input(input);
 405
 406         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 407
 408         // Don't care what the output was, just that it does not crash.
 409 }
 410
 411 }  // namespace movit