#define NO_SDL_GLEXT 1
-#define WIDTH 1280
-#define HEIGHT 720
-
#include <epoxy/gl.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_video.h>
#include <assert.h>
+#include <getopt.h>
#include <stdio.h>
#include <unistd.h>
#include <algorithm>
#include <memory>
+#include <map>
+#include <vector>
#define BUFFER_OFFSET(i) ((char *)nullptr + (i))
constexpr unsigned finest_level = 1;
constexpr unsigned patch_size_pixels = 12;
+// Weighting constants for the different parts of the variational refinement.
+// These don't correspond 1:1 to the values given in the DIS paper,
+// since we have different normalizations and ranges in some cases.
+float vr_gamma = 10.0f, vr_delta = 5.0f, vr_alpha = 10.0f;
+
+bool enable_timing = true;
+bool enable_variational_refinement = true; // Just for debugging.
+
// Some global OpenGL objects.
+// TODO: These should really be part of DISComputeFlow.
GLuint nearest_sampler, linear_sampler, smoothness_sampler;
GLuint vertex_vbo;
return obj;
}
-
-GLuint load_texture(const char *filename, unsigned width, unsigned height)
+GLuint load_texture(const char *filename, unsigned *width_ret, unsigned *height_ret)
{
- FILE *fp = fopen(filename, "rb");
- if (fp == nullptr) {
- perror(filename);
+ SDL_Surface *surf = IMG_Load(filename);
+ if (surf == nullptr) {
+ fprintf(stderr, "IMG_Load(%s): %s\n", filename, IMG_GetError());
exit(1);
}
- unique_ptr<uint8_t[]> pix(new uint8_t[width * height]);
- if (fread(pix.get(), width * height, 1, fp) != 1) {
- fprintf(stderr, "Short read from %s\n", filename);
+
+ // For whatever reason, SDL doesn't support converting to YUV surfaces
+ // nor grayscale, so we'll do it (slowly) ourselves.
+ SDL_Surface *rgb_surf = SDL_ConvertSurfaceFormat(surf, SDL_PIXELFORMAT_RGBA8888, /*flags=*/0);
+ if (rgb_surf == nullptr) {
+ fprintf(stderr, "SDL_ConvertSurfaceFormat(%s): %s\n", filename, SDL_GetError());
exit(1);
}
- fclose(fp);
- // Convert to bottom-left origin.
- for (unsigned y = 0; y < height / 2; ++y) {
+ SDL_FreeSurface(surf);
+
+ unsigned width = rgb_surf->w, height = rgb_surf->h;
+ const uint8_t *sptr = (uint8_t *)rgb_surf->pixels;
+ unique_ptr<uint8_t[]> pix(new uint8_t[width * height]);
+
+ // Extract the Y component, and convert to bottom-left origin.
+ for (unsigned y = 0; y < height; ++y) {
unsigned y2 = height - 1 - y;
- swap_ranges(&pix[y * width], &pix[y * width + width], &pix[y2 * width]);
+ for (unsigned x = 0; x < width; ++x) {
+ uint8_t r = sptr[(y2 * width + x) * 4 + 3];
+ uint8_t g = sptr[(y2 * width + x) * 4 + 2];
+ uint8_t b = sptr[(y2 * width + x) * 4 + 1];
+
+ // Rec. 709.
+ pix[y * width + x] = lrintf(r * 0.2126f + g * 0.7152f + b * 0.0722f);
+ }
}
+ SDL_FreeSurface(rgb_surf);
int levels = 1;
for (int w = width, h = height; w > 1 || h > 1; ) {
glTextureSubImage2D(tex, 0, 0, 0, width, height, GL_RED, GL_UNSIGNED_BYTE, pix.get());
glGenerateTextureMipmap(tex);
+ *width_ret = width;
+ *height_ret = height;
+
return tex;
}
glProgramUniform1i(program, location, texture_unit);
}
+// A class that caches FBOs that render to a given set of textures.
+// It never frees anything, so it is only suitable for rendering to
+// the same (small) set of textures over and over again.
+template<size_t num_elements>
+class PersistentFBOSet {
+public:
+ void render_to(const array<GLuint, num_elements> &textures);
+
+ // Convenience wrappers.
+ void render_to(GLuint texture0, enable_if<num_elements == 1> * = nullptr) {
+ render_to({{texture0}});
+ }
+
+ void render_to(GLuint texture0, GLuint texture1, enable_if<num_elements == 2> * = nullptr) {
+ render_to({{texture0, texture1}});
+ }
+
+ void render_to(GLuint texture0, GLuint texture1, GLuint texture2, enable_if<num_elements == 3> * = nullptr) {
+ render_to({{texture0, texture1, texture2}});
+ }
+
+ void render_to(GLuint texture0, GLuint texture1, GLuint texture2, GLuint texture3, enable_if<num_elements == 4> * = nullptr) {
+ render_to({{texture0, texture1, texture2, texture3}});
+ }
+
+private:
+ // TODO: Delete these on destruction.
+ map<array<GLuint, num_elements>, GLuint> fbos;
+};
+
+template<size_t num_elements>
+void PersistentFBOSet<num_elements>::render_to(const array<GLuint, num_elements> &textures)
+{
+ auto it = fbos.find(textures);
+ if (it != fbos.end()) {
+ glBindFramebuffer(GL_FRAMEBUFFER, it->second);
+ return;
+ }
+
+ GLuint fbo;
+ glCreateFramebuffers(1, &fbo);
+ GLenum bufs[num_elements];
+ for (size_t i = 0; i < num_elements; ++i) {
+ glNamedFramebufferTexture(fbo, GL_COLOR_ATTACHMENT0 + i, textures[i], 0);
+ bufs[i] = GL_COLOR_ATTACHMENT0 + i;
+ }
+ glNamedFramebufferDrawBuffers(fbo, num_elements, bufs);
+
+ fbos[textures] = fbo;
+ glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+}
+
// Compute gradients in every point, used for the motion search.
// The DIS paper doesn't actually mention how these are computed,
// but seemingly, a 3x3 Sobel operator is used here (at least in
void exec(GLint tex0_view, GLint grad0_tex, int level_width, int level_height);
private:
+ PersistentFBOSet<1> fbos;
GLuint sobel_vs_obj;
GLuint sobel_fs_obj;
GLuint sobel_program;
glBindSampler(0, nearest_sampler);
glProgramUniform1i(sobel_program, uniform_tex, 0);
- GLuint grad0_fbo; // TODO: cleanup
- glCreateFramebuffers(1, &grad0_fbo);
- glNamedFramebufferTexture(grad0_fbo, GL_COLOR_ATTACHMENT0, grad0_tex, 0);
-
glViewport(0, 0, level_width, level_height);
- glBindFramebuffer(GL_FRAMEBUFFER, grad0_fbo);
+ fbos.render_to(grad0_tex);
glBindVertexArray(sobel_vao);
glUseProgram(sobel_program);
glDisable(GL_BLEND);
class MotionSearch {
public:
MotionSearch();
- void exec(GLuint tex0_view, GLuint tex1_view, GLuint grad0_tex, GLuint flow_tex, GLuint flow_out_tex, int level_width, int level_height, int width_patches, int height_patches);
+ void exec(GLuint tex0_view, GLuint tex1_view, GLuint grad0_tex, GLuint flow_tex, GLuint flow_out_tex, int level_width, int level_height, int prev_level_width, int prev_level_height, int width_patches, int height_patches);
private:
+ PersistentFBOSet<1> fbos;
+
GLuint motion_vs_obj;
GLuint motion_fs_obj;
GLuint motion_search_program;
GLuint motion_search_vao;
- GLuint uniform_image_size, uniform_inv_image_size;
+ GLuint uniform_image_size, uniform_inv_image_size, uniform_inv_flow_size, uniform_inv_prev_level_size;
GLuint uniform_image0_tex, uniform_image1_tex, uniform_grad0_tex, uniform_flow_tex;
};
uniform_image_size = glGetUniformLocation(motion_search_program, "image_size");
uniform_inv_image_size = glGetUniformLocation(motion_search_program, "inv_image_size");
+ uniform_inv_flow_size = glGetUniformLocation(motion_search_program, "inv_flow_size");
+ uniform_inv_prev_level_size = glGetUniformLocation(motion_search_program, "inv_prev_level_size");
uniform_image0_tex = glGetUniformLocation(motion_search_program, "image0_tex");
uniform_image1_tex = glGetUniformLocation(motion_search_program, "image1_tex");
uniform_grad0_tex = glGetUniformLocation(motion_search_program, "grad0_tex");
uniform_flow_tex = glGetUniformLocation(motion_search_program, "flow_tex");
}
-void MotionSearch::exec(GLuint tex0_view, GLuint tex1_view, GLuint grad0_tex, GLuint flow_tex, GLuint flow_out_tex, int level_width, int level_height, int width_patches, int height_patches)
+void MotionSearch::exec(GLuint tex0_view, GLuint tex1_view, GLuint grad0_tex, GLuint flow_tex, GLuint flow_out_tex, int level_width, int level_height, int prev_level_width, int prev_level_height, int width_patches, int height_patches)
{
glUseProgram(motion_search_program);
glProgramUniform2f(motion_search_program, uniform_image_size, level_width, level_height);
glProgramUniform2f(motion_search_program, uniform_inv_image_size, 1.0f / level_width, 1.0f / level_height);
-
- GLuint flow_fbo; // TODO: cleanup
- glCreateFramebuffers(1, &flow_fbo);
- glNamedFramebufferTexture(flow_fbo, GL_COLOR_ATTACHMENT0, flow_out_tex, 0);
+ glProgramUniform2f(motion_search_program, uniform_inv_flow_size, 1.0f / width_patches, 1.0f / height_patches);
+ glProgramUniform2f(motion_search_program, uniform_inv_prev_level_size, 1.0f / prev_level_width, 1.0f / prev_level_height);
glViewport(0, 0, width_patches, height_patches);
- glBindFramebuffer(GL_FRAMEBUFFER, flow_fbo);
+ fbos.render_to(flow_out_tex);
glBindVertexArray(motion_search_vao);
glUseProgram(motion_search_program);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
void exec(GLuint tex0_view, GLuint tex1_view, GLuint flow_tex, GLuint dense_flow_tex, int level_width, int level_height, int width_patches, int height_patches);
private:
+ PersistentFBOSet<1> fbos;
+
GLuint densify_vs_obj;
GLuint densify_fs_obj;
GLuint densify_program;
float patch_spacing_x = float(level_width - patch_size_pixels) / (width_patches - 1);
float patch_spacing_y = float(level_height - patch_size_pixels) / (height_patches - 1);
+ if (width_patches == 1) patch_spacing_x = 0.0f; // Avoid infinities.
+ if (height_patches == 1) patch_spacing_y = 0.0f;
glProgramUniform2f(densify_program, uniform_patch_spacing,
patch_spacing_x / level_width,
patch_spacing_y / level_height);
- GLuint dense_flow_fbo; // TODO: cleanup
- glCreateFramebuffers(1, &dense_flow_fbo);
- glNamedFramebufferTexture(dense_flow_fbo, GL_COLOR_ATTACHMENT0, dense_flow_tex, 0);
-
glViewport(0, 0, level_width, level_height);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glBindVertexArray(densify_vao);
- glBindFramebuffer(GL_FRAMEBUFFER, dense_flow_fbo);
+ fbos.render_to(dense_flow_tex);
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, width_patches * height_patches);
}
// I_0 and I_w. The prewarping is what enables us to solve the variational
// flow for du,dv instead of u,v.
//
+// Also calculates the normalized flow, ie. divides by z (this is needed because
+// Densify works by additive blending) and multiplies by the image size.
+//
// See variational_refinement.txt for more information.
class Prewarp {
public:
Prewarp();
- void exec(GLuint tex0_view, GLuint tex1_view, GLuint flow_tex, GLuint I_tex, GLuint I_t_tex, int level_width, int level_height);
+ void exec(GLuint tex0_view, GLuint tex1_view, GLuint flow_tex, GLuint normalized_flow_tex, GLuint I_tex, GLuint I_t_tex, int level_width, int level_height);
private:
+ PersistentFBOSet<3> fbos;
+
GLuint prewarp_vs_obj;
GLuint prewarp_fs_obj;
GLuint prewarp_program;
GLuint prewarp_vao;
GLuint uniform_image0_tex, uniform_image1_tex, uniform_flow_tex;
+ GLuint uniform_image_size;
};
Prewarp::Prewarp()
uniform_image0_tex = glGetUniformLocation(prewarp_program, "image0_tex");
uniform_image1_tex = glGetUniformLocation(prewarp_program, "image1_tex");
uniform_flow_tex = glGetUniformLocation(prewarp_program, "flow_tex");
+
+ uniform_image_size = glGetUniformLocation(prewarp_program, "image_size");
}
-void Prewarp::exec(GLuint tex0_view, GLuint tex1_view, GLuint flow_tex, GLuint I_tex, GLuint I_t_tex, int level_width, int level_height)
+void Prewarp::exec(GLuint tex0_view, GLuint tex1_view, GLuint flow_tex, GLuint I_tex, GLuint I_t_tex, GLuint normalized_flow_tex, int level_width, int level_height)
{
glUseProgram(prewarp_program);
bind_sampler(prewarp_program, uniform_image1_tex, 1, tex1_view, linear_sampler);
bind_sampler(prewarp_program, uniform_flow_tex, 2, flow_tex, nearest_sampler);
- GLuint prewarp_fbo; // TODO: cleanup
- glCreateFramebuffers(1, &prewarp_fbo);
- GLenum bufs[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
- glNamedFramebufferDrawBuffers(prewarp_fbo, 2, bufs);
- glNamedFramebufferTexture(prewarp_fbo, GL_COLOR_ATTACHMENT0, I_tex, 0);
- glNamedFramebufferTexture(prewarp_fbo, GL_COLOR_ATTACHMENT1, I_t_tex, 0);
+ glProgramUniform2f(prewarp_program, uniform_image_size, level_width, level_height);
glViewport(0, 0, level_width, level_height);
glDisable(GL_BLEND);
glBindVertexArray(prewarp_vao);
- glBindFramebuffer(GL_FRAMEBUFFER, prewarp_fbo);
+ fbos.render_to(I_tex, I_t_tex, normalized_flow_tex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
void exec(GLuint input_tex, GLuint I_x_y_tex, GLuint beta_0_tex, int level_width, int level_height);
private:
+ PersistentFBOSet<2> fbos;
+
GLuint derivatives_vs_obj;
GLuint derivatives_fs_obj;
GLuint derivatives_program;
bind_sampler(derivatives_program, uniform_tex, 0, input_tex, nearest_sampler);
- GLuint derivatives_fbo; // TODO: cleanup
- glCreateFramebuffers(1, &derivatives_fbo);
- GLenum bufs[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
- glNamedFramebufferDrawBuffers(derivatives_fbo, 2, bufs);
- glNamedFramebufferTexture(derivatives_fbo, GL_COLOR_ATTACHMENT0, I_x_y_tex, 0);
- glNamedFramebufferTexture(derivatives_fbo, GL_COLOR_ATTACHMENT1, beta_0_tex, 0);
-
glViewport(0, 0, level_width, level_height);
glDisable(GL_BLEND);
glBindVertexArray(derivatives_vao);
- glBindFramebuffer(GL_FRAMEBUFFER, derivatives_fbo);
+ fbos.render_to(I_x_y_tex, beta_0_tex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
void exec(GLuint flow_tex, GLuint diff_flow_tex, GLuint smoothness_x_tex, GLuint smoothness_y_tex, int level_width, int level_height);
private:
+ PersistentFBOSet<2> fbos;
+
GLuint smoothness_vs_obj;
GLuint smoothness_fs_obj;
GLuint smoothness_program;
GLuint smoothness_vao;
GLuint uniform_flow_tex, uniform_diff_flow_tex;
+ GLuint uniform_alpha;
};
ComputeSmoothness::ComputeSmoothness()
uniform_flow_tex = glGetUniformLocation(smoothness_program, "flow_tex");
uniform_diff_flow_tex = glGetUniformLocation(smoothness_program, "diff_flow_tex");
+ uniform_alpha = glGetUniformLocation(smoothness_program, "alpha");
}
void ComputeSmoothness::exec(GLuint flow_tex, GLuint diff_flow_tex, GLuint smoothness_x_tex, GLuint smoothness_y_tex, int level_width, int level_height)
bind_sampler(smoothness_program, uniform_flow_tex, 0, flow_tex, nearest_sampler);
bind_sampler(smoothness_program, uniform_diff_flow_tex, 1, diff_flow_tex, nearest_sampler);
-
- GLuint smoothness_fbo; // TODO: cleanup
- glCreateFramebuffers(1, &smoothness_fbo);
- GLenum bufs[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
- glNamedFramebufferDrawBuffers(smoothness_fbo, 2, bufs);
- glNamedFramebufferTexture(smoothness_fbo, GL_COLOR_ATTACHMENT0, smoothness_x_tex, 0);
- glNamedFramebufferTexture(smoothness_fbo, GL_COLOR_ATTACHMENT1, smoothness_y_tex, 0);
+ glProgramUniform1f(smoothness_program, uniform_alpha, vr_alpha);
glViewport(0, 0, level_width, level_height);
- // Make sure the smoothness on the right and upper borders is zero.
- // We could have done this by making a (W-1)x(H-1) texture instead
- // (we're sampling smoothness with all-zero border color), but we'd
- // have to adjust the sampling coordinates, which is annoying.
- glScissor(0, 0, level_width - 1, level_height - 1);
- glEnable(GL_SCISSOR_TEST);
-
glDisable(GL_BLEND);
glBindVertexArray(smoothness_vao);
- glBindFramebuffer(GL_FRAMEBUFFER, smoothness_fbo);
+ fbos.render_to(smoothness_x_tex, smoothness_y_tex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
- glDisable(GL_SCISSOR_TEST);
+ // Make sure the smoothness on the right and upper borders is zero.
+ // We could have done this by making (W-1)xH and Wx(H-1) textures instead
+ // (we're sampling smoothness with all-zero border color), but we'd
+ // have to adjust the sampling coordinates, which is annoying.
+ glClearTexSubImage(smoothness_x_tex, 0, level_width - 1, 0, 0, 1, level_height, 1, GL_RED, GL_FLOAT, nullptr);
+ glClearTexSubImage(smoothness_y_tex, 0, 0, level_height - 1, 0, level_width, 1, 1, GL_RED, GL_FLOAT, nullptr);
}
// Set up the equations set (two equations in two unknowns, per pixel).
void exec(GLuint I_x_y_tex, GLuint I_t_tex, GLuint diff_flow_tex, GLuint flow_tex, GLuint beta_0_tex, GLuint smoothness_x_tex, GLuint smoothness_y_tex, GLuint equation_tex, int level_width, int level_height);
private:
+ PersistentFBOSet<1> fbos;
+
GLuint equations_vs_obj;
GLuint equations_fs_obj;
GLuint equations_program;
GLuint equations_vao;
GLuint uniform_I_x_y_tex, uniform_I_t_tex;
- GLuint uniform_diff_flow_tex, uniform_flow_tex;
+ GLuint uniform_diff_flow_tex, uniform_base_flow_tex;
GLuint uniform_beta_0_tex;
GLuint uniform_smoothness_x_tex, uniform_smoothness_y_tex;
-
+ GLuint uniform_gamma, uniform_delta;
};
SetupEquations::SetupEquations()
uniform_I_x_y_tex = glGetUniformLocation(equations_program, "I_x_y_tex");
uniform_I_t_tex = glGetUniformLocation(equations_program, "I_t_tex");
uniform_diff_flow_tex = glGetUniformLocation(equations_program, "diff_flow_tex");
- uniform_flow_tex = glGetUniformLocation(equations_program, "flow_tex");
+ uniform_base_flow_tex = glGetUniformLocation(equations_program, "base_flow_tex");
uniform_beta_0_tex = glGetUniformLocation(equations_program, "beta_0_tex");
uniform_smoothness_x_tex = glGetUniformLocation(equations_program, "smoothness_x_tex");
uniform_smoothness_y_tex = glGetUniformLocation(equations_program, "smoothness_y_tex");
+ uniform_gamma = glGetUniformLocation(equations_program, "gamma");
+ uniform_delta = glGetUniformLocation(equations_program, "delta");
}
-void SetupEquations::exec(GLuint I_x_y_tex, GLuint I_t_tex, GLuint diff_flow_tex, GLuint flow_tex, GLuint beta_0_tex, GLuint smoothness_x_tex, GLuint smoothness_y_tex, GLuint equation_tex, int level_width, int level_height)
+void SetupEquations::exec(GLuint I_x_y_tex, GLuint I_t_tex, GLuint diff_flow_tex, GLuint base_flow_tex, GLuint beta_0_tex, GLuint smoothness_x_tex, GLuint smoothness_y_tex, GLuint equation_tex, int level_width, int level_height)
{
glUseProgram(equations_program);
bind_sampler(equations_program, uniform_I_x_y_tex, 0, I_x_y_tex, nearest_sampler);
bind_sampler(equations_program, uniform_I_t_tex, 1, I_t_tex, nearest_sampler);
bind_sampler(equations_program, uniform_diff_flow_tex, 2, diff_flow_tex, nearest_sampler);
- bind_sampler(equations_program, uniform_flow_tex, 3, flow_tex, nearest_sampler);
+ bind_sampler(equations_program, uniform_base_flow_tex, 3, base_flow_tex, nearest_sampler);
bind_sampler(equations_program, uniform_beta_0_tex, 4, beta_0_tex, nearest_sampler);
bind_sampler(equations_program, uniform_smoothness_x_tex, 5, smoothness_x_tex, smoothness_sampler);
bind_sampler(equations_program, uniform_smoothness_y_tex, 6, smoothness_y_tex, smoothness_sampler);
-
- GLuint equations_fbo; // TODO: cleanup
- glCreateFramebuffers(1, &equations_fbo);
- glNamedFramebufferTexture(equations_fbo, GL_COLOR_ATTACHMENT0, equation_tex, 0);
+ glProgramUniform1f(equations_program, uniform_delta, vr_delta);
+ glProgramUniform1f(equations_program, uniform_gamma, vr_gamma);
glViewport(0, 0, level_width, level_height);
glDisable(GL_BLEND);
glBindVertexArray(equations_vao);
- glBindFramebuffer(GL_FRAMEBUFFER, equations_fbo);
+ fbos.render_to(equation_tex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
-// Calculate the smoothness constraints between neighboring pixels;
-// s_x(x,y) stores smoothness between pixel (x,y) and (x+1,y),
-// and s_y(x,y) stores between (x,y) and (x,y+1). We'll sample with
-// border color (0,0) later, so that there's zero diffusion out of
-// the border.
+// Actually solve the equation sets made by SetupEquations, by means of
+// successive over-relaxation (SOR).
//
// See variational_refinement.txt for more information.
class SOR {
void exec(GLuint diff_flow_tex, GLuint equation_tex, GLuint smoothness_x_tex, GLuint smoothness_y_tex, int level_width, int level_height, int num_iterations);
private:
+ PersistentFBOSet<1> fbos;
+
GLuint sor_vs_obj;
GLuint sor_fs_obj;
GLuint sor_program;
bind_sampler(sor_program, uniform_smoothness_y_tex, 2, smoothness_y_tex, smoothness_sampler);
bind_sampler(sor_program, uniform_equation_tex, 3, equation_tex, nearest_sampler);
- GLuint sor_fbo; // TODO: cleanup
- glCreateFramebuffers(1, &sor_fbo);
- glNamedFramebufferTexture(sor_fbo, GL_COLOR_ATTACHMENT0, diff_flow_tex, 0); // NOTE: Bind to same as we render from!
-
glViewport(0, 0, level_width, level_height);
glDisable(GL_BLEND);
glBindVertexArray(sor_vao);
- glBindFramebuffer(GL_FRAMEBUFFER, sor_fbo);
+ fbos.render_to(diff_flow_tex); // NOTE: Bind to same as we render from!
for (int i = 0; i < num_iterations; ++i) {
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
// Simply add the differential flow found by the variational refinement to the base flow.
-// The output is in diff_flow_tex; we don't need to make a new texture.
+// The output is in base_flow_tex; we don't need to make a new texture.
class AddBaseFlow {
public:
AddBaseFlow();
void exec(GLuint base_flow_tex, GLuint diff_flow_tex, int level_width, int level_height);
private:
+ PersistentFBOSet<1> fbos;
+
GLuint add_flow_vs_obj;
GLuint add_flow_fs_obj;
GLuint add_flow_program;
GLuint add_flow_vao;
- GLuint uniform_base_flow_tex;
+ GLuint uniform_diff_flow_tex;
};
AddBaseFlow::AddBaseFlow()
glEnableVertexArrayAttrib(add_flow_vao, position_attrib);
glVertexAttribPointer(position_attrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
- uniform_base_flow_tex = glGetUniformLocation(add_flow_program, "base_flow_tex");
+ uniform_diff_flow_tex = glGetUniformLocation(add_flow_program, "diff_flow_tex");
}
void AddBaseFlow::exec(GLuint base_flow_tex, GLuint diff_flow_tex, int level_width, int level_height)
{
glUseProgram(add_flow_program);
- bind_sampler(add_flow_program, uniform_base_flow_tex, 0, base_flow_tex, nearest_sampler);
-
- GLuint add_flow_fbo; // TODO: cleanup
- glCreateFramebuffers(1, &add_flow_fbo);
- glNamedFramebufferTexture(add_flow_fbo, GL_COLOR_ATTACHMENT0, diff_flow_tex, 0);
+ bind_sampler(add_flow_program, uniform_diff_flow_tex, 0, diff_flow_tex, nearest_sampler);
glViewport(0, 0, level_width, level_height);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glBindVertexArray(add_flow_vao);
- glBindFramebuffer(GL_FRAMEBUFFER, add_flow_fbo);
+ fbos.render_to(base_flow_tex);
+
+ glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+}
+
+// Take a copy of the flow, bilinearly interpolated and scaled up.
+class ResizeFlow {
+public:
+ ResizeFlow();
+ void exec(GLuint in_tex, GLuint out_tex, int input_width, int input_height, int output_width, int output_height);
+
+private:
+ PersistentFBOSet<1> fbos;
+
+ GLuint resize_flow_vs_obj;
+ GLuint resize_flow_fs_obj;
+ GLuint resize_flow_program;
+ GLuint resize_flow_vao;
+
+ GLuint uniform_flow_tex;
+ GLuint uniform_scale_factor;
+};
+
+ResizeFlow::ResizeFlow()
+{
+ resize_flow_vs_obj = compile_shader(read_file("vs.vert"), GL_VERTEX_SHADER);
+ resize_flow_fs_obj = compile_shader(read_file("resize_flow.frag"), GL_FRAGMENT_SHADER);
+ resize_flow_program = link_program(resize_flow_vs_obj, resize_flow_fs_obj);
+
+ // Set up the VAO containing all the required position/texcoord data.
+ glCreateVertexArrays(1, &resize_flow_vao);
+ glBindVertexArray(resize_flow_vao);
+ glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
+
+ GLint position_attrib = glGetAttribLocation(resize_flow_program, "position");
+ glEnableVertexArrayAttrib(resize_flow_vao, position_attrib);
+ glVertexAttribPointer(position_attrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
+
+ uniform_flow_tex = glGetUniformLocation(resize_flow_program, "flow_tex");
+ uniform_scale_factor = glGetUniformLocation(resize_flow_program, "scale_factor");
+}
+
+void ResizeFlow::exec(GLuint flow_tex, GLuint out_tex, int input_width, int input_height, int output_width, int output_height)
+{
+ glUseProgram(resize_flow_program);
+
+ bind_sampler(resize_flow_program, uniform_flow_tex, 0, flow_tex, nearest_sampler);
+
+ glProgramUniform2f(resize_flow_program, uniform_scale_factor, float(output_width) / input_width, float(output_height) / input_height);
+
+ glViewport(0, 0, output_width, output_height);
+ glDisable(GL_BLEND);
+ glBindVertexArray(resize_flow_vao);
+ fbos.render_to(out_tex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
-int main(void)
+class GPUTimers {
+public:
+ void print();
+ pair<GLuint, GLuint> begin_timer(const string &name, int level);
+
+private:
+ struct Timer {
+ string name;
+ int level;
+ pair<GLuint, GLuint> query;
+ };
+ vector<Timer> timers;
+};
+
+pair<GLuint, GLuint> GPUTimers::begin_timer(const string &name, int level)
{
- if (SDL_Init(SDL_INIT_EVERYTHING) == -1) {
- fprintf(stderr, "SDL_Init failed: %s\n", SDL_GetError());
- exit(1);
+ if (!enable_timing) {
+ return make_pair(0, 0);
}
- SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
- SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
- SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
- SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
- // SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
- SDL_Window *window = SDL_CreateWindow("OpenGL window",
- SDL_WINDOWPOS_UNDEFINED,
- SDL_WINDOWPOS_UNDEFINED,
- 64, 64,
- SDL_WINDOW_OPENGL);
- SDL_GLContext context = SDL_GL_CreateContext(window);
- assert(context != nullptr);
+ GLuint queries[2];
+ glGenQueries(2, queries);
+ glQueryCounter(queries[0], GL_TIMESTAMP);
+
+ Timer timer;
+ timer.name = name;
+ timer.level = level;
+ timer.query.first = queries[0];
+ timer.query.second = queries[1];
+ timers.push_back(timer);
+ return timer.query;
+}
- // Load pictures.
- GLuint tex0 = load_texture("test1499.pgm", WIDTH, HEIGHT);
- GLuint tex1 = load_texture("test1500.pgm", WIDTH, HEIGHT);
+void GPUTimers::print()
+{
+ for (const Timer &timer : timers) {
+ // NOTE: This makes the CPU wait for the GPU.
+ GLuint64 time_start, time_end;
+ glGetQueryObjectui64v(timer.query.first, GL_QUERY_RESULT, &time_start);
+ glGetQueryObjectui64v(timer.query.second, GL_QUERY_RESULT, &time_end);
+ //fprintf(stderr, "GPU time used = %.1f ms\n", time_elapsed / 1e6);
+ for (int i = 0; i < timer.level * 2; ++i) {
+ fprintf(stderr, " ");
+ }
+ fprintf(stderr, "%-30s %4.1f ms\n", timer.name.c_str(), GLint64(time_end - time_start) / 1e6);
+ }
+}
+// A simple RAII class for timing until the end of the scope.
+class ScopedTimer {
+public:
+ ScopedTimer(const string &name, GPUTimers *timers)
+ : timers(timers), level(0)
+ {
+ query = timers->begin_timer(name, level);
+ }
+
+ ScopedTimer(const string &name, ScopedTimer *parent_timer)
+ : timers(parent_timer->timers),
+ level(parent_timer->level + 1)
+ {
+ query = timers->begin_timer(name, level);
+ }
+
+ ~ScopedTimer()
+ {
+ end();
+ }
+
+ void end()
+ {
+ if (enable_timing && !ended) {
+ glQueryCounter(query.second, GL_TIMESTAMP);
+ ended = true;
+ }
+ }
+
+private:
+ GPUTimers *timers;
+ int level;
+ pair<GLuint, GLuint> query;
+ bool ended = false;
+};
+
+class DISComputeFlow {
+public:
+ DISComputeFlow(int width, int height);
+
+ // Returns a texture that must be released with release_texture()
+ // after use.
+ GLuint exec(GLuint tex0, GLuint tex1);
+ void release_texture(GLuint tex);
+
+private:
+ int width, height;
+ GLuint initial_flow_tex;
+
+ // The various passes.
+ Sobel sobel;
+ MotionSearch motion_search;
+ Densify densify;
+ Prewarp prewarp;
+ Derivatives derivatives;
+ ComputeSmoothness compute_smoothness;
+ SetupEquations setup_equations;
+ SOR sor;
+ AddBaseFlow add_base_flow;
+ ResizeFlow resize_flow;
+
+ struct Texture {
+ GLuint tex_num;
+ GLenum format;
+ GLuint width, height;
+ bool in_use = false;
+ };
+ vector<Texture> textures;
+
+ GLuint get_texture(GLenum format, GLuint width, GLuint height);
+};
+
+DISComputeFlow::DISComputeFlow(int width, int height)
+ : width(width), height(height)
+{
// Make some samplers.
glCreateSamplers(1, &nearest_sampler);
glSamplerParameteri(nearest_sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
float zero[] = { 0.0f, 0.0f, 0.0f, 0.0f };
glSamplerParameterfv(smoothness_sampler, GL_TEXTURE_BORDER_COLOR, zero);
- float vertices[] = {
- 0.0f, 1.0f,
- 0.0f, 0.0f,
- 1.0f, 1.0f,
- 1.0f, 0.0f,
- };
- glCreateBuffers(1, &vertex_vbo);
- glNamedBufferData(vertex_vbo, sizeof(vertices), vertices, GL_STATIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
-
// Initial flow is zero, 1x1.
- GLuint initial_flow_tex;
glCreateTextures(GL_TEXTURE_2D, 1, &initial_flow_tex);
glTextureStorage2D(initial_flow_tex, 1, GL_RG16F, 1, 1);
+ glClearTexImage(initial_flow_tex, 0, GL_RG, GL_FLOAT, nullptr);
+}
- GLuint prev_level_flow_tex = initial_flow_tex;
+GLuint DISComputeFlow::exec(GLuint tex0, GLuint tex1)
+{
+ for (const Texture &tex : textures) {
+ assert(!tex.in_use);
+ }
- Sobel sobel;
- MotionSearch motion_search;
- Densify densify;
- Prewarp prewarp;
- Derivatives derivatives;
- ComputeSmoothness compute_smoothness;
- SetupEquations setup_equations;
- SOR sor;
- AddBaseFlow add_base_flow;
+ int prev_level_width = 1, prev_level_height = 1;
+ GLuint prev_level_flow_tex = initial_flow_tex;
- GLuint query;
- glGenQueries(1, &query);
- glBeginQuery(GL_TIME_ELAPSED, query);
+ GPUTimers timers;
+ ScopedTimer total_timer("Total", &timers);
for (int level = coarsest_level; level >= int(finest_level); --level) {
- int level_width = WIDTH >> level;
- int level_height = HEIGHT >> level;
+ char timer_name[256];
+ snprintf(timer_name, sizeof(timer_name), "Level %d", level);
+ ScopedTimer level_timer(timer_name, &total_timer);
+
+ int level_width = width >> level;
+ int level_height = height >> level;
float patch_spacing_pixels = patch_size_pixels * (1.0f - patch_overlap_ratio);
int width_patches = 1 + lrintf((level_width - patch_size_pixels) / patch_spacing_pixels);
int height_patches = 1 + lrintf((level_height - patch_size_pixels) / patch_spacing_pixels);
// Create a new texture; we could be fancy and render use a multi-level
// texture, but meh.
- GLuint grad0_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &grad0_tex);
- glTextureStorage2D(grad0_tex, 1, GL_RG16F, level_width, level_height);
+ GLuint grad0_tex = get_texture(GL_RG16F, level_width, level_height);
// Find the derivative.
- sobel.exec(tex0_view, grad0_tex, level_width, level_height);
+ {
+ ScopedTimer timer("Sobel", &level_timer);
+ sobel.exec(tex0_view, grad0_tex, level_width, level_height);
+ }
// Motion search to find the initial flow. We use the flow from the previous
// level (sampled bilinearly; no fancy tricks) as a guide, then search from there.
// Create an output flow texture.
- GLuint flow_out_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &flow_out_tex);
- glTextureStorage2D(flow_out_tex, 1, GL_RGB16F, width_patches, height_patches);
+ GLuint flow_out_tex = get_texture(GL_RGB16F, width_patches, height_patches);
// And draw.
- motion_search.exec(tex0_view, tex1_view, grad0_tex, prev_level_flow_tex, flow_out_tex, level_width, level_height, width_patches, height_patches);
+ {
+ ScopedTimer timer("Motion search", &level_timer);
+ motion_search.exec(tex0_view, tex1_view, grad0_tex, prev_level_flow_tex, flow_out_tex, level_width, level_height, prev_level_width, prev_level_height, width_patches, height_patches);
+ }
+ release_texture(grad0_tex);
// Densification.
// Set up an output texture (initially zero).
- GLuint dense_flow_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &dense_flow_tex);
- glTextureStorage2D(dense_flow_tex, 1, GL_RGB16F, level_width, level_height);
+ GLuint dense_flow_tex = get_texture(GL_RGB16F, level_width, level_height);
+ glClearTexImage(dense_flow_tex, 0, GL_RGB, GL_FLOAT, nullptr);
// And draw.
- densify.exec(tex0_view, tex1_view, flow_out_tex, dense_flow_tex, level_width, level_height, width_patches, height_patches);
+ {
+ ScopedTimer timer("Densification", &level_timer);
+ densify.exec(tex0_view, tex1_view, flow_out_tex, dense_flow_tex, level_width, level_height, width_patches, height_patches);
+ }
+ release_texture(flow_out_tex);
// Everything below here in the loop belongs to variational refinement.
- // It is not done yet.
-
- // Prewarping; create I and I_t.
- GLuint I_tex, I_t_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &I_tex);
- glCreateTextures(GL_TEXTURE_2D, 1, &I_t_tex);
- glTextureStorage2D(I_tex, 1, GL_R16F, level_width, level_height);
- glTextureStorage2D(I_t_tex, 1, GL_R16F, level_width, level_height);
- prewarp.exec(tex0_view, tex1_view, dense_flow_tex, I_tex, I_t_tex, level_width, level_height);
+ ScopedTimer varref_timer("Variational refinement", &level_timer);
+
+ // Prewarping; create I and I_t, and a normalized base flow (so we don't
+ // have to normalize it over and over again, and also save some bandwidth).
+ //
+ // During the entire rest of the variational refinement, flow will be measured
+ // in pixels, not 0..1 normalized OpenGL texture coordinates.
+ // This is because variational refinement depends so heavily on derivatives,
+ // which are measured in intensity levels per pixel.
+ GLuint I_tex = get_texture(GL_R16F, level_width, level_height);
+ GLuint I_t_tex = get_texture(GL_R16F, level_width, level_height);
+ GLuint base_flow_tex = get_texture(GL_RG16F, level_width, level_height);
+ {
+ ScopedTimer timer("Prewarping", &varref_timer);
+ prewarp.exec(tex0_view, tex1_view, dense_flow_tex, I_tex, I_t_tex, base_flow_tex, level_width, level_height);
+ }
+ release_texture(dense_flow_tex);
// Calculate I_x and I_y. We're only calculating first derivatives;
// the others will be taken on-the-fly in order to sample from fewer
// textures overall, since sampling from the L1 cache is cheap.
// (TODO: Verify that this is indeed faster than making separate
// double-derivative textures.)
- GLuint I_x_y_tex, beta_0_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &I_x_y_tex);
- glCreateTextures(GL_TEXTURE_2D, 1, &beta_0_tex);
- glTextureStorage2D(I_x_y_tex, 1, GL_RG16F, level_width, level_height);
- glTextureStorage2D(beta_0_tex, 1, GL_R16F, level_width, level_height);
- derivatives.exec(I_tex, I_x_y_tex, beta_0_tex, level_width, level_height);
+ GLuint I_x_y_tex = get_texture(GL_RG16F, level_width, level_height);
+ GLuint beta_0_tex = get_texture(GL_R16F, level_width, level_height);
+ {
+ ScopedTimer timer("First derivatives", &varref_timer);
+ derivatives.exec(I_tex, I_x_y_tex, beta_0_tex, level_width, level_height);
+ }
+ release_texture(I_tex);
// We need somewhere to store du and dv (the flow increment, relative
// to the non-refined base flow u0 and v0). It starts at zero.
- GLuint du_dv_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &du_dv_tex);
- glTextureStorage2D(du_dv_tex, 1, GL_RG16F, level_width, level_height);
+ GLuint du_dv_tex = get_texture(GL_RG16F, level_width, level_height);
+ glClearTexImage(du_dv_tex, 0, GL_RG, GL_FLOAT, nullptr);
// And for smoothness.
- GLuint smoothness_x_tex, smoothness_y_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &smoothness_x_tex);
- glCreateTextures(GL_TEXTURE_2D, 1, &smoothness_y_tex);
- glTextureStorage2D(smoothness_x_tex, 1, GL_R16F, level_width, level_height);
- glTextureStorage2D(smoothness_y_tex, 1, GL_R16F, level_width, level_height);
+ GLuint smoothness_x_tex = get_texture(GL_R16F, level_width, level_height);
+ GLuint smoothness_y_tex = get_texture(GL_R16F, level_width, level_height);
// And finally for the equation set. See SetupEquations for
// the storage format.
- GLuint equation_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &equation_tex);
- glTextureStorage2D(equation_tex, 1, GL_RGBA32UI, level_width, level_height);
+ GLuint equation_tex = get_texture(GL_RGBA32UI, level_width, level_height);
for (int outer_idx = 0; outer_idx < level + 1; ++outer_idx) {
// Calculate the smoothness terms between the neighboring pixels,
// both in x and y direction.
- compute_smoothness.exec(dense_flow_tex, du_dv_tex, smoothness_x_tex, smoothness_y_tex, level_width, level_height);
+ {
+ ScopedTimer timer("Compute smoothness", &varref_timer);
+ compute_smoothness.exec(base_flow_tex, du_dv_tex, smoothness_x_tex, smoothness_y_tex, level_width, level_height);
+ }
// Set up the 2x2 equation system for each pixel.
- setup_equations.exec(I_x_y_tex, I_t_tex, du_dv_tex, dense_flow_tex, beta_0_tex, smoothness_x_tex, smoothness_y_tex, equation_tex, level_width, level_height);
+ {
+ ScopedTimer timer("Set up equations", &varref_timer);
+ setup_equations.exec(I_x_y_tex, I_t_tex, du_dv_tex, base_flow_tex, beta_0_tex, smoothness_x_tex, smoothness_y_tex, equation_tex, level_width, level_height);
+ }
// Run a few SOR (or quasi-SOR, since we're not really Jacobi) iterations.
// Note that these are to/from the same texture.
- sor.exec(du_dv_tex, equation_tex, smoothness_x_tex, smoothness_y_tex, level_width, level_height, 5);
+ {
+ ScopedTimer timer("SOR", &varref_timer);
+ sor.exec(du_dv_tex, equation_tex, smoothness_x_tex, smoothness_y_tex, level_width, level_height, 5);
+ }
}
+ release_texture(I_t_tex);
+ release_texture(I_x_y_tex);
+ release_texture(beta_0_tex);
+ release_texture(smoothness_x_tex);
+ release_texture(smoothness_y_tex);
+ release_texture(equation_tex);
+
// Add the differential flow found by the variational refinement to the base flow,
// giving the final flow estimate for this level.
// The output is in diff_flow_tex; we don't need to make a new texture.
- add_base_flow.exec(dense_flow_tex, du_dv_tex, level_width, level_height);
+ //
+ // Disabling this doesn't save any time (although we could easily make it so that
+ // it is more efficient), but it helps debug the motion search.
+ if (enable_variational_refinement) {
+ ScopedTimer timer("Add differential flow", &varref_timer);
+ add_base_flow.exec(base_flow_tex, du_dv_tex, level_width, level_height);
+ }
+ release_texture(du_dv_tex);
- prev_level_flow_tex = du_dv_tex;
+ if (prev_level_flow_tex != initial_flow_tex) {
+ release_texture(prev_level_flow_tex);
+ }
+ prev_level_flow_tex = base_flow_tex;
+ prev_level_width = level_width;
+ prev_level_height = level_height;
}
- glEndQuery(GL_TIME_ELAPSED);
-
- GLint available;
- do {
- glGetQueryObjectiv(query, GL_QUERY_RESULT_AVAILABLE, &available);
- usleep(1000);
- } while (!available);
- GLuint64 time_elapsed;
- glGetQueryObjectui64v(query, GL_QUERY_RESULT, &time_elapsed);
- fprintf(stderr, "GPU time used = %.1f ms\n", time_elapsed / 1e6);
-
- int level_width = WIDTH >> finest_level;
- int level_height = HEIGHT >> finest_level;
- unique_ptr<float[]> dense_flow(new float[level_width * level_height * 3]);
- glGetTextureImage(prev_level_flow_tex, 0, GL_RGB, GL_FLOAT, level_width * level_height * 3 * sizeof(float), dense_flow.get());
-
- FILE *fp = fopen("flow.ppm", "wb");
- FILE *flowfp = fopen("flow.flo", "wb");
- fprintf(fp, "P6\n%d %d\n255\n", level_width, level_height);
- fprintf(flowfp, "FEIH");
- fwrite(&level_width, 4, 1, flowfp);
- fwrite(&level_height, 4, 1, flowfp);
- for (unsigned y = 0; y < unsigned(level_height); ++y) {
- int yy = level_height - y - 1;
- for (unsigned x = 0; x < unsigned(level_width); ++x) {
- float du = dense_flow[(yy * level_width + x) * 3 + 0];
- float dv = dense_flow[(yy * level_width + x) * 3 + 1];
- float w = dense_flow[(yy * level_width + x) * 3 + 2];
+ total_timer.end();
+
+ timers.print();
+
+ // Scale up the flow to the final size (if needed).
+ if (finest_level == 0) {
+ return prev_level_flow_tex;
+ } else {
+ GLuint final_tex = get_texture(GL_RG16F, width, height);
+ resize_flow.exec(prev_level_flow_tex, final_tex, prev_level_width, prev_level_height, width, height);
+ release_texture(prev_level_flow_tex);
+ return final_tex;
+ }
+}
- du = (du / w) * level_width;
- dv = (-dv / w) * level_height;
+GLuint DISComputeFlow::get_texture(GLenum format, GLuint width, GLuint height)
+{
+ for (Texture &tex : textures) {
+ if (!tex.in_use && tex.format == format &&
+ tex.width == width && tex.height == height) {
+ tex.in_use = true;
+ return tex.tex_num;
+ }
+ }
+
+ Texture tex;
+ glCreateTextures(GL_TEXTURE_2D, 1, &tex.tex_num);
+ glTextureStorage2D(tex.tex_num, 1, format, width, height);
+ tex.format = format;
+ tex.width = width;
+ tex.height = height;
+ tex.in_use = true;
+ textures.push_back(tex);
+ return tex.tex_num;
+}
- fwrite(&du, 4, 1, flowfp);
- fwrite(&dv, 4, 1, flowfp);
+void DISComputeFlow::release_texture(GLuint tex_num)
+{
+ for (Texture &tex : textures) {
+ if (tex.tex_num == tex_num) {
+ assert(tex.in_use);
+ tex.in_use = false;
+ return;
+ }
+ }
+ assert(false);
+}
+
+// OpenGL uses a bottom-left coordinate system, .flo files use a top-left coordinate system.
+void flip_coordinate_system(float *dense_flow, unsigned width, unsigned height)
+{
+ for (unsigned i = 0; i < width * height; ++i) {
+ dense_flow[i * 2 + 1] = -dense_flow[i * 2 + 1];
+ }
+}
+
+void write_flow(const char *filename, const float *dense_flow, unsigned width, unsigned height)
+{
+ FILE *flowfp = fopen(filename, "wb");
+ fprintf(flowfp, "FEIH");
+ fwrite(&width, 4, 1, flowfp);
+ fwrite(&height, 4, 1, flowfp);
+ for (unsigned y = 0; y < height; ++y) {
+ int yy = height - y - 1;
+ fwrite(&dense_flow[yy * width * 2], width * 2 * sizeof(float), 1, flowfp);
+ }
+ fclose(flowfp);
+}
+
+void write_ppm(const char *filename, const float *dense_flow, unsigned width, unsigned height)
+{
+ FILE *fp = fopen(filename, "wb");
+ fprintf(fp, "P6\n%d %d\n255\n", width, height);
+ for (unsigned y = 0; y < unsigned(height); ++y) {
+ int yy = height - y - 1;
+ for (unsigned x = 0; x < unsigned(width); ++x) {
+ float du = dense_flow[(yy * width + x) * 2 + 0];
+ float dv = dense_flow[(yy * width + x) * 2 + 1];
uint8_t r, g, b;
flow2rgb(du, dv, &r, &g, &b);
}
}
fclose(fp);
- fclose(flowfp);
+}
+
+int main(int argc, char **argv)
+{
+ static const option long_options[] = {
+ { "alpha", required_argument, 0, 'a' },
+ { "delta", required_argument, 0, 'd' },
+ { "gamma", required_argument, 0, 'g' },
+ { "disable-timing", no_argument, 0, 1000 },
+ { "ignore-variational-refinement", no_argument, 0, 1001 } // Still calculates it, just doesn't apply it.
+ };
+
+ for ( ;; ) {
+ int option_index = 0;
+ int c = getopt_long(argc, argv, "a:d:g:", long_options, &option_index);
+
+ if (c == -1) {
+ break;
+ }
+ switch (c) {
+ case 'a':
+ vr_alpha = atof(optarg);
+ break;
+ case 'd':
+ vr_delta = atof(optarg);
+ break;
+ case 'g':
+ vr_gamma = atof(optarg);
+ break;
+ case 1000:
+ enable_timing = false;
+ break;
+ case 1001:
+ enable_variational_refinement = false;
+ break;
+ default:
+ fprintf(stderr, "Unknown option '%s'\n", argv[option_index]);
+ exit(1);
+ };
+ }
+
+ if (SDL_Init(SDL_INIT_EVERYTHING) == -1) {
+ fprintf(stderr, "SDL_Init failed: %s\n", SDL_GetError());
+ exit(1);
+ }
+ SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+ SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
+ SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
+ SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
+ // SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
+ SDL_Window *window = SDL_CreateWindow("OpenGL window",
+ SDL_WINDOWPOS_UNDEFINED,
+ SDL_WINDOWPOS_UNDEFINED,
+ 64, 64,
+ SDL_WINDOW_OPENGL);
+ SDL_GLContext context = SDL_GL_CreateContext(window);
+ assert(context != nullptr);
+
+ const char *filename0 = argc >= (optind + 1) ? argv[optind] : "test1499.png";
+ const char *filename1 = argc >= (optind + 2) ? argv[optind + 1] : "test1500.png";
+ const char *flow_filename = argc >= (optind + 3) ? argv[optind + 2] : "flow.flo";
+ fprintf(stderr, "%s %s -> %s\n", filename0, filename1, flow_filename);
+
+ // Load pictures.
+ unsigned width1, height1, width2, height2;
+ GLuint tex0 = load_texture(filename0, &width1, &height1);
+ GLuint tex1 = load_texture(filename1, &width2, &height2);
+
+ if (width1 != width2 || height1 != height2) {
+ fprintf(stderr, "Image dimensions don't match (%dx%d versus %dx%d)\n",
+ width1, height1, width2, height2);
+ exit(1);
+ }
+
+ // FIXME: Should be part of DISComputeFlow (but needs to be initialized
+ // before all the render passes).
+ float vertices[] = {
+ 0.0f, 1.0f,
+ 0.0f, 0.0f,
+ 1.0f, 1.0f,
+ 1.0f, 0.0f,
+ };
+ glCreateBuffers(1, &vertex_vbo);
+ glNamedBufferData(vertex_vbo, sizeof(vertices), vertices, GL_STATIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
+
+ DISComputeFlow compute_flow(width1, height1);
+ GLuint final_tex = compute_flow.exec(tex0, tex1);
+
+ unique_ptr<float[]> dense_flow(new float[width1 * height1 * 2]);
+ glGetTextureImage(final_tex, 0, GL_RG, GL_FLOAT, width1 * height1 * 2 * sizeof(float), dense_flow.get());
+
+ compute_flow.release_texture(final_tex);
+
+ flip_coordinate_system(dense_flow.get(), width1, height1);
+ write_flow(flow_filename, dense_flow.get(), width1, height1);
+ write_ppm("flow.ppm", dense_flow.get(), width1, height1);
+
+ dense_flow.reset();
+
+ // See if there are more flows on the command line (ie., more than three arguments),
+ // and if so, process them.
+ int num_flows = (argc - optind) / 3;
+ for (int i = 1; i < num_flows; ++i) {
+ const char *filename0 = argv[optind + i * 3 + 0];
+ const char *filename1 = argv[optind + i * 3 + 1];
+ const char *flow_filename = argv[optind + i * 3 + 2];
+ fprintf(stderr, "%s %s -> %s\n", filename0, filename1, flow_filename);
+
+ GLuint width, height;
+ GLuint tex0 = load_texture(filename0, &width, &height);
+ if (width != width1 || height != height1) {
+ fprintf(stderr, "%s: Image dimensions don't match (%dx%d versus %dx%d)\n",
+ filename0, width, height, width1, height1);
+ exit(1);
+ }
+
+ GLuint tex1 = load_texture(filename1, &width, &height);
+ if (width != width1 || height != height1) {
+ fprintf(stderr, "%s: Image dimensions don't match (%dx%d versus %dx%d)\n",
+ filename1, width, height, width1, height1);
+ exit(1);
+ }
+
+ GLuint final_tex = compute_flow.exec(tex0, tex1);
+
+ unique_ptr<float[]> dense_flow(new float[width * height * 2]);
+ glGetTextureImage(final_tex, 0, GL_RG, GL_FLOAT, width * height * 2 * sizeof(float), dense_flow.get());
+
+ compute_flow.release_texture(final_tex);
+
+ flip_coordinate_system(dense_flow.get(), width, height);
+ write_flow(flow_filename, dense_flow.get(), width, height);
+ }
fprintf(stderr, "err = %d\n", glGetError());
}