#include "precomp.hpp"

#include "opencl_kernels_imgproc.hpp"

#include "hal_replacement.hpp"

#include "opencv2/core/hal/intrin.hpp"

#include "opencv2/core/openvx/ovx_defs.hpp"

#include "resize.hpp"

#include "opencv2/core/softfloat.hpp"

#include "fixedpoint.inl.hpp"

using namespace cv;

{

template <typename ET, bool needsign> struct fixedtype { typedef fixedpoint64 type; };

template <> struct fixedtype<uint32_t, false> { typedef ufixedpoint64 type; };

template <bool needsign> struct fixedtype<int16_t, needsign> { typedef fixedpoint32 type; };

template <> struct fixedtype<uint16_t, false> { typedef ufixedpoint32 type; };

template <bool needsign> struct fixedtype<int8_t, needsign> { typedef fixedpoint32 type; };

template <> struct fixedtype<uint8_t, false> { typedef ufixedpoint16 type; };

template <typename ET, typename FT, int n, bool mulall>

static void hlineResize(ET* src, int cn, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

}

template <typename ET, typename FT, int n, bool mulall, int cncnt> struct hline

};

template <typename ET, typename FT> struct hline<ET, FT, 2, true, 1>

{

static void ResizeCn(ET* src, int, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

}

};

template <typename ET, typename FT> struct hline<ET, FT, 2, true, 2>

{

static void ResizeCn(ET* src, int, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

}

};

template <typename ET, typename FT> struct hline<ET, FT, 2, true, 3>

{

static void ResizeCn(ET* src, int, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

}

};

template <typename ET, typename FT> struct hline<ET, FT, 2, true, 4>

{

static void ResizeCn(ET* src, int, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

}

};

template <typename ET, typename FT> struct hline<ET, FT, 4, true, 1>

{

static void ResizeCn(ET* src, int, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

}

};

template <typename ET, typename FT> struct hline<ET, FT, 4, true, 2>

{

static void ResizeCn(ET* src, int, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

}

};

template <typename ET, typename FT> struct hline<ET, FT, 4, true, 3>

{

static void ResizeCn(ET* src, int, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

}

};

template <typename ET, typename FT> struct hline<ET, FT, 4, true, 4>

{

static void ResizeCn(ET* src, int, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

}

};

template <typename ET, typename FT, int n, bool mulall, int cncnt>

static void hlineResizeCn(ET* src, int cn, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)

{

hline<ET, FT, n, mulall, cncnt>::ResizeCn(src, cn, ofst, m, dst, dst_min, dst_max, dst_width);

};

template <>

void hlineResizeCn<uint8_t, ufixedpoint16, 2, true, 1>(uint8_t* src, int, int *ofst, ufixedpoint16* m, ufixedpoint16* dst, int dst_min, int dst_max, int dst_width)

{

int i = 0;

ufixedpoint16 src_0(src[0]);

v_uint16x8 v_src_0 = v_setall_u16(*((uint16_t*)&src_0));

for (; i < dst_min - 7; i += 8, m += 16, dst += 8) // Points that fall left from src image so became equal to leftmost src point

{

v_store((uint16_t*)dst, v_src_0);

}

for (; i < dst_min; i++, m += 2)

{

*(dst++) = src_0;

}

for (; i < dst_max - 7 && ofst[i + 7] + 15 <= ofst[dst_width - 1]; i += 8, m += 16, dst += 8)

{

v_uint32x4 v_src01 = v_combine_low(v_reinterpret_as_u32(v_load_expand(src + ofst[i ])), v_reinterpret_as_u32(v_load_expand(src + ofst[i + 1])));

v_uint32x4 v_src23 = v_combine_low(v_reinterpret_as_u32(v_load_expand(src + ofst[i + 2])), v_reinterpret_as_u32(v_load_expand(src + ofst[i + 3])));

v_uint32x4 v_src45 = v_combine_low(v_reinterpret_as_u32(v_load_expand(src + ofst[i + 4])), v_reinterpret_as_u32(v_load_expand(src + ofst[i + 5])));

v_uint32x4 v_src67 = v_combine_low(v_reinterpret_as_u32(v_load_expand(src + ofst[i + 6])), v_reinterpret_as_u32(v_load_expand(src + ofst[i + 7])));

v_uint32x4 v_zip02, v_zip13, v_zip46, v_zip57;

v_zip(v_src01, v_src23, v_zip02, v_zip13);

v_zip(v_src45, v_src67, v_zip46, v_zip57);

v_uint32x4 v_src0, v_src1;

v_zip(v_combine_low(v_zip02, v_zip46), v_combine_low(v_zip13, v_zip57), v_src0, v_src1);

v_int16x8 v_mul0 = v_load((int16_t*)m);

v_int16x8 v_mul1 = v_load((int16_t*)m + 8);

v_uint32x4 v_res0 = v_reinterpret_as_u32(v_dotprod(v_reinterpret_as_s16(v_src0), v_mul0));

v_uint32x4 v_res1 = v_reinterpret_as_u32(v_dotprod(v_reinterpret_as_s16(v_src1), v_mul1));

v_store((uint16_t*)dst, v_pack(v_res0, v_res1));

}

for (; i < dst_max; i += 1, m += 2)

{

uint8_t* px = src + ofst[i];

*(dst++) = m[0] * px[0] + m[1] * px[1];

}

src_0 = (src + ofst[dst_width - 1])[0];

v_src_0 = v_setall_u16(*((uint16_t*)&src_0));

for (; i < dst_width - 7; i += 8, dst += 8) // Points that fall left from src image so became equal to leftmost src point

{

v_store((uint16_t*)dst, v_src_0);

}

for (; i < dst_width; i++)

{

*(dst++) = src_0;

}

}

template <>

void hlineResizeCn<uint8_t, ufixedpoint16, 2, true, 2>(uint8_t* src, int, int *ofst, ufixedpoint16* m, ufixedpoint16* dst, int dst_min, int dst_max, int dst_width)

{

int i = 0;

ufixedpoint16 srccn[8] = { src[0], src[1], src[0], src[1], src[0], src[1], src[0], src[1] };

v_uint16x8 v_srccn = v_load((uint16_t*)srccn);

for (; i < dst_min - 3; i += 4, m += 8, dst += 8) // Points that fall left from src image so became equal to leftmost src point

{

v_store((uint16_t*)dst, v_srccn);

}

for (; i < dst_min; i++, m += 2)

{

*(dst++) = srccn[0];

*(dst++) = srccn[1];

}

for (; i < dst_max - 3 && ofst[i + 3] + 7 <= ofst[dst_width - 1]; i += 4, m += 8, dst += 8)

{

v_uint32x4 v_src0 = v_combine_low(v_reinterpret_as_u32(v_load_expand(src + 2 * ofst[i ])), v_reinterpret_as_u32(v_load_expand(src + 2 * ofst[i + 1])));

v_uint32x4 v_src1 = v_combine_low(v_reinterpret_as_u32(v_load_expand(src + 2 * ofst[i + 2])), v_reinterpret_as_u32(v_load_expand(src + 2 * ofst[i + 3])));

v_uint32x4 v_zip0, v_zip1;

v_zip(v_src0, v_src1, v_zip0, v_zip1);

v_zip(v_zip0, v_zip1, v_src0, v_src1);

v_int16x8 v_src0123, v_src4567;

v_zip(v_reinterpret_as_s16(v_src0), v_reinterpret_as_s16(v_src1), v_src0123, v_src4567);

v_uint32x4 v_mul = v_load((uint32_t*)m);//AaBbCcDd

v_zip(v_mul, v_mul, v_zip0, v_zip1);//AaAaBbBb CcCcDdDd

v_uint32x4 v_res0 = v_reinterpret_as_u32(v_dotprod(v_src0123, v_reinterpret_as_s16(v_zip0)));

v_uint32x4 v_res1 = v_reinterpret_as_u32(v_dotprod(v_src4567, v_reinterpret_as_s16(v_zip1)));

v_store((uint16_t*)dst, v_pack(v_res0, v_res1));//AB1AB2CD1CD2

}

for (; i < dst_max; i += 1, m += 2)

{

uint8_t* px = src + 2 * ofst[i];

*(dst++) = m[0] * px[0] + m[1] * px[2];

*(dst++) = m[0] * px[1] + m[1] * px[3];

}

srccn[0] = (src + 2 * ofst[dst_width - 1])[0]; srccn[1] = (src + 2 * ofst[dst_width - 1])[1]; srccn[2] = (src + 2 * ofst[dst_width - 1])[0]; srccn[3] = (src + 2 * ofst[dst_width - 1])[1];

srccn[4] = (src + 2 * ofst[dst_width - 1])[0]; srccn[5] = (src + 2 * ofst[dst_width - 1])[1]; srccn[6] = (src + 2 * ofst[dst_width - 1])[0]; srccn[7] = (src + 2 * ofst[dst_width - 1])[1];

v_srccn = v_load((uint16_t*)srccn);

for (; i < dst_width - 3; i += 4, dst += 8) // Points that fall left from src image so became equal to leftmost src point

{

v_store((uint16_t*)dst, v_srccn);

}

for (; i < dst_width; i++)

{

*(dst++) = srccn[0];

*(dst++) = srccn[1];

}

}

template <>

void hlineResizeCn<uint8_t, ufixedpoint16, 2, true, 4>(uint8_t* src, int, int *ofst, ufixedpoint16* m, ufixedpoint16* dst, int dst_min, int dst_max, int dst_width)

{

int i = 0;

ufixedpoint16 srccn[8] = { src[0], src[1], src[2], src[3], src[0], src[1], src[2], src[3] };

v_uint16x8 v_srccn = v_load((uint16_t*)srccn);

for (; i < dst_min - 1; i += 2, m += 4, dst += 8) // Points that fall left from src image so became equal to leftmost src point

{

v_store((uint16_t*)dst, v_srccn);

}

if (i < dst_min) // Points that fall left from src image so became equal to leftmost src point

{

*(dst++) = srccn[0];

*(dst++) = srccn[1];

*(dst++) = srccn[2];

*(dst++) = srccn[3];

i++; m += 2;

}

for (; i < dst_max - 1 && ofst[i + 1] + 3 <= ofst[dst_width - 1]; i += 2, m += 4, dst += 8)

{

v_int16x8 v_src01 = v_reinterpret_as_s16(v_load_expand(src + 4 * ofst[i ]));

v_int16x8 v_src23 = v_reinterpret_as_s16(v_load_expand(src + 4 * ofst[i + 1]));

v_int16x8 v_tmp0, v_tmp1;

v_recombine(v_src01, v_src23, v_tmp0, v_tmp1);

v_zip(v_tmp0, v_tmp1, v_src01, v_src23);

v_int16x8 v_mul01 = v_reinterpret_as_s16(v_setall_u32(((uint32_t*)m)[0]));//AaAaAaAa

v_int16x8 v_mul23 = v_reinterpret_as_s16(v_setall_u32(((uint32_t*)m)[1]));//BbBbBbBb

v_uint32x4 v_res0 = v_reinterpret_as_u32(v_dotprod(v_src01, v_mul01));

v_uint32x4 v_res1 = v_reinterpret_as_u32(v_dotprod(v_src23, v_mul23));

v_store((uint16_t*)dst, v_pack(v_res0, v_res1));//AB1AB2CD1CD2

}

for (; i < dst_max; i += 1, m += 2)

{

uint8_t* px = src + 4 * ofst[i];

*(dst++) = m[0] * px[0] + m[1] * px[4];

*(dst++) = m[0] * px[1] + m[1] * px[5];

*(dst++) = m[0] * px[2] + m[1] * px[6];

*(dst++) = m[0] * px[3] + m[1] * px[7];

}

srccn[0] = (src + 4 * ofst[dst_width - 1])[0]; srccn[1] = (src + 4 * ofst[dst_width - 1])[1]; srccn[2] = (src + 4 * ofst[dst_width - 1])[2]; srccn[3] = (src + 4 * ofst[dst_width - 1])[3];

srccn[4] = (src + 4 * ofst[dst_width - 1])[0]; srccn[5] = (src + 4 * ofst[dst_width - 1])[1]; srccn[6] = (src + 4 * ofst[dst_width - 1])[2]; srccn[7] = (src + 4 * ofst[dst_width - 1])[3];

v_srccn = v_load((uint16_t*)srccn);

for (; i < dst_width - 1; i += 2, dst += 8) // Points that fall right from src image so became equal to rightmost src point

{

v_store((uint16_t*)dst, v_srccn);

}

if (i < dst_width)

{

*(dst++) = srccn[0];

*(dst++) = srccn[1];

*(dst++) = srccn[2];

*(dst++) = srccn[3];

}

}

template <>

void hlineResizeCn<uint16_t, ufixedpoint32, 2, true, 1>(uint16_t* src, int, int *ofst, ufixedpoint32* m, ufixedpoint32* dst, int dst_min, int dst_max, int dst_width)

{

int i = 0;

ufixedpoint32 src_0(src[0]);

v_uint32x4 v_src_0 = v_setall_u32(*((uint32_t*)&src_0));

for (; i < dst_min - 3; i += 4, m += 8, dst += 4) // Points that fall left from src image so became equal to leftmost src point

{

v_store((uint32_t*)dst, v_src_0);

}

for (; i < dst_min; i++, m += 2)

{

*(dst++) = src_0;

}

for (; i < dst_max - 3 && ofst[i + 3] + 8 <= ofst[dst_width - 1]; i += 4, m += 8, dst += 4)

{

v_uint32x4 v_src0 = v_combine_low(v_load_expand(src + ofst[i]), v_load_expand(src + ofst[i + 1]));

v_uint32x4 v_mul0 = v_load((uint32_t*)m);

v_uint32x4 v_src1 = v_combine_low(v_load_expand(src + ofst[i + 2]), v_load_expand(src + ofst[i + 3]));

v_uint32x4 v_mul1 = v_load((uint32_t*)m + 4);

v_uint32x4 v_res0 = v_src0 * v_mul0;//a1a2b1b2

v_uint32x4 v_res1 = v_src1 * v_mul1;//c1c2d1d2

v_uint32x4 v_tmp0, v_tmp1;

v_recombine(v_res0, v_res1, v_tmp0, v_tmp1);//a1a2c1c2 b1b2d1d2

v_zip(v_tmp0, v_tmp1, v_res0, v_res1);//a1b1a2b2 c1d1c2d2

v_recombine(v_res0, v_res1, v_tmp0, v_tmp1);//a1b1c1d1 a2b2c2d2

v_store((uint32_t*)dst, v_tmp0 + v_tmp1);//abcd

}

for (; i < dst_max; i += 1, m += 2)

{

uint16_t* px = src + ofst[i];

*(dst++) = m[0] * px[0] + m[1] * px[1];

}

src_0 = (src + ofst[dst_width - 1])[0];

v_src_0 = v_setall_u32(*((uint32_t*)&src_0));

for (; i < dst_width - 3; i += 4, dst += 4)

{

v_store((uint32_t*)dst, v_src_0);

}

for (; i < dst_width; i++)

{

*(dst++) = src_0;

}

}

template <typename ET, typename FT>

void vlineSet(FT* src, ET* dst, int dst_width)

}

template <>

void vlineSet<uint8_t, ufixedpoint16>(ufixedpoint16* src, uint8_t* dst, int dst_width)

{

static const v_uint16x8 v_fixedRound = v_setall_u16((uint16_t)((1U << 8) >> 1));

int i = 0;

for (; i < dst_width - 15; i += 16, src += 16, dst += 16)

{

v_uint16x8 v_src0 = v_load((uint16_t*)src);

v_uint16x8 v_src1 = v_load((uint16_t*)src + 8);

v_uint16x8 v_res0 = (v_src0 + v_fixedRound) >> 8;

v_uint16x8 v_res1 = (v_src1 + v_fixedRound) >> 8;

v_store(dst, v_pack(v_res0, v_res1));

}

for (; i < dst_width; i++)

*(dst++) = *(src++);

}

template <typename ET, typename FT, int n>

void vlineResize(FT* src, size_t src_step, FT* m, ET* dst, int dst_width)

}

template <>

void vlineResize<uint8_t, ufixedpoint16, 2>(ufixedpoint16* src, size_t src_step, ufixedpoint16* m, uint8_t* dst, int dst_width)

{

static const v_int32x4 v_fixedRound = v_setall_s32((int32_t)((1 << 16) >> 1));

static const v_int16x8 v_128 = v_reinterpret_as_s16(v_setall_u16((uint16_t)1<<15));

static const v_int8x16 v_128_16 = v_reinterpret_as_s8 (v_setall_u8 ((uint8_t) 1<<7));

int i = 0;

ufixedpoint16* src1 = src + src_step;

v_int16x8 v_mul = v_reinterpret_as_s16(v_setall_u32(((uint32_t*)m)[0]));

for (; i < dst_width - 15; i += 16, src += 16, src1 += 16, dst += 16)

{

v_int16x8 v_src00 = v_load((int16_t*)src);

v_int16x8 v_src10 = v_load((int16_t*)src1);

v_int16x8 v_tmp0, v_tmp1;

v_zip(v_add_wrap(v_src00,v_128), v_add_wrap(v_src10,v_128), v_tmp0, v_tmp1);

v_int32x4 v_res0 = v_dotprod(v_tmp0, v_mul);

v_int32x4 v_res1 = v_dotprod(v_tmp1, v_mul);

v_int16x8 v_src01 = v_load((int16_t*)src + 8);

v_int16x8 v_src11 = v_load((int16_t*)src1 + 8);

v_zip(v_add_wrap(v_src01,v_128), v_add_wrap(v_src11,v_128), v_tmp0, v_tmp1);

v_int32x4 v_res2 = v_dotprod(v_tmp0, v_mul);

v_int32x4 v_res3 = v_dotprod(v_tmp1, v_mul);

v_int8x16 v_res = v_pack(v_pack((v_res0 + v_fixedRound) >> 16,

(v_res1 + v_fixedRound) >> 16),

v_pack((v_res2 + v_fixedRound) >> 16,

(v_res3 + v_fixedRound) >> 16));

v_store(dst, v_reinterpret_as_u8(v_sub_wrap(v_res, v_128_16)));

}

for (; i < dst_width; i++)

{

*(dst++) = (uint8_t)(*(src++) * m[0] + *(src1++) * m[1]);

}

}

template <typename ET> class interpolationLinear

};

template <typename ET, typename FT, int interp_y_len>

class resize_bitExactInvoker :

};

template <typename ET, typename interpolation>

void resize_bitExact(const uchar* src, size_t src_step, int src_width, int src_height,

}

typedef void(*be_resize_func)(const uchar* src, size_t src_step, int src_width, int src_height,

uchar* dst, size_t dst_step, int dst_width, int dst_height,

int cn, double inv_scale_x, double inv_scale_y);

}

namespace cv

{

const int INTER_RESIZE_COEF_BITS=11;

const int INTER_RESIZE_COEF_SCALE=1 << INTER_RESIZE_COEF_BITS;

static inline void interpolateCubic( float x, float* coeffs )

}

static inline void interpolateLanczos4( float x, float* coeffs )

}

template<typename ST, typename DT> struct Cast

};

template<typename ST, typename DT, int bits> struct FixedPtCast

};

class resizeNNInvoker :

};

static void

resizeNN( const Mat& src, Mat& dst, double fx, double fy )

}

struct VResizeNoVec

{

int operator()(const uchar**, uchar*, const uchar*, int ) const { return 0; }

};

struct HResizeNoVec