From 152965f3342d51973711e3cace0143640d712c13 Mon Sep 17 00:00:00 2001 From: Jorge Rodriguez Date: Thu, 24 Jul 2014 00:47:00 -0700 Subject: [PATCH] Decode enough scanlines into a ring buffer to make sure that we have enough source scanlines to do a vertical sampling. --- stb_resample.h | 230 +++++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 207 insertions(+), 23 deletions(-) diff --git a/stb_resample.h b/stb_resample.h index 3ff072d..c3186e1 100644 --- a/stb_resample.h +++ b/stb_resample.h @@ -160,6 +160,20 @@ typedef struct typedef struct { + const void* input_data; + int input_w; + int input_h; + int input_stride_bytes; + + void* output_data; + int output_w; + int output_h; + int output_stride_bytes; + + int channels; + stbr_type type; + stbr_filter filter; + int total_coefficients; int kernel_texel_width; @@ -167,6 +181,11 @@ typedef struct float* horizontal_coefficients; float* decode_buffer; + + int ring_buffer_first_scanline; + int ring_buffer_last_scanline; + int ring_buffer_begin_index; + float* ring_buffer; } stbr__info; @@ -219,7 +238,7 @@ stbr_inline static stbr_size_t stbr__texel_index(int x, int y, int c, int width_ stbr_inline static stbr__contributors* stbr__get_contributor(stbr__info* stbr_info, int n) { - STBR_DEBUG_ASSERT(n >= 0 /*&& n < output_w*/); + STBR_DEBUG_ASSERT(n >= 0 && n < stbr_info->output_w); return &stbr_info->horizontal_contributors[n]; } @@ -228,37 +247,46 @@ stbr_inline static float* stbr__get_coefficient(stbr__info* stbr_info, int n, in return &stbr_info->horizontal_coefficients[stbr_info->kernel_texel_width*n + c]; } +// What input texels contribute to this output texel? +static void stbr__calculate_sample_range(int n, float out_filter_radius, float scale_ratio, int* in_first_texel, int* in_last_texel, float* in_center_of_out) +{ + // What input texels contribute to this output texel? + float out_texel_center = (float)n + 0.5f; + float out_texel_influence_lowerbound = out_texel_center - out_filter_radius; + float out_texel_influence_upperbound = out_texel_center + out_filter_radius; + + float in_texel_influence_lowerbound = out_texel_influence_lowerbound / scale_ratio; + float in_texel_influence_upperbound = out_texel_influence_upperbound / scale_ratio; + + *in_center_of_out = out_texel_center / scale_ratio; + *in_first_texel = (int)(floor(in_texel_influence_lowerbound + 0.5)); + *in_last_texel = (int)(floor(in_texel_influence_upperbound - 0.5)); +} + // Each scan line uses the same kernel values so we should calculate the kernel // values once and then we can use them for every scan line. -static void stbr__calculate_horizontal_filters(stbr__info* stbr_info, stbr_filter filter, int input_w, int output_w) +static void stbr__calculate_horizontal_filters(stbr__info* stbr_info) { int n, i; - float scale_ratio = (float)output_w / input_w; + float scale_ratio = (float)stbr_info->output_w / stbr_info->input_w; - float out_pixels_radius = stbr__filter_info_table[filter].support * scale_ratio; + float out_pixels_radius = stbr__filter_info_table[stbr_info->filter].support * scale_ratio; - STBR_UNIMPLEMENTED(output_w < input_w); + STBR_UNIMPLEMENTED(stbr_info->output_w < stbr_info->input_w); - for (n = 0; n < output_w; n++) + for (n = 0; n < stbr_info->output_w; n++) { - // What input texels contribute to this output texel? - float out_texel_center = (float)n + 0.5f; - float out_texel_influence_lowerbound = out_texel_center - out_pixels_radius; - float out_texel_influence_upperbound = out_texel_center + out_pixels_radius; + float in_center_of_out; // Center of the current out texel in the in texel space + int in_first_texel, in_last_texel; - float in_center_of_out = out_texel_center / scale_ratio; - float in_texel_influence_lowerbound = out_texel_influence_lowerbound / scale_ratio; - float in_texel_influence_upperbound = out_texel_influence_upperbound / scale_ratio; - - int in_first_texel = (int)(floor(in_texel_influence_lowerbound + 0.5)); - int in_last_texel = (int)(floor(in_texel_influence_upperbound - 0.5)); + stbr__calculate_sample_range(n, out_pixels_radius, scale_ratio, &in_first_texel, &in_last_texel, &in_center_of_out); float total_filter = 0; float filter_scale; STBR_DEBUG_ASSERT(in_last_texel - in_first_texel <= stbr_info->kernel_texel_width); STBR_DEBUG_ASSERT(in_first_texel >= 0); - STBR_DEBUG_ASSERT(in_last_texel < input_w); + STBR_DEBUG_ASSERT(in_last_texel < stbr_info->input_w); stbr__get_contributor(stbr_info, n)->n0 = in_first_texel; stbr__get_contributor(stbr_info, n)->n1 = in_last_texel; @@ -266,7 +294,7 @@ static void stbr__calculate_horizontal_filters(stbr__info* stbr_info, stbr_filte for (i = 0; i <= in_last_texel - in_first_texel; i++) { float in_texel_center = (float)(i + in_first_texel) + 0.5f; - total_filter += *stbr__get_coefficient(stbr_info, n, i) = stbr__filter_info_table[filter].kernel(in_center_of_out - in_texel_center); + total_filter += *stbr__get_coefficient(stbr_info, n, i) = stbr__filter_info_table[stbr_info->filter].kernel(in_center_of_out - in_texel_center); } STBR_DEBUG_ASSERT(total_filter > 0); @@ -280,20 +308,112 @@ static void stbr__calculate_horizontal_filters(stbr__info* stbr_info, stbr_filte } } +static float* stbr__get_decode_buffer_index(stbr__info* stbr_info, int x, int c) +{ + STBR_DEBUG_ASSERT(x >= 0 && x < stbr_info->input_w); + STBR_DEBUG_ASSERT(c >= 0 && c < stbr_info->channels); + + return &stbr_info->decode_buffer[x * stbr_info->channels + c]; +} + +static void stbr__decode_scanline(stbr__info* stbr_info, int n) +{ + int x, c; + int channels = stbr_info->channels; + int input_w = stbr_info->input_w; + const void* input_data = stbr_info->input_data; + float* decode_buffer = stbr_info->decode_buffer; + + STBR_UNIMPLEMENTED(stbr_info->type != STBR_TYPE_UINT8); + + for (x = 0; x < input_w; x++) + { + for (c = 0; c < channels; c++) + { + int buffer_index = x * channels + c; + decode_buffer[buffer_index] = ((float)((const unsigned char*)input_data)[buffer_index]) / 255; + } + } +} + +static void stbr__resample_horizontal(stbr__info* stbr_info, int n) +{ + int x, k, c; + int output_w = stbr_info->output_w; + int kernel_texel_width = stbr_info->kernel_texel_width; + int channels = stbr_info->channels; + float* decode_buffer = stbr_info->decode_buffer; + stbr__contributors* horizontal_contributors = stbr_info->horizontal_contributors; + float* horizontal_coefficients = stbr_info->horizontal_coefficients; + + int ring_buffer_index; + float* ring_buffer; + + if (stbr_info->ring_buffer_begin_index < 0) + ring_buffer_index = stbr_info->ring_buffer_begin_index = 0; + else + { + ring_buffer_index = (stbr_info->ring_buffer_begin_index + (stbr_info->ring_buffer_last_scanline - stbr_info->ring_buffer_first_scanline) + 1) % stbr_info->kernel_texel_width; + STBR_DEBUG_ASSERT(ring_buffer_index != stbr_info->ring_buffer_begin_index); + } + + ring_buffer = &stbr_info->ring_buffer[ring_buffer_index]; + + for (x = 0; x < output_w; x++) + { + int n0 = horizontal_contributors[x].n0; + int n1 = horizontal_contributors[x].n1; + + int out_texel_index = x * channels; + int coefficient_group_index = x * kernel_texel_width; + int coefficient_counter = 0; + + STBR_DEBUG_ASSERT(n1 >= n0); + + for (k = n0; k <= n1; k++) + { + int coefficient_index = coefficient_group_index + (coefficient_counter++); + int in_texel_index = k * channels; + + if (!horizontal_coefficients[coefficient_index]) + continue; + + for (c = 0; c < channels; c++) + ring_buffer[out_texel_index + c] += decode_buffer[in_texel_index + c] * horizontal_coefficients[coefficient_index]; + } + } + + stbr_info->ring_buffer_last_scanline = n; +} + +static void stbr__decode_and_resample(stbr__info* stbr_info, int n) +{ + // Decode the nth scanline from the source image into the decode buffer. + stbr__decode_scanline(stbr_info, n); + + // Now resample it into the ring buffer. + stbr__resample_horizontal(stbr_info, n); + + // Now it's sitting in the ring buffer ready to be used as source for the vertical sampling. +} + STBRDEF int stbr_resize_arbitrary(const void* input_data, int input_w, int input_h, int input_stride_in_bytes, void* output_data, int output_w, int output_h, int output_stride_in_bytes, int channels, stbr_type type, stbr_filter filter, void* tempmem, stbr_size_t tempmem_size_in_bytes) { + int y; int width_stride_input = input_stride_in_bytes ? input_stride_in_bytes : channels * input_w; int width_stride_output = output_stride_in_bytes ? output_stride_in_bytes : channels * output_w; #ifdef STBR_DEBUG_OVERWRITE_TEST #define OVERWRITE_ARRAY_SIZE 64 - unsigned char overwrite_contents_pre[OVERWRITE_ARRAY_SIZE]; + unsigned char overwrite_output_pre[OVERWRITE_ARRAY_SIZE]; + unsigned char overwrite_tempmem_pre[OVERWRITE_ARRAY_SIZE]; stbr_size_t begin_forbidden = width_stride_output * (output_h - 1) + output_w * channels; - memcpy(overwrite_contents_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE); + memcpy(overwrite_output_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE); + memcpy(overwrite_tempmem_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE); #endif STBR_UNIMPLEMENTED(type != STBR_TYPE_UINT8); @@ -311,6 +431,20 @@ STBRDEF int stbr_resize_arbitrary(const void* input_data, int input_w, int input stbr__info* stbr_info = (stbr__info*)tempmem; + stbr_info->input_data = input_data; + stbr_info->input_w = input_w; + stbr_info->input_h = input_h; + stbr_info->input_stride_bytes = width_stride_input; + + stbr_info->output_data = output_data; + stbr_info->output_w = output_w; + stbr_info->output_h = output_h; + stbr_info->output_stride_bytes = width_stride_output; + + stbr_info->channels = channels; + stbr_info->type = type; + stbr_info->filter = filter; + stbr_info->total_coefficients = stbr__get_total_coefficients(filter, input_w, output_w); stbr_info->kernel_texel_width = stbr__get_filter_texel_width(filter, output_w > input_w ? 1 : 0); @@ -319,13 +453,62 @@ STBRDEF int stbr_resize_arbitrary(const void* input_data, int input_w, int input stbr_info->horizontal_contributors = STBR__NEXT_MEMPTR(stbr_info, sizeof(stbr__info), stbr__contributors); stbr_info->horizontal_coefficients = STBR__NEXT_MEMPTR(stbr_info->horizontal_contributors, output_w * sizeof(stbr__contributors), float); stbr_info->decode_buffer = STBR__NEXT_MEMPTR(stbr_info->horizontal_coefficients, stbr_info->total_coefficients * sizeof(stbr__contributors), float); + stbr_info->ring_buffer = STBR__NEXT_MEMPTR(stbr_info->decode_buffer, input_w * channels * sizeof(float), float); #undef STBR__NEXT_MEMPTR - stbr__calculate_horizontal_filters(stbr_info, filter, input_w, output_w); + // This signals that the ring buffer is empty + stbr_info->ring_buffer_begin_index = -1; + + stbr__calculate_horizontal_filters(stbr_info); + + float scale_ratio = (float)output_h / input_h; + float out_scanlines_radius = stbr__filter_info_table[filter].support * scale_ratio; + + for (y = 0; y < output_h; y++) + { + float in_center_of_out; // Center of the current out scanline in the in scanline space + int in_first_scanline, in_last_scanline; + + stbr__calculate_sample_range(y, out_scanlines_radius, scale_ratio, &in_first_scanline, &in_last_scanline, &in_center_of_out); + + STBR_DEBUG_ASSERT(in_last_scanline - in_first_scanline <= stbr_info->kernel_texel_width); + STBR_DEBUG_ASSERT(in_first_scanline >= 0); + STBR_DEBUG_ASSERT(in_last_scanline < input_w); + + if (stbr_info->ring_buffer_begin_index >= 0) + { + // Get rid of whatever we don't need anymore. + while (in_first_scanline > stbr_info->ring_buffer_first_scanline) + { + if (stbr_info->ring_buffer_first_scanline == stbr_info->ring_buffer_last_scanline) + { + // We just popped the last scanline off the ring buffer. + // Reset it to the empty state. + stbr_info->ring_buffer_begin_index = -1; + stbr_info->ring_buffer_first_scanline = 0; + stbr_info->ring_buffer_last_scanline = 0; + break; + } + else + stbr_info->ring_buffer_first_scanline++; + } + } + + // Load in new ones. + if (stbr_info->ring_buffer_begin_index < 0) + stbr__decode_and_resample(stbr_info, 0); + + while (in_last_scanline < stbr_info->ring_buffer_last_scanline) + stbr__decode_and_resample(stbr_info, stbr_info->ring_buffer_last_scanline + 1); + + // Now all buffers should be ready to do a row a vertical sampling. + //stbr__resample_vertical(); + } #ifdef STBR_DEBUG_OVERWRITE_TEST - STBR_DEBUG_ASSERT(memcmp(overwrite_contents_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE) == 0); + STBR_DEBUG_ASSERT(memcmp(overwrite_output_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE) == 0); + STBR_DEBUG_ASSERT(memcmp(overwrite_tempmem_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE) == 0); #endif return 1; @@ -343,8 +526,9 @@ STBRDEF stbr_size_t stbr_calculate_memory(int input_w, int input_h, int input_st int decode_buffer_size = input_w * channels * sizeof(float); int contributors_size = output_w * sizeof(stbr__contributors); int coefficients_size = stbr__get_total_coefficients(filter, input_w, output_w) * sizeof(float); + int ring_buffer_size = output_w * channels * sizeof(float) * stbr__get_filter_texel_width(filter, output_w > input_w ? 1 : 0); - return info_size + decode_buffer_size + contributors_size + coefficients_size; + return info_size + decode_buffer_size + contributors_size + coefficients_size + ring_buffer_size; } #endif // STB_RESAMPLE_IMPLEMENTATION