| /* |
| * Copyright (c) 2016, Alliance for Open Media. All rights reserved |
| * |
| * This source code is subject to the terms of the BSD 2 Clause License and |
| * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
| * was not distributed with this source code in the LICENSE file, you can |
| * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
| * Media Patent License 1.0 was not distributed with this source code in the |
| * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
| */ |
| |
| /**************************************************************************** |
| * |
| * Module Title : scale.c |
| * |
| * Description : Image scaling functions. |
| * |
| ***************************************************************************/ |
| |
| /**************************************************************************** |
| * Header Files |
| ****************************************************************************/ |
| #include "config/aom_scale_rtcd.h" |
| |
| #include "aom_mem/aom_mem.h" |
| #include "aom_scale/aom_scale.h" |
| #include "aom_scale/yv12config.h" |
| |
| typedef struct { |
| int expanded_frame_width; |
| int expanded_frame_height; |
| |
| int HScale; |
| int HRatio; |
| int VScale; |
| int VRatio; |
| |
| YV12_BUFFER_CONFIG *src_yuv_config; |
| YV12_BUFFER_CONFIG *dst_yuv_config; |
| |
| } SCALE_VARS; |
| |
| /**************************************************************************** |
| * |
| * ROUTINE : scale1d_2t1_i |
| * |
| * INPUTS : const unsigned char *source : Pointer to data to be scaled. |
| * int source_step : Number of pixels to step on |
| * in source. |
| * unsigned int source_scale : Scale for source (UNUSED). |
| * unsigned int source_length : Length of source (UNUSED). |
| * unsigned char *dest : Pointer to output data array. |
| * int dest_step : Number of pixels to step on |
| * in destination. |
| * unsigned int dest_scale : Scale for destination |
| * (UNUSED). |
| * unsigned int dest_length : Length of destination. |
| * |
| * OUTPUTS : None. |
| * |
| * RETURNS : void |
| * |
| * FUNCTION : Performs 2-to-1 interpolated scaling. |
| * |
| * SPECIAL NOTES : None. |
| * |
| ****************************************************************************/ |
| static void scale1d_2t1_i(const unsigned char *source, int source_step, |
| unsigned int source_scale, unsigned int source_length, |
| unsigned char *dest, int dest_step, |
| unsigned int dest_scale, unsigned int dest_length) { |
| const unsigned char *const dest_end = dest + dest_length * dest_step; |
| (void)source_length; |
| (void)source_scale; |
| (void)dest_scale; |
| |
| source_step *= 2; // Every other row. |
| |
| dest[0] = source[0]; // Special case: 1st pixel. |
| source += source_step; |
| dest += dest_step; |
| |
| while (dest < dest_end) { |
| const unsigned int a = 3 * source[-source_step]; |
| const unsigned int b = 10 * source[0]; |
| const unsigned int c = 3 * source[source_step]; |
| *dest = (unsigned char)((8 + a + b + c) >> 4); |
| source += source_step; |
| dest += dest_step; |
| } |
| } |
| |
| /**************************************************************************** |
| * |
| * ROUTINE : scale1d_2t1_ps |
| * |
| * INPUTS : const unsigned char *source : Pointer to data to be scaled. |
| * int source_step : Number of pixels to step on |
| * in source. |
| * unsigned int source_scale : Scale for source (UNUSED). |
| * unsigned int source_length : Length of source (UNUSED). |
| * unsigned char *dest : Pointer to output data array. |
| * int dest_step : Number of pixels to step on |
| * in destination. |
| * unsigned int dest_scale : Scale for destination |
| * (UNUSED). |
| * unsigned int dest_length : Length of destination. |
| * |
| * OUTPUTS : None. |
| * |
| * RETURNS : void |
| * |
| * FUNCTION : Performs 2-to-1 point subsampled scaling. |
| * |
| * SPECIAL NOTES : None. |
| * |
| ****************************************************************************/ |
| static void scale1d_2t1_ps(const unsigned char *source, int source_step, |
| unsigned int source_scale, |
| unsigned int source_length, unsigned char *dest, |
| int dest_step, unsigned int dest_scale, |
| unsigned int dest_length) { |
| const unsigned char *const dest_end = dest + dest_length * dest_step; |
| (void)source_length; |
| (void)source_scale; |
| (void)dest_scale; |
| |
| source_step *= 2; // Every other row. |
| |
| while (dest < dest_end) { |
| *dest = *source; |
| source += source_step; |
| dest += dest_step; |
| } |
| } |
| /**************************************************************************** |
| * |
| * ROUTINE : scale1d_c |
| * |
| * INPUTS : const unsigned char *source : Pointer to data to be scaled. |
| * int source_step : Number of pixels to step on |
| * in source. |
| * unsigned int source_scale : Scale for source. |
| * unsigned int source_length : Length of source (UNUSED). |
| * unsigned char *dest : Pointer to output data array. |
| * int dest_step : Number of pixels to step on |
| * in destination. |
| * unsigned int dest_scale : Scale for destination. |
| * unsigned int dest_length : Length of destination. |
| * |
| * OUTPUTS : None. |
| * |
| * RETURNS : void |
| * |
| * FUNCTION : Performs linear interpolation in one dimension. |
| * |
| * SPECIAL NOTES : None. |
| * |
| ****************************************************************************/ |
| static void scale1d_c(const unsigned char *source, int source_step, |
| unsigned int source_scale, unsigned int source_length, |
| unsigned char *dest, int dest_step, |
| unsigned int dest_scale, unsigned int dest_length) { |
| const unsigned char *const dest_end = dest + dest_length * dest_step; |
| const unsigned int round_value = dest_scale / 2; |
| unsigned int left_modifier = dest_scale; |
| unsigned int right_modifier = 0; |
| unsigned char left_pixel = source[0]; |
| unsigned char right_pixel = source[source_step]; |
| |
| (void)source_length; |
| |
| /* These asserts are needed if there are boundary issues... */ |
| /* assert ( dest_scale > source_scale );*/ |
| /* assert ( (source_length - 1) * dest_scale >= (dest_length - 1) * |
| * source_scale);*/ |
| |
| while (dest < dest_end) { |
| *dest = (unsigned char)((left_modifier * left_pixel + |
| right_modifier * right_pixel + round_value) / |
| dest_scale); |
| |
| right_modifier += source_scale; |
| |
| while (right_modifier > dest_scale) { |
| right_modifier -= dest_scale; |
| source += source_step; |
| left_pixel = source[0]; |
| right_pixel = source[source_step]; |
| } |
| |
| left_modifier = dest_scale - right_modifier; |
| } |
| } |
| |
| /**************************************************************************** |
| * |
| * ROUTINE : Scale2D |
| * |
| * INPUTS : const unsigned char *source : Pointer to data to be |
| * scaled. |
| * int source_pitch : Stride of source image. |
| * unsigned int source_width : Width of input image. |
| * unsigned int source_height : Height of input image. |
| * unsigned char *dest : Pointer to output data |
| * array. |
| * int dest_pitch : Stride of destination |
| * image. |
| * unsigned int dest_width : Width of destination image. |
| * unsigned int dest_height : Height of destination |
| * image. |
| * unsigned char *temp_area : Pointer to temp work area. |
| * unsigned char temp_area_height : Height of temp work area. |
| * unsigned int hscale : Horizontal scale factor |
| * numerator. |
| * unsigned int hratio : Horizontal scale factor |
| * denominator. |
| * unsigned int vscale : Vertical scale factor |
| * numerator. |
| * unsigned int vratio : Vertical scale factor |
| * denominator. |
| * unsigned int interlaced : Interlace flag. |
| * |
| * OUTPUTS : None. |
| * |
| * RETURNS : void |
| * |
| * FUNCTION : Performs 2-tap linear interpolation in two dimensions. |
| * |
| * SPECIAL NOTES : Expansion is performed one band at a time to help with |
| * caching. |
| * |
| ****************************************************************************/ |
| static void Scale2D( |
| /*const*/ |
| unsigned char *source, int source_pitch, unsigned int source_width, |
| unsigned int source_height, unsigned char *dest, int dest_pitch, |
| unsigned int dest_width, unsigned int dest_height, unsigned char *temp_area, |
| unsigned char temp_area_height, unsigned int hscale, unsigned int hratio, |
| unsigned int vscale, unsigned int vratio, unsigned int interlaced) { |
| unsigned int i, j, k; |
| unsigned int bands; |
| unsigned int dest_band_height; |
| unsigned int source_band_height; |
| |
| typedef void (*Scale1D)(const unsigned char *source, int source_step, |
| unsigned int source_scale, unsigned int source_length, |
| unsigned char *dest, int dest_step, |
| unsigned int dest_scale, unsigned int dest_length); |
| |
| Scale1D Scale1Dv = scale1d_c; |
| Scale1D Scale1Dh = scale1d_c; |
| |
| void (*horiz_line_scale)(const unsigned char *, unsigned int, unsigned char *, |
| unsigned int) = NULL; |
| void (*vert_band_scale)(unsigned char *, int, unsigned char *, int, |
| unsigned int) = NULL; |
| |
| int ratio_scalable = 1; |
| int interpolation = 0; |
| |
| unsigned char *source_base; |
| unsigned char *line_src; |
| |
| source_base = (unsigned char *)source; |
| |
| if (source_pitch < 0) { |
| int offset; |
| |
| offset = (source_height - 1); |
| offset *= source_pitch; |
| |
| source_base += offset; |
| } |
| |
| /* find out the ratio for each direction */ |
| switch (hratio * 10 / hscale) { |
| case 8: |
| /* 4-5 Scale in Width direction */ |
| horiz_line_scale = aom_horizontal_line_5_4_scale; |
| break; |
| case 6: |
| /* 3-5 Scale in Width direction */ |
| horiz_line_scale = aom_horizontal_line_5_3_scale; |
| break; |
| case 5: |
| /* 1-2 Scale in Width direction */ |
| horiz_line_scale = aom_horizontal_line_2_1_scale; |
| break; |
| default: |
| /* The ratio is not acceptable now */ |
| /* throw("The ratio is not acceptable for now!"); */ |
| ratio_scalable = 0; |
| break; |
| } |
| |
| switch (vratio * 10 / vscale) { |
| case 8: |
| /* 4-5 Scale in vertical direction */ |
| vert_band_scale = aom_vertical_band_5_4_scale; |
| source_band_height = 5; |
| dest_band_height = 4; |
| break; |
| case 6: |
| /* 3-5 Scale in vertical direction */ |
| vert_band_scale = aom_vertical_band_5_3_scale; |
| source_band_height = 5; |
| dest_band_height = 3; |
| break; |
| case 5: |
| /* 1-2 Scale in vertical direction */ |
| |
| if (interlaced) { |
| /* if the content is interlaced, point sampling is used */ |
| vert_band_scale = aom_vertical_band_2_1_scale; |
| } else { |
| interpolation = 1; |
| /* if the content is progressive, interplo */ |
| vert_band_scale = aom_vertical_band_2_1_scale_i; |
| } |
| |
| source_band_height = 2; |
| dest_band_height = 1; |
| break; |
| default: |
| /* The ratio is not acceptable now */ |
| /* throw("The ratio is not acceptable for now!"); */ |
| ratio_scalable = 0; |
| break; |
| } |
| |
| if (ratio_scalable) { |
| if (source_height == dest_height) { |
| /* for each band of the image */ |
| for (k = 0; k < dest_height; ++k) { |
| horiz_line_scale(source, source_width, dest, dest_width); |
| source += source_pitch; |
| dest += dest_pitch; |
| } |
| |
| return; |
| } |
| |
| if (interpolation) { |
| if (source < source_base) source = source_base; |
| |
| horiz_line_scale(source, source_width, temp_area, dest_width); |
| } |
| |
| for (k = 0; k < (dest_height + dest_band_height - 1) / dest_band_height; |
| ++k) { |
| /* scale one band horizontally */ |
| for (i = 0; i < source_band_height; ++i) { |
| /* Trap case where we could read off the base of the source buffer */ |
| |
| line_src = source + i * source_pitch; |
| |
| if (line_src < source_base) line_src = source_base; |
| |
| horiz_line_scale(line_src, source_width, |
| temp_area + (i + 1) * dest_pitch, dest_width); |
| } |
| |
| /* Vertical scaling is in place */ |
| vert_band_scale(temp_area + dest_pitch, dest_pitch, dest, dest_pitch, |
| dest_width); |
| |
| if (interpolation) |
| memcpy(temp_area, temp_area + source_band_height * dest_pitch, |
| dest_width); |
| |
| /* Next band... */ |
| source += (unsigned long)source_band_height * source_pitch; |
| dest += (unsigned long)dest_band_height * dest_pitch; |
| } |
| |
| return; |
| } |
| |
| if (hscale == 2 && hratio == 1) Scale1Dh = scale1d_2t1_ps; |
| |
| if (vscale == 2 && vratio == 1) { |
| if (interlaced) |
| Scale1Dv = scale1d_2t1_ps; |
| else |
| Scale1Dv = scale1d_2t1_i; |
| } |
| |
| if (source_height == dest_height) { |
| /* for each band of the image */ |
| for (k = 0; k < dest_height; ++k) { |
| Scale1Dh(source, 1, hscale, source_width + 1, dest, 1, hratio, |
| dest_width); |
| source += source_pitch; |
| dest += dest_pitch; |
| } |
| |
| return; |
| } |
| |
| if (dest_height > source_height) { |
| dest_band_height = temp_area_height - 1; |
| source_band_height = dest_band_height * source_height / dest_height; |
| } else { |
| source_band_height = temp_area_height - 1; |
| dest_band_height = source_band_height * vratio / vscale; |
| } |
| |
| /* first row needs to be done so that we can stay one row ahead for vertical |
| * zoom */ |
| Scale1Dh(source, 1, hscale, source_width + 1, temp_area, 1, hratio, |
| dest_width); |
| |
| /* for each band of the image */ |
| bands = (dest_height + dest_band_height - 1) / dest_band_height; |
| |
| for (k = 0; k < bands; ++k) { |
| /* scale one band horizontally */ |
| for (i = 1; i < source_band_height + 1; ++i) { |
| if (k * source_band_height + i < source_height) { |
| Scale1Dh(source + i * source_pitch, 1, hscale, source_width + 1, |
| temp_area + i * dest_pitch, 1, hratio, dest_width); |
| } else { /* Duplicate the last row */ |
| /* copy temp_area row 0 over from last row in the past */ |
| memcpy(temp_area + i * dest_pitch, temp_area + (i - 1) * dest_pitch, |
| dest_pitch); |
| } |
| } |
| |
| /* scale one band vertically */ |
| for (j = 0; j < dest_width; ++j) { |
| Scale1Dv(&temp_area[j], dest_pitch, vscale, source_band_height + 1, |
| &dest[j], dest_pitch, vratio, dest_band_height); |
| } |
| |
| /* copy temp_area row 0 over from last row in the past */ |
| memcpy(temp_area, temp_area + source_band_height * dest_pitch, dest_pitch); |
| |
| /* move to the next band */ |
| source += source_band_height * source_pitch; |
| dest += dest_band_height * dest_pitch; |
| } |
| } |
| |
| /**************************************************************************** |
| * |
| * ROUTINE : aom_scale_frame |
| * |
| * INPUTS : YV12_BUFFER_CONFIG *src : Pointer to frame to be |
| * scaled. |
| * YV12_BUFFER_CONFIG *dst : Pointer to buffer to hold |
| * scaled frame. |
| * unsigned char *temp_area : Pointer to temp work area. |
| * unsigned char temp_area_height : Height of temp work area. |
| * unsigned int hscale : Horizontal scale factor |
| * numerator. |
| * unsigned int hratio : Horizontal scale factor |
| * denominator. |
| * unsigned int vscale : Vertical scale factor |
| * numerator. |
| * unsigned int vratio : Vertical scale factor |
| * denominator. |
| * unsigned int interlaced : Interlace flag. |
| * |
| * OUTPUTS : None. |
| * |
| * RETURNS : void |
| * |
| * FUNCTION : Performs 2-tap linear interpolation in two dimensions. |
| * |
| * SPECIAL NOTES : Expansion is performed one band at a time to help with |
| * caching. |
| * |
| ****************************************************************************/ |
| void aom_scale_frame(YV12_BUFFER_CONFIG *src, YV12_BUFFER_CONFIG *dst, |
| unsigned char *temp_area, unsigned char temp_height, |
| unsigned int hscale, unsigned int hratio, |
| unsigned int vscale, unsigned int vratio, |
| unsigned int interlaced, const int num_planes) { |
| const int dw = (hscale - 1 + src->y_width * hratio) / hscale; |
| const int dh = (vscale - 1 + src->y_height * vratio) / vscale; |
| |
| for (int plane = 0; plane < num_planes; ++plane) { |
| const int is_uv = plane > 0; |
| const int plane_dw = dw >> is_uv; |
| const int plane_dh = dh >> is_uv; |
| |
| Scale2D((unsigned char *)src->buffers[plane], src->strides[is_uv], |
| src->widths[is_uv], src->heights[is_uv], |
| (unsigned char *)dst->buffers[plane], dst->strides[is_uv], plane_dw, |
| plane_dh, temp_area, temp_height, hscale, hratio, vscale, vratio, |
| interlaced); |
| |
| if (plane_dw < dst->widths[is_uv]) |
| for (int i = 0; i < plane_dh; ++i) |
| memset(dst->buffers[plane] + i * dst->strides[is_uv] + plane_dw - 1, |
| dst->buffers[plane][i * dst->strides[is_uv] + plane_dw - 2], |
| dst->widths[is_uv] - plane_dw + 1); |
| |
| if (plane_dh < dst->heights[is_uv]) |
| for (int i = plane_dh - 1; i < dst->heights[is_uv]; ++i) |
| memcpy(dst->buffers[plane] + i * dst->strides[is_uv], |
| dst->buffers[plane] + (plane_dh - 2) * dst->strides[is_uv], |
| dst->widths[is_uv] + 1); |
| } |
| } |
