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

   1 // Unit tests for ResampleEffect.
   2
   3 #include <epoxy/gl.h>
   4 #include <gtest/gtest.h>
   5 #include <math.h>
   6
   7 #include "effect_chain.h"
   8 #include "flat_input.h"
   9 #include "image_format.h"
  10 #include "resample_effect.h"
  11 #include "test_util.h"
  12
  13 namespace movit {
  14
  15 namespace {
  16
  17 float sinc(float x)
  18 {
  19         return sin(M_PI * x) / (M_PI * x);
  20 }
  21
  22 float lanczos(float x, float a)
  23 {
  24         if (fabs(x) >= a) {
  25                 return 0.0f;
  26         } else {
  27                 return sinc(x) * sinc(x / a);
  28         }
  29 }
  30
  31 }  // namespace
  32
  33 TEST(ResampleEffectTest, IdentityTransformDoesNothing) {
  34         const int size = 4;
  35
  36         float data[size * size] = {
  37                 0.0, 1.0, 0.0, 1.0,
  38                 0.0, 1.0, 1.0, 0.0,
  39                 0.0, 0.5, 1.0, 0.5,
  40                 0.0, 0.0, 0.0, 0.0,
  41         };
  42         float out_data[size * size];
  43
  44         EffectChainTester tester(data, size, size, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
  45         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
  46         ASSERT_TRUE(resample_effect->set_int("width", 4));
  47         ASSERT_TRUE(resample_effect->set_int("height", 4));
  48         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
  49
  50         expect_equal(data, out_data, size, size);
  51 }
  52
  53 TEST(ResampleEffectTest, UpscaleByTwoGetsCorrectPixelCenters) {
  54         const int size = 5;
  55
  56         float data[size * size] = {
  57                 0.0, 0.0, 0.0, 0.0, 0.0,
  58                 0.0, 0.0, 0.0, 0.0, 0.0,
  59                 0.0, 0.0, 1.0, 0.0, 0.0,
  60                 0.0, 0.0, 0.0, 0.0, 0.0,
  61                 0.0, 0.0, 0.0, 0.0, 0.0,
  62         };
  63         float expected_data[size * size * 4], out_data[size * size * 4];
  64
  65         for (int y = 0; y < size * 2; ++y) {
  66                 for (int x = 0; x < size * 2; ++x) {
  67                         float weight = lanczos((x - size + 0.5f) * 0.5f, 3.0f);
  68                         weight *= lanczos((y - size + 0.5f) * 0.5f, 3.0f);
  69                         expected_data[y * (size * 2) + x] = weight;
  70                 }
  71         }
  72
  73         EffectChainTester tester(NULL, size * 2, size * 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
  74
  75         ImageFormat format;
  76         format.color_space = COLORSPACE_sRGB;
  77         format.gamma_curve = GAMMA_LINEAR;
  78
  79         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, size, size);
  80         input->set_pixel_data(data);
  81         tester.get_chain()->add_input(input);
  82
  83         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
  84         ASSERT_TRUE(resample_effect->set_int("width", size * 2));
  85         ASSERT_TRUE(resample_effect->set_int("height", size * 2));
  86         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
  87
  88         expect_equal(expected_data, out_data, size * 2, size * 2);
  89 }
  90
  91 TEST(ResampleEffectTest, DownscaleByTwoGetsCorrectPixelCenters) {
  92         const int size = 5;
  93
  94         // This isn't a perfect dot, since the Lanczos filter has a slight
  95         // sharpening effect; the most important thing is that we have kept
  96         // the texel center right (everything is nicely symmetric).
  97         // The approximate magnitudes have been checked against ImageMagick.
  98         float expected_data[size * size] = {
  99                  0.0045, -0.0067, -0.0599, -0.0067,  0.0045,
 100                 -0.0067,  0.0100,  0.0892,  0.0100, -0.0067,
 101                 -0.0599,  0.0890,  0.7925,  0.0892, -0.0599,
 102                 -0.0067,  0.0100,  0.0890,  0.0100, -0.0067,
 103                  0.0045, -0.0067, -0.0599, -0.0067,  0.0045,
 104         };
 105         float data[size * size * 4], out_data[size * size];
 106
 107         for (int y = 0; y < size * 2; ++y) {
 108                 for (int x = 0; x < size * 2; ++x) {
 109                         float weight = lanczos((x - size + 0.5f) * 0.5f, 3.0f);
 110                         weight *= lanczos((y - size + 0.5f) * 0.5f, 3.0f);
 111                         data[y * (size * 2) + x] = weight;
 112                 }
 113         }
 114
 115         EffectChainTester tester(NULL, size, size, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
 116
 117         ImageFormat format;
 118         format.color_space = COLORSPACE_sRGB;
 119         format.gamma_curve = GAMMA_LINEAR;
 120
 121         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, size * 2, size * 2);
 122         input->set_pixel_data(data);
 123         tester.get_chain()->add_input(input);
 124
 125         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 126         ASSERT_TRUE(resample_effect->set_int("width", size));
 127         ASSERT_TRUE(resample_effect->set_int("height", size));
 128         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 129
 130         expect_equal(expected_data, out_data, size, size);
 131 }
 132
 133 TEST(ResampleEffectTest, UpscaleByThreeGetsCorrectPixelCenters) {
 134         const int size = 5;
 135
 136         float data[size * size] = {
 137                 0.0, 0.0, 0.0, 0.0, 0.0,
 138                 0.0, 0.0, 0.0, 0.0, 0.0,
 139                 0.0, 0.0, 1.0, 0.0, 0.0,
 140                 0.0, 0.0, 0.0, 0.0, 0.0,
 141                 0.0, 0.0, 0.0, 0.0, 0.0,
 142         };
 143         float out_data[size * size * 9];
 144
 145         EffectChainTester tester(NULL, size * 3, size * 3, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
 146
 147         ImageFormat format;
 148         format.color_space = COLORSPACE_sRGB;
 149         format.gamma_curve = GAMMA_LINEAR;
 150
 151         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, size, size);
 152         input->set_pixel_data(data);
 153         tester.get_chain()->add_input(input);
 154
 155         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 156         ASSERT_TRUE(resample_effect->set_int("width", size * 3));
 157         ASSERT_TRUE(resample_effect->set_int("height", size * 3));
 158         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 159
 160         // We only bother checking that the middle pixel is still correct,
 161         // and that symmetry holds.
 162         EXPECT_FLOAT_EQ(1.0, out_data[7 * (size * 3) + 7]);
 163         for (unsigned y = 0; y < size * 3; ++y) {
 164                 for (unsigned x = 0; x < size * 3; ++x) {
 165                         EXPECT_NEAR(out_data[y * (size * 3) + x], out_data[(size * 3 - y - 1) * (size * 3) + x], 1e-6);
 166                         EXPECT_NEAR(out_data[y * (size * 3) + x], out_data[y * (size * 3) + (size * 3 - x - 1)], 1e-6);
 167                 }
 168         }
 169 }
 170
 171 TEST(ResampleEffectTest, HeavyResampleGetsSumRight) {
 172         // Do only one resample pass, more specifically the last one, which goes to
 173         // our fp32 output. This allows us to analyze the precision without intermediate
 174         // fp16 rounding.
 175         const int swidth = 1, sheight = 1280;
 176         const int dwidth = 1, dheight = 64;
 177
 178         float data[swidth * sheight], out_data[dwidth * dheight], expected_data[dwidth * dheight];
 179         for (int y = 0; y < sheight; ++y) {
 180                 for (int x = 0; x < swidth; ++x) {
 181                         data[y * swidth + x] = 1.0f;
 182                 }
 183         }
 184         for (int y = 0; y < dheight; ++y) {
 185                 for (int x = 0; x < dwidth; ++x) {
 186                         expected_data[y * dwidth + x] = 1.0f;
 187                 }
 188         }
 189
 190         EffectChainTester tester(NULL, dwidth, dheight, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR, GL_RGBA32F);
 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, swidth, sheight);
 197         input->set_pixel_data(data);
 198
 199         tester.get_chain()->add_input(input);
 200         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 201         ASSERT_TRUE(resample_effect->set_int("width", dwidth));
 202         ASSERT_TRUE(resample_effect->set_int("height", dheight));
 203         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 204
 205         // Require that we are within 10-bit accuracy. Note that this limit is for
 206         // one pass only, but the limit is tight enough that it should be good enough
 207         // for 10-bit accuracy even after two passes.
 208         expect_equal(expected_data, out_data, dwidth, dheight, 0.12 / 1023.0);
 209 }
 210
 211 TEST(ResampleEffectTest, ReadWholePixelFromLeft) {
 212         const int size = 5;
 213
 214         float data[size * size] = {
 215                 0.0, 0.0, 0.0, 0.0, 0.0,
 216                 0.0, 0.0, 0.0, 0.0, 0.0,
 217                 0.0, 0.0, 1.0, 0.0, 0.0,
 218                 0.0, 0.0, 0.0, 0.0, 0.0,
 219                 0.0, 0.0, 0.0, 0.0, 0.0,
 220         };
 221         float expected_data[size * size] = {
 222                 0.0, 0.0, 0.0, 0.0, 0.0,
 223                 0.0, 0.0, 0.0, 0.0, 0.0,
 224                 0.0, 1.0, 0.0, 0.0, 0.0,
 225                 0.0, 0.0, 0.0, 0.0, 0.0,
 226                 0.0, 0.0, 0.0, 0.0, 0.0,
 227         };
 228         float out_data[size * size];
 229
 230         EffectChainTester tester(data, size, size, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
 231         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 232         ASSERT_TRUE(resample_effect->set_int("width", size));
 233         ASSERT_TRUE(resample_effect->set_int("height", size));
 234         ASSERT_TRUE(resample_effect->set_float("left", 1.0f));
 235         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 236
 237         expect_equal(expected_data, out_data, size, size);
 238 }
 239
 240 TEST(ResampleEffectTest, ReadQuarterPixelFromLeft) {
 241         const int size = 5;
 242
 243         float data[size * size] = {
 244                 0.0, 0.0, 0.0, 0.0, 0.0,
 245                 0.0, 0.0, 0.0, 0.0, 0.0,
 246                 0.0, 0.0, 1.0, 0.0, 0.0,
 247                 0.0, 0.0, 0.0, 0.0, 0.0,
 248                 0.0, 0.0, 0.0, 0.0, 0.0,
 249         };
 250
 251         float expected_data[size * size] = {
 252                 0.0, 0.0, 0.0, 0.0, 0.0,
 253                 0.0, 0.0, 0.0, 0.0, 0.0,
 254
 255                 // sin(x*pi)/(x*pi) * sin(x*pi/3)/(x*pi/3) for
 256                 // x = -1.75, -0.75, 0.25, 1.25, 2.25.
 257                 // Note that the weight is mostly on the left side.
 258                 -0.06779, 0.27019, 0.89007, -0.13287, 0.03002,
 259
 260                 0.0, 0.0, 0.0, 0.0, 0.0,
 261                 0.0, 0.0, 0.0, 0.0, 0.0,
 262         };
 263         float out_data[size * size];
 264
 265         EffectChainTester tester(data, size, size, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
 266         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 267         ASSERT_TRUE(resample_effect->set_int("width", size));
 268         ASSERT_TRUE(resample_effect->set_int("height", size));
 269         ASSERT_TRUE(resample_effect->set_float("left", 0.25f));
 270         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 271
 272         expect_equal(expected_data, out_data, size, size);
 273 }
 274
 275 TEST(ResampleEffectTest, ReadQuarterPixelFromTop) {
 276         const int width = 3;
 277         const int height = 5;
 278
 279         float data[width * height] = {
 280                 0.0, 0.0, 0.0,
 281                 0.0, 0.0, 0.0,
 282                 1.0, 0.0, 0.0,
 283                 0.0, 0.0, 0.0,
 284                 0.0, 0.0, 0.0,
 285         };
 286
 287         // See ReadQuarterPixelFromLeft for explanation of the data.
 288         float expected_data[width * height] = {
 289                 -0.06779, 0.0, 0.0,
 290                  0.27019, 0.0, 0.0,
 291                  0.89007, 0.0, 0.0,
 292                 -0.13287, 0.0, 0.0,
 293                  0.03002, 0.0, 0.0,
 294         };
 295         float out_data[width * height];
 296
 297         EffectChainTester tester(data, width, height, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
 298         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 299         ASSERT_TRUE(resample_effect->set_int("width", width));
 300         ASSERT_TRUE(resample_effect->set_int("height", height));
 301         ASSERT_TRUE(resample_effect->set_float("top", 0.25f));
 302         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 303
 304         expect_equal(expected_data, out_data, width, height);
 305 }
 306
 307 TEST(ResampleEffectTest, ReadHalfPixelFromLeftAndScale) {
 308         const int src_width = 4;
 309         const int dst_width = 8;
 310
 311         float data[src_width * 1] = {
 312                 1.0, 2.0, 3.0, 4.0,
 313         };
 314         float expected_data[dst_width * 1] = {
 315                 // Empirical; the real test is that we are the same for 0.499 and 0.501.
 316                 1.1553, 1.7158, 2.2500, 2.7461, 3.2812, 3.8418, 4.0703, 4.0508
 317         };
 318         float out_data[dst_width * 1];
 319
 320         EffectChainTester tester(NULL, dst_width, 1, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
 321
 322         ImageFormat format;
 323         format.color_space = COLORSPACE_sRGB;
 324         format.gamma_curve = GAMMA_LINEAR;
 325
 326         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, src_width, 1);
 327         input->set_pixel_data(data);
 328         tester.get_chain()->add_input(input);
 329
 330         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 331         ASSERT_TRUE(resample_effect->set_int("width", dst_width));
 332         ASSERT_TRUE(resample_effect->set_int("height", 1));
 333
 334         // Check that we are (almost) the same no matter the rounding.
 335         ASSERT_TRUE(resample_effect->set_float("left", 0.499f));
 336         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 337         expect_equal(expected_data, out_data, dst_width, 1, 1.5f / 255.0f, 0.4f / 255.0f);
 338
 339         ASSERT_TRUE(resample_effect->set_float("left", 0.501f));
 340         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 341         expect_equal(expected_data, out_data, dst_width, 1, 1.5f / 255.0f, 0.4f / 255.0f);
 342 }
 343
 344 TEST(ResampleEffectTest, Zoom) {
 345         const int width = 5;
 346         const int height = 3;
 347
 348         float data[width * height] = {
 349                 0.0, 0.0, 0.0, 0.0, 0.0,
 350                 0.2, 0.4, 0.6, 0.4, 0.2,
 351                 0.0, 0.0, 0.0, 0.0, 0.0,
 352         };
 353         float expected_data[width * height] = {
 354                 0.0, 0.0,    0.0, 0.0,    0.0,
 355                 0.4, 0.5396, 0.6, 0.5396, 0.4,
 356                 0.0, 0.0,    0.0, 0.0,    0.0,
 357         };
 358         float out_data[width * height];
 359
 360         EffectChainTester tester(data, width, height, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
 361         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 362         ASSERT_TRUE(resample_effect->set_int("width", width));
 363         ASSERT_TRUE(resample_effect->set_int("height", height));
 364         ASSERT_TRUE(resample_effect->set_float("zoom_x", 2.0f));
 365         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 366
 367         expect_equal(expected_data, out_data, width, height);
 368 }
 369
 370 TEST(ResampleEffectTest, VerticalZoomFromTop) {
 371         const int width = 5;
 372         const int height = 5;
 373
 374         float data[width * height] = {
 375                 0.2, 0.4, 0.6, 0.4, 0.2,
 376                 0.0, 0.0, 0.0, 0.0, 0.0,
 377                 0.0, 0.0, 0.0, 0.0, 0.0,
 378                 0.0, 0.0, 0.0, 0.0, 0.0,
 379                 0.0, 0.0, 0.0, 0.0, 0.0,
 380         };
 381
 382         // Largely empirical data; the main point is that the top line
 383         // is unchanged, since that's our zooming point.
 384         float expected_data[width * height] = {
 385                  0.2000,  0.4000,  0.6000,  0.4000,  0.2000,
 386                  0.1389,  0.2778,  0.4167,  0.2778,  0.1389,
 387                  0.0600,  0.1199,  0.1798,  0.1199,  0.0600,
 388                  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
 389                 -0.0229, -0.0459, -0.0688, -0.0459, -0.0229,
 390         };
 391         float out_data[width * height];
 392
 393         EffectChainTester tester(data, width, height, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
 394         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 395         ASSERT_TRUE(resample_effect->set_int("width", width));
 396         ASSERT_TRUE(resample_effect->set_int("height", height));
 397         ASSERT_TRUE(resample_effect->set_float("zoom_y", 3.0f));
 398         ASSERT_TRUE(resample_effect->set_float("zoom_center_y", 0.5f / height));
 399         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 400
 401         expect_equal(expected_data, out_data, width, height);
 402 }
 403
 404 TEST(ResampleEffectTest, Precision) {
 405         const int size = 1920;  // Difficult non-power-of-two size.
 406         const int offset = 5;
 407
 408         // Deliberately put the data of interest very close to the right,
 409         // where texture coordinates are farther from 0 and thus less precise.
 410         float data[size * 2] = {0};
 411         data[size - offset] = 1.0f;
 412         float expected_data[size * 2] = {0};
 413         for (int x = 0; x < size * 2; ++x) {
 414                 expected_data[x] = lanczos((x - (size - 2 * offset + 1) + 0.5f) * 0.5f, 3.0f);
 415         }
 416         float out_data[size * 2];
 417
 418         EffectChainTester tester(data, size * 2, 1, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
 419         Effect *resample_effect = tester.get_chain()->add_effect(new ResampleEffect());
 420         ASSERT_TRUE(resample_effect->set_int("width", size * 2));
 421         ASSERT_TRUE(resample_effect->set_int("height", 1));
 422         ASSERT_TRUE(resample_effect->set_float("zoom_x", 2.0f));
 423         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 424
 425         expect_equal(expected_data, out_data, size, 1);
 426 }
 427
 428 }  // namespace movit