#include <math.h>
#include <stdio.h>
#include <algorithm>
+#include <mutex>
#include <Eigen/Sparse>
#include <Eigen/SparseQR>
#include <Eigen/OrderingMethods>
// You need to call lanczos_table_init_done before the first call to
// lanczos_weight_cached.
#define LANCZOS_TABLE_SIZE 2048
-bool lanczos_table_init_done = false;
+static once_flag lanczos_table_init_done;
float lanczos_table[LANCZOS_TABLE_SIZE + 2];
void init_lanczos_table()
for (unsigned i = 0; i < LANCZOS_TABLE_SIZE + 2; ++i) {
lanczos_table[i] = lanczos_weight(float(i) * (LANCZOS_RADIUS / LANCZOS_TABLE_SIZE));
}
- lanczos_table_init_done = true;
}
float lanczos_weight_cached(float x)
} // namespace
ResampleEffect::ResampleEffect()
- : owns_effects(true),
- input_width(1280),
+ : input_width(1280),
input_height(720),
offset_x(0.0f), offset_y(0.0f),
zoom_x(1.0f), zoom_y(1.0f),
register_int("height", &output_height);
// The first blur pass will forward resolution information to us.
- hpass = new SingleResamplePassEffect(this);
+ hpass_owner.reset(new SingleResamplePassEffect(this));
+ hpass = hpass_owner.get();
CHECK(hpass->set_int("direction", SingleResamplePassEffect::HORIZONTAL));
- vpass = new SingleResamplePassEffect(nullptr);
+ vpass_owner.reset(new SingleResamplePassEffect(this));
+ vpass = vpass_owner.get();
CHECK(vpass->set_int("direction", SingleResamplePassEffect::VERTICAL));
update_size();
ResampleEffect::~ResampleEffect()
{
- if (owns_effects) {
- delete hpass;
- delete vpass;
- }
}
void ResampleEffect::rewrite_graph(EffectChain *graph, Node *self)
{
- Node *hpass_node = graph->add_node(hpass);
- Node *vpass_node = graph->add_node(vpass);
+ Node *hpass_node = graph->add_node(hpass_owner.release());
+ Node *vpass_node = graph->add_node(vpass_owner.release());
graph->connect_nodes(hpass_node, vpass_node);
graph->replace_receiver(self, hpass_node);
graph->replace_sender(self, vpass_node);
self->disabled = true;
- owns_effects = false;
}
// We get this information forwarded from the first blur pass,
SingleResamplePassEffect::SingleResamplePassEffect(ResampleEffect *parent)
: parent(parent),
direction(HORIZONTAL),
- input_width(1280),
- input_height(720),
+ input_width(1280),
+ input_height(720),
offset(0.0),
zoom(1.0),
last_input_width(-1),
last_output_width(-1),
last_output_height(-1),
last_offset(0.0 / 0.0), // NaN.
- last_zoom(0.0 / 0.0), // NaN.
- last_texture_width(-1), last_texture_height(-1)
+ last_zoom(0.0 / 0.0) // NaN.
{
register_int("direction", (int *)&direction);
register_int("input_width", &input_width);
register_uniform_float("sample_x_offset", &uniform_sample_x_offset);
register_uniform_float("whole_pixel_offset", &uniform_whole_pixel_offset);
- glGenTextures(1, &texnum);
-
- if (!lanczos_table_init_done) {
- // Could in theory race between two threads if we are unlucky,
- // but that is harmless, since they'll write the same data.
- init_lanczos_table();
- }
+ call_once(lanczos_table_init_done, init_lanczos_table);
}
SingleResamplePassEffect::~SingleResamplePassEffect()
{
- glDeleteTextures(1, &texnum);
}
string SingleResamplePassEffect::output_fragment_shader()
assert(false);
}
- ScalingWeights weights = calculate_scaling_weights(src_size, dst_size, zoom, offset);
+ ScalingWeights weights = calculate_bilinear_scaling_weights(src_size, dst_size, zoom, offset);
src_bilinear_samples = weights.src_bilinear_samples;
num_loops = weights.num_loops;
slice_height = 1.0f / weights.num_loops;
// Encode as a two-component texture. Note the GL_REPEAT.
glActiveTexture(GL_TEXTURE0 + *sampler_num);
check_error();
- glBindTexture(GL_TEXTURE_2D, texnum);
+ glBindTexture(GL_TEXTURE_2D, tex.get_texnum());
check_error();
- if (last_texture_width == -1) {
- // Need to set this state the first time.
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- check_error();
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
- check_error();
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
- check_error();
- }
GLenum type, internal_format;
void *pixels;
pixels = weights.bilinear_weights_fp16.get();
}
- if (int(weights.src_bilinear_samples) == last_texture_width &&
- int(weights.dst_samples) == last_texture_height &&
- internal_format == last_texture_internal_format) {
- // Texture dimensions and type are unchanged; it is more efficient
- // to just update it rather than making an entirely new texture.
- glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, weights.src_bilinear_samples, weights.dst_samples, GL_RG, type, pixels);
- } else {
- glTexImage2D(GL_TEXTURE_2D, 0, internal_format, weights.src_bilinear_samples, weights.dst_samples, 0, GL_RG, type, pixels);
- last_texture_width = weights.src_bilinear_samples;
- last_texture_height = weights.dst_samples;
- last_texture_internal_format = internal_format;
- }
- check_error();
+ tex.update(weights.src_bilinear_samples, weights.dst_samples, internal_format, GL_RG, type, pixels);
}
+namespace {
+
ScalingWeights calculate_scaling_weights(unsigned src_size, unsigned dst_size, float zoom, float offset)
{
- if (!lanczos_table_init_done) {
- // Only needed if run from outside ResampleEffect.
- init_lanczos_table();
- }
+ // Only needed if run from outside ResampleEffect.
+ call_once(lanczos_table_init_done, init_lanczos_table);
// For many resamplings (e.g. 640 -> 1280), we will end up with the same
// set of samples over and over again in a loop. Thus, we can compute only
// to compute the destination pixel, and how many depend on the scaling factor.
// Thus, the kernel width will vary with how much we scale.
float radius_scaling_factor = min(scaling_factor, 1.0f);
- int int_radius = lrintf(LANCZOS_RADIUS / radius_scaling_factor);
- int src_samples = int_radius * 2 + 1;
+ const int int_radius = lrintf(LANCZOS_RADIUS / radius_scaling_factor);
+ const int src_samples = int_radius * 2 + 1;
unique_ptr<Tap<float>[]> weights(new Tap<float>[dst_samples * src_samples]);
float subpixel_offset = offset - lrintf(offset); // The part not covered by whole_pixel_offset.
assert(subpixel_offset >= -0.5f && subpixel_offset <= 0.5f);
+ float inv_scaling_factor = 1.0f / scaling_factor;
for (unsigned y = 0; y < dst_samples; ++y) {
// Find the point around which we want to sample the source image,
// compensating for differing pixel centers as the scale changes.
- float center_src_y = (y + 0.5f) / scaling_factor - 0.5f;
+ float center_src_y = (y + 0.5f) * inv_scaling_factor - 0.5f;
int base_src_y = lrintf(center_src_y);
// Now sample <int_radius> pixels on each side around that point.
}
}
+ ScalingWeights ret;
+ ret.src_bilinear_samples = src_samples;
+ ret.dst_samples = dst_samples;
+ ret.num_loops = num_loops;
+ ret.bilinear_weights_fp16 = nullptr;
+ ret.bilinear_weights_fp32 = move(weights);
+ return ret;
+}
+
+} // namespace
+
+ScalingWeights calculate_bilinear_scaling_weights(unsigned src_size, unsigned dst_size, float zoom, float offset)
+{
+ ScalingWeights ret = calculate_scaling_weights(src_size, dst_size, zoom, offset);
+ unique_ptr<Tap<float>[]> weights = move(ret.bilinear_weights_fp32);
+ const int src_samples = ret.src_bilinear_samples;
+
// Now make use of the bilinear filtering in the GPU to reduce the number of samples
// we need to make. Try fp16 first; if it's not accurate enough, we go to fp32.
// Our tolerance level for total error is a bit higher than the one for invididual
// samples, since one would assume overall errors in the shape don't matter as much.
const float max_error = 2.0f / (255.0f * 255.0f);
unique_ptr<Tap<fp16_int_t>[]> bilinear_weights_fp16;
- int src_bilinear_samples = combine_many_samples(weights.get(), src_size, src_samples, dst_samples, &bilinear_weights_fp16);
+ int src_bilinear_samples = combine_many_samples(weights.get(), src_size, src_samples, ret.dst_samples, &bilinear_weights_fp16);
unique_ptr<Tap<float>[]> bilinear_weights_fp32 = nullptr;
double max_sum_sq_error_fp16 = 0.0;
- for (unsigned y = 0; y < dst_samples; ++y) {
+ for (unsigned y = 0; y < ret.dst_samples; ++y) {
double sum_sq_error_fp16 = compute_sum_sq_error(
weights.get() + y * src_samples, src_samples,
bilinear_weights_fp16.get() + y * src_bilinear_samples, src_bilinear_samples,
if (max_sum_sq_error_fp16 > max_error) {
bilinear_weights_fp16.reset();
- src_bilinear_samples = combine_many_samples(weights.get(), src_size, src_samples, dst_samples, &bilinear_weights_fp32);
+ src_bilinear_samples = combine_many_samples(weights.get(), src_size, src_samples, ret.dst_samples, &bilinear_weights_fp32);
}
- ScalingWeights ret;
ret.src_bilinear_samples = src_bilinear_samples;
- ret.dst_samples = dst_samples;
- ret.num_loops = num_loops;
ret.bilinear_weights_fp16 = move(bilinear_weights_fp16);
ret.bilinear_weights_fp32 = move(bilinear_weights_fp32);
return ret;
glActiveTexture(GL_TEXTURE0 + *sampler_num);
check_error();
- glBindTexture(GL_TEXTURE_2D, texnum);
+ glBindTexture(GL_TEXTURE_2D, tex.get_texnum());
check_error();
uniform_sample_tex = *sampler_num;
}
}
+Support2DTexture::Support2DTexture()
+{
+ glGenTextures(1, &texnum);
+ check_error();
+ glBindTexture(GL_TEXTURE_2D, texnum);
+ check_error();
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ check_error();
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ check_error();
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ check_error();
+}
+
+Support2DTexture::~Support2DTexture()
+{
+ glDeleteTextures(1, &texnum);
+ check_error();
+}
+
+void Support2DTexture::update(GLint width, GLint height, GLenum internal_format, GLenum format, GLenum type, const GLvoid * data)
+{
+ glBindTexture(GL_TEXTURE_2D, texnum);
+ check_error();
+ if (width == last_texture_width &&
+ height == last_texture_height &&
+ internal_format == last_texture_internal_format) {
+ // Texture dimensions and type are unchanged; it is more efficient
+ // to just update it rather than making an entirely new texture.
+ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, data);
+ check_error();
+ } else {
+ glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, type, data);
+ check_error();
+ last_texture_width = width;
+ last_texture_height = height;
+ last_texture_internal_format = internal_format;
+ }
+}
+
} // namespace movit
projects / movit / blobdiff