Fix a bug where PaddingEffect could create assertion errors.
[movit] / flat_input_test.cpp
1 // Unit tests for FlatInput.
2
3 #include <stddef.h>
4
5 #include "effect_chain.h"
6 #include "flat_input.h"
7 #include "gtest/gtest.h"
8 #include "test_util.h"
9
10 TEST(FlatInput, SimpleGrayscale) {
11         const int size = 4;
12
13         float data[size] = {
14                 0.0,
15                 0.5,
16                 0.7,
17                 1.0,
18         };
19         float expected_data[4 * size] = {
20                 0.0, 0.0, 0.0, 1.0,
21                 0.5, 0.5, 0.5, 1.0,
22                 0.7, 0.7, 0.7, 1.0,
23                 1.0, 1.0, 1.0, 1.0,
24         };
25         float out_data[4 * size];
26
27         EffectChainTester tester(data, 1, size, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
28         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
29
30         expect_equal(expected_data, out_data, 4, size);
31 }
32
33 TEST(FlatInput, RGB) {
34         const int size = 5;
35
36         float data[3 * size] = {
37                 0.0, 0.0, 0.0,
38                 0.5, 0.0, 0.0,
39                 0.0, 0.5, 0.0,
40                 0.0, 0.0, 0.7,
41                 0.0, 0.3, 0.7,
42         };
43         float expected_data[4 * size] = {
44                 0.0, 0.0, 0.0, 1.0,
45                 0.5, 0.0, 0.0, 1.0,
46                 0.0, 0.5, 0.0, 1.0,
47                 0.0, 0.0, 0.7, 1.0,
48                 0.0, 0.3, 0.7, 1.0,
49         };
50         float out_data[4 * size];
51
52         EffectChainTester tester(data, 1, size, FORMAT_RGB, COLORSPACE_sRGB, GAMMA_LINEAR);
53         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
54
55         expect_equal(expected_data, out_data, 4, size);
56 }
57
58 TEST(FlatInput, RGBA) {
59         const int size = 5;
60
61         float data[4 * size] = {
62                 0.0, 0.0, 0.0, 1.0,
63                 0.5, 0.0, 0.0, 0.3,
64                 0.0, 0.5, 0.0, 0.7,
65                 0.0, 0.0, 0.7, 1.0,
66                 0.0, 0.3, 0.7, 0.2,
67         };
68         float expected_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 out_data[4 * size];
76
77         EffectChainTester tester(data, 1, size, FORMAT_RGBA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, GAMMA_LINEAR);
78         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
79
80         expect_equal(expected_data, out_data, 4, size);
81 }
82
83 // Note: The sRGB conversion itself is tested in EffectChainTester,
84 // since it also wants to test the chain building itself.
85 // Here, we merely test that alpha is left alone; the test will usually
86 // run using the sRGB OpenGL extension, but might be run with a
87 // GammaExpansionEffect if the card/driver happens not to support that.
88 TEST(FlatInput, AlphaIsNotModifiedBySRGBConversion) {
89         const int size = 5;
90
91         unsigned char data[4 * size] = {
92                 0, 0, 0, 0,
93                 0, 0, 0, 63,
94                 0, 0, 0, 127,
95                 0, 0, 0, 191,
96                 0, 0, 0, 255,
97         };
98         float expected_data[4 * size] = {
99                 0, 0, 0, 0.0 / 255.0,
100                 0, 0, 0, 63.0 / 255.0,
101                 0, 0, 0, 127.0 / 255.0,
102                 0, 0, 0, 191.0 / 255.0,
103                 0, 0, 0, 255.0 / 255.0,
104         };
105         float out_data[4 * size];
106
107         EffectChainTester tester(NULL, 1, size);
108         tester.add_input(data, FORMAT_RGBA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, GAMMA_sRGB);
109         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
110
111         expect_equal(expected_data, out_data, 4, size);
112 }
113
114 TEST(FlatInput, BGR) {
115         const int size = 5;
116
117         float data[3 * size] = {
118                 0.0, 0.0, 0.0,
119                 0.5, 0.0, 0.0,
120                 0.0, 0.5, 0.0,
121                 0.0, 0.0, 0.7,
122                 0.0, 0.3, 0.7,
123         };
124         float expected_data[4 * size] = {
125                 0.0, 0.0, 0.0, 1.0,
126                 0.0, 0.0, 0.5, 1.0,
127                 0.0, 0.5, 0.0, 1.0,
128                 0.7, 0.0, 0.0, 1.0,
129                 0.7, 0.3, 0.0, 1.0,
130         };
131         float out_data[4 * size];
132
133         EffectChainTester tester(data, 1, size, FORMAT_BGR, COLORSPACE_sRGB, GAMMA_LINEAR);
134         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
135
136         expect_equal(expected_data, out_data, 4, size);
137 }
138
139 TEST(FlatInput, BGRA) {
140         const int size = 5;
141
142         float data[4 * size] = {
143                 0.0, 0.0, 0.0, 1.0,
144                 0.5, 0.0, 0.0, 0.3,
145                 0.0, 0.5, 0.0, 0.7,
146                 0.0, 0.0, 0.7, 1.0,
147                 0.0, 0.3, 0.7, 0.2,
148         };
149         float expected_data[4 * size] = {
150                 0.0, 0.0, 0.0, 1.0,
151                 0.0, 0.0, 0.5, 0.3,
152                 0.0, 0.5, 0.0, 0.7,
153                 0.7, 0.0, 0.0, 1.0,
154                 0.7, 0.3, 0.0, 0.2,
155         };
156         float out_data[4 * size];
157
158         EffectChainTester tester(data, 1, size, FORMAT_BGRA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, GAMMA_LINEAR);
159         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
160
161         expect_equal(expected_data, out_data, 4, size);
162 }
163
164 TEST(FlatInput, Pitch) {
165         const int pitch = 3;
166         const int width = 2;
167         const int height = 4;
168
169         float data[pitch * height] = {
170                 0.0, 1.0, 999.0f,
171                 0.5, 0.5, 999.0f,
172                 0.7, 0.2, 999.0f,
173                 1.0, 0.6, 999.0f,
174         };
175         float expected_data[4 * width * height] = {
176                 0.0, 0.0, 0.0, 1.0,  1.0, 1.0, 1.0, 1.0,
177                 0.5, 0.5, 0.5, 1.0,  0.5, 0.5, 0.5, 1.0,
178                 0.7, 0.7, 0.7, 1.0,  0.2, 0.2, 0.2, 1.0,
179                 1.0, 1.0, 1.0, 1.0,  0.6, 0.6, 0.6, 1.0,
180         };
181         float out_data[4 * width * height];
182
183         EffectChainTester tester(NULL, width, height);
184
185         ImageFormat format;
186         format.color_space = COLORSPACE_sRGB;
187         format.gamma_curve = GAMMA_LINEAR;
188
189         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, width, height);
190         input->set_pitch(pitch);
191         input->set_pixel_data(data);
192         tester.get_chain()->add_input(input);
193
194         tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
195         expect_equal(expected_data, out_data, 4 * width, height);
196 }
197
198 TEST(FlatInput, UpdatedData) {
199         const int width = 2;
200         const int height = 4;
201
202         float data[width * height] = {
203                 0.0, 1.0,
204                 0.5, 0.5,
205                 0.7, 0.2,
206                 1.0, 0.6,
207         };
208         float out_data[width * height];
209
210         EffectChainTester tester(NULL, width, height);
211
212         ImageFormat format;
213         format.color_space = COLORSPACE_sRGB;
214         format.gamma_curve = GAMMA_LINEAR;
215
216         FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, width, height);
217         input->set_pixel_data(data);
218         tester.get_chain()->add_input(input);
219
220         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
221         expect_equal(data, out_data, width, height);
222
223         data[6] = 0.3;
224         input->invalidate_pixel_data();
225
226         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
227         expect_equal(data, out_data, width, height);
228 }