/*
* Copyright (C) 2016 The Android Open Source Project
* Copyright (C) 2016 Mopria Alliance, Inc.
* Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "wprint_scaler.h"
#include <assert.h>
#include <stdio.h>
#define ROUND_4_DOWN(x) ((x) & ~3)
#define ROUND_4_UP(x) (ROUND_4_DOWN((x) + 3))
#define PSCALER_FRACT_BITS_COUNT 24
typedef enum {
FRACTION_ROUND_UP,
FRACTION_TRUNCATE
} pscaler_fraction_t;
static uint32
_scaler_fraction_part(uint32 iNum, uint32 iDen, pscaler_fraction_t mode, bool_t *overflow);
static void _hw_scale_image_plane(scaler_config_t *pscaler_config, scaler_mode_t scaleMode);
static void _calculate_factors(scaler_config_t *pscaler_config, scaler_mode_t scaleMode);
void scaler_make_image_scaler_tables(uint16 image_input_width, uint16 image_input_buf_width,
uint16 image_output_width, uint16 image_output_buf_width, uint16 image_input_height,
uint16 image_output_height, scaler_config_t *pscaler_config) {
pscaler_config->iSrcWidth = image_input_width;
pscaler_config->iSrcHeight = image_input_height;
pscaler_config->iOutWidth = image_output_width;
pscaler_config->iOutHeight = image_output_height;
if ((image_input_width >= image_output_width) &&
(image_input_height >= image_output_height)) { // scale DOWN
pscaler_config->scaleMode = PSCALER_SCALE_DOWN;
} else if ((image_input_width <= image_output_width) &&
(image_input_height <= image_output_height)) { // scale UP
pscaler_config->scaleMode = PSCALER_SCALE_UP;
} else if (image_input_width > image_output_width) { // mixed scale Y-axis first
pscaler_config->scaleMode = PSCALER_SCALE_MIXED_YUP;
} else { // mixed scale X-axis first
pscaler_config->scaleMode = PSCALER_SCALE_MIXED_XUP;
}
// Setup scale factors
_calculate_factors(pscaler_config, pscaler_config->scaleMode);
// calculates initial buffer sizes for scaling whole image
// start rows == 0
// end_rows == image height
// buffer widths == image widths
pscaler_config->fSrcStartRow.decimal = 0;
pscaler_config->fSrcStartRow.fraction = 0;
pscaler_config->iSrcStartRow = 0;
pscaler_config->iSrcEndRow = pscaler_config->iSrcHeight;
pscaler_config->iSrcBufWidth = image_input_buf_width;
pscaler_config->iOutStartRow = 0;
pscaler_config->iOutEndRow = pscaler_config->iOutHeight;
pscaler_config->iOutBufWidth = image_output_buf_width;
pscaler_config->pSrcBuf = NULL;
pscaler_config->pOutBuf = NULL;
pscaler_config->pTmpBuf = NULL;
}
void scaler_calculate_scaling_rows(uint16 start_output_row_number, uint16 end_output_row_number,
void *tables_ptr, uint16 *start_input_row_number, uint16 *end_input_row_number,
uint16 *num_output_rows_generated, uint16 *num_rows_offset_to_start_output_row,
uint32 *mixed_axis_temp_buffer_size_needed) {
float64_t fSrcEndRow;
bool_t overflow;
scaler_config_t *pscaler_config;
pscaler_config = (scaler_config_t *) tables_ptr;
assert (start_output_row_number < pscaler_config->iOutHeight);
// copy the output start and end rows
// Don't ever attempt to output a single row from the scaler.
if (end_output_row_number == start_output_row_number) {
if (start_output_row_number == 0) {
pscaler_config->iOutStartRow = start_output_row_number;
pscaler_config->iOutEndRow = end_output_row_number + 1;
*num_rows_offset_to_start_output_row = 0;
} else {
pscaler_config->iOutStartRow = start_output_row_number - 1;
pscaler_config->iOutEndRow = end_output_row_number;
*num_rows_offset_to_start_output_row = 1;
}
} else {
pscaler_config->iOutStartRow = start_output_row_number;
pscaler_config->iOutEndRow = end_output_row_number;
*num_rows_offset_to_start_output_row = 0;
}
if (pscaler_config->iOutEndRow >= pscaler_config->iOutHeight) { // last stripe
pscaler_config->iOutEndRow = pscaler_config->iOutHeight - 1;
}
if (pscaler_config->scaleMode == PSCALER_SCALE_UP ||
pscaler_config->scaleMode == PSCALER_SCALE_MIXED_YUP) {
// scale factors are calculated as dim-1/dim-1
pscaler_config->iSrcHeight--;
pscaler_config->iOutHeight--;
}
pscaler_config->fSrcStartRow.decimal = (uint32) pscaler_config->iOutStartRow *
(uint32) pscaler_config->iSrcHeight / (uint32) pscaler_config->iOutHeight;
pscaler_config->fSrcStartRow.fraction = _scaler_fraction_part(
(uint32) pscaler_config->iOutStartRow * (uint32) pscaler_config->iSrcHeight,
(uint32) pscaler_config->iOutHeight, FRACTION_ROUND_UP, &overflow);
if (overflow) {
pscaler_config->fSrcStartRow.decimal++;
}
pscaler_config->iSrcStartRow = pscaler_config->fSrcStartRow.decimal;
if (pscaler_config->scaleMode == PSCALER_SCALE_UP ||
pscaler_config->scaleMode == PSCALER_SCALE_MIXED_YUP) {
fSrcEndRow.decimal = (uint32) pscaler_config->iOutEndRow *
(uint32) pscaler_config->iSrcHeight / (uint32) pscaler_config->iOutHeight;
fSrcEndRow.fraction = _scaler_fraction_part(
(uint32) pscaler_config->iOutEndRow * (uint32) pscaler_config->iSrcHeight,
(uint32) pscaler_config->iOutHeight, FRACTION_TRUNCATE, &overflow);
pscaler_config->iSrcEndRow = (uint16) fSrcEndRow.decimal;
if (0 != fSrcEndRow.fraction) {
// will cause an extra output row to be created...
pscaler_config->iSrcEndRow++;
pscaler_config->iOutEndRow++;
}
// restore dimensions
pscaler_config->iSrcHeight++;
pscaler_config->iOutHeight++;
} else {
fSrcEndRow.decimal = (uint32) (pscaler_config->iOutEndRow + 1) *
(uint32) pscaler_config->iSrcHeight /
(uint32) pscaler_config->iOutHeight;
fSrcEndRow.fraction = _scaler_fraction_part(
(uint32) (pscaler_config->iOutEndRow + 1) * (uint32) pscaler_config->iSrcHeight,
(uint32) pscaler_config->iOutHeight, FRACTION_TRUNCATE, &overflow);
pscaler_config->iSrcEndRow = (uint16) fSrcEndRow.decimal;
if (0 == fSrcEndRow.fraction) {
pscaler_config->iSrcEndRow--;
}
}
// check to be sure we're not going beyond the source image
if (pscaler_config->iSrcEndRow >= pscaler_config->iSrcHeight) { // last stripe
pscaler_config->iSrcEndRow = pscaler_config->iSrcHeight - 1;
}
*start_input_row_number = pscaler_config->iSrcStartRow;
*end_input_row_number = pscaler_config->iSrcEndRow;
*num_output_rows_generated = (pscaler_config->iOutEndRow - pscaler_config->iOutStartRow + 1);
// Calculate the 2nd pass buffer size if mixed scaling is done
if (pscaler_config->scaleMode == PSCALER_SCALE_MIXED_XUP) {
*mixed_axis_temp_buffer_size_needed =
ROUND_4_UP(pscaler_config->iOutWidth + 1) *
(*end_input_row_number - *start_input_row_number + 1);
} else if (pscaler_config->scaleMode == PSCALER_SCALE_MIXED_YUP) {
*mixed_axis_temp_buffer_size_needed =
ROUND_4_UP(pscaler_config->iSrcWidth) * (*num_output_rows_generated + 1);
} else {
*mixed_axis_temp_buffer_size_needed = 0;
}
(*num_output_rows_generated)++;
}
void scaler_scale_image_data(uint8 *input_plane, void *tables_ptr, uint8 *scaled_output_plane,
uint8 *temp_buffer_for_mixed_axis_scaling) {
uint16 iOrigWidth, iOrigHeight, iOrigOutBufWidth, iOrigSrcBufWidth;
uint16 iOrigOutStartRow, iOrigOutEndRow, iOrigSrcStartRow, iOrigSrcEndRow;
float64_t fOrigSrcStartRow;
uint8 *pOrigBuf;
scaler_config_t *pscaler_config;
pscaler_config = (scaler_config_t *) tables_ptr;
pscaler_config->pSrcBuf = input_plane;
pscaler_config->pOutBuf = scaled_output_plane;
if ((PSCALER_SCALE_MIXED_XUP == pscaler_config->scaleMode) ||
(PSCALER_SCALE_MIXED_YUP == pscaler_config->scaleMode)) {
pscaler_config->pTmpBuf = temp_buffer_for_mixed_axis_scaling;
// save the output buffer
pOrigBuf = pscaler_config->pOutBuf;
// use the temp buff as the output buff for pass 1
pscaler_config->pOutBuf = pscaler_config->pTmpBuf;
if (PSCALER_SCALE_MIXED_YUP == pscaler_config->scaleMode) {
// save the original output widths
iOrigWidth = pscaler_config->iOutWidth;
iOrigOutBufWidth = pscaler_config->iOutBufWidth;
// set output widths to input widths (1::1)
pscaler_config->iOutWidth = pscaler_config->iSrcWidth;
pscaler_config->iOutBufWidth = pscaler_config->iSrcBufWidth;
// calculate the new scaler factors
_calculate_factors(pscaler_config, PSCALER_SCALE_UP);
// Run the photo scaler hardware
_hw_scale_image_plane(pscaler_config, PSCALER_SCALE_UP);
// reset the output widths
pscaler_config->iOutWidth = iOrigWidth;
pscaler_config->iOutBufWidth = iOrigOutBufWidth;
} else {
// save the original output height and row info
iOrigHeight = pscaler_config->iOutHeight;
iOrigOutStartRow = pscaler_config->iOutStartRow;
iOrigOutEndRow = pscaler_config->iOutEndRow;
fOrigSrcStartRow.fraction = pscaler_config->fSrcStartRow.fraction;
// set output height and rows to input height and rows(1::1)
pscaler_config->iOutHeight = pscaler_config->iSrcHeight;
pscaler_config->iOutStartRow = pscaler_config->iSrcStartRow;
pscaler_config->iOutEndRow = pscaler_config->iSrcEndRow;
pscaler_config->fSrcStartRow.fraction = 0;
// calculate the new scaler factors
_calculate_factors(pscaler_config, PSCALER_SCALE_UP);
// Run the photo scaler hardware
_hw_scale_image_plane(pscaler_config, PSCALER_SCALE_UP);
// reset the output height and rows
pscaler_config->iOutHeight = iOrigHeight;
pscaler_config->iOutStartRow = iOrigOutStartRow;
pscaler_config->iOutEndRow = iOrigOutEndRow;
pscaler_config->fSrcStartRow.fraction = fOrigSrcStartRow.fraction;
}
// restore the original output buffer
pscaler_config->pOutBuf = pOrigBuf;
// save the original input buffer
pOrigBuf = pscaler_config->pSrcBuf;
// use the previous output (temp) buffer as the new input buffer
pscaler_config->pSrcBuf = pscaler_config->pTmpBuf;
if (PSCALER_SCALE_MIXED_YUP == pscaler_config->scaleMode) {
// save the original input height and rows
iOrigHeight = pscaler_config->iSrcHeight;
iOrigSrcStartRow = pscaler_config->iSrcStartRow;
iOrigSrcEndRow = pscaler_config->iSrcEndRow;
fOrigSrcStartRow.decimal = pscaler_config->fSrcStartRow.decimal;
fOrigSrcStartRow.fraction = pscaler_config->fSrcStartRow.fraction;
// set the height and rows to 1::1 for the second pass
pscaler_config->iSrcHeight = pscaler_config->iOutHeight;
pscaler_config->iSrcStartRow = pscaler_config->iOutStartRow;
pscaler_config->iSrcEndRow = pscaler_config->iOutEndRow;
pscaler_config->fSrcStartRow.decimal = pscaler_config->iOutStartRow;
pscaler_config->fSrcStartRow.fraction = 0;
// calculate new scale factors
_calculate_factors(pscaler_config, PSCALER_SCALE_DOWN);
// Run the photo scaler hardware
_hw_scale_image_plane(pscaler_config, PSCALER_SCALE_DOWN);
// restore original input height and rows
pscaler_config->iSrcHeight = iOrigHeight;
pscaler_config->iSrcStartRow = iOrigSrcStartRow;
pscaler_config->iSrcEndRow = iOrigSrcEndRow;
pscaler_config->fSrcStartRow.decimal = fOrigSrcStartRow.decimal;
pscaler_config->fSrcStartRow.fraction = fOrigSrcStartRow.fraction;
} else {
// save the original input widths
iOrigWidth = pscaler_config->iSrcWidth;
iOrigSrcBufWidth = pscaler_config->iSrcBufWidth;
// set the widths to 1::1 for the second pass
pscaler_config->iSrcWidth = pscaler_config->iOutWidth;
pscaler_config->iSrcBufWidth = pscaler_config->iOutBufWidth;
// calculate new scale factors
_calculate_factors(pscaler_config, PSCALER_SCALE_DOWN);
// Run the photo scaler hardware
_hw_scale_image_plane(pscaler_config, PSCALER_SCALE_DOWN);
// restore original input widths
pscaler_config->iSrcWidth = iOrigWidth;
pscaler_config->iSrcBufWidth = iOrigSrcBufWidth;
}
// restore the input buffer
pscaler_config->pTmpBuf = pscaler_config->pSrcBuf;
pscaler_config->pSrcBuf = pOrigBuf;
// release the temp buffer
pscaler_config->pTmpBuf = NULL;
} else {
// Run the photo scaler hardware
_hw_scale_image_plane(pscaler_config, pscaler_config->scaleMode);
}
}
static void _calculate_factors(scaler_config_t *pscaler_config, scaler_mode_t scaleMode) {
bool_t overflow;
if ((pscaler_config->scaleMode == PSCALER_SCALE_UP) ||
(pscaler_config->scaleMode == PSCALER_SCALE_MIXED_YUP)) {
// scale up factors are computed as (dim-1)/(dim-1)
pscaler_config->iSrcHeight--;
pscaler_config->iOutHeight--;
}
if ((pscaler_config->scaleMode == PSCALER_SCALE_UP) ||
(pscaler_config->scaleMode == PSCALER_SCALE_MIXED_XUP)) {
pscaler_config->iSrcWidth--;
pscaler_config->iOutWidth--;
}
pscaler_config->fXfactor.decimal = (uint32) pscaler_config->iOutWidth /
(uint32) pscaler_config->iSrcWidth;
pscaler_config->fXfactor.fraction = _scaler_fraction_part(
(uint32) pscaler_config->iOutWidth,
(uint32) pscaler_config->iSrcWidth,
FRACTION_TRUNCATE,
&overflow);
pscaler_config->fXfactorInv.decimal = (uint32) pscaler_config->iSrcWidth /
(uint32) pscaler_config->iOutWidth;
pscaler_config->fXfactorInv.fraction = _scaler_fraction_part(
(uint32) pscaler_config->iSrcWidth, (uint32) pscaler_config->iOutWidth,
FRACTION_ROUND_UP, &overflow);
if (overflow) {
pscaler_config->fXfactorInv.decimal++;
}
pscaler_config->fYfactor.decimal = (uint32) pscaler_config->iOutHeight /
(uint32) pscaler_config->iSrcHeight;
pscaler_config->fYfactor.fraction = _scaler_fraction_part(
(uint32) pscaler_config->iOutHeight, (uint32) pscaler_config->iSrcHeight,
FRACTION_TRUNCATE, &overflow);
pscaler_config->fYfactorInv.decimal = (uint32) pscaler_config->iSrcHeight /
(uint32) pscaler_config->iOutHeight;
pscaler_config->fYfactorInv.fraction = _scaler_fraction_part(
(uint32) pscaler_config->iSrcHeight, (uint32) pscaler_config->iOutHeight,
FRACTION_ROUND_UP, &overflow);
if (overflow) {
pscaler_config->fYfactorInv.decimal++;
}
if ((pscaler_config->scaleMode == PSCALER_SCALE_UP) ||
(pscaler_config->scaleMode == PSCALER_SCALE_MIXED_YUP)) {
// restore original dimensions
pscaler_config->iSrcHeight++;
pscaler_config->iOutHeight++;
}
if ((pscaler_config->scaleMode == PSCALER_SCALE_UP) ||
(pscaler_config->scaleMode == PSCALER_SCALE_MIXED_XUP)) {
pscaler_config->iSrcWidth++;
pscaler_config->iOutWidth++;
}
}
static uint32 _scaler_fraction_part(uint32 iNum, uint32 iDen, pscaler_fraction_t mode,
bool_t *overflow) {
uint32 iFract; // fractional part
uint32 iRem; // remainder part
int i; // loop counter
*overflow = 0;
iFract = 0;
iRem = iNum % iDen;
if (iRem == 0) {
return (0);
}
for (i = PSCALER_FRACT_BITS_COUNT - 1; i >= 0; i--) {
iRem <<= 1;
if (iRem == iDen) {
iFract |= (1 << i);
break;
} else if (iRem > iDen) {
iFract |= (1 << i);
iRem -= iDen;
}
}
if (mode == FRACTION_TRUNCATE) {
return (iFract << 8);
} else {
if (iRem == 0) {
return (iFract << 8);
} else {
if (iFract < 0x00ffffff) {
iFract++;
return (iFract << 8);
} else {
*overflow = 1;
return (0);
}
}
}
}
#define _RESTRICT_ __restrict__
static inline void _scale_row_down_9in(uint8 *_RESTRICT_ in0, uint8 *_RESTRICT_ in1,
uint8 *_RESTRICT_ in2, uint8 *_RESTRICT_ in3, uint8 *_RESTRICT_ in4, uint8 *_RESTRICT_ in5,
uint8 *_RESTRICT_ in6, uint8 *_RESTRICT_ in7, uint8 *_RESTRICT_ in8, uint8 *_RESTRICT_ out,
uint64 position_x, uint64 x_factor_inv, uint32 top_weight, uint32 bot_weight,
uint32 weight_reciprocal, int out_width) {
int x;
uint32 in_col;
sint32 total_weight;
for (x = 0; x < out_width; x++) {
uint32 acc_r = 0;
uint32 acc_g = 0;
uint32 acc_b = 0;
uint32 curr_weight = 256 - ((position_x >> 24) & 0xff);
total_weight = x_factor_inv >> 24;
in_col = position_x >> 32;
while (total_weight > 0) {
acc_r += (uint32) in0[(in_col * 3) + 0] * curr_weight * top_weight;
acc_r += (uint32) in1[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in2[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in3[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in4[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in5[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in6[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in7[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in8[(in_col * 3) + 0] * curr_weight * bot_weight;
acc_g += (uint32) in0[(in_col * 3) + 1] * curr_weight * top_weight;
acc_g += (uint32) in1[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in2[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in3[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in4[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in5[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in6[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in7[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in8[(in_col * 3) + 1] * curr_weight * bot_weight;
acc_b += (uint32) in0[(in_col * 3) + 2] * curr_weight * top_weight;
acc_b += (uint32) in1[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in2[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in3[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in4[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in5[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in6[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in7[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in8[(in_col * 3) + 2] * curr_weight * bot_weight;
in_col++;
total_weight -= curr_weight;
curr_weight = total_weight > 256 ? 256 : total_weight;
}
position_x += x_factor_inv;
out[(x * 3) + 0] = ((uint64) acc_r * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 0] = ((uint64) acc_g * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 0] = ((uint64) acc_b * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
}
}
static inline void _scale_row_down_8in(uint8 *_RESTRICT_ in0, uint8 *_RESTRICT_ in1,
uint8 *_RESTRICT_ in2, uint8 *_RESTRICT_ in3, uint8 *_RESTRICT_ in4, uint8 *_RESTRICT_ in5,
uint8 *_RESTRICT_ in6, uint8 *_RESTRICT_ in7, uint8 *_RESTRICT_ out, uint64 position_x,
uint64 x_factor_inv, uint32 top_weight,
uint32 bot_weight, uint32 weight_reciprocal,
int out_width) {
int x;
uint32 in_col;
sint32 total_weight;
for (x = 0; x < out_width; x++) {
uint32 acc_r = 0;
uint32 acc_g = 0;
uint32 acc_b = 0;
uint32 curr_weight = 256 - ((position_x >> 24) & 0xff);
total_weight = x_factor_inv >> 24;
in_col = position_x >> 32;
while (total_weight > 0) {
acc_r += (uint32) in0[(in_col * 3) + 0] * curr_weight * top_weight;
acc_r += (uint32) in1[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in2[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in3[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in4[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in5[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in6[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in7[(in_col * 3) + 0] * curr_weight * bot_weight;
acc_g += (uint32) in0[(in_col * 3) + 1] * curr_weight * top_weight;
acc_g += (uint32) in1[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in2[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in3[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in4[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in5[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in6[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in7[(in_col * 3) + 1] * curr_weight * bot_weight;
acc_b += (uint32) in0[(in_col * 3) + 2] * curr_weight * top_weight;
acc_b += (uint32) in1[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in2[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in3[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in4[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in5[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in6[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in7[(in_col * 3) + 2] * curr_weight * bot_weight;
in_col++;
total_weight -= curr_weight;
curr_weight = total_weight > 256 ? 256 : total_weight;
}
position_x += x_factor_inv;
out[(x * 3) + 0] = ((uint64) acc_r * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 1] = ((uint64) acc_g * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 2] = ((uint64) acc_b * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
}
}
static inline void _scale_row_down_7in(uint8 *_RESTRICT_ in0, uint8 *_RESTRICT_ in1,
uint8 *_RESTRICT_ in2, uint8 *_RESTRICT_ in3, uint8 *_RESTRICT_ in4, uint8 *_RESTRICT_ in5,
uint8 *_RESTRICT_ in6, uint8 *_RESTRICT_ out, uint64 position_x, uint64 x_factor_inv,
uint32 top_weight, uint32 bot_weight, uint32 weight_reciprocal, int out_width) {
int x;
uint32 in_col;
sint32 total_weight;
for (x = 0; x < out_width; x++) {
uint32 acc_r = 0;
uint32 acc_g = 0;
uint32 acc_b = 0;
uint32 curr_weight = 256 - ((position_x >> 24) & 0xff);
total_weight = x_factor_inv >> 24;
in_col = position_x >> 32;
while (total_weight > 0) {
acc_r += (uint32) in0[(in_col * 3) + 0] * curr_weight * top_weight;
acc_r += (uint32) in1[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in2[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in3[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in4[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in5[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in6[(in_col * 3) + 0] * curr_weight * bot_weight;
acc_g += (uint32) in0[(in_col * 3) + 1] * curr_weight * top_weight;
acc_g += (uint32) in1[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in2[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in3[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in4[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in5[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in6[(in_col * 3) + 1] * curr_weight * bot_weight;
acc_b += (uint32) in0[(in_col * 3) + 2] * curr_weight * top_weight;
acc_b += (uint32) in1[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in2[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in3[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in4[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in5[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in6[(in_col * 3) + 2] * curr_weight * bot_weight;
in_col++;
total_weight -= curr_weight;
curr_weight = total_weight > 256 ? 256 : total_weight;
}
position_x += x_factor_inv;
out[(x * 3) + 0] = ((uint64) acc_r * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 1] = ((uint64) acc_g * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 2] = ((uint64) acc_b * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
}
}
static inline void _scale_row_down_6in(uint8 *_RESTRICT_ in0, uint8 *_RESTRICT_ in1,
uint8 *_RESTRICT_ in2, uint8 *_RESTRICT_ in3, uint8 *_RESTRICT_ in4, uint8 *_RESTRICT_ in5,
uint8 *_RESTRICT_ out, uint64 position_x, uint64 x_factor_inv, uint32 top_weight,
uint32 bot_weight, uint32 weight_reciprocal, int out_width) {
int x;
uint32 in_col;
sint32 total_weight;
for (x = 0; x < out_width; x++) {
uint32 acc_r = 0;
uint32 acc_g = 0;
uint32 acc_b = 0;
uint32 curr_weight = 256 - ((position_x >> 24) & 0xff);
total_weight = x_factor_inv >> 24;
in_col = position_x >> 32;
while (total_weight > 0) {
acc_r += (uint32) in0[(in_col * 3) + 0] * curr_weight * top_weight;
acc_r += (uint32) in1[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in2[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in3[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in4[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in5[(in_col * 3) + 0] * curr_weight * bot_weight;
acc_g += (uint32) in0[(in_col * 3) + 1] * curr_weight * top_weight;
acc_g += (uint32) in1[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in2[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in3[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in4[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in5[(in_col * 3) + 1] * curr_weight * bot_weight;
acc_b += (uint32) in0[(in_col * 3) + 2] * curr_weight * top_weight;
acc_b += (uint32) in1[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in2[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in3[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in4[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in5[(in_col * 3) + 2] * curr_weight * bot_weight;
in_col++;
total_weight -= curr_weight;
curr_weight = total_weight > 256 ? 256 : total_weight;
}
position_x += x_factor_inv;
out[(x * 3) + 0] = ((uint64) acc_r * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 1] = ((uint64) acc_g * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 2] = ((uint64) acc_b * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
}
}
static inline void _scale_row_down_5in(uint8 *_RESTRICT_ in0, uint8 *_RESTRICT_ in1,
uint8 *_RESTRICT_ in2, uint8 *_RESTRICT_ in3, uint8 *_RESTRICT_ in4, uint8 *_RESTRICT_ out,
uint64 position_x, uint64 x_factor_inv, uint32 top_weight, uint32 bot_weight,
uint32 weight_reciprocal, int out_width) {
int x;
uint32 in_col;
sint32 total_weight;
for (x = 0; x < out_width; x++) {
uint32 acc_r = 0;
uint32 acc_g = 0;
uint32 acc_b = 0;
uint32 curr_weight = 256 - ((position_x >> 24) & 0xff);
total_weight = x_factor_inv >> 24;
in_col = position_x >> 32;
while (total_weight > 0) {
acc_r += (uint32) in0[(in_col * 3) + 0] * curr_weight * top_weight;
acc_r += (uint32) in1[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in2[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in3[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in4[(in_col * 3) + 0] * curr_weight * bot_weight;
acc_g += (uint32) in0[(in_col * 3) + 1] * curr_weight * top_weight;
acc_g += (uint32) in1[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in2[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in3[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in4[(in_col * 3) + 1] * curr_weight * bot_weight;
acc_b += (uint32) in0[(in_col * 3) + 2] * curr_weight * top_weight;
acc_b += (uint32) in1[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in2[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in3[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in4[(in_col * 3) + 2] * curr_weight * bot_weight;
in_col++;
total_weight -= curr_weight;
curr_weight = total_weight > 256 ? 256 : total_weight;
}
position_x += x_factor_inv;
out[(x * 3) + 0] = ((uint64) acc_r * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 1] = ((uint64) acc_g * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 2] = ((uint64) acc_b * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
}
}
static inline void _scale_row_down_4in(uint8 *_RESTRICT_ in0, uint8 *_RESTRICT_ in1,
uint8 *_RESTRICT_ in2, uint8 *_RESTRICT_ in3, uint8 *_RESTRICT_ out, uint64 position_x,
uint64 x_factor_inv, uint32 top_weight, uint32 bot_weight, uint32 weight_reciprocal,
int out_width) {
int x;
uint32 in_col;
sint32 total_weight;
for (x = 0; x < out_width; x++) {
uint32 acc_r = 0;
uint32 acc_g = 0;
uint32 acc_b = 0;
uint32 curr_weight = 256 - ((position_x >> 24) & 0xff);
total_weight = x_factor_inv >> 24;
in_col = position_x >> 32;
while (total_weight > 0) {
acc_r += (uint32) in0[(in_col * 3) + 0] * curr_weight * top_weight;
acc_r += (uint32) in1[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in2[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in3[(in_col * 3) + 0] * curr_weight * bot_weight;
acc_g += (uint32) in0[(in_col * 3) + 1] * curr_weight * top_weight;
acc_g += (uint32) in1[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in2[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in3[(in_col * 3) + 1] * curr_weight * bot_weight;
acc_b += (uint32) in0[(in_col * 3) + 2] * curr_weight * top_weight;
acc_b += (uint32) in1[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in2[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in3[(in_col * 3) + 2] * curr_weight * bot_weight;
in_col++;
total_weight -= curr_weight;
curr_weight = total_weight > 256 ? 256 : total_weight;
}
position_x += x_factor_inv;
out[(x * 3) + 0] = ((uint64) acc_r * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 1] = ((uint64) acc_g * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 2] = ((uint64) acc_b * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
}
}
static inline void _scale_row_down_3in(uint8 *_RESTRICT_ in0, uint8 *_RESTRICT_ in1,
uint8 *_RESTRICT_ in2, uint8 *_RESTRICT_ out, uint64 position_x, uint64 x_factor_inv,
uint32 top_weight, uint32 bot_weight, uint32 weight_reciprocal, int out_width) {
int x;
uint32 in_col;
sint32 total_weight;
for (x = 0; x < out_width; x++) {
uint32 acc_r = 0;
uint32 acc_g = 0;
uint32 acc_b = 0;
uint32 curr_weight = 256 - ((position_x >> 24) & 0xff);
total_weight = x_factor_inv >> 24;
in_col = position_x >> 32;
while (total_weight > 0) {
acc_r += (uint32) in0[(in_col * 3) + 0] * curr_weight * top_weight;
acc_r += (uint32) in1[(in_col * 3) + 0] * curr_weight << 8;
acc_r += (uint32) in2[(in_col * 3) + 0] * curr_weight * bot_weight;
acc_g += (uint32) in0[(in_col * 3) + 1] * curr_weight * top_weight;
acc_g += (uint32) in1[(in_col * 3) + 1] * curr_weight << 8;
acc_g += (uint32) in2[(in_col * 3) + 1] * curr_weight * bot_weight;
acc_b += (uint32) in0[(in_col * 3) + 2] * curr_weight * top_weight;
acc_b += (uint32) in1[(in_col * 3) + 2] * curr_weight << 8;
acc_b += (uint32) in2[(in_col * 3) + 2] * curr_weight * bot_weight;
in_col++;
total_weight -= curr_weight;
curr_weight = total_weight > 256 ? 256 : total_weight;
}
position_x += x_factor_inv;
out[(x * 3) + 0] = ((uint64) acc_r * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 1] = ((uint64) acc_g * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 2] = ((uint64) acc_b * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
}
}
static inline void _scale_row_down_2in(uint8 *_RESTRICT_ in0, uint8 *_RESTRICT_ in1,
uint8 *_RESTRICT_ out, uint64 position_x, uint64 x_factor_inv, uint32 top_weight,
uint32 bot_weight, uint32 weight_reciprocal, int out_width) {
int x;
uint32 in_col;
sint32 total_weight;
for (x = 0; x < out_width; x++) {
uint32 acc_r = 0;
uint32 acc_g = 0;
uint32 acc_b = 0;
uint32 curr_weight = 256 - ((position_x >> 24) & 0xff);
total_weight = x_factor_inv >> 24;
in_col = position_x >> 32;
while (total_weight > 0) {
acc_r += (uint32) in0[(in_col * 3) + 0] * curr_weight * top_weight;
acc_r += (uint32) in1[(in_col * 3) + 0] * curr_weight * bot_weight;
acc_g += (uint32) in0[(in_col * 3) + 1] * curr_weight * top_weight;
acc_g += (uint32) in1[(in_col * 3) + 1] * curr_weight * bot_weight;
acc_b += (uint32) in0[(in_col * 3) + 2] * curr_weight * top_weight;
acc_b += (uint32) in1[(in_col * 3) + 2] * curr_weight * bot_weight;
in_col++;
total_weight -= curr_weight;
curr_weight = total_weight > 256 ? 256 : total_weight;
}
position_x += x_factor_inv;
out[(x * 3) + 0] = ((uint64) acc_r * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 1] = ((uint64) acc_g * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 2] = ((uint64) acc_b * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
}
}
static inline void _scale_row_down(uint8 *in, uint8 *_RESTRICT_ out, uint32 in_row_ofs,
uint64 position_x, uint64 position_y, uint64 x_factor_inv, uint64 y_factor_inv,
uint32 weight_reciprocal, int out_width) {
int x;
uint32 y, in_col, in_rows, top_weight, bot_weight;
sint32 total_weight;
total_weight = y_factor_inv >> 24;
top_weight = (uint32) 256 - ((position_y >> 24) & 0xff);
if ((sint32) top_weight > total_weight) {
top_weight = total_weight;
}
total_weight -= top_weight;
if (total_weight & 0xff) {
bot_weight = total_weight & 0xff;
} else if (total_weight > 255) {
bot_weight = 256;
} else {
bot_weight = 0;
}
total_weight -= bot_weight;
assert(total_weight >= 0);
assert((total_weight & 0xff) == 0);
in_rows = 2 + (total_weight >> 8);
if (in_rows == 2) {
_scale_row_down_2in(in, in + in_row_ofs,
out, position_x, x_factor_inv, top_weight, bot_weight, weight_reciprocal,
out_width);
} else if (in_rows == 3) {
_scale_row_down_3in(in, in + in_row_ofs, in + 2 * in_row_ofs,
out, position_x, x_factor_inv, top_weight, bot_weight, weight_reciprocal,
out_width);
} else if (in_rows == 4) {
_scale_row_down_4in(in, in + in_row_ofs, in + 2 * in_row_ofs, in + 3 * in_row_ofs,
out, position_x, x_factor_inv, top_weight, bot_weight, weight_reciprocal,
out_width);
} else if (in_rows == 5) {
_scale_row_down_5in(in, in + in_row_ofs, in + 2 * in_row_ofs, in + 3 * in_row_ofs,
in + 4 * in_row_ofs,
out, position_x, x_factor_inv,
top_weight, bot_weight, weight_reciprocal,
out_width);
} else if (in_rows == 6) {
_scale_row_down_6in(in, in + in_row_ofs, in + 2 * in_row_ofs, in + 3 * in_row_ofs,
in + 4 * in_row_ofs, in + 5 * in_row_ofs,
out, position_x, x_factor_inv, top_weight, bot_weight, weight_reciprocal,
out_width);
} else if (in_rows == 7) {
_scale_row_down_7in(in, in + in_row_ofs, in + 2 * in_row_ofs, in + 3 * in_row_ofs,
in + 4 * in_row_ofs, in + 5 * in_row_ofs, in + 6 * in_row_ofs,
out, position_x, x_factor_inv, top_weight, bot_weight, weight_reciprocal,
out_width);
} else if (in_rows == 8) {
_scale_row_down_8in(in, in + in_row_ofs, in + 2 * in_row_ofs, in + 3 * in_row_ofs,
in + 4 * in_row_ofs, in + 5 * in_row_ofs, in + 6 * in_row_ofs,
in + 7 * in_row_ofs,
out, position_x, x_factor_inv, top_weight, bot_weight, weight_reciprocal,
out_width);
} else if (in_rows == 9) {
_scale_row_down_9in(in, in + in_row_ofs, in + 2 * in_row_ofs, in + 3 * in_row_ofs,
in + 4 * in_row_ofs, in + 5 * in_row_ofs, in + 6 * in_row_ofs,
in + 7 * in_row_ofs, in + 8 * in_row_ofs,
out, position_x, x_factor_inv, top_weight, bot_weight, weight_reciprocal,
out_width);
} else {
for (x = 0; x < out_width; x++) {
uint32 acc_r = 0;
uint32 acc_g = 0;
uint32 acc_b = 0;
uint32 curr_weight = 256 - ((position_x >> 24) & 0xff);
total_weight = x_factor_inv >> 24;
in_col = position_x >> 32;
while (total_weight > 0) {
acc_r += (uint32) in[(in_col * 3) + 0] * curr_weight * top_weight;
acc_g += (uint32) in[(in_col * 3) + 1] * curr_weight * top_weight;
acc_b += (uint32) in[(in_col * 3) + 2] * curr_weight * top_weight;
for (y = 1; y < in_rows - 1; y++) {
acc_r += (uint32) in[y * in_row_ofs + ((in_col * 3) + 0)] * curr_weight * 256;
acc_g += (uint32) in[y * in_row_ofs + ((in_col * 3) + 1)] * curr_weight * 256;
acc_b += (uint32) in[y * in_row_ofs + ((in_col * 3) + 2)] * curr_weight * 256;
}
acc_r +=
(uint32) in[y * in_row_ofs + ((in_col * 3) + 0)] * curr_weight * bot_weight;
acc_g +=
(uint32) in[y * in_row_ofs + ((in_col * 3) + 1)] * curr_weight * bot_weight;
acc_b +=
(uint32) in[y * in_row_ofs + ((in_col * 3) + 2)] * curr_weight * bot_weight;
in_col++;
total_weight -= curr_weight;
curr_weight = total_weight > 256 ? 256 : total_weight;
}
position_x += x_factor_inv;
out[(x * 3) + 0] = ((uint64) acc_r * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 1] = ((uint64) acc_g * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
out[(x * 3) + 2] = ((uint64) acc_b * weight_reciprocal + ((uint64) 1 << 31)) >> 32;
}
}
}
static void _scale_row_up(uint8 *_RESTRICT_ in0, uint8 *_RESTRICT_ in1, uint8 *_RESTRICT_ out,
sint32 weight_y, uint64 position_x, uint64 increment_x, int out_width) {
int x;
for (x = 0; x < out_width; x++) {
sint32 top_val_r, bot_val_r;
sint32 top_val_g, bot_val_g;
sint32 top_val_b, bot_val_b;
// Position is tracked with 32 bits of precision, but interpolation is
// only guided by 10. REVISIT - Check ASM and make sure the compiler
// handled the second part here optimally.
uint32 pix_x = position_x >> 32;
sint32 weight_x = (position_x & 0xffffffff) >> 22;
// top_val and bot_val become 18-bit values here
top_val_r = (in0[(pix_x * 3) + 0] << 10) +
weight_x * ((sint32) in0[((pix_x + 1) * 3) + 0] - in0[(pix_x * 3) + 0]);
bot_val_r = (in1[(pix_x * 3) + 0] << 10) +
weight_x * ((sint32) in1[((pix_x + 1) * 3) + 0] - in1[(pix_x * 3) + 0]);
top_val_g = (in0[(pix_x * 3) + 1] << 10) +
weight_x * ((sint32) in0[((pix_x + 1) * 3) + 1] - in0[(pix_x * 3) + 1]);
bot_val_g = (in1[(pix_x * 3) + 1] << 10) +
weight_x * ((sint32) in1[((pix_x + 1) * 3) + 1] - in1[(pix_x * 3) + 1]);
top_val_b = (in0[(pix_x * 3) + 2] << 10) +
weight_x * ((sint32) in0[((pix_x + 1) * 3) + 2] - in0[(pix_x * 3) + 2]);
bot_val_b = (in1[(pix_x * 3) + 2] << 10) +
weight_x * ((sint32) in1[((pix_x + 1) * 3) + 2] - in1[(pix_x * 3) + 2]);
// out is an 8-bit value. We do not need to range-check, as overflow
// is mathematically impossible.
out[(x * 3) + 0] = ((top_val_r << 10) + weight_y * (bot_val_r - top_val_r)) >> 20;
out[(x * 3) + 1] = ((top_val_g << 10) + weight_y * (bot_val_g - top_val_g)) >> 20;
out[(x * 3) + 2] = ((top_val_b << 10) + weight_y * (bot_val_b - top_val_b)) >> 20;
position_x += increment_x;
}
}
static void _hw_scale_image_plane(scaler_config_t *pscaler_config, scaler_mode_t scaleMode) {
// These pointers duplicate h/w regs
uint64 x_factor, y_factor, x_factor_inv, y_factor_inv;
uint32 x_output_width, y_output_width;
uint32 input_pixel_ptr_offset, output_pixel_ptr_offset;
uint32 first_xi;
uint64 first_y_src, first_x_src, weight_reciprocal;
// These are internal state
uint32 r;
uint8 *outp;
x_output_width = pscaler_config->iOutWidth;
y_output_width = pscaler_config->iOutEndRow -
pscaler_config->iOutStartRow + 1;
input_pixel_ptr_offset = pscaler_config->iSrcBufWidth;
output_pixel_ptr_offset = pscaler_config->iOutBufWidth;
x_factor = (uint64) pscaler_config->fXfactor.decimal << 32;
x_factor |= pscaler_config->fXfactor.fraction;
y_factor = (uint64) pscaler_config->fYfactor.decimal << 32;
y_factor |= pscaler_config->fYfactor.fraction;
x_factor_inv = (uint64) pscaler_config->fXfactorInv.decimal << 32;
x_factor_inv |= pscaler_config->fXfactorInv.fraction;
y_factor_inv = (uint64) pscaler_config->fYfactorInv.decimal << 32;
y_factor_inv |= pscaler_config->fYfactorInv.fraction;
first_y_src = (uint64) pscaler_config->fSrcStartRow.decimal << 32;
first_y_src |= pscaler_config->fSrcStartRow.fraction;
// PC REVISIT - The HW has config registers for these, but they aren't being
// used by lib_photo_scaler do I don't want to use them, either. For now
// just print them so I can figure out what's going on and then clear the
// associated variables. Maybe we're always running the scaler from the
// left edge of the source so they're implicitly zero?
first_xi = pscaler_config->iOutStartColumn;
first_x_src = (uint64) pscaler_config->fSrcStartColumn.decimal << 32;
first_x_src |= pscaler_config->fSrcStartColumn.fraction;
first_xi = first_x_src = 0;
weight_reciprocal = ((uint64) 1 << 32);
weight_reciprocal /= (x_factor_inv >> 24) * (y_factor_inv >> 24);
outp = (pscaler_config->pOutBuf) + (first_xi * 3);
// PC - Assume pSrcBuf is already aligned to "true" base of input,
// so ignore whole-number part of first_y_src.
first_y_src = first_y_src & 0xffffffff;
for (r = 0; r < y_output_width; r++) {
uint8 *inp = (pscaler_config->pSrcBuf) +
(first_y_src >> 32) * input_pixel_ptr_offset;
{
if (scaleMode == PSCALER_SCALE_UP) {
_scale_row_up(inp, inp + input_pixel_ptr_offset, outp,
(first_y_src & 0xffffffff) >> 22, first_x_src,
x_factor_inv, x_output_width);
} else {
_scale_row_down(inp, outp, input_pixel_ptr_offset,
first_x_src, first_y_src, x_factor_inv, y_factor_inv,
weight_reciprocal, x_output_width);
}
}
first_y_src += y_factor_inv;
outp += output_pixel_ptr_offset;
}
}