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