X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=resample_effect.cpp;h=4598d34e7bb61b44d91acea41648345a059f6757;hp=86d574b32d6468f22688a7c894de6356f1895909;hb=dce0f4f2b6d57aa02f2074fdb3925c756d2a96ba;hpb=8e9f58fec54a4c879035b214fd7411f6ff7b3a32 diff --git a/resample_effect.cpp b/resample_effect.cpp index 86d574b..4598d34 100644 --- a/resample_effect.cpp +++ b/resample_effect.cpp @@ -129,7 +129,7 @@ unsigned combine_samples(const Tap *src, Tap *dst, float num_s for (unsigned i = 0, j = 0; i < num_src_samples; ++i, ++j) { // Copy the sample directly; it will be overwritten later if we can combine. - if (dst != NULL) { + if (dst != nullptr) { dst[j].weight = convert_float(src[i].weight); dst[j].pos = convert_float(src[i].pos); } @@ -169,7 +169,7 @@ unsigned combine_samples(const Tap *src, Tap *dst, float num_s } // OK, we can combine this and the next sample. - if (dst != NULL) { + if (dst != nullptr) { dst[j].weight = total_weight; dst[j].pos = pos; } @@ -206,7 +206,7 @@ void normalize_sum(Tap* vals, unsigned num) // // The greedy strategy for combining samples is optimal. template -unsigned combine_many_samples(const Tap *weights, unsigned src_size, unsigned src_samples, unsigned dst_samples, Tap **bilinear_weights) +unsigned combine_many_samples(const Tap *weights, unsigned src_size, unsigned src_samples, unsigned dst_samples, unique_ptr[]> *bilinear_weights) { float num_subtexels = src_size / movit_texel_subpixel_precision; float inv_num_subtexels = movit_texel_subpixel_precision / src_size; @@ -215,16 +215,15 @@ unsigned combine_many_samples(const Tap *weights, unsigned src_size, unsi unsigned max_samples_saved = UINT_MAX; for (unsigned y = 0; y < dst_samples && max_samples_saved > 0; ++y) { - unsigned num_samples_saved = combine_samples(weights + y * src_samples, NULL, num_subtexels, inv_num_subtexels, src_samples, max_samples_saved, pos1_pos2_diff, inv_pos1_pos2_diff); + unsigned num_samples_saved = combine_samples(weights + y * src_samples, nullptr, num_subtexels, inv_num_subtexels, src_samples, max_samples_saved, pos1_pos2_diff, inv_pos1_pos2_diff); 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; - if (*bilinear_weights != NULL) delete[] *bilinear_weights; - *bilinear_weights = new Tap[dst_samples * src_bilinear_samples]; + bilinear_weights->reset(new Tap[dst_samples * src_bilinear_samples]); for (unsigned y = 0; y < dst_samples; ++y) { - Tap *bilinear_weights_ptr = *bilinear_weights + y * src_bilinear_samples; + Tap *bilinear_weights_ptr = bilinear_weights->get() + y * src_bilinear_samples; unsigned num_samples_saved = combine_samples( weights + y * src_samples, bilinear_weights_ptr, @@ -301,7 +300,8 @@ double compute_sum_sq_error(const Tap* weights, unsigned num_weights, } // namespace ResampleEffect::ResampleEffect() - : input_width(1280), + : owns_effects(true), + input_width(1280), input_height(720), offset_x(0.0f), offset_y(0.0f), zoom_x(1.0f), zoom_y(1.0f), @@ -313,12 +313,20 @@ ResampleEffect::ResampleEffect() // The first blur pass will forward resolution information to us. hpass = new SingleResamplePassEffect(this); CHECK(hpass->set_int("direction", SingleResamplePassEffect::HORIZONTAL)); - vpass = new SingleResamplePassEffect(NULL); + vpass = new SingleResamplePassEffect(nullptr); 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); @@ -327,6 +335,7 @@ void ResampleEffect::rewrite_graph(EffectChain *graph, Node *self) 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, @@ -527,15 +536,15 @@ void SingleResamplePassEffect::update_texture(GLuint glsl_program_num, const str GLenum type, internal_format; void *pixels; - assert((weights.bilinear_weights_fp16 == NULL) != (weights.bilinear_weights_fp32 == NULL)); - if (weights.bilinear_weights_fp32 != NULL) { + assert((weights.bilinear_weights_fp16 == nullptr) != (weights.bilinear_weights_fp32 == nullptr)); + if (weights.bilinear_weights_fp32 != nullptr) { type = GL_FLOAT; internal_format = GL_RG32F; - pixels = weights.bilinear_weights_fp32; + pixels = weights.bilinear_weights_fp32.get(); } else { type = GL_HALF_FLOAT; internal_format = GL_RG16F; - pixels = weights.bilinear_weights_fp16; + pixels = weights.bilinear_weights_fp16.get(); } if (int(weights.src_bilinear_samples) == last_texture_width && @@ -551,9 +560,6 @@ void SingleResamplePassEffect::update_texture(GLuint glsl_program_num, const str last_texture_internal_format = internal_format; } check_error(); - - delete[] weights.bilinear_weights_fp16; - delete[] weights.bilinear_weights_fp32; } ScalingWeights calculate_scaling_weights(unsigned src_size, unsigned dst_size, float zoom, float offset) @@ -636,7 +642,7 @@ ScalingWeights calculate_scaling_weights(unsigned src_size, unsigned dst_size, f 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; - Tap *weights = new Tap[dst_samples * src_samples]; + unique_ptr[]> weights(new Tap[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); for (unsigned y = 0; y < dst_samples; ++y) { @@ -660,14 +666,14 @@ ScalingWeights calculate_scaling_weights(unsigned src_size, unsigned dst_size, f // 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); - Tap *bilinear_weights_fp16 = NULL; - int src_bilinear_samples = combine_many_samples(weights, src_size, src_samples, dst_samples, &bilinear_weights_fp16); - Tap *bilinear_weights_fp32 = NULL; + unique_ptr[]> bilinear_weights_fp16; + int src_bilinear_samples = combine_many_samples(weights.get(), src_size, src_samples, dst_samples, &bilinear_weights_fp16); + unique_ptr[]> bilinear_weights_fp32 = nullptr; double max_sum_sq_error_fp16 = 0.0; for (unsigned y = 0; y < dst_samples; ++y) { double sum_sq_error_fp16 = compute_sum_sq_error( - weights + y * src_samples, src_samples, - bilinear_weights_fp16 + y * src_bilinear_samples, src_bilinear_samples, + weights.get() + y * src_samples, src_samples, + bilinear_weights_fp16.get() + y * src_bilinear_samples, src_bilinear_samples, src_size); max_sum_sq_error_fp16 = std::max(max_sum_sq_error_fp16, sum_sq_error_fp16); if (max_sum_sq_error_fp16 > max_error) { @@ -676,19 +682,16 @@ ScalingWeights calculate_scaling_weights(unsigned src_size, unsigned dst_size, f } if (max_sum_sq_error_fp16 > max_error) { - delete[] bilinear_weights_fp16; - bilinear_weights_fp16 = NULL; - src_bilinear_samples = combine_many_samples(weights, src_size, src_samples, dst_samples, &bilinear_weights_fp32); + bilinear_weights_fp16.reset(); + src_bilinear_samples = combine_many_samples(weights.get(), src_size, src_samples, dst_samples, &bilinear_weights_fp32); } - delete[] weights; - ScalingWeights ret; ret.src_bilinear_samples = src_bilinear_samples; ret.dst_samples = dst_samples; ret.num_loops = num_loops; - ret.bilinear_weights_fp16 = bilinear_weights_fp16; - ret.bilinear_weights_fp32 = bilinear_weights_fp32; + ret.bilinear_weights_fp16 = move(bilinear_weights_fp16); + ret.bilinear_weights_fp32 = move(bilinear_weights_fp32); return ret; }