Microoptimization in ResampleEffect.

[movit] / resample_effect.cpp

diff --git a/resample_effect.cpp b/resample_effect.cpp
index 0ec611af75bd9bff87e85837410387816e5f9e5a..156098e993dbac47c2132c46dc7d1ed9348bb9c9 100644 (file)
--- a/resample_effect.cpp
+++ b/resample_effect.cpp
@@ -61,7 +61,7 @@ unsigned gcd(unsigned a, unsigned b)
 }
 
 template<class DestFloat>
-unsigned combine_samples(const Tap<float> *src, Tap<DestFloat> *dst, unsigned src_size, unsigned num_src_samples, unsigned max_samples_saved)
+unsigned combine_samples(const Tap<float> *src, Tap<DestFloat> *dst, float num_subtexels, float inv_num_subtexels, unsigned num_src_samples, unsigned max_samples_saved)
 {
        // Cut off near-zero values at both sides.
        unsigned num_samples_saved = 0;
@@ -109,7 +109,7 @@ unsigned combine_samples(const Tap<float> *src, Tap<DestFloat> *dst, unsigned sr
 
                fp16_int_t pos, total_weight;
                float sum_sq_error;
-               combine_two_samples(w1, w2, pos1, pos2, src_size, &pos, &total_weight, &sum_sq_error);
+               combine_two_samples(w1, w2, pos1, pos2, num_subtexels, inv_num_subtexels, &pos, &total_weight, &sum_sq_error);
 
                // If the interpolation error is larger than that of about sqrt(2) of
                // a level at 8-bit precision, don't combine. (You'd think 1.0 was enough,
@@ -142,8 +142,9 @@ void normalize_sum(Tap<T>* vals, unsigned num)
                for (unsigned i = 0; i < num; ++i) {
                        sum += to_fp64(vals[i].weight);
                }
+               double inv_sum = 1.0 / sum;
                for (unsigned i = 0; i < num; ++i) {
-                       vals[i].weight = from_fp64<T>(to_fp64(vals[i].weight) / sum);
+                       vals[i].weight = from_fp64<T>(to_fp64(vals[i].weight) * inv_sum);
                }
        }
 }
@@ -159,23 +160,28 @@ void normalize_sum(Tap<T>* vals, unsigned num)
 template<class DestFloat>
 unsigned combine_many_samples(const Tap<float> *weights, unsigned src_size, unsigned src_samples, unsigned dst_samples, Tap<DestFloat> **bilinear_weights)
 {
-       int src_bilinear_samples = 0;
-       for (unsigned y = 0; y < dst_samples; ++y) {
-               unsigned num_samples_saved = combine_samples<DestFloat>(weights + y * src_samples, NULL, src_size, src_samples, UINT_MAX);
-               src_bilinear_samples = max<int>(src_bilinear_samples, src_samples - num_samples_saved);
+       float num_subtexels = src_size / movit_texel_subpixel_precision;
+       float inv_num_subtexels = movit_texel_subpixel_precision / src_size;
+
+       unsigned max_samples_saved = UINT_MAX;
+       for (unsigned y = 0; y < dst_samples && max_samples_saved > 0; ++y) {
+               unsigned num_samples_saved = combine_samples<DestFloat>(weights + y * src_samples, NULL, num_subtexels, inv_num_subtexels, src_samples, max_samples_saved);
+               max_samples_saved = min(max_samples_saved, num_samples_saved);
        }
 
        // Now that we know the right width, actually combine the samples.
+       unsigned src_bilinear_samples = src_samples - max_samples_saved;
        *bilinear_weights = new Tap<DestFloat>[dst_samples * src_bilinear_samples];
        for (unsigned y = 0; y < dst_samples; ++y) {
                Tap<DestFloat> *bilinear_weights_ptr = *bilinear_weights + y * src_bilinear_samples;
                unsigned num_samples_saved = combine_samples(
                        weights + y * src_samples,
                        bilinear_weights_ptr,
-                       src_size,
+                       num_subtexels,
+                       inv_num_subtexels,
                        src_samples,
-                       src_samples - src_bilinear_samples);
-               assert(int(src_samples) - int(num_samples_saved) == src_bilinear_samples);
+                       max_samples_saved);
+               assert(num_samples_saved == max_samples_saved);
                normalize_sum(bilinear_weights_ptr, src_bilinear_samples);
        }
        return src_bilinear_samples;
@@ -390,6 +396,13 @@ SingleResamplePassEffect::SingleResamplePassEffect(ResampleEffect *parent)
        register_int("output_height", &output_height);
        register_float("offset", &offset);
        register_float("zoom", &zoom);
+       register_uniform_sampler2d("sample_tex", &uniform_sample_tex);
+       register_uniform_int("num_samples", &uniform_num_samples);  // FIXME: What about GLSL pre-1.30?
+       register_uniform_float("num_loops", &uniform_num_loops);
+       register_uniform_float("slice_height", &uniform_slice_height);
+       register_uniform_float("sample_x_scale", &uniform_sample_x_scale);
+       register_uniform_float("sample_x_offset", &uniform_sample_x_offset);
+       register_uniform_float("whole_pixel_offset", &uniform_whole_pixel_offset);
 
        glGenTextures(1, &texnum);
 }
@@ -625,23 +638,21 @@ void SingleResamplePassEffect::set_gl_state(GLuint glsl_program_num, const strin
        glBindTexture(GL_TEXTURE_2D, texnum);
        check_error();
 
-       set_uniform_int(glsl_program_num, prefix, "sample_tex", *sampler_num);
+       uniform_sample_tex = *sampler_num;
        ++*sampler_num;
-       set_uniform_int(glsl_program_num, prefix, "num_samples", src_bilinear_samples);
-       set_uniform_float(glsl_program_num, prefix, "num_loops", num_loops);
-       set_uniform_float(glsl_program_num, prefix, "slice_height", slice_height);
+       uniform_num_samples = src_bilinear_samples;
+       uniform_num_loops = num_loops;
+       uniform_slice_height = slice_height;
 
        // Instructions for how to convert integer sample numbers to positions in the weight texture.
-       set_uniform_float(glsl_program_num, prefix, "sample_x_scale", 1.0f / src_bilinear_samples);
-       set_uniform_float(glsl_program_num, prefix, "sample_x_offset", 0.5f / src_bilinear_samples);
+       uniform_sample_x_scale = 1.0f / src_bilinear_samples;
+       uniform_sample_x_offset = 0.5f / src_bilinear_samples;
 
-       float whole_pixel_offset;
        if (direction == SingleResamplePassEffect::VERTICAL) {
-               whole_pixel_offset = lrintf(offset) / float(input_height);
+               uniform_whole_pixel_offset = lrintf(offset) / float(input_height);
        } else {
-               whole_pixel_offset = lrintf(offset) / float(input_width);
+               uniform_whole_pixel_offset = lrintf(offset) / float(input_width);
        }
-       set_uniform_float(glsl_program_num, prefix, "whole_pixel_offset", whole_pixel_offset);
 
        // We specifically do not want mipmaps on the input texture;
        // they break minification.