Release Movit 1.3.2. (From a branch, since I do not want to break ABI compatibility...
[movit] / util.cpp
1 #include <epoxy/gl.h>
2 #include <assert.h>
3 #include <math.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <locale>
8 #include <sstream>
9 #include <string>
10 #include <Eigen/Core>
11
12 #include "fp16.h"
13 #include "init.h"
14 #include "util.h"
15
16 #if defined(__APPLE__)
17 #include <OpenGL/OpenGL.h>
18 #elif defined(WIN32)
19 #include <epoxy/wgl.h>
20 #else
21 #include <epoxy/glx.h>
22 #include <epoxy/egl.h>
23 #endif
24
25 using namespace std;
26
27 namespace movit {
28
29 extern string *movit_data_directory;
30
31 void hsv2rgb(float h, float s, float v, float *r, float *g, float *b)
32 {
33         if (h < 0.0f) {
34                 h += 2.0f * M_PI;
35         }
36         float c = v * s;
37         float hp = (h * 180.0 / M_PI) / 60.0;
38         float x = c * (1 - fabs(fmod(hp, 2.0f) - 1.0f));
39
40         if (hp >= 0 && hp < 1) {
41                 *r = c;
42                 *g = x;
43                 *b = 0.0f;
44         } else if (hp >= 1 && hp < 2) {
45                 *r = x;
46                 *g = c;
47                 *b = 0.0f;
48         } else if (hp >= 2 && hp < 3) {
49                 *r = 0.0f;
50                 *g = c;
51                 *b = x;
52         } else if (hp >= 3 && hp < 4) {
53                 *r = 0.0f;
54                 *g = x;
55                 *b = c;
56         } else if (hp >= 4 && hp < 5) {
57                 *r = x;
58                 *g = 0.0f;
59                 *b = c;
60         } else {
61                 *r = c;
62                 *g = 0.0f;
63                 *b = x;
64         }
65
66         float m = v - c;
67         *r += m;
68         *g += m;
69         *b += m;
70 }
71
72 void hsv2rgb_normalized(float h, float s, float v, float *r, float *g, float *b)
73 {
74         float ref_r, ref_g, ref_b;
75         hsv2rgb(h, s, v, r, g, b);
76         hsv2rgb(h, 0.0f, v, &ref_r, &ref_g, &ref_b);
77         float lum = 0.2126 * *r + 0.7152 * *g + 0.0722 * *b;
78         float ref_lum = 0.2126 * ref_r + 0.7152 * ref_g + 0.0722 * ref_b;
79         if (lum > 1e-3) {
80                 float fac = ref_lum / lum;
81                 *r *= fac;
82                 *g *= fac;
83                 *b *= fac;
84         }
85 }
86
87 string read_file(const string &filename)
88 {
89         const string full_pathname = *movit_data_directory + "/" + filename;
90
91         FILE *fp = fopen(full_pathname.c_str(), "r");
92         if (fp == NULL) {
93                 perror(full_pathname.c_str());
94                 exit(1);
95         }
96
97         int ret = fseek(fp, 0, SEEK_END);
98         if (ret == -1) {
99                 perror("fseek(SEEK_END)");
100                 exit(1);
101         }
102
103         int size = ftell(fp);
104
105         ret = fseek(fp, 0, SEEK_SET);
106         if (ret == -1) {
107                 perror("fseek(SEEK_SET)");
108                 exit(1);
109         }
110
111         string str;
112         str.resize(size);
113         ret = fread(&str[0], size, 1, fp);
114         if (ret == -1) {
115                 perror("fread");
116                 exit(1);
117         }
118         if (ret == 0) {
119                 fprintf(stderr, "Short read when trying to read %d bytes from %s\n",
120                         size, full_pathname.c_str());
121                 exit(1);
122         }
123         fclose(fp);
124
125         return str;
126 }
127
128 string read_version_dependent_file(const string &base, const string &extension)
129 {
130         if (movit_shader_model == MOVIT_GLSL_130) {
131                 return read_file(base + ".130." + extension);
132         } else if (movit_shader_model == MOVIT_GLSL_150) {
133                 return read_file(base + ".150." + extension);
134         } else if (movit_shader_model == MOVIT_ESSL_300) {
135                 return read_file(base + ".300es." + extension);
136         } else {
137                 assert(false);
138         }
139 }
140
141 GLuint compile_shader(const string &shader_src, GLenum type)
142 {
143         GLuint obj = glCreateShader(type);
144         const GLchar* source[] = { shader_src.data() };
145         const GLint length[] = { (GLint)shader_src.size() };
146         glShaderSource(obj, 1, source, length);
147         glCompileShader(obj);
148
149         GLchar info_log[4096];
150         GLsizei log_length = sizeof(info_log) - 1;
151         glGetShaderInfoLog(obj, log_length, &log_length, info_log);
152         info_log[log_length] = 0; 
153         if (strlen(info_log) > 0) {
154                 fprintf(stderr, "Shader compile log: %s\n", info_log);
155         }
156
157         GLint status;
158         glGetShaderiv(obj, GL_COMPILE_STATUS, &status);
159         if (status == GL_FALSE) {
160                 fprintf(stderr, "Failed to compile shader: %s\n", shader_src.c_str());
161                 exit(1);
162         }
163
164         return obj;
165 }
166
167 void print_3x3_matrix(const Eigen::Matrix3d& m)
168 {
169         printf("%6.4f %6.4f %6.4f\n", m(0,0), m(0,1), m(0,2));
170         printf("%6.4f %6.4f %6.4f\n", m(1,0), m(1,1), m(1,2));
171         printf("%6.4f %6.4f %6.4f\n", m(2,0), m(2,1), m(2,2));
172         printf("\n");
173 }
174
175 string output_glsl_mat3(const string &name, const Eigen::Matrix3d &m)
176 {
177         // Use stringstream to be independent of the current locale in a thread-safe manner.
178         stringstream ss;
179         ss.imbue(locale("C"));
180         ss.precision(8);
181         ss << scientific;
182         ss << "const mat3 " << name << " = mat3(\n";
183         ss << "    " << m(0,0) << ", " << m(1,0) << ", " << m(2,0) << ",\n";
184         ss << "    " << m(0,1) << ", " << m(1,1) << ", " << m(2,1) << ",\n";
185         ss << "    " << m(0,2) << ", " << m(1,2) << ", " << m(2,2) << ");\n\n";
186         return ss.str();
187 }
188
189 string output_glsl_float(const string &name, float x)
190 {
191         // Use stringstream to be independent of the current locale in a thread-safe manner.
192         stringstream ss;
193         ss.imbue(locale("C"));
194         ss.precision(8);
195         ss << scientific;
196         ss << "const float " << name << " = " << x << ";\n";
197         return ss.str();
198 }
199
200 string output_glsl_vec2(const string &name, float x, float y)
201 {
202         // Use stringstream to be independent of the current locale in a thread-safe manner.
203         stringstream ss;
204         ss.imbue(locale("C"));
205         ss.precision(8);
206         ss << scientific;
207         ss << "const vec2 " << name << " = vec2(" << x << ", " << y << ");\n";
208         return ss.str();
209 }
210
211 string output_glsl_vec3(const string &name, float x, float y, float z)
212 {
213         // Use stringstream to be independent of the current locale in a thread-safe manner.
214         stringstream ss;
215         ss.imbue(locale("C"));
216         ss.precision(8);
217         ss << scientific;
218         ss << "const vec3 " << name << " = vec3(" << x << ", " << y << ", " << z << ");\n";
219         return ss.str();
220 }
221
222 template<class DestFloat>
223 void combine_two_samples(float w1, float w2, float pos1, float pos2, float num_subtexels, float inv_num_subtexels,
224                          DestFloat *offset, DestFloat *total_weight, float *sum_sq_error)
225 {
226         assert(movit_initialized);
227         assert(w1 * w2 >= 0.0f);  // Should not have differing signs.
228         float z;  // Normalized 0..1 between pos1 and pos2.
229         if (fabs(w1 + w2) < 1e-6) {
230                 z = 0.5f;
231         } else {
232                 z = w2 / (w1 + w2);
233         }
234
235         // Round to the desired precision. Note that this might take z outside the 0..1 range.
236         *offset = from_fp32<DestFloat>(pos1 + z * (pos2 - pos1));
237         z = (to_fp32(*offset) - pos1) / (pos2 - pos1);
238
239         // Round to the minimum number of bits we have measured earlier.
240         // The card will do this for us anyway, but if we know what the real z
241         // is, we can pick a better total_weight below.
242         z = lrintf(z * num_subtexels) * inv_num_subtexels;
243         
244         // Choose total weight w so that we minimize total squared error
245         // for the effective weights:
246         //
247         //   e = (w(1-z) - a)² + (wz - b)²
248         //
249         // Differentiating by w and setting equal to zero:
250         //
251         //   2(w(1-z) - a)(1-z) + 2(wz - b)z = 0
252         //   w(1-z)² - a(1-z) + wz² - bz = 0
253         //   w((1-z)² + z²) = a(1-z) + bz
254         //   w = (a(1-z) + bz) / ((1-z)² + z²)
255         //
256         // If z had infinite precision, this would simply reduce to w = w1 + w2.
257         *total_weight = from_fp32<DestFloat>((w1 + z * (w2 - w1)) / (z * z + (1 - z) * (1 - z)));
258
259         if (sum_sq_error != NULL) {
260                 float err1 = to_fp32(*total_weight) * (1 - z) - w1;
261                 float err2 = to_fp32(*total_weight) * z - w2;
262                 *sum_sq_error = err1 * err1 + err2 * err2;
263         }
264 }
265
266 // Explicit instantiations.
267 template
268 void combine_two_samples<float>(float w1, float w2, float pos1, float pos2, float num_subtexels, float inv_num_subtexels,
269                                 float *offset, float *total_weight, float *sum_sq_error);
270
271 template
272 void combine_two_samples<fp16_int_t>(float w1, float w2, float pos1, float pos2, float num_subtexels, float inv_num_subtexels,
273                                      fp16_int_t *offset, fp16_int_t *total_weight, float *sum_sq_error);
274
275 GLuint generate_vbo(GLint size, GLenum type, GLsizeiptr data_size, const GLvoid *data)
276 {
277         GLuint vbo;
278         glGenBuffers(1, &vbo);
279         check_error();
280         glBindBuffer(GL_ARRAY_BUFFER, vbo);
281         check_error();
282         glBufferData(GL_ARRAY_BUFFER, data_size, data, GL_STATIC_DRAW);
283         check_error();
284         glBindBuffer(GL_ARRAY_BUFFER, 0);
285         check_error();
286
287         return vbo;
288 }
289
290 GLuint fill_vertex_attribute(GLuint glsl_program_num, const string &attribute_name, GLint size, GLenum type, GLsizeiptr data_size, const GLvoid *data)
291 {
292         int attrib = glGetAttribLocation(glsl_program_num, attribute_name.c_str());
293         if (attrib == -1) {
294                 return -1;
295         }
296
297         GLuint vbo = generate_vbo(size, type, data_size, data);
298
299         glBindBuffer(GL_ARRAY_BUFFER, vbo);
300         check_error();
301         glEnableVertexAttribArray(attrib);
302         check_error();
303         glVertexAttribPointer(attrib, size, type, GL_FALSE, 0, BUFFER_OFFSET(0));
304         check_error();
305         glBindBuffer(GL_ARRAY_BUFFER, 0);
306         check_error();
307
308         return vbo;
309 }
310
311 void cleanup_vertex_attribute(GLuint glsl_program_num, const string &attribute_name, GLuint vbo)
312 {
313         int attrib = glGetAttribLocation(glsl_program_num, attribute_name.c_str());
314         if (attrib == -1) {
315                 return;
316         }
317
318         glDisableVertexAttribArray(attrib);
319         check_error();
320         glDeleteBuffers(1, &vbo);
321         check_error();
322 }
323
324 unsigned div_round_up(unsigned a, unsigned b)
325 {
326         return (a + b - 1) / b;
327 }
328
329 // Algorithm from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2.
330 unsigned next_power_of_two(unsigned v)
331 {
332         v--;
333         v |= v >> 1;
334         v |= v >> 2;
335         v |= v >> 4;
336         v |= v >> 8;
337         v |= v >> 16;
338         v++;
339         return v;
340 }
341
342 void *get_gl_context_identifier()
343 {
344 #if defined(__APPLE__)
345         return (void *)CGLGetCurrentContext();
346 #elif defined(WIN32)
347         return (void *)wglGetCurrentContext();
348 #else
349         void *ret = (void *)eglGetCurrentContext();
350         if (ret != NULL) {
351                 return ret;
352         }
353         return (void *)glXGetCurrentContext();
354 #endif
355 }
356
357 }  // namespace movit