// Copyright 2014 Google Inc. All Rights Reserved.

//

// Use of this source code is governed by a BSD-style license

// that can be found in the COPYING file in the root of the source

// tree. An additional intellectual property rights grant can be found

// in the file PATENTS. All contributing project authors may

// be found in the AUTHORS file in the root of the source tree.

// -----------------------------------------------------------------------------

//

// Rescaling functions

//

// Author: Skal (pascal.massimino@gmail.com)

#include <assert.h>

#include "src/dsp/dsp.h"

#include "src/utils/rescaler_utils.h"

//------------------------------------------------------------------------------

// Implementations of critical functions ImportRow / ExportRow

#define ROUNDER (WEBP_RESCALER_ONE >> 1)

#define MULT_FIX(x, y) (((uint64_t)(x) * (y) + ROUNDER) >> WEBP_RESCALER_RFIX)

#define MULT_FIX_FLOOR(x, y) (((uint64_t)(x) * (y)) >> WEBP_RESCALER_RFIX)

//------------------------------------------------------------------------------

// Row import

void WebPRescalerImportRowExpand_C(WebPRescaler* const wrk,

const uint8_t* src) {

const int x_stride = wrk->num_channels;

const int x_out_max = wrk->dst_width * wrk->num_channels;

int channel;

assert(!WebPRescalerInputDone(wrk));

assert(wrk->x_expand);

for (channel = 0; channel < x_stride; ++channel) {

int x_in = channel;

int x_out = channel;

// simple bilinear interpolation

int accum = wrk->x_add;

int left = src[x_in];

int right = (wrk->src_width > 1) ? src[x_in + x_stride] : left;

x_in += x_stride;

while (1) {

wrk->frow[x_out] = right * wrk->x_add + (left - right) * accum;

x_out += x_stride;

if (x_out >= x_out_max) break;

accum -= wrk->x_sub;

if (accum < 0) {

left = right;

x_in += x_stride;

assert(x_in < wrk->src_width * x_stride);

right = src[x_in];

accum += wrk->x_add;

}

}

assert(wrk->x_sub == 0 /* <- special case for src_width=1 */ || accum == 0);

}

}

void WebPRescalerImportRowShrink_C(WebPRescaler* const wrk,

const uint8_t* src) {

const int x_stride = wrk->num_channels;

const int x_out_max = wrk->dst_width * wrk->num_channels;

int channel;

assert(!WebPRescalerInputDone(wrk));

assert(!wrk->x_expand);

for (channel = 0; channel < x_stride; ++channel) {

int x_in = channel;

int x_out = channel;

uint32_t sum = 0;

int accum = 0;

while (x_out < x_out_max) {

uint32_t base = 0;

accum += wrk->x_add;

while (accum > 0) {

accum -= wrk->x_sub;

assert(x_in < wrk->src_width * x_stride);

base = src[x_in];

sum += base;

x_in += x_stride;

}

{ // Emit next horizontal pixel.

const rescaler_t frac = base * (-accum);

wrk->frow[x_out] = sum * wrk->x_sub - frac;

// fresh fractional start for next pixel

sum = (int)MULT_FIX(frac, wrk->fx_scale);

}

x_out += x_stride;

}

assert(accum == 0);

}

}

//------------------------------------------------------------------------------

// Row export

void WebPRescalerExportRowExpand_C(WebPRescaler* const wrk) {

int x_out;

uint8_t* const dst = wrk->dst;

rescaler_t* const irow = wrk->irow;

const int x_out_max = wrk->dst_width * wrk->num_channels;

const rescaler_t* const frow = wrk->frow;

assert(!WebPRescalerOutputDone(wrk));

assert(wrk->y_accum <= 0);

assert(wrk->y_expand);

assert(wrk->y_sub != 0);

if (wrk->y_accum == 0) {

for (x_out = 0; x_out < x_out_max; ++x_out) {

const uint32_t J = frow[x_out];

const int v = (int)MULT_FIX(J, wrk->fy_scale);

dst[x_out] = (v > 255) ? 255u : (uint8_t)v;

}

} else {

const uint32_t B = WEBP_RESCALER_FRAC(-wrk->y_accum, wrk->y_sub);

const uint32_t A = (uint32_t)(WEBP_RESCALER_ONE - B);

for (x_out = 0; x_out < x_out_max; ++x_out) {

const uint64_t I = (uint64_t)A * frow[x_out]

+ (uint64_t)B * irow[x_out];

const uint32_t J = (uint32_t)((I + ROUNDER) >> WEBP_RESCALER_RFIX);

const int v = (int)MULT_FIX(J, wrk->fy_scale);

dst[x_out] = (v > 255) ? 255u : (uint8_t)v;

}

}

}

void WebPRescalerExportRowShrink_C(WebPRescaler* const wrk) {

int x_out;

uint8_t* const dst = wrk->dst;

rescaler_t* const irow = wrk->irow;

const int x_out_max = wrk->dst_width * wrk->num_channels;

const rescaler_t* const frow = wrk->frow;

const uint32_t yscale = wrk->fy_scale * (-wrk->y_accum);

assert(!WebPRescalerOutputDone(wrk));

assert(wrk->y_accum <= 0);

assert(!wrk->y_expand);

if (yscale) {

for (x_out = 0; x_out < x_out_max; ++x_out) {

const uint32_t frac = (uint32_t)MULT_FIX_FLOOR(frow[x_out], yscale);

const int v = (int)MULT_FIX(irow[x_out] - frac, wrk->fxy_scale);

dst[x_out] = (v > 255) ? 255u : (uint8_t)v;

irow[x_out] = frac; // new fractional start

}

} else {

for (x_out = 0; x_out < x_out_max; ++x_out) {

const int v = (int)MULT_FIX(irow[x_out], wrk->fxy_scale);

dst[x_out] = (v > 255) ? 255u : (uint8_t)v;

irow[x_out] = 0;

}

}

}

#undef MULT_FIX_FLOOR

#undef MULT_FIX

#undef ROUNDER

//------------------------------------------------------------------------------

// Main entry calls

void WebPRescalerImportRow(WebPRescaler* const wrk, const uint8_t* src) {

assert(!WebPRescalerInputDone(wrk));

if (!wrk->x_expand) {

WebPRescalerImportRowShrink(wrk, src);

} else {

WebPRescalerImportRowExpand(wrk, src);

}

}

void WebPRescalerExportRow(WebPRescaler* const wrk) {

if (wrk->y_accum <= 0) {

assert(!WebPRescalerOutputDone(wrk));

if (wrk->y_expand) {

WebPRescalerExportRowExpand(wrk);

} else if (wrk->fxy_scale) {

WebPRescalerExportRowShrink(wrk);

} else { // special case

int i;

assert(wrk->src_height == wrk->dst_height && wrk->x_add == 1);

assert(wrk->src_width == 1 && wrk->dst_width <= 2);

for (i = 0; i < wrk->num_channels * wrk->dst_width; ++i) {

wrk->dst[i] = wrk->irow[i];

wrk->irow[i] = 0;

}

}

wrk->y_accum += wrk->y_add;

wrk->dst += wrk->dst_stride;

++wrk->dst_y;

}

}

//------------------------------------------------------------------------------

WebPRescalerImportRowFunc WebPRescalerImportRowExpand;

WebPRescalerImportRowFunc WebPRescalerImportRowShrink;

WebPRescalerExportRowFunc WebPRescalerExportRowExpand;

WebPRescalerExportRowFunc WebPRescalerExportRowShrink;

extern void WebPRescalerDspInitSSE2(void);

extern void WebPRescalerDspInitMIPS32(void);

extern void WebPRescalerDspInitMIPSdspR2(void);

extern void WebPRescalerDspInitMSA(void);

extern void WebPRescalerDspInitNEON(void);

WEBP_DSP_INIT_FUNC(WebPRescalerDspInit) {

#if !defined(WEBP_REDUCE_SIZE)

#if !WEBP_NEON_OMIT_C_CODE

WebPRescalerExportRowExpand = WebPRescalerExportRowExpand_C;

WebPRescalerExportRowShrink = WebPRescalerExportRowShrink_C;

#endif

WebPRescalerImportRowExpand = WebPRescalerImportRowExpand_C;

WebPRescalerImportRowShrink = WebPRescalerImportRowShrink_C;

if (VP8GetCPUInfo != NULL) {

#if defined(WEBP_USE_SSE2)

if (VP8GetCPUInfo(kSSE2)) {

WebPRescalerDspInitSSE2();

}

#endif

#if defined(WEBP_USE_MIPS32)

if (VP8GetCPUInfo(kMIPS32)) {

WebPRescalerDspInitMIPS32();

}

#endif

#if defined(WEBP_USE_MIPS_DSP_R2)

if (VP8GetCPUInfo(kMIPSdspR2)) {

WebPRescalerDspInitMIPSdspR2();

}

#endif

#if defined(WEBP_USE_MSA)

if (VP8GetCPUInfo(kMSA)) {

WebPRescalerDspInitMSA();

}

#endif

}

#if defined(WEBP_USE_NEON)

if (WEBP_NEON_OMIT_C_CODE ||

(VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {

WebPRescalerDspInitNEON();

}

#endif

assert(WebPRescalerExportRowExpand != NULL);

assert(WebPRescalerExportRowShrink != NULL);

assert(WebPRescalerImportRowExpand != NULL);

assert(WebPRescalerImportRowShrink != NULL);

#endif // WEBP_REDUCE_SIZE

}