8#ifndef META_OCEAN_CV_FRAME_INTERPOLATOR_BILINEAR_H
9#define META_OCEAN_CV_FRAME_INTERPOLATOR_BILINEAR_H
85 static inline bool resize(
Frame& frame,
const unsigned int width,
const unsigned int height,
Worker* worker =
nullptr);
283 static bool rotate(
const Frame& source,
Frame& target,
const Scalar horizontalAnchorPosition,
const Scalar verticalAnchorPosition,
const Scalar angle,
Worker* worker =
nullptr,
const uint8_t* borderColor =
nullptr);
316 template <
typename TScalar = Scalar>
337 template <
typename TSource,
typename TTarget,
typename TScalar = Scalar,
typename TIntermediate = TScalar>
338 static bool interpolatePixel(
const TSource* frame,
const unsigned int channels,
const unsigned int width,
const unsigned int height,
const unsigned int framePaddingElements,
const PixelCenter pixelCenter,
const VectorT2<TScalar>& position, TTarget* result,
const TIntermediate& resultBias = TIntermediate(0));
388 template <
typename T,
unsigned int tChannels>
389 static inline void resize(
const T* source, T* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker =
nullptr);
410 template <
typename T,
unsigned int tChannels>
411 static inline void scale(
const T* source, T* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker =
nullptr);
429 template <
unsigned int tChannels>
430 static inline void rotate8BitPerChannel(
const uint8_t* source, uint8_t* target,
const unsigned int width,
const unsigned int height,
const Scalar horizontalAnchorPosition,
const Scalar verticalAnchorPosition,
const Scalar angle,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker =
nullptr,
const uint8_t* borderColor =
nullptr);
459 template <
unsigned int tChannels>
460 static inline void affine8BitPerChannel(
const uint8_t* source,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const SquareMatrix3& source_A_target,
const uint8_t* borderColor, uint8_t* target,
const PixelPositionI& targetOrigin,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker =
nullptr);
483 template <
typename T,
unsigned int tChannels>
484 static inline void homography(
const T* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3& input_H_output,
const T* borderColor, T* output,
const PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
Worker* worker =
nullptr);
508 template <
unsigned int tChannels>
509 static inline void homographies8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3 homographies[4],
const uint8_t* borderColor, uint8_t* output,
const Vector2& outputQuadrantCenter,
const PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
Worker* worker =
nullptr);
533 template <
unsigned int tChannels>
534 static inline void homographyMask8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3& input_H_output, uint8_t* output, uint8_t* outputMask,
const PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const uint8_t maskValue ,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
Worker* worker =
nullptr);
560 template <
unsigned int tChannels>
561 static inline void homographiesMask8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3 homographies[4], uint8_t* output, uint8_t* outputMask,
const Vector2& outputQuadrantCenter,
const PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
Worker* worker =
nullptr,
const uint8_t maskValue = 0xFF);
581 template <
unsigned int tChannels>
603 template <
unsigned int tChannels>
604 static inline void homographyWithCameraMask8BitPerChannel(
const PinholeCamera& inputCamera,
const PinholeCamera& outputCamera,
const uint8_t* input,
const unsigned int inputPaddingElements,
const SquareMatrix3&
homography, uint8_t* output, uint8_t* outputMask,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
Worker* worker =
nullptr,
const uint8_t maskValue = 0xFF);
624 template <
typename T,
unsigned int tChannels>
625 static inline void lookup(
const T* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable& input_LT_output,
const bool offset,
const T* borderColor, T* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
Worker* worker =
nullptr,
const bool useOptimizedNEON =
false,
const bool useOptimizedBilinearValuesAndFactorCalculation =
false,
const bool useOptimizedNEONFactorReplication =
false,
const bool use4ChannelSamplingFastPaths =
false);
646 template <
unsigned int tChannels>
647 static inline void lookupMask8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable& input_LT_output,
const bool offset, uint8_t* output, uint8_t* outputMask,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
Worker* worker =
nullptr,
const uint8_t maskValue = 0xFF);
667 template <
typename T,
unsigned int tChannels>
668 static void resampleCameraImage(
const T* sourceFrame,
const AnyCamera& sourceCamera,
const SquareMatrix3& source_R_target,
const AnyCamera& targetCamera, T* targetFrame,
const unsigned int sourceFramePaddingElements,
const unsigned int targetFramePaddingElements,
LookupCorner2<Vector2>* source_OLT_target =
nullptr,
Worker* worker =
nullptr,
const unsigned int binSizeInPixel = 8u,
const T* borderColor =
nullptr);
684 template <
unsigned int tChannels, PixelCenter tPixelCenter = PC_TOP_LEFT,
typename TScalar = Scalar>
705 template <
typename TSource,
typename TTarget,
unsigned int tChannels, PixelCenter tPixelCenter = PC_TOP_LEFT,
typename TScalar = Scalar,
typename TIntermediate = TScalar>
706 static inline void interpolatePixel(
const TSource* frame,
const unsigned int width,
const unsigned int height,
const unsigned int framePaddingElements,
const VectorT2<TScalar>& position, TTarget* result,
const TIntermediate& resultBias = TIntermediate(0));
723 template <
unsigned int tChannels,
bool tAlphaAtFront,
bool tTransparentIs0xFF>
738 static Scalar patchIntensitySum1Channel(
const uint32_t* linedIntegralFrame,
const unsigned int frameWidth,
const unsigned int frameHeight,
const unsigned int lineIntegralFramePaddingElements,
const Vector2& center,
const CV::PixelCenter pixelCenter,
const unsigned int patchWidth,
const unsigned int patchHeight);
751 static bool coversHomographyInputFrame(
const unsigned int inputWidth,
const unsigned int inputHeight,
const unsigned int outputWidth,
const unsigned int outputHeight,
const SquareMatrix3& input_H_output,
const int outputOriginX = 0,
const int outputOriginY = 0);
775 template <
unsigned int tChannels>
776 static inline void homography8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3& input_H_output,
const uint8_t* borderColor, uint8_t* output,
const PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
Worker* worker =
nullptr);
795 template <
unsigned int tChannels>
796 static inline void scale8BitPerChannel(
const uint8_t* source, uint8_t* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker =
nullptr);
814 template <
unsigned int tChannels>
815 static void scale8BitPerChannelSubset(
const uint8_t* source, uint8_t* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows);
841 template <
typename T>
842 static void interpolateRowVertical(
const T* sourceRowTop,
const T* sourceRowBottom, T* targetRow,
const unsigned int elements,
const float factorBottom);
857 template <
typename T,
unsigned int tChannels>
858 static void interpolateRowHorizontal(
const T* extendedSourceRow, T* targetRow,
const unsigned int targetWidth,
const unsigned int channels,
const unsigned int* interpolationLocations,
const float* interpolationFactorsRight);
860#if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
885 template <
typename T>
886 static void interpolateRowVerticalNEON(
const T* sourceRowTop,
const T* sourceRowBottom, T* targetRow,
const unsigned int elements,
const float factorBottom);
900 template <
unsigned int tChannels>
916 template <
typename T,
unsigned int tChannels>
917 static void interpolateRowHorizontalNEON(
const T* extendedSourceRow, T* targetRow,
const unsigned int targetWidth,
const unsigned int channels,
const unsigned int* interpolationLocations,
const float* interpolationFactorsRight);
937 static void scale8BitPerChannelSubset7BitPrecisionNEON(
const uint8_t* source, uint8_t* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int channels,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows);
959 template <
typename T,
typename TScale,
unsigned int tChannels>
960 static void scaleSubset(
const T* source, T* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows);
978 template <
unsigned int tChannels>
979 static void rotate8BitPerChannelSubset(
const uint8_t* source, uint8_t* target,
const unsigned int width,
const unsigned int height,
const Scalar horizontalAnchorPosition,
const Scalar verticalAnchorPosition,
const Scalar angle,
const uint8_t* borderColor,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows);
1007 template <
unsigned int tChannels>
1008 static inline void affine8BitPerChannelSubset(
const uint8_t* source,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const SquareMatrix3* source_A_target,
const uint8_t* borderColor, uint8_t* target,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements);
1029 template <
unsigned int tChannels>
1030 static inline void homography8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output,
const uint8_t* borderColor, uint8_t* output,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows);
1051 template <
typename T,
unsigned int tChannels>
1052 static inline void homographySubset(
const T* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output,
const T* borderColor, T* output,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows);
1054#if defined(OCEAN_HARDWARE_SSE_VERSION) && OCEAN_HARDWARE_SSE_VERSION >= 41
1083 template <
unsigned int tChannels>
1084 static inline void affine8BitPerChannelSSESubset(
const uint8_t* source,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const SquareMatrix3* source_A_target,
const uint8_t* borderColor, uint8_t* target,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements);
1105 template <
unsigned int tChannels>
1106 static inline void homography8BitPerChannelSSESubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output,
const uint8_t* borderColor, uint8_t* output,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows);
1123 template <
unsigned int tChannels>
1124 static OCEAN_FORCE_INLINE
void interpolate4Pixels8BitPerChannelSSE(
const uint8_t* source,
const unsigned int offsetsTopLeft[4],
const unsigned int offsetsTopRight[4],
const unsigned int offsetsBottomLeft[4],
const unsigned int offsetsBottomRight[4],
const unsigned int validPixels[4],
const typename DataType<uint8_t, tChannels>::Type& borderColor,
const __m128i& m128_factorsRight,
const __m128i& m128_factorsBottom,
typename DataType<uint8_t, tChannels>::Type* targetPositionPixels);
1140 template <
unsigned int tChannels>
1141 static OCEAN_FORCE_INLINE __m128i
interpolate4Pixels8BitPerChannelSSE(
const __m128i& m128_sourcesTopLeft,
const __m128i& m128_sourcesTopRight,
const __m128i& m128_sourcesBottomLeft,
const __m128i& m128_sourcesBottomRight,
const __m128i& m128_factorsTopLeft,
const __m128i& m128_factorsTopRight,
const __m128i& m128_factorsBottomLeft,
const __m128i& m128_factorsBottomRight);
1145#if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
1174 template <
unsigned int tChannels>
1175 static inline void affine8BitPerChannelNEONSubset(
const uint8_t* source,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const SquareMatrix3* source_A_target,
const uint8_t* borderColor, uint8_t* target,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements);
1196 template <
unsigned int tChannels>
1197 static inline void homography8BitPerChannelNEONSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output,
const uint8_t* borderColor, uint8_t* output,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows);
1214 template <
unsigned int tChannels>
1215 static OCEAN_FORCE_INLINE
void interpolate4Pixels8BitPerChannelNEON(
const uint8_t* source,
const unsigned int offsetsTopLeftElements[4],
const unsigned int offsetsTopRightElements[4],
const unsigned int offsetsBottomLeftElements[4],
const unsigned int offsetsBottomRightElements[4],
const unsigned int validPixels[4],
const typename DataType<uint8_t, tChannels>::Type& borderColor,
const uint32x4_t& m128_factorsRight,
const uint32x4_t& m128_factorsBottom,
typename DataType<uint8_t, tChannels>::Type* targetPositionPixels);
1226 static OCEAN_FORCE_INLINE
void interpolate8Pixels1Channel8BitNEON(
const uint8x8_t& topLeft_u_8x8,
const uint8x8_t& topRight_u_8x8,
const uint8x8_t& bottomLeft_u_8x8,
const uint8x8_t& bottomRight_u_8x8,
const uint8x16_t& factorsRight_factorsBottom_128_u_8x16, uint8_t* targetPositionPixels);
1242 static OCEAN_FORCE_INLINE
void interpolate4Pixels4Channel8BitPerChannelNEON(
const uint8x16_t& topLeftPixels_u8x16,
const uint8x16_t& topRightPixels_u8x16,
const uint8x16_t& bottomLeftPixels_u8x16,
const uint8x16_t& bottomRightPixels_u8x16,
const uint32x4_t& m128_factorsRight,
const uint32x4_t& m128_factorsBottom,
typename DataType<uint8_t, 4u>::Type* targetPositionPixels,
const bool useOptimizedNEONFactorReplication =
false);
1266 template <
unsigned int tChannels>
1267 static inline void homographies8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* homographies,
const uint8_t* borderColor, uint8_t* output,
const Scalar outputQuadrantCenterX,
const Scalar outputQuadrantCenterY,
const int outputOriginX,
const int outputOriginY,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows);
1287 template <
unsigned int tChannels>
1288 static inline void homographyMask8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output, uint8_t* output, uint8_t* outputMask,
const uint8_t maskValue,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows);
1312 template <
unsigned int tChannels>
1313 static inline void homographiesMask8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* homographies, uint8_t* output, uint8_t* outputMask,
const uint8_t maskValue,
const Scalar outputQuadrantCenterX,
const Scalar outputQuadrantCenterY,
const int outputOriginX,
const int outputOriginY,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows);
1331 template <
unsigned int tChannels>
1332 static void homographyWithCamera8BitPerChannelSubset(
const PinholeCamera* inputCamera,
const PinholeCamera* outputCamera,
const PinholeCamera::DistortionLookup* outputCameraDistortionLookup,
const uint8_t* input,
const SquareMatrix3* normalizedHomography,
const bool useDistortionParameters,
const uint8_t* borderColor, uint8_t* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows);
1351 template <
unsigned int tChannels>
1352 static void homographyWithCameraMask8BitPerChannelSubset(
const PinholeCamera* inputCamera,
const PinholeCamera* outputCamera,
const PinholeCamera::DistortionLookup* outputCameraDistortionLookup,
const uint8_t* input,
const unsigned int inputPaddingElements,
const SquareMatrix3* normalizedHomography, uint8_t* output, uint8_t* outputMask,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
const uint8_t maskValue,
const unsigned int firstRow,
const unsigned int numberRows);
1370 template <
unsigned int tChannels>
1371 static void lookup8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable* input_LT_output,
const bool offset,
const uint8_t* borderColor, uint8_t* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows);
1390 template <
typename T,
unsigned int tChannels>
1391 static void lookupSubset(
const T* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable* input_LT_output,
const bool offset,
const T* borderColor, T* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows);
1393#if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
1411 template <
unsigned int tChannels>
1412 static void lookup8BitPerChannelSubsetNEON(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable* input_LT_output,
const bool offset,
const uint8_t* borderColor, uint8_t* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows,
const bool useOptimizedNEON =
false,
const bool useOptimizedBilinearValuesAndFactorCalculation =
false,
const bool useOptimizedNEONFactorReplication =
false,
const bool use4ChannelSamplingFastPaths =
false);
1435 template <
unsigned int tChannels>
1436 static void lookupMask8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable* input_LT_output,
const bool offset, uint8_t* output, uint8_t* outputMask,
const uint8_t maskValue,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows);
1441 ocean_assert(frame.
isValid());
1442 ocean_assert(width >= 1u && height >= 1u);
1446 if (!
resize(frame, target, worker))
1454 frame = std::move(target);
1458template <
typename TScalar>
1461 ocean_assert(frame !=
nullptr);
1462 ocean_assert(channels >= 1u && channels <= 8u);
1547 ocean_assert(
false &&
"Invalid channel number");
1551template <
typename TSource,
typename TTarget,
typename TScalar,
typename TIntermediate>
1554 ocean_assert(frame !=
nullptr);
1555 ocean_assert(channels >= 1u && channels <= 8u);
1562 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 1u, PC_TOP_LEFT, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1566 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 2u, PC_TOP_LEFT, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1570 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 3u, PC_TOP_LEFT, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1574 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 4u, PC_TOP_LEFT, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1578 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 5u, PC_TOP_LEFT, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1582 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 6u, PC_TOP_LEFT, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1586 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 7u, PC_TOP_LEFT, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1590 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 8u, PC_TOP_LEFT, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1604 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 1u, PC_CENTER, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1608 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 2u, PC_CENTER, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1612 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 3u, PC_CENTER, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1616 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 4u, PC_CENTER, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1620 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 5u, PC_CENTER, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1624 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 6u, PC_CENTER, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1628 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 7u, PC_CENTER, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1632 FrameInterpolatorBilinear::interpolatePixel<TSource, TTarget, 8u, PC_CENTER, TScalar, TIntermediate>(frame, width, height, framePaddingElements, position, result, resultBias);
1640 ocean_assert(
false &&
"Invalid channel number");
1644template <
typename T,
unsigned int tChannels>
1645inline void FrameInterpolatorBilinear::resize(
const T* source, T* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker)
1647 ocean_assert(source !=
nullptr && target !=
nullptr);
1648 ocean_assert(sourceWidth >= 1u && sourceHeight >= 1u);
1649 ocean_assert(targetWidth >= 1u && targetHeight >= 1u);
1651 const double sourceX_s_targetX = double(sourceWidth) / double(targetWidth);
1652 const double sourceY_s_targetY = double(sourceHeight) / double(targetHeight);
1654 scale<T, tChannels>(source, target, sourceWidth, sourceHeight, targetWidth, targetHeight, sourceX_s_targetX, sourceY_s_targetY, sourcePaddingElements, targetPaddingElements, worker);
1657template <
typename T,
unsigned int tChannels>
1658inline void FrameInterpolatorBilinear::scale(
const T* source, T* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker)
1660 ocean_assert(source !=
nullptr && target !=
nullptr);
1661 ocean_assert(sourceWidth >= 1u && sourceHeight >= 1u);
1662 ocean_assert(targetWidth >= 1u && targetHeight >= 1u);
1663 ocean_assert(sourceX_s_targetX > 0.0);
1664 ocean_assert(sourceY_s_targetY > 0.0);
1666 if (sourceWidth == targetWidth && sourceHeight == targetHeight && sourceX_s_targetX == 1.0 && sourceY_s_targetY == 1.0)
1668 FrameConverter::subFrame<T>(source, target, sourceWidth, sourceHeight, targetWidth, targetHeight, tChannels, 0u, 0u, 0u, 0u, sourceWidth, sourceHeight, sourcePaddingElements, targetPaddingElements);
1672 if (std::is_same<T, uint8_t>::value)
1676 scale8BitPerChannel<tChannels>((
const uint8_t*)source, (uint8_t*)target, sourceWidth, sourceHeight, targetWidth, targetHeight, sourceX_s_targetX, sourceY_s_targetY, sourcePaddingElements, targetPaddingElements, worker);
1684 worker->
executeFunction(
Worker::Function::createStatic(&
scaleSubset<T, TScale, tChannels>, source, target, sourceWidth, sourceHeight, targetWidth, targetHeight, sourceX_s_targetX, sourceY_s_targetY, sourcePaddingElements, targetPaddingElements, 0u, 0u), 0u, targetHeight);
1688 scaleSubset<T, TScale, tChannels>(source, target, sourceWidth, sourceHeight, targetWidth, targetHeight, sourceX_s_targetX, sourceY_s_targetY, sourcePaddingElements, targetPaddingElements, 0u, targetHeight);
1693template <
unsigned int tChannels>
1694inline void FrameInterpolatorBilinear::affine8BitPerChannel(
const uint8_t* source,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const SquareMatrix3& source_A_target,
const uint8_t* borderColor, uint8_t* target,
const CV::PixelPositionI& targetOrigin,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker)
1701 if (targetWidth >= 4u)
1703#if defined(OCEAN_HARDWARE_SSE_VERSION) && OCEAN_HARDWARE_SSE_VERSION >= 41
1704 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::affine8BitPerChannelSSESubset<tChannels>, source, sourceWidth, sourceHeight, &adjustedAffineTransform, borderColor, target, targetWidth, targetHeight, 0u, 0u, sourcePaddingElements, targetPaddingElements), 0, targetHeight, 8u, 9u, 20u);
1706#elif defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
1707 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::affine8BitPerChannelNEONSubset<tChannels>, source, sourceWidth, sourceHeight, &adjustedAffineTransform, borderColor, target, targetWidth, targetHeight, 0u, 0u, sourcePaddingElements, targetPaddingElements), 0, targetHeight, 8u, 9u, 20u);
1712 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::affine8BitPerChannelSubset<tChannels>, source, sourceWidth, sourceHeight, &adjustedAffineTransform, borderColor, target, targetWidth, targetHeight, 0u, 0u, sourcePaddingElements, targetPaddingElements), 0, targetHeight, 8u, 9u, 20u);
1716 if (targetWidth >= 4u)
1718#if defined(OCEAN_HARDWARE_SSE_VERSION) && OCEAN_HARDWARE_SSE_VERSION >= 41
1719 affine8BitPerChannelSSESubset<tChannels>(source, sourceWidth, sourceHeight, &adjustedAffineTransform, borderColor, target, targetWidth, targetHeight, 0u, targetHeight, sourcePaddingElements, targetPaddingElements);
1721#elif defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
1722 affine8BitPerChannelNEONSubset<tChannels>(source, sourceWidth, sourceHeight, &adjustedAffineTransform, borderColor, target, targetWidth, targetHeight, 0u, targetHeight, sourcePaddingElements, targetPaddingElements);
1727 affine8BitPerChannelSubset<tChannels>(source, sourceWidth, sourceHeight, &adjustedAffineTransform, borderColor, target, targetWidth, targetHeight, 0u, targetHeight, sourcePaddingElements, targetPaddingElements);
1731template <
unsigned int tChannels>
1732inline void FrameInterpolatorBilinear::homography8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3& input_H_output,
const uint8_t* borderColor, uint8_t* output,
const CV::PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
Worker* worker)
1739 if (outputWidth >= 4u)
1741#if defined(OCEAN_HARDWARE_SSE_VERSION) && OCEAN_HARDWARE_SSE_VERSION >= 41
1742 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::homography8BitPerChannelSSESubset<tChannels>, input, inputWidth, inputHeight, &input_H_shiftedOutput, borderColor, output, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, 0u), 0, outputHeight, 10u, 11u, 20u);
1744#elif defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
1745 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::homography8BitPerChannelNEONSubset<tChannels>, input, inputWidth, inputHeight, &input_H_shiftedOutput, borderColor, output, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, 0u), 0, outputHeight, 10u, 11u, 20u);
1750 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::homography8BitPerChannelSubset<tChannels>, input, inputWidth, inputHeight, &input_H_shiftedOutput, borderColor, output, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, 0u), 0, outputHeight, 10u, 11u, 20u);
1754 if (outputWidth >= 4u)
1756#if defined(OCEAN_HARDWARE_SSE_VERSION) && OCEAN_HARDWARE_SSE_VERSION >= 41
1757 homography8BitPerChannelSSESubset<tChannels>(input, inputWidth, inputHeight, &input_H_shiftedOutput, borderColor, output, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, outputHeight);
1759#elif defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
1760 homography8BitPerChannelNEONSubset<tChannels>(input, inputWidth, inputHeight, &input_H_shiftedOutput, borderColor, output, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, outputHeight);
1765 homography8BitPerChannelSubset<tChannels>(input, inputWidth, inputHeight, &input_H_shiftedOutput, borderColor, output, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, outputHeight);
1769template <
typename T,
unsigned int tChannels>
1770inline void FrameInterpolatorBilinear::homography(
const T* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3& input_H_output,
const T* borderColor, T* output,
const CV::PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
Worker* worker)
1772 if (std::is_same<T, uint8_t>::value)
1774 homography8BitPerChannel<tChannels>((
const uint8_t*)input, inputWidth, inputHeight, input_H_output, (
const uint8_t*)borderColor, (uint8_t*)output, outputOrigin, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, worker);
1784 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::homographySubset<T, tChannels>, input, inputWidth, inputHeight, &input_H_shiftedOutput, borderColor, output, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, 0u), 0, outputHeight, 10u, 11u, 20u);
1788 homographySubset<T, tChannels>(input, inputWidth, inputHeight, &input_H_shiftedOutput, borderColor, output, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, outputHeight);
1793template <
unsigned int tChannels>
1794inline void FrameInterpolatorBilinear::homographies8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3 homographies[4],
const uint8_t* borderColor, uint8_t* output,
const Vector2& outputQuadrantCenter,
const PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
Worker* worker)
1798 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::homographies8BitPerChannelSubset<tChannels>, input, inputWidth, inputHeight, homographies, borderColor, output, outputQuadrantCenter.
x(), outputQuadrantCenter.
y(), outputOrigin.
x(), outputOrigin.
y(), outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, 0u), 0, outputHeight, 14u, 15u, 20u);
1802 homographies8BitPerChannelSubset<tChannels>(input, inputWidth, inputHeight, homographies, borderColor, output, outputQuadrantCenter.
x(), outputQuadrantCenter.
y(), outputOrigin.
x(), outputOrigin.
y(), outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, 0u, outputHeight);
1806template <
unsigned int tChannels>
1807inline void FrameInterpolatorBilinear::homographyMask8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3& input_H_output, uint8_t* output, uint8_t* outputMask,
const CV::PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const uint8_t maskValue,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
Worker* worker)
1814 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::homographyMask8BitPerChannelSubset<tChannels>, input, inputWidth, inputHeight, &input_H_shiftedOutput, output, outputMask, maskValue, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, outputMaskPaddingElements, 0u, 0u), 0, outputHeight, 12u, 13u, 20u);
1818 homographyMask8BitPerChannelSubset<tChannels>(input, inputWidth, inputHeight, &input_H_shiftedOutput, output, outputMask, maskValue, outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, outputMaskPaddingElements, 0u, outputHeight);
1822template <
unsigned int tChannels>
1823inline void FrameInterpolatorBilinear::homographiesMask8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3 homographies[4], uint8_t* output, uint8_t* outputMask,
const Vector2& outputQuadrantCenter,
const CV::PixelPositionI& outputOrigin,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
Worker* worker,
const uint8_t maskValue)
1827 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::homographiesMask8BitPerChannelSubset<tChannels>, input, inputWidth, inputHeight, homographies, output, outputMask, maskValue, outputQuadrantCenter.
x(), outputQuadrantCenter.
y(), outputOrigin.
x(), outputOrigin.
y(), outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, outputMaskPaddingElements, 0u, 0u), 0, outputHeight);
1831 homographiesMask8BitPerChannelSubset<tChannels>(input, inputWidth, inputHeight, homographies, output, outputMask, maskValue, outputQuadrantCenter.
x(), outputQuadrantCenter.
y(), outputOrigin.
x(), outputOrigin.
y(), outputWidth, outputHeight, inputPaddingElements, outputPaddingElements, outputMaskPaddingElements, 0u, outputHeight);
1835template <
unsigned int tChannels>
1840 const PinholeCamera::DistortionLookup outputCameraDistortionLookup(outputCamera, 10u);
1844 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::homographyWithCamera8BitPerChannelSubset<tChannels>, &inputCamera, &outputCamera, &outputCameraDistortionLookup, input, &normalizedHomography, useDistortionParameters, borderColor, output, inputPaddingElements, outputPaddingElements, 0u, 0u), 0, outputCamera.
height());
1848 homographyWithCamera8BitPerChannelSubset<tChannels>(&inputCamera, &outputCamera, &outputCameraDistortionLookup, input, &normalizedHomography, useDistortionParameters, borderColor, output, inputPaddingElements, outputPaddingElements, 0u, outputCamera.
height());
1852template <
unsigned int tChannels>
1853inline void FrameInterpolatorBilinear::homographyWithCameraMask8BitPerChannel(
const PinholeCamera& inputCamera,
const PinholeCamera& outputCamera,
const uint8_t* input,
const unsigned int inputPaddingElements,
const SquareMatrix3&
homography, uint8_t* output, uint8_t* outputMask,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
Worker* worker,
const uint8_t maskValue)
1857 const PinholeCamera::DistortionLookup outputCameraDistortionLookup(outputCamera, 10u);
1861 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::homographyWithCameraMask8BitPerChannelSubset<tChannels>, &inputCamera, &outputCamera, &outputCameraDistortionLookup, input, inputPaddingElements, &normalizedHomography, output, outputMask, outputPaddingElements, outputMaskPaddingElements, maskValue, 0u, 0u), 0, outputCamera.
height(), 11u, 12u, 10u);
1865 homographyWithCameraMask8BitPerChannelSubset<tChannels>(&inputCamera, &outputCamera, &outputCameraDistortionLookup, input, inputPaddingElements, &normalizedHomography, output, outputMask, outputPaddingElements, outputMaskPaddingElements, maskValue, 0u, outputCamera.
height());
1869template <
typename T,
unsigned int tChannels>
1870inline void FrameInterpolatorBilinear::lookup(
const T* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable& input_LT_output,
const bool offset,
const T* borderColor, T* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
Worker* worker,
const bool useOptimizedNEON,
const bool useOptimizedBilinearValuesAndFactorCalculation, [[maybe_unused]]
const bool useOptimizedNEONFactorReplication, [[maybe_unused]]
const bool use4ChannelSamplingFastPaths)
1872 if constexpr (std::is_same<T, uint8_t>::value)
1874#if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
1875 if ((tChannels >= 1u && input_LT_output.
sizeX() >= 8) || (tChannels >= 2u && input_LT_output.
sizeX() >= 4))
1881 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::lookup8BitPerChannelSubsetNEON<tChannels>, input, inputWidth, inputHeight, &input_LT_output, offset, borderColor, output, inputPaddingElements, outputPaddingElements, 0u, 0u, useOptimizedNEON, useOptimizedBilinearValuesAndFactorCalculation, useOptimizedNEONFactorReplication, use4ChannelSamplingFastPaths), 0u, (
unsigned int)(input_LT_output.
sizeY()), 9u, 10u, 20u);
1885 lookup8BitPerChannelSubsetNEON<tChannels>(input, inputWidth, inputHeight, &input_LT_output, offset, borderColor, output, inputPaddingElements, outputPaddingElements, 0u, (
unsigned int)(input_LT_output.
sizeY()), useOptimizedNEON, useOptimizedBilinearValuesAndFactorCalculation, useOptimizedNEONFactorReplication, use4ChannelSamplingFastPaths);
1894 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::lookup8BitPerChannelSubset<tChannels>, input, inputWidth, inputHeight, &input_LT_output, offset, borderColor, output, inputPaddingElements, outputPaddingElements, 0u, 0u), 0u, (
unsigned int)input_LT_output.
sizeY(), 9u, 10u, 20u);
1898 lookup8BitPerChannelSubset<tChannels>(input, inputWidth, inputHeight, &input_LT_output, offset, borderColor, output, inputPaddingElements, outputPaddingElements, 0u, (
unsigned int)(input_LT_output.
sizeY()));
1903 ocean_assert((!std::is_same<T, uint8_t>::value));
1907 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::lookupSubset<T, tChannels>, input, inputWidth, inputHeight, &input_LT_output, offset, borderColor, output, inputPaddingElements, outputPaddingElements, 0u, 0u), 0u, (
unsigned int)(input_LT_output.
sizeY()), 9u, 10u, 20u);
1911 lookupSubset<T, tChannels>(input, inputWidth, inputHeight, &input_LT_output, offset, borderColor, output, inputPaddingElements, outputPaddingElements, 0u, (
unsigned int)(input_LT_output.
sizeY()));
1916template <
unsigned int tChannels>
1917inline void FrameInterpolatorBilinear::lookupMask8BitPerChannel(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable& input_LT_output,
const bool offset, uint8_t* output, uint8_t* outputMask,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
Worker* worker,
const uint8_t maskValue)
1921 worker->
executeFunction(
Worker::Function::createStatic(&
FrameInterpolatorBilinear::lookupMask8BitPerChannelSubset<tChannels>, input, inputWidth, inputHeight, &input_LT_output, offset, output, outputMask, maskValue, inputPaddingElements, outputPaddingElements, outputMaskPaddingElements, 0u, 0u), 0u, (
unsigned int)(input_LT_output.
sizeY()), 11u, 12u, 20u);
1925 lookupMask8BitPerChannelSubset<tChannels>(input, inputWidth, inputHeight, &input_LT_output, offset, output, outputMask, maskValue, inputPaddingElements, outputPaddingElements, outputMaskPaddingElements, 0u, (
unsigned int)(input_LT_output.
sizeY()));
1929template <
typename T,
unsigned int tChannels>
1930void FrameInterpolatorBilinear::resampleCameraImage(
const T* sourceFrame,
const AnyCamera& sourceCamera,
const SquareMatrix3& source_R_target,
const AnyCamera& targetCamera, T* targetFrame,
const unsigned int sourceFramePaddingElements,
const unsigned int targetFramePaddingElements,
LookupCorner2<Vector2>* source_OLT_target,
Worker* worker,
const unsigned int binSizeInPixel,
const T* borderColor)
1932 static_assert(tChannels >= 1u,
"Invalid channel number!");
1934 ocean_assert(sourceFrame !=
nullptr);
1935 ocean_assert(sourceCamera.
isValid());
1937 ocean_assert(targetCamera.
isValid());
1938 ocean_assert(targetFrame !=
nullptr);
1939 ocean_assert(binSizeInPixel >= 1u);
1941 const size_t binsX = std::max(1u, targetCamera.
width() / binSizeInPixel);
1942 const size_t binsY = std::max(1u, targetCamera.
height() / binSizeInPixel);
1945 for (
size_t yBin = 0; yBin <= lookupTable.
binsY(); ++yBin)
1947 for (
size_t xBin = 0; xBin <= lookupTable.
binsX(); ++xBin)
1951 constexpr bool makeUnitVector =
false;
1953 const Vector3 rayI = source_R_target * targetCamera.
vector(cornerPosition, makeUnitVector);
1970 lookup<T, tChannels>(sourceFrame, sourceCamera.
width(), sourceCamera.
height(), lookupTable,
true , borderColor, targetFrame, sourceFramePaddingElements, targetFramePaddingElements, worker);
1972 if (source_OLT_target)
1974 *source_OLT_target = std::move(lookupTable);
1978template <
unsigned int tChannels>
1979void FrameInterpolatorBilinear::rotate8BitPerChannel(
const uint8_t* source, uint8_t* target,
const unsigned int width,
const unsigned int height,
const Scalar horizontalAnchorPosition,
const Scalar verticalAnchorPosition,
const Scalar angle,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker,
const uint8_t* borderColor)
1981 static_assert(tChannels != 0u,
"Invalid channel number!");
1983 ocean_assert(source !=
nullptr && target !=
nullptr);
1984 ocean_assert(width >= 1u && height >= 1u);
1988 worker->
executeFunction(
Worker::Function::createStatic(&
rotate8BitPerChannelSubset<tChannels>, source, target, width, height, horizontalAnchorPosition, verticalAnchorPosition, angle, borderColor, sourcePaddingElements, targetPaddingElements, 0u, 0u), 0u, height);
1992 rotate8BitPerChannelSubset<tChannels>(source, target, width, height, horizontalAnchorPosition, verticalAnchorPosition, angle, borderColor, sourcePaddingElements, targetPaddingElements, 0u, height);
1996template <
unsigned int tChannels, PixelCenter tPixelCenter,
typename TScalar>
1999 static_assert(tChannels != 0u,
"Invalid channel number!");
2000 static_assert(tPixelCenter ==
PC_TOP_LEFT || tPixelCenter ==
PC_CENTER,
"Invalid pixel center!");
2002 ocean_assert(frame !=
nullptr && result !=
nullptr);
2003 ocean_assert(width != 0u && height != 0u);
2005 const unsigned int frameStrideElements = width * tChannels + framePaddingElements;
2007 ocean_assert(position.
x() >= TScalar(0));
2008 ocean_assert(position.
y() >= TScalar(0));
2012 ocean_assert(position.
x() <= TScalar(width - 1u));
2013 ocean_assert(position.
y() <= TScalar(height - 1u));
2015 const unsigned int left = (
unsigned int)(position.
x());
2016 const unsigned int top = (
unsigned int)(position.
y());
2017 ocean_assert(left < width && top < height);
2019 const TScalar tx = position.
x() - TScalar(left);
2020 ocean_assert(tx >= 0 && tx <= 1);
2021 const unsigned int txi = (
unsigned int)(tx * TScalar(128) + TScalar(0.5));
2022 const unsigned int txi_ = 128u - txi;
2024 const TScalar ty = position.
y() - TScalar(top);
2025 ocean_assert(ty >= 0 && ty <= 1);
2026 const unsigned int tyi = (
unsigned int)(ty * TScalar(128) + TScalar(0.5));
2027 const unsigned int tyi_ = 128u - tyi;
2029 const unsigned int rightOffset = left + 1u < width ? tChannels : 0u;
2030 const unsigned int bottomOffset = top + 1u < height ? frameStrideElements : 0u;
2032 const uint8_t*
const topLeft = frame + top * frameStrideElements + tChannels * left;
2034 const unsigned int txty = txi * tyi;
2035 const unsigned int txty_ = txi * tyi_;
2036 const unsigned int tx_ty = txi_ * tyi;
2037 const unsigned int tx_ty_ = txi_ * tyi_;
2039 for (
unsigned int n = 0u; n < tChannels; ++n)
2041 result[n] = uint8_t((topLeft[n] * tx_ty_ + topLeft[rightOffset + n] * txty_ + topLeft[bottomOffset + n] * tx_ty + topLeft[bottomOffset + rightOffset + n] * txty + 8192u) >> 14u);
2046 ocean_assert(tPixelCenter ==
PC_CENTER);
2048 ocean_assert(position.
x() <= TScalar(width));
2049 ocean_assert(position.
y() <= TScalar(height));
2051 const TScalar xShifted = std::max(TScalar(0.0), position.
x() - TScalar(0.5));
2052 const TScalar yShifted = std::max(TScalar(0.0), position.
y() - TScalar(0.5));
2054 const unsigned int left = (
unsigned int)(xShifted);
2055 const unsigned int top = (
unsigned int)(yShifted);
2057 ocean_assert(left < width);
2058 ocean_assert(top < height);
2060 const TScalar tx = xShifted - TScalar(left);
2061 const TScalar ty = yShifted - TScalar(top);
2063 ocean_assert(tx >= 0 && tx <= 1);
2064 ocean_assert(ty >= 0 && ty <= 1);
2066 const unsigned int txi = (
unsigned int)(tx * TScalar(128) + TScalar(0.5));
2067 const unsigned int txi_ = 128u - txi;
2069 const unsigned int tyi = (
unsigned int)(ty * TScalar(128) + TScalar(0.5));
2070 const unsigned int tyi_ = 128u - tyi;
2072 const unsigned int rightOffset = left + 1u < width ? tChannels : 0u;
2073 const unsigned int bottomOffset = top + 1u < height ? frameStrideElements : 0u;
2075 const uint8_t*
const topLeft = frame + top * frameStrideElements + left * tChannels;
2077 const unsigned int txty = txi * tyi;
2078 const unsigned int txty_ = txi * tyi_;
2079 const unsigned int tx_ty = txi_ * tyi;
2080 const unsigned int tx_ty_ = txi_ * tyi_;
2082 for (
unsigned int n = 0u; n < tChannels; ++n)
2084 result[n] = uint8_t((topLeft[n] * tx_ty_ + topLeft[rightOffset + n] * txty_ + topLeft[bottomOffset + n] * tx_ty + topLeft[bottomOffset + rightOffset + n] * txty + 8192u) >> 14u);
2089template <
typename TSource,
typename TTarget,
unsigned int tChannels, PixelCenter tPixelCenter,
typename TScalar,
typename TIntermediate>
2092 static_assert(tChannels != 0u,
"Invalid channel number!");
2093 static_assert(tPixelCenter ==
PC_TOP_LEFT || tPixelCenter ==
PC_CENTER,
"Invalid pixel center!");
2095 ocean_assert(frame !=
nullptr && result !=
nullptr);
2096 ocean_assert(width != 0u && height != 0u);
2098 const unsigned int frameStrideElements = width * tChannels + framePaddingElements;
2100 ocean_assert(position.
x() >= TScalar(0));
2101 ocean_assert(position.
y() >= TScalar(0));
2105 ocean_assert(position.
x() <= TScalar(width - 1u));
2106 ocean_assert(position.
y() <= TScalar(height - 1u));
2108 const unsigned int left = (
unsigned int)(position.
x());
2109 const unsigned int top = (
unsigned int)(position.
y());
2111 const TScalar tx = position.
x() - TScalar(left);
2112 ocean_assert(tx >= 0 && tx <= 1);
2114 const TScalar ty = position.
y() - TScalar(top);
2115 ocean_assert(ty >= 0 && ty <= 1);
2117 const unsigned int rightOffset = left + 1u < width ? tChannels : 0u;
2118 const unsigned int bottomOffset = top + 1u < height ? frameStrideElements : 0u;
2120 const TSource*
const topLeft = frame + top * frameStrideElements + tChannels * left;
2122 const TIntermediate txty = TIntermediate(tx) * TIntermediate(ty);
2123 const TIntermediate txty_ = TIntermediate(tx) * (TIntermediate(1) - TIntermediate(ty));
2124 const TIntermediate tx_ty = (TIntermediate(1) - TIntermediate(tx)) * TIntermediate(ty);
2125 const TIntermediate tx_ty_ = (TIntermediate(1) - TIntermediate(tx)) * (TIntermediate(1) - TIntermediate(ty));
2129 for (
unsigned int n = 0u; n < tChannels; ++n)
2131 result[n] = TTarget(TIntermediate(topLeft[n]) * tx_ty_ + TIntermediate(topLeft[rightOffset + n]) * txty_ + TIntermediate(topLeft[bottomOffset + n]) * tx_ty + TIntermediate(topLeft[bottomOffset + rightOffset + n]) * txty + resultBias);
2136 ocean_assert(tPixelCenter ==
PC_CENTER);
2138 ocean_assert(position.
x() <= TScalar(width));
2139 ocean_assert(position.
y() <= TScalar(height));
2141 const TScalar xShifted = std::max(TScalar(0.0), position.
x() - TScalar(0.5));
2142 const TScalar yShifted = std::max(TScalar(0.0), position.
y() - TScalar(0.5));
2144 const unsigned int left = (
unsigned int)(xShifted);
2145 const unsigned int top = (
unsigned int)(yShifted);
2147 ocean_assert(left < width);
2148 ocean_assert(top < height);
2150 const TScalar tx = xShifted - TScalar(left);
2151 const TScalar ty = yShifted - TScalar(top);
2153 ocean_assert(tx >= 0 && tx <= 1);
2154 ocean_assert(ty >= 0 && ty <= 1);
2156 const unsigned int rightOffset = left + 1u < width ? tChannels : 0u;
2157 const unsigned int bottomOffset = top + 1u < height ? frameStrideElements : 0u;
2159 const TSource*
const topLeft = frame + top * frameStrideElements + tChannels * left;
2161 const TIntermediate txty = TIntermediate(tx) * TIntermediate(ty);
2162 const TIntermediate txty_ = TIntermediate(tx) * (TIntermediate(1) - TIntermediate(ty));
2163 const TIntermediate tx_ty = (TIntermediate(1) - TIntermediate(tx)) * TIntermediate(ty);
2164 const TIntermediate tx_ty_ = (TIntermediate(1) - TIntermediate(tx)) * (TIntermediate(1) - TIntermediate(ty));
2168 for (
unsigned int n = 0u; n < tChannels; ++n)
2170 result[n] = TTarget(TIntermediate(topLeft[n]) * tx_ty_ + TIntermediate(topLeft[rightOffset + n]) * txty_ + TIntermediate(topLeft[bottomOffset + n]) * tx_ty + TIntermediate(topLeft[bottomOffset + rightOffset + n]) * txty + resultBias);
2175template <
unsigned int tChannels,
bool tAlphaAtFront,
bool tTransparentIs0xFF>
2178 static_assert(tChannels != 0u,
"Invalid channel number!");
2180 ocean_assert(frame && result);
2187 for (
unsigned int n = 0u; n < tChannels - 1u; ++n)
2197 const unsigned int frameStrideElements = width * tChannels + framePaddingElements;
2202 ocean_assert(left >= -1 && left <
int(width));
2203 ocean_assert(top >= -1 && top <
int(height));
2205 if ((
unsigned int)left < width - 1u && (
unsigned int)top < height - 1u)
2209 const unsigned int txi = (
unsigned int)((pos.
x() -
Scalar(left)) *
Scalar(128) +
Scalar(0.5));
2210 const unsigned int txi_ = 128u - txi;
2212 const unsigned int tyi = (
unsigned int)((pos.
y() -
Scalar(top)) *
Scalar(128) +
Scalar(0.5));
2213 const unsigned int tyi_ = 128u - tyi;
2215 const uint8_t*
const topLeft = frame + top * frameStrideElements + left * tChannels;
2217 const unsigned int txty = txi * tyi;
2218 const unsigned int txty_ = txi * tyi_;
2219 const unsigned int tx_ty = txi_ * tyi;
2220 const unsigned int tx_ty_ = txi_ * tyi_;
2222 for (
unsigned int n = 0u; n < tChannels; ++n)
2224 result[n] = (topLeft[n] * tx_ty_ + topLeft[tChannels + n] * txty_
2225 + topLeft[frameStrideElements + n] * tx_ty + topLeft[frameStrideElements + tChannels + n] * txty + 8192u) >> 14u;
2232 const unsigned int txi = (
unsigned int)((pos.
x() -
Scalar(left)) *
Scalar(128) +
Scalar(0.5));
2233 const unsigned int txi_ = 128u - txi;
2235 const unsigned int tyi = (
unsigned int)((pos.
y() -
Scalar(top)) *
Scalar(128) +
Scalar(0.5));
2236 const unsigned int tyi_ = 128u - tyi;
2238 const unsigned int rightOffset = (left >= 0 && left + 1u < width) ? tChannels : 0u;
2239 const unsigned int bottomOffset = (top >= 0 && top + 1u < height) ? frameStrideElements : 0u;
2241 ocean_assert(left <
int(width) && top <
int(height));
2242 const uint8_t*
const topLeft = frame + max(0, top) * frameStrideElements + max(0, left) * tChannels;
2244 const unsigned int txty = txi * tyi;
2245 const unsigned int txty_ = txi * tyi_;
2246 const unsigned int tx_ty = txi_ * tyi;
2247 const unsigned int tx_ty_ = txi_ * tyi_;
2251 result[n] = (topLeft[n] * tx_ty_ + topLeft[rightOffset + n] * txty_
2252 + topLeft[bottomOffset + n] * tx_ty + topLeft[bottomOffset + rightOffset + n] * txty + 8192u) >> 14u;
2264template <
unsigned int tChannels>
2265void FrameInterpolatorBilinear::affine8BitPerChannelSubset(
const uint8_t* source,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const SquareMatrix3* source_A_target,
const uint8_t* borderColor, uint8_t* target,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int firstTargetRow,
const unsigned int numberOutputRows,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements)
2267 static_assert(tChannels >= 1u,
"Invalid channel number!");
2269 ocean_assert(source !=
nullptr && target !=
nullptr);
2270 ocean_assert(sourceWidth > 0u && sourceHeight > 0u);
2271 ocean_assert_and_suppress_unused(targetWidth > 0u && targetHeight > 0u, targetHeight);
2272 ocean_assert(source_A_target);
2275 ocean_assert(firstTargetRow + numberOutputRows <= targetHeight);
2277 const unsigned int targetStrideElements = tChannels * targetWidth + targetPaddingElements;
2279 const Scalar scalarSourceWidth_1 =
Scalar(sourceWidth - 1u);
2280 const Scalar scalarSourceHeight_1 =
Scalar(sourceHeight - 1u);
2284 uint8_t zeroColor[tChannels] = {uint8_t(0)};
2285 const PixelType*
const bColor = borderColor ? (PixelType*)borderColor : (PixelType*)zeroColor;
2287 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberOutputRows; ++y)
2289 PixelType* targetRow = (PixelType*)(target + y * targetStrideElements);
2315 for (
unsigned int x = 0u; x < targetWidth; ++x)
2320 const Scalar debugSourceX = (*source_A_target)[0] *
Scalar(x) + (*source_A_target)[3] *
Scalar(y) + (*source_A_target)[6];
2321 const Scalar debugSourceY = (*source_A_target)[1] *
Scalar(x) + (*source_A_target)[4] *
Scalar(y) + (*source_A_target)[7];
2325 if (sourcePosition.
x() <
Scalar(0) || sourcePosition.
x() > scalarSourceWidth_1 || sourcePosition.
y() <
Scalar(0) || sourcePosition.
y() > scalarSourceHeight_1)
2327 *targetRow = *bColor;
2339template <
unsigned int tChannels>
2340void FrameInterpolatorBilinear::homography8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output,
const uint8_t* borderColor, uint8_t* output,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows)
2342 static_assert(tChannels >= 1u,
"Invalid channel number!");
2344 ocean_assert(input !=
nullptr && output !=
nullptr);
2345 ocean_assert(inputWidth > 0u && inputHeight > 0u);
2346 ocean_assert(outputWidth > 0u && outputHeight > 0u);
2347 ocean_assert(input_H_output !=
nullptr);
2349 ocean_assert_and_suppress_unused(firstOutputRow + numberOutputRows <= outputHeight, outputHeight);
2351 const unsigned int outputStrideElements = outputWidth * tChannels + outputPaddingElements;
2353 const Scalar scalarInputWidth_1 =
Scalar(inputWidth - 1u);
2354 const Scalar scalarInputHeight_1 =
Scalar(inputHeight - 1u);
2358 uint8_t zeroColor[tChannels] = {uint8_t(0)};
2359 const PixelType bColor = borderColor ? *(PixelType*)borderColor : *(PixelType*)zeroColor;
2361 for (
unsigned int y = firstOutputRow; y < firstOutputRow + numberOutputRows; ++y)
2387 const Scalar X2 = (*input_H_output)(2, 0);
2388 const Scalar constValue2 = (*input_H_output)(2, 1) *
Scalar(y) + (*input_H_output)(2, 2);
2390 PixelType* outputRowPixel = (PixelType*)(output + y * outputStrideElements);
2392 for (
unsigned int x = 0u; x < outputWidth; ++x)
2399 ocean_assert(inputPosition.
isEqual(debugInputPosition,
Scalar(0.01)));
2402 if (inputPosition.
x() <
Scalar(0) || inputPosition.
x() > scalarInputWidth_1 || inputPosition.
y() <
Scalar(0) || inputPosition.
y() > scalarInputHeight_1)
2404 *outputRowPixel = bColor;
2416template <
typename T,
unsigned int tChannels>
2417void FrameInterpolatorBilinear::homographySubset(
const T* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output,
const T* borderColor, T* output,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows)
2419 static_assert(tChannels >= 1u,
"Invalid channel number!");
2421 ocean_assert(input !=
nullptr && output !=
nullptr);
2422 ocean_assert(inputWidth > 0u && inputHeight > 0u);
2423 ocean_assert_and_suppress_unused(outputWidth > 0u && outputHeight > 0u, outputHeight);
2424 ocean_assert(input_H_output !=
nullptr);
2426 ocean_assert(firstOutputRow + numberOutputRows <= outputHeight);
2428 const unsigned int outputStrideElements = outputWidth * tChannels + outputPaddingElements;
2430 const Scalar scalarInputWidth1 =
Scalar(inputWidth - 1u);
2431 const Scalar scalarInputHeight1 =
Scalar(inputHeight - 1u);
2438 constexpr T zeroColor[tChannels] = {T(0)};
2439 const PixelType*
const bColor = borderColor ? (PixelType*)(borderColor) : (PixelType*)(zeroColor);
2441 constexpr TIntermediate bias = TIntermediate(0);
2443 for (
unsigned int y = firstOutputRow; y < firstOutputRow + numberOutputRows; ++y)
2469 const Scalar X2 = (*input_H_output)(2, 0);
2470 const Scalar constValue2 = (*input_H_output)(2, 1) *
Scalar(y) + (*input_H_output)(2, 2);
2472 PixelType* outputRowPixel = (PixelType*)(output + y * outputStrideElements);
2474 for (
unsigned int x = 0u; x < outputWidth; ++x)
2481 ocean_assert((std::is_same<float, Scalar>::value) || inputPosition.
isEqual(debugInputPosition,
Scalar(0.01)));
2484 if (inputPosition.
x() >=
Scalar(0) && inputPosition.
x() <= scalarInputWidth1 && inputPosition.
y() >=
Scalar(0) && inputPosition.
y() <= scalarInputHeight1)
2486 interpolatePixel<T, T, tChannels, CV::PC_TOP_LEFT, Scalar, TIntermediate>(input, inputWidth, inputHeight, inputPaddingElements, inputPosition, (T*)(outputRowPixel), bias);
2490 *outputRowPixel = *bColor;
2498#if defined(OCEAN_HARDWARE_SSE_VERSION) && OCEAN_HARDWARE_SSE_VERSION >= 41
2500template <
unsigned int tChannels>
2501inline void FrameInterpolatorBilinear::affine8BitPerChannelSSESubset(
const uint8_t* source,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const SquareMatrix3* source_A_target,
const uint8_t* borderColor, uint8_t* target,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements)
2503 static_assert(tChannels >= 1u,
"Invalid channel number!");
2505 ocean_assert(source && target);
2506 ocean_assert(sourceWidth > 0u && sourceHeight > 0u);
2507 ocean_assert(targetWidth >= 4u && targetHeight > 0u);
2508 ocean_assert(source_A_target);
2511 ocean_assert_and_suppress_unused(firstTargetRow + numberTargetRows <= targetHeight, targetHeight);
2513 const unsigned int sourceStrideElements = tChannels * sourceWidth + sourcePaddingElements;
2514 const unsigned int targetStrideElements = tChannels * targetWidth + targetPaddingElements;
2518 uint8_t zeroColor[tChannels] = {uint8_t(0)};
2519 const PixelType*
const bColor = borderColor ? (PixelType*)borderColor : (PixelType*)zeroColor;
2521 OCEAN_ALIGN_DATA(16)
unsigned int validPixels[4];
2523 OCEAN_ALIGN_DATA(16)
unsigned int topLeftOffsets[4];
2524 OCEAN_ALIGN_DATA(16)
unsigned int topRightOffsets[4];
2525 OCEAN_ALIGN_DATA(16)
unsigned int bottomLeftOffsets[4];
2526 OCEAN_ALIGN_DATA(16)
unsigned int bottomRightOffsets[4];
2529 const __m128 m128_f_X0 = _mm_set_ps1(
float((*source_A_target)(0, 0)));
2530 const __m128 m128_f_X1 = _mm_set_ps1(
float((*source_A_target)(1, 0)));
2532 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
2534 PixelType* targetRow = (PixelType*)(target + y * targetStrideElements);
2558 const __m128 m128_f_C0 = _mm_set_ps1(
float((*source_A_target)(0, 1) *
Scalar(y) + (*source_A_target)(0, 2)));
2559 const __m128 m128_f_C1 = _mm_set_ps1(
float((*source_A_target)(1, 1) *
Scalar(y) + (*source_A_target)(1, 2)));
2562 const __m128 m128_f_zero = _mm_setzero_ps();
2565 const __m128i m128_i_channels = _mm_set1_epi32(tChannels);
2568 const __m128i m128_i_sourceStrideElements = _mm_set1_epi32(sourceStrideElements);
2571 const __m128i m128_i_sourceWidth_1 = _mm_set1_epi32(
int(sourceWidth) - 1);
2572 const __m128i m128_i_sourceHeight_1 = _mm_set1_epi32(
int(sourceHeight) - 1);
2575 const __m128 m128_f_sourceWidth_1 = _mm_set_ps1(
float(sourceWidth - 1u));
2576 const __m128 m128_f_sourceHeight_1 = _mm_set_ps1(
float(sourceHeight - 1u));
2578 for (
unsigned int x = 0u; x < targetWidth; x += 4u)
2580 if (x + 4u > targetWidth)
2585 ocean_assert(x >= 4u && targetWidth > 4u);
2586 const unsigned int newX = targetWidth - 4u;
2588 ocean_assert(x > newX);
2589 targetRow -= x - newX;
2594 ocean_assert(!(x + 4u < targetWidth));
2600 const __m128 m128_f_x_0123 = _mm_set_ps(
float(x + 3u),
float(x + 2u),
float(x + 1u),
float(x + 0u));
2603 const __m128 m128_f_sourceX = _mm_add_ps(_mm_mul_ps(m128_f_X0, m128_f_x_0123), m128_f_C0);
2604 const __m128 m128_f_sourceY = _mm_add_ps(_mm_mul_ps(m128_f_X1, m128_f_x_0123), m128_f_C1);
2607 const __m128 m128_f_validPixelX = _mm_and_ps(_mm_cmple_ps(m128_f_sourceX, m128_f_sourceWidth_1), _mm_cmpge_ps(m128_f_sourceX, m128_f_zero));
2608 const __m128 m128_f_validPixelY = _mm_and_ps(_mm_cmple_ps(m128_f_sourceY, m128_f_sourceHeight_1), _mm_cmpge_ps(m128_f_sourceY, m128_f_zero));
2610 const __m128i m128_i_validPixel = _mm_castps_si128(_mm_and_ps(m128_f_validPixelX, m128_f_validPixelY));
2613 if (_mm_test_all_zeros(m128_i_validPixel, _mm_set1_epi32(0xFFFFFFFF)))
2616 OCEAN_ALIGN_DATA(16)
unsigned int debugValidPixels[4];
2617 _mm_store_si128((__m128i*)debugValidPixels, m128_i_validPixel);
2618 ocean_assert(!(debugValidPixels[0] || debugValidPixels[1] || debugValidPixels[2] || debugValidPixels[3]));
2621 targetRow[0] = *bColor;
2622 targetRow[1] = *bColor;
2623 targetRow[2] = *bColor;
2624 targetRow[3] = *bColor;
2632 _mm_store_si128((__m128i*)validPixels, m128_i_validPixel);
2633 ocean_assert(validPixels[0] || validPixels[1] || validPixels[2] || validPixels[3]);
2637 const __m128 m128_f_tx_floor = _mm_floor_ps(m128_f_sourceX);
2638 const __m128 m128_f_ty_floor = _mm_floor_ps(m128_f_sourceY);
2641 const __m128i m128_i_left = _mm_cvtps_epi32(m128_f_tx_floor);
2642 const __m128i m128_i_top = _mm_cvtps_epi32(m128_f_ty_floor);
2645 const __m128i m128_i_right = _mm_min_epu32(_mm_add_epi32(m128_i_left, _mm_set1_epi32(1)), m128_i_sourceWidth_1);
2646 const __m128i m128_i_bottom = _mm_min_epu32(_mm_add_epi32(m128_i_top, _mm_set1_epi32(1)), m128_i_sourceHeight_1);
2649 const __m128i m128_i_topLeftOffset = _mm_add_epi32(_mm_mullo_epi32(m128_i_top, m128_i_sourceStrideElements), _mm_mullo_epi32(m128_i_channels, m128_i_left));
2650 const __m128i m128_i_topRightOffset = _mm_add_epi32(_mm_mullo_epi32(m128_i_top, m128_i_sourceStrideElements), _mm_mullo_epi32(m128_i_channels, m128_i_right));
2651 const __m128i m128_i_bottomLeftOffset = _mm_add_epi32(_mm_mullo_epi32(m128_i_bottom, m128_i_sourceStrideElements), _mm_mullo_epi32(m128_i_channels, m128_i_left));
2652 const __m128i m128_i_bottomRightOffset = _mm_add_epi32(_mm_mullo_epi32(m128_i_bottom, m128_i_sourceStrideElements), _mm_mullo_epi32(m128_i_channels, m128_i_right));
2655 _mm_store_si128((__m128i*)topLeftOffsets, m128_i_topLeftOffset);
2656 _mm_store_si128((__m128i*)topRightOffsets, m128_i_topRightOffset);
2657 _mm_store_si128((__m128i*)bottomLeftOffsets, m128_i_bottomLeftOffset);
2658 _mm_store_si128((__m128i*)bottomRightOffsets, m128_i_bottomRightOffset);
2666 __m128 m128_f_tx = _mm_sub_ps(m128_f_sourceX, m128_f_tx_floor);
2667 __m128 m128_f_ty = _mm_sub_ps(m128_f_sourceY, m128_f_ty_floor);
2670 m128_f_tx = _mm_mul_ps(m128_f_tx, _mm_set_ps1(128.0f));
2671 m128_f_ty = _mm_mul_ps(m128_f_ty, _mm_set_ps1(128.0f));
2673 m128_f_tx = _mm_round_ps(m128_f_tx, _MM_FROUND_TO_NEAREST_INT);
2674 m128_f_ty = _mm_round_ps(m128_f_ty, _MM_FROUND_TO_NEAREST_INT);
2676 const __m128i m128_i_tx = _mm_cvtps_epi32(m128_f_tx);
2677 const __m128i m128_i_ty = _mm_cvtps_epi32(m128_f_ty);
2685template <
unsigned int tChannels>
2686inline void FrameInterpolatorBilinear::homography8BitPerChannelSSESubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output,
const uint8_t* borderColor, uint8_t* output,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows)
2688 static_assert(tChannels >= 1u,
"Invalid channel number!");
2690 ocean_assert(input !=
nullptr && output !=
nullptr);
2691 ocean_assert(inputWidth > 0u && inputHeight > 0u);
2692 ocean_assert(outputWidth >= 4u && outputHeight > 0u);
2693 ocean_assert(input_H_output !=
nullptr);
2695 ocean_assert_and_suppress_unused(firstOutputRow + numberOutputRows <= outputHeight, outputHeight);
2697 const unsigned int inputStrideElements = inputWidth * tChannels + inputPaddingElements;
2698 const unsigned int outputStrideElements = outputWidth * tChannels + outputPaddingElements;
2702 uint8_t zeroColor[tChannels] = {uint8_t(0)};
2703 const PixelType*
const bColor = borderColor ? (PixelType*)borderColor : (PixelType*)zeroColor;
2705 OCEAN_ALIGN_DATA(16)
unsigned int validPixels[4];
2707 OCEAN_ALIGN_DATA(16)
unsigned int topLeftOffsets[4];
2708 OCEAN_ALIGN_DATA(16)
unsigned int topRightOffsets[4];
2709 OCEAN_ALIGN_DATA(16)
unsigned int bottomLeftOffsets[4];
2710 OCEAN_ALIGN_DATA(16)
unsigned int bottomRightOffsets[4];
2713 const __m128 m128_f_X0 = _mm_set_ps1(
float((*input_H_output)(0, 0)));
2714 const __m128 m128_f_X1 = _mm_set_ps1(
float((*input_H_output)(1, 0)));
2715 const __m128 m128_f_X2 = _mm_set_ps1(
float((*input_H_output)(2, 0)));
2718 const __m128 m128_f_zero = _mm_setzero_ps();
2721 const __m128i m128_i_channels = _mm_set1_epi32(tChannels);
2724 const __m128i m128_i_inputStrideElements = _mm_set1_epi32(inputStrideElements);
2727 const __m128i m128_i_inputWidth_1 = _mm_set1_epi32(
int(inputWidth) - 1);
2728 const __m128i m128_i_inputHeight_1 = _mm_set1_epi32(
int(inputHeight) - 1);
2731 const __m128 m128_f_inputWidth_1 = _mm_set_ps1(
float(inputWidth - 1u));
2732 const __m128 m128_f_inputHeight_1 = _mm_set_ps1(
float(inputHeight - 1u));
2734 for (
unsigned int y = firstOutputRow; y < firstOutputRow + numberOutputRows; ++y)
2736 PixelType* outputPixelData = (PixelType*)(output + y * outputStrideElements);
2760 const __m128 m128_f_C0 = _mm_set_ps1(
float((*input_H_output)(0, 1) *
Scalar(y) + (*input_H_output)(0, 2)));
2761 const __m128 m128_f_C1 = _mm_set_ps1(
float((*input_H_output)(1, 1) *
Scalar(y) + (*input_H_output)(1, 2)));
2762 const __m128 m128_f_C2 = _mm_set_ps1(
float((*input_H_output)(2, 1) *
Scalar(y) + (*input_H_output)(2, 2)));
2764 for (
unsigned int x = 0u; x < outputWidth; x += 4u)
2766 if (x + 4u > outputWidth)
2771 ocean_assert(x >= 4u && outputWidth > 4u);
2772 const unsigned int newX = outputWidth - 4u;
2774 ocean_assert(x > newX);
2775 outputPixelData -= x - newX;
2780 ocean_assert(!(x + 4u < outputWidth));
2786 const __m128 m128_f_x_0123 = _mm_set_ps(
float(x + 3u),
float(x + 2u),
float(x + 1u),
float(x + 0u));
2789 const __m128 m128_f_xx = _mm_add_ps(_mm_mul_ps(m128_f_X0, m128_f_x_0123), m128_f_C0);
2790 const __m128 m128_f_yy = _mm_add_ps(_mm_mul_ps(m128_f_X1, m128_f_x_0123), m128_f_C1);
2791 const __m128 m128_f_zz = _mm_add_ps(_mm_mul_ps(m128_f_X2, m128_f_x_0123), m128_f_C2);
2793#ifdef USE_APPROXIMATED_INVERSE_OF_ZZ
2798 const __m128 inv_zz_128 = _mm_rcp_ps(m128_f_zz);
2801 const __m128 m128_f_inputX = _mm_mul_ps(m128_f_xx, inv_zz_128);
2802 const __m128 m128_f_inputY = _mm_mul_ps(m128_f_yy, inv_zz_128);
2807 const __m128 m128_f_inputX = _mm_div_ps(m128_f_xx, m128_f_zz);
2808 const __m128 m128_f_inputY = _mm_div_ps(m128_f_yy, m128_f_zz);
2814 const __m128 m128_f_validPixelX = _mm_and_ps(_mm_cmple_ps (m128_f_inputX, m128_f_inputWidth_1), _mm_cmpge_ps(m128_f_inputX, m128_f_zero));
2815 const __m128 m128_f_validPixelY = _mm_and_ps(_mm_cmple_ps (m128_f_inputY, m128_f_inputHeight_1), _mm_cmpge_ps(m128_f_inputY, m128_f_zero));
2817 const __m128i m128_i_validPixel = _mm_castps_si128(_mm_and_ps(m128_f_validPixelX, m128_f_validPixelY));
2820 if (_mm_test_all_zeros(m128_i_validPixel, _mm_set1_epi32(0xFFFFFFFF)))
2823 OCEAN_ALIGN_DATA(16)
unsigned int debugValidPixels[4];
2824 _mm_store_si128((__m128i*)debugValidPixels, m128_i_validPixel);
2825 ocean_assert(!(debugValidPixels[0] || debugValidPixels[1] || debugValidPixels[2] || debugValidPixels[3]));
2828 outputPixelData[0] = *bColor;
2829 outputPixelData[1] = *bColor;
2830 outputPixelData[2] = *bColor;
2831 outputPixelData[3] = *bColor;
2833 outputPixelData += 4;
2839 _mm_store_si128((__m128i*)validPixels, m128_i_validPixel);
2840 ocean_assert(validPixels[0] || validPixels[1] || validPixels[2] || validPixels[3]);
2844 const __m128 m128_f_tx_floor = _mm_floor_ps(m128_f_inputX);
2845 const __m128 m128_f_ty_floor = _mm_floor_ps(m128_f_inputY);
2848 const __m128i m128_i_left = _mm_cvtps_epi32(m128_f_tx_floor);
2849 const __m128i m128_i_top = _mm_cvtps_epi32(m128_f_ty_floor);
2852 const __m128i m128_i_right = _mm_min_epu32(_mm_add_epi32(m128_i_left, _mm_set1_epi32(1)), m128_i_inputWidth_1);
2853 const __m128i m128_i_bottom = _mm_min_epu32(_mm_add_epi32(m128_i_top, _mm_set1_epi32(1)), m128_i_inputHeight_1);
2856 const __m128i m128_i_topLeftOffset = _mm_add_epi32(_mm_mullo_epi32(m128_i_top, m128_i_inputStrideElements), _mm_mullo_epi32(m128_i_channels, m128_i_left));
2857 const __m128i m128_i_topRightOffset = _mm_add_epi32(_mm_mullo_epi32(m128_i_top, m128_i_inputStrideElements), _mm_mullo_epi32(m128_i_channels, m128_i_right));
2858 const __m128i m128_i_bottomLeftOffset = _mm_add_epi32(_mm_mullo_epi32(m128_i_bottom, m128_i_inputStrideElements), _mm_mullo_epi32(m128_i_channels, m128_i_left));
2859 const __m128i m128_i_bottomRightOffset = _mm_add_epi32(_mm_mullo_epi32(m128_i_bottom, m128_i_inputStrideElements), _mm_mullo_epi32(m128_i_channels, m128_i_right));
2862 _mm_store_si128((__m128i*)topLeftOffsets, m128_i_topLeftOffset);
2863 _mm_store_si128((__m128i*)topRightOffsets, m128_i_topRightOffset);
2864 _mm_store_si128((__m128i*)bottomLeftOffsets, m128_i_bottomLeftOffset);
2865 _mm_store_si128((__m128i*)bottomRightOffsets, m128_i_bottomRightOffset);
2873 __m128 m128_f_tx = _mm_sub_ps(m128_f_inputX, m128_f_tx_floor);
2874 __m128 m128_f_ty = _mm_sub_ps(m128_f_inputY, m128_f_ty_floor);
2877 m128_f_tx = _mm_mul_ps(m128_f_tx, _mm_set_ps1(128.0f));
2878 m128_f_ty = _mm_mul_ps(m128_f_ty, _mm_set_ps1(128.0f));
2880 m128_f_tx = _mm_round_ps(m128_f_tx, _MM_FROUND_TO_NEAREST_INT);
2881 m128_f_ty = _mm_round_ps(m128_f_ty, _MM_FROUND_TO_NEAREST_INT);
2883 const __m128i m128_i_tx = _mm_cvtps_epi32(m128_f_tx);
2884 const __m128i m128_i_ty = _mm_cvtps_epi32(m128_f_ty);
2887 outputPixelData += 4;
2893OCEAN_FORCE_INLINE __m128i
FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelSSE<3u>(
const __m128i& sourcesTopLeft,
const __m128i& sourcesTopRight,
const __m128i& sourcesBottomLeft,
const __m128i& sourcesBottomRight,
const __m128i& factorsTopLeft,
const __m128i& factorsTopRight,
const __m128i& factorsBottomLeft,
const __m128i& factorsBottomRight)
2910 const __m128i mask32_Channel0 =
SSE::set128i(0xFFFFFF09FFFFFF06ull, 0xFFFFFF03FFFFFF00ull);
2911 const __m128i mask32_Channel1 =
SSE::set128i(0xFFFFFF0AFFFFFF07ull, 0xFFFFFF04FFFFFF01ull);
2912 const __m128i mask32_Channel2 =
SSE::set128i(0xFFFFFF0BFFFFFF08ull, 0xFFFFFF05FFFFFF02ull);
2920 __m128i multiplication_channel0 = _mm_mullo_epi32(factorsTopLeft, _mm_shuffle_epi8(sourcesTopLeft, mask32_Channel0));
2923 __m128i multiplication_channel1 = _mm_mullo_epi32(factorsTopLeft, _mm_shuffle_epi8(sourcesTopLeft, mask32_Channel1));
2926 __m128i multiplication_channel2 = _mm_mullo_epi32(factorsTopLeft, _mm_shuffle_epi8(sourcesTopLeft, mask32_Channel2));
2930 multiplication_channel0 = _mm_add_epi32(multiplication_channel0, _mm_mullo_epi32(factorsTopRight, _mm_shuffle_epi8(sourcesTopRight, mask32_Channel0)));
2931 multiplication_channel1 = _mm_add_epi32(multiplication_channel1, _mm_mullo_epi32(factorsTopRight, _mm_shuffle_epi8(sourcesTopRight, mask32_Channel1)));
2932 multiplication_channel2 = _mm_add_epi32(multiplication_channel2, _mm_mullo_epi32(factorsTopRight, _mm_shuffle_epi8(sourcesTopRight, mask32_Channel2)));
2936 multiplication_channel0 = _mm_add_epi32(multiplication_channel0, _mm_mullo_epi32(factorsBottomLeft, _mm_shuffle_epi8(sourcesBottomLeft, mask32_Channel0)));
2937 multiplication_channel1 = _mm_add_epi32(multiplication_channel1, _mm_mullo_epi32(factorsBottomLeft, _mm_shuffle_epi8(sourcesBottomLeft, mask32_Channel1)));
2938 multiplication_channel2 = _mm_add_epi32(multiplication_channel2, _mm_mullo_epi32(factorsBottomLeft, _mm_shuffle_epi8(sourcesBottomLeft, mask32_Channel2)));
2942 multiplication_channel0 = _mm_add_epi32(multiplication_channel0, _mm_mullo_epi32(factorsBottomRight, _mm_shuffle_epi8(sourcesBottomRight, mask32_Channel0)));
2943 multiplication_channel1 = _mm_add_epi32(multiplication_channel1, _mm_mullo_epi32(factorsBottomRight, _mm_shuffle_epi8(sourcesBottomRight, mask32_Channel1)));
2944 multiplication_channel2 = _mm_add_epi32(multiplication_channel2, _mm_mullo_epi32(factorsBottomRight, _mm_shuffle_epi8(sourcesBottomRight, mask32_Channel2)));
2947 const __m128i m128_i_8192 = _mm_set1_epi32(8192);
2956 __m128i interpolation_channel0 = _mm_shuffle_epi8(_mm_srli_epi32(_mm_add_epi32(multiplication_channel0, m128_i_8192), 14),
SSE::set128i(0xFFFFFFFFFFFF0CFFull, 0xFF08FFFF04FFFF00ull));
2962 __m128i interpolation_channel1 = _mm_shuffle_epi8(_mm_srli_epi32(_mm_add_epi32(multiplication_channel1, m128_i_8192), 14),
SSE::set128i(0xFFFFFFFFFF0CFFFFull, 0x08FFFF04FFFF00FFull));
2968 __m128i interpolation_channel2 = _mm_shuffle_epi8(_mm_srli_epi32(_mm_add_epi32(multiplication_channel2, m128_i_8192), 14),
SSE::set128i(0xFFFFFFFF0CFFFF08ull, 0xFFFF04FFFF00FFFFull));
2973 return _mm_or_si128(_mm_or_si128(interpolation_channel0, interpolation_channel1), interpolation_channel2);
2977OCEAN_FORCE_INLINE __m128i
FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelSSE<4u>(
const __m128i& sourcesTopLeft,
const __m128i& sourcesTopRight,
const __m128i& sourcesBottomLeft,
const __m128i& sourcesBottomRight,
const __m128i& factorsTopLeft,
const __m128i& factorsTopRight,
const __m128i& factorsBottomLeft,
const __m128i& factorsBottomRight)
2994 const __m128i mask32_Channel0 =
SSE::set128i(0xA0A0A00CA0A0A008ull, 0xA0A0A004A0A0A000ull);
2995 const __m128i mask32_Channel1 =
SSE::set128i(0xA0A0A00DA0A0A009ull, 0xA0A0A005A0A0A001ull);
2996 const __m128i mask32_Channel2 =
SSE::set128i(0xA0A0A00EA0A0A00Aull, 0xA0A0A006A0A0A002ull);
2997 const __m128i mask32_Channel3 =
SSE::set128i(0xA0A0A00FA0A0A00Bull, 0xA0A0A007A0A0A003ull);
3005 __m128i multiplication_channel0 = _mm_mullo_epi32(factorsTopLeft, _mm_shuffle_epi8(sourcesTopLeft, mask32_Channel0));
3008 __m128i multiplication_channel1 = _mm_mullo_epi32(factorsTopLeft, _mm_shuffle_epi8(sourcesTopLeft, mask32_Channel1));
3011 __m128i multiplication_channel2 = _mm_mullo_epi32(factorsTopLeft, _mm_shuffle_epi8(sourcesTopLeft, mask32_Channel2));
3014 __m128i multiplication_channel3 = _mm_mullo_epi32(factorsTopLeft, _mm_shuffle_epi8(sourcesTopLeft, mask32_Channel3));
3018 multiplication_channel0 = _mm_add_epi32(multiplication_channel0, _mm_mullo_epi32(factorsTopRight, _mm_shuffle_epi8(sourcesTopRight, mask32_Channel0)));
3019 multiplication_channel1 = _mm_add_epi32(multiplication_channel1, _mm_mullo_epi32(factorsTopRight, _mm_shuffle_epi8(sourcesTopRight, mask32_Channel1)));
3020 multiplication_channel2 = _mm_add_epi32(multiplication_channel2, _mm_mullo_epi32(factorsTopRight, _mm_shuffle_epi8(sourcesTopRight, mask32_Channel2)));
3021 multiplication_channel3 = _mm_add_epi32(multiplication_channel3, _mm_mullo_epi32(factorsTopRight, _mm_shuffle_epi8(sourcesTopRight, mask32_Channel3)));
3025 multiplication_channel0 = _mm_add_epi32(multiplication_channel0, _mm_mullo_epi32(factorsBottomLeft, _mm_shuffle_epi8(sourcesBottomLeft, mask32_Channel0)));
3026 multiplication_channel1 = _mm_add_epi32(multiplication_channel1, _mm_mullo_epi32(factorsBottomLeft, _mm_shuffle_epi8(sourcesBottomLeft, mask32_Channel1)));
3027 multiplication_channel2 = _mm_add_epi32(multiplication_channel2, _mm_mullo_epi32(factorsBottomLeft, _mm_shuffle_epi8(sourcesBottomLeft, mask32_Channel2)));
3028 multiplication_channel3 = _mm_add_epi32(multiplication_channel3, _mm_mullo_epi32(factorsBottomLeft, _mm_shuffle_epi8(sourcesBottomLeft, mask32_Channel3)));
3032 multiplication_channel0 = _mm_add_epi32(multiplication_channel0, _mm_mullo_epi32(factorsBottomRight, _mm_shuffle_epi8(sourcesBottomRight, mask32_Channel0)));
3033 multiplication_channel1 = _mm_add_epi32(multiplication_channel1, _mm_mullo_epi32(factorsBottomRight, _mm_shuffle_epi8(sourcesBottomRight, mask32_Channel1)));
3034 multiplication_channel2 = _mm_add_epi32(multiplication_channel2, _mm_mullo_epi32(factorsBottomRight, _mm_shuffle_epi8(sourcesBottomRight, mask32_Channel2)));
3035 multiplication_channel3 = _mm_add_epi32(multiplication_channel3, _mm_mullo_epi32(factorsBottomRight, _mm_shuffle_epi8(sourcesBottomRight, mask32_Channel3)));
3038 const __m128i m128_i_8192 = _mm_set1_epi32(8192);
3045 __m128i interpolation_channel0 = _mm_srli_epi32(_mm_add_epi32(multiplication_channel0, m128_i_8192), 14);
3050 __m128i interpolation_channel1 = _mm_slli_epi32(_mm_srli_epi32(_mm_add_epi32(multiplication_channel1, m128_i_8192), 14), 8);
3054 __m128i interpolation_channel2 = _mm_slli_epi32(_mm_srli_epi32(_mm_add_epi32(multiplication_channel2, m128_i_8192), 14), 16);
3058 __m128i interpolation_channel3 = _mm_slli_epi32(_mm_srli_epi32(_mm_add_epi32(multiplication_channel3, m128_i_8192), 14), 24);
3063 return _mm_or_si128(_mm_or_si128(interpolation_channel0, interpolation_channel1), _mm_or_si128(interpolation_channel2, interpolation_channel3));
3066#ifdef OCEAN_COMPILER_MSC
3072OCEAN_FORCE_INLINE
void FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelSSE<1u>(
const uint8_t* source,
const unsigned int offsetsTopLeft[4],
const unsigned int offsetsTopRight[4],
const unsigned int offsetsBottomLeft[4],
const unsigned int offsetsBottomRight[4],
const unsigned int validPixels[4],
const DataType<uint8_t, 1u>::Type& borderColor,
const __m128i& m128_factorsRight,
const __m128i& m128_factorsBottom,
typename DataType<uint8_t, 1u>::Type* targetPositionPixels)
3074 ocean_assert(source !=
nullptr);
3075 ocean_assert(targetPositionPixels !=
nullptr);
3081 OCEAN_ALIGN_DATA(16) PixelType pixels[16];
3085 for (
unsigned int i = 0u; i < 4u; ++i)
3089 pixels[i * 4u + 0u] = *((PixelType*)(source + offsetsTopLeft[i]));
3090 pixels[i * 4u + 1u] = *((PixelType*)(source + offsetsTopRight[i]));
3091 pixels[i * 4u + 2u] = *((PixelType*)(source + offsetsBottomLeft[i]));
3092 pixels[i * 4u + 3u] = *((PixelType*)(source + offsetsBottomRight[i]));
3096 pixels[i * 4u + 0u] = borderColor;
3097 pixels[i * 4u + 1u] = borderColor;
3098 pixels[i * 4u + 2u] = borderColor;
3099 pixels[i * 4u + 3u] = borderColor;
3103 static_assert(
sizeof(__m128i) ==
sizeof(pixels),
"Invalid data type!");
3105 const __m128i m128_pixels = _mm_load_si128((
const __m128i*)pixels);
3111 const __m128i m128_factorsLeft = _mm_sub_epi32(_mm_set1_epi32(128), m128_factorsRight);
3112 const __m128i m128_factorsTop = _mm_sub_epi32(_mm_set1_epi32(128), m128_factorsBottom);
3117 const __m128i m128_factorsTopLeft = _mm_mullo_epi32(m128_factorsTop, m128_factorsLeft);
3118 const __m128i m128_factorsTopRight = _mm_mullo_epi32(m128_factorsTop, m128_factorsRight);
3119 const __m128i m128_factorsBottomLeft = _mm_mullo_epi32(m128_factorsBottom, m128_factorsLeft);
3120 const __m128i m128_factorsBottomRight = _mm_mullo_epi32(m128_factorsBottom, m128_factorsRight);
3136 const __m128i mask32_topLeft =
SSE::set128i(0xFFFFFF0CFFFFFF08ull, 0xFFFFFF04FFFFFF00ull);
3137 const __m128i mask32_topRight =
SSE::set128i(0xFFFFFF0DFFFFFF09ull, 0xFFFFFF05FFFFFF01ull);
3138 const __m128i mask32_bottomLeft =
SSE::set128i(0xFFFFFF0EFFFFFF0Aull, 0xFFFFFF06FFFFFF02ull);
3139 const __m128i mask32_bottomRight =
SSE::set128i(0xFFFFFF0FFFFFFF0Bull, 0xFFFFFF07FFFFFF03ull);
3147 __m128i multiplicationA = _mm_mullo_epi32(m128_factorsTopLeft, _mm_shuffle_epi8(m128_pixels, mask32_topLeft));
3148 __m128i multiplicationB = _mm_mullo_epi32(m128_factorsTopRight, _mm_shuffle_epi8(m128_pixels, mask32_topRight));
3150 multiplicationA = _mm_add_epi32(multiplicationA, _mm_mullo_epi32(m128_factorsBottomLeft, _mm_shuffle_epi8(m128_pixels, mask32_bottomLeft)));
3151 multiplicationB = _mm_add_epi32(multiplicationB, _mm_mullo_epi32(m128_factorsBottomRight, _mm_shuffle_epi8(m128_pixels, mask32_bottomRight)));
3153 __m128i multiplication = _mm_add_epi32(multiplicationA, multiplicationB);
3155 const __m128i m128_i_8192 = _mm_set1_epi32(8192);
3160 const __m128i result = _mm_shuffle_epi8(_mm_srli_epi32(_mm_add_epi32(multiplication, m128_i_8192), 14),
SSE::set128i(0xFFFFFFFFFFFFFFFFull, 0xFFFFFFFF0C080400ull));
3162 *((
unsigned int*)targetPositionPixels) = _mm_extract_epi32(result, 0);
3166OCEAN_FORCE_INLINE
void FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelSSE<3u>(
const uint8_t* source,
const unsigned int offsetsTopLeft[4],
const unsigned int offsetsTopRight[4],
const unsigned int offsetsBottomLeft[4],
const unsigned int offsetsBottomRight[4],
const unsigned int validPixels[4],
const DataType<uint8_t, 3u>::Type& borderColor,
const __m128i& m128_factorsRight,
const __m128i& m128_factorsBottom,
typename DataType<uint8_t, 3u>::Type* targetPositionPixels)
3168 ocean_assert(source !=
nullptr);
3169 ocean_assert(targetPositionPixels !=
nullptr);
3175 OCEAN_ALIGN_DATA(16) PixelType topLeftPixels[6];
3176 OCEAN_ALIGN_DATA(16) PixelType topRightPixels[6];
3177 OCEAN_ALIGN_DATA(16) PixelType bottomLeftPixels[6];
3178 OCEAN_ALIGN_DATA(16) PixelType bottomRightPixels[6];
3182 for (
unsigned int i = 0u; i < 4u; ++i)
3186 topLeftPixels[i] = *((PixelType*)(source + offsetsTopLeft[i]));
3187 topRightPixels[i] = *((PixelType*)(source + offsetsTopRight[i]));
3188 bottomLeftPixels[i] = *((PixelType*)(source + offsetsBottomLeft[i]));
3189 bottomRightPixels[i] = *((PixelType*)(source + offsetsBottomRight[i]));
3193 topLeftPixels[i] = borderColor;
3194 topRightPixels[i] = borderColor;
3195 bottomLeftPixels[i] = borderColor;
3196 bottomRightPixels[i] = borderColor;
3200 static_assert(
sizeof(__m128i) <=
sizeof(topLeftPixels),
"Invalid data type!");
3202 const __m128i m128_topLeftPixels = _mm_load_si128((
const __m128i*)topLeftPixels);
3203 const __m128i m128_topRightPixels = _mm_load_si128((
const __m128i*)topRightPixels);
3204 const __m128i m128_bottomLeftPixels = _mm_load_si128((
const __m128i*)bottomLeftPixels);
3205 const __m128i m128_bottomRightPixels = _mm_load_si128((
const __m128i*)bottomRightPixels);
3211 const __m128i m128_factorsLeft = _mm_sub_epi32(_mm_set1_epi32(128), m128_factorsRight);
3212 const __m128i m128_factorsTop = _mm_sub_epi32(_mm_set1_epi32(128), m128_factorsBottom);
3217 const __m128i m128_factorsTopLeft = _mm_mullo_epi32(m128_factorsTop, m128_factorsLeft);
3218 const __m128i m128_factorsTopRight = _mm_mullo_epi32(m128_factorsTop, m128_factorsRight);
3219 const __m128i m128_factorsBottomLeft = _mm_mullo_epi32(m128_factorsBottom, m128_factorsLeft);
3220 const __m128i m128_factorsBottomRight = _mm_mullo_epi32(m128_factorsBottom, m128_factorsRight);
3223 const __m128i m128_interpolationResult =
interpolate4Pixels8BitPerChannelSSE<3u>(m128_topLeftPixels, m128_topRightPixels, m128_bottomLeftPixels, m128_bottomRightPixels, m128_factorsTopLeft, m128_factorsTopRight, m128_factorsBottomLeft, m128_factorsBottomRight);
3226 memcpy(targetPositionPixels, &m128_interpolationResult, 12u);
3232OCEAN_FORCE_INLINE
void FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelSSE<4u>(
const uint8_t* source,
const unsigned int offsetsTopLeft[4],
const unsigned int offsetsTopRight[4],
const unsigned int offsetsBottomLeft[4],
const unsigned int offsetsBottomRight[4],
const unsigned int validPixels[4],
const DataType<uint8_t, 4u>::Type& borderColor,
const __m128i& m128_factorsRight,
const __m128i& m128_factorsBottom,
typename DataType<uint8_t, 4u>::Type* targetPositionPixels)
3234 ocean_assert(source !=
nullptr);
3235 ocean_assert(targetPositionPixels !=
nullptr);
3241 OCEAN_ALIGN_DATA(16) PixelType topLeftPixels[4];
3242 OCEAN_ALIGN_DATA(16) PixelType topRightPixels[4];
3243 OCEAN_ALIGN_DATA(16) PixelType bottomLeftPixels[4];
3244 OCEAN_ALIGN_DATA(16) PixelType bottomRightPixels[4];
3249 for (
unsigned int i = 0u; i < 4u; ++i)
3253 topLeftPixels[i] = *((PixelType*)(source + offsetsTopLeft[i]));
3254 topRightPixels[i] = *((PixelType*)(source + offsetsTopRight[i]));
3255 bottomLeftPixels[i] = *((PixelType*)(source + offsetsBottomLeft[i]));
3256 bottomRightPixels[i] = *((PixelType*)(source + offsetsBottomRight[i]));
3260 topLeftPixels[i] = borderColor;
3261 topRightPixels[i] = borderColor;
3262 bottomLeftPixels[i] = borderColor;
3263 bottomRightPixels[i] = borderColor;
3267 static_assert(
sizeof(__m128i) ==
sizeof(topLeftPixels),
"Invalid data type!");
3269 const __m128i m128_topLeftPixels = _mm_load_si128((
const __m128i*)topLeftPixels);
3270 const __m128i m128_topRightPixels = _mm_load_si128((
const __m128i*)topRightPixels);
3271 const __m128i m128_bottomLeftPixels = _mm_load_si128((
const __m128i*)bottomLeftPixels);
3272 const __m128i m128_bottomRightPixels = _mm_load_si128((
const __m128i*)bottomRightPixels);
3278 const __m128i m128_factorsLeft = _mm_sub_epi32(_mm_set1_epi32(128), m128_factorsRight);
3279 const __m128i m128_factorsTop = _mm_sub_epi32(_mm_set1_epi32(128), m128_factorsBottom);
3284 const __m128i m128_factorsTopLeft = _mm_mullo_epi32(m128_factorsTop, m128_factorsLeft);
3285 const __m128i m128_factorsTopRight = _mm_mullo_epi32(m128_factorsTop, m128_factorsRight);
3286 const __m128i m128_factorsBottomLeft = _mm_mullo_epi32(m128_factorsBottom, m128_factorsLeft);
3287 const __m128i m128_factorsBottomRight = _mm_mullo_epi32(m128_factorsBottom, m128_factorsRight);
3290 const __m128i m128_interpolationResult =
interpolate4Pixels8BitPerChannelSSE<4u>(m128_topLeftPixels, m128_topRightPixels, m128_bottomLeftPixels, m128_bottomRightPixels, m128_factorsTopLeft, m128_factorsTopRight, m128_factorsBottomLeft, m128_factorsBottomRight);
3292 _mm_storeu_si128((__m128i*)targetPositionPixels, m128_interpolationResult);
3295template <
unsigned int tChannels>
3296OCEAN_FORCE_INLINE
void FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelSSE(
const uint8_t* source,
const unsigned int offsetsTopLeft[4],
const unsigned int offsetsTopRight[4],
const unsigned int offsetsBottomLeft[4],
const unsigned int offsetsBottomRight[4],
const unsigned int validPixels[4],
const typename DataType<uint8_t, tChannels>::Type& borderColor,
const __m128i& m128_factorsRight,
const __m128i& m128_factorsBottom,
typename DataType<uint8_t, tChannels>::Type* targetPositionPixels)
3298 ocean_assert(source !=
nullptr);
3299 ocean_assert(targetPositionPixels !=
nullptr);
3303 OCEAN_ALIGN_DATA(16)
unsigned int factorsTopLeft[4];
3304 OCEAN_ALIGN_DATA(16)
unsigned int factorsTopRight[4];
3305 OCEAN_ALIGN_DATA(16)
unsigned int factorsBottomLeft[4];
3306 OCEAN_ALIGN_DATA(16)
unsigned int factorsBottomRight[4];
3312 const __m128i m128_factorsLeft = _mm_sub_epi32(_mm_set1_epi32(128), m128_factorsRight);
3313 const __m128i m128_factorsTop = _mm_sub_epi32(_mm_set1_epi32(128), m128_factorsBottom);
3318 const __m128i m128_factorsTopLeft = _mm_mullo_epi32(m128_factorsTop, m128_factorsLeft);
3319 const __m128i m128_factorsTopRight = _mm_mullo_epi32(m128_factorsTop, m128_factorsRight);
3320 const __m128i m128_factorsBottomLeft = _mm_mullo_epi32(m128_factorsBottom, m128_factorsLeft);
3321 const __m128i m128_factorsBottomRight = _mm_mullo_epi32(m128_factorsBottom, m128_factorsRight);
3325 _mm_store_si128((__m128i*)factorsTopLeft, m128_factorsTopLeft);
3326 _mm_store_si128((__m128i*)factorsTopRight, m128_factorsTopRight);
3327 _mm_store_si128((__m128i*)factorsBottomLeft, m128_factorsBottomLeft);
3328 _mm_store_si128((__m128i*)factorsBottomRight, m128_factorsBottomRight);
3330 for (
unsigned int i = 0u; i < 4u; ++i)
3334 const uint8_t* topLeft = source + offsetsTopLeft[i];
3335 const uint8_t* topRight = source + offsetsTopRight[i];
3337 const uint8_t* bottomLeft = source + offsetsBottomLeft[i];
3338 const uint8_t* bottomRight = source + offsetsBottomRight[i];
3340 const unsigned int& factorTopLeft = factorsTopLeft[i];
3341 const unsigned int& factorTopRight = factorsTopRight[i];
3342 const unsigned int& factorBottomLeft = factorsBottomLeft[i];
3343 const unsigned int& factorBottomRight = factorsBottomRight[i];
3345 for (
unsigned int n = 0u; n < tChannels; ++n)
3347 ((uint8_t*)targetPositionPixels)[n] = (uint8_t)((topLeft[n] * factorTopLeft + topRight[n] * factorTopRight + bottomLeft[n] * factorBottomLeft + bottomRight[n] * factorBottomRight + 8192u) >> 14u);
3352 *targetPositionPixels = borderColor;
3355 targetPositionPixels++;
3361#if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
3363template <
unsigned int tChannels>
3364void FrameInterpolatorBilinear::affine8BitPerChannelNEONSubset(
const uint8_t* source,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const SquareMatrix3* source_A_target,
const uint8_t* borderColor, uint8_t* target,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements)
3366 static_assert(tChannels >= 1u,
"Invalid channel number!");
3368 ocean_assert(source && target);
3369 ocean_assert(sourceWidth > 0u && sourceHeight > 0u);
3370 ocean_assert_and_suppress_unused(targetWidth >= 4u && targetHeight > 0u, targetHeight);
3371 ocean_assert(source_A_target);
3374 ocean_assert(firstTargetRow + numberTargetRows <= targetHeight);
3376 const unsigned int sourceStrideElements = sourceWidth * tChannels + sourcePaddingElements;
3377 const unsigned int targetStrideElements = targetWidth * tChannels + targetPaddingElements;
3381 uint8_t zeroColor[tChannels] = {uint8_t(0)};
3382 const PixelType*
const bColor = borderColor ? (PixelType*)borderColor : (PixelType*)zeroColor;
3384 unsigned int validPixels[4];
3386 unsigned int topLeftOffsetsElements[4];
3387 unsigned int topRightOffsetsElements[4];
3388 unsigned int bottomLeftOffsetsElements[4];
3389 unsigned int bottomRightOffsetsElements[4];
3391 const uint32x4_t constantChannels_u_32x4 = vdupq_n_u32(tChannels);
3394 const float32x4_t m128_f_X0 = vdupq_n_f32(
float((*source_A_target)(0, 0)));
3395 const float32x4_t m128_f_X1 = vdupq_n_f32(
float((*source_A_target)(1, 0)));
3397 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
3399 PixelType* targetRow = (PixelType*)(target + y * targetStrideElements);
3423 const float32x4_t m128_f_C0 = vdupq_n_f32(
float((*source_A_target)(0, 1) *
Scalar(y) + (*source_A_target)(0, 2)));
3424 const float32x4_t m128_f_C1 = vdupq_n_f32(
float((*source_A_target)(1, 1) *
Scalar(y) + (*source_A_target)(1, 2)));
3427 const float32x4_t m128_f_zero = vdupq_n_f32(0.0f);
3430 const uint32x4_t m128_u_sourceStrideElements = vdupq_n_u32(sourceStrideElements);
3433 const uint32x4_t m128_u_sourceWidth_1 = vdupq_n_u32(sourceWidth - 1u);
3434 const uint32x4_t m128_u_sourceHeight_1 = vdupq_n_u32(sourceHeight - 1u);
3437 const float32x4_t m128_f_sourceWidth_1 = vdupq_n_f32(
float(sourceWidth - 1u));
3438 const float32x4_t m128_f_sourceHeight_1 = vdupq_n_f32(
float(sourceHeight - 1u));
3440 for (
unsigned int x = 0u; x < targetWidth; x += 4u)
3442 if (x + 4u > targetWidth)
3447 ocean_assert(x >= 4u && targetWidth > 4u);
3448 const unsigned int newX = targetWidth - 4u;
3450 ocean_assert(x > newX);
3451 targetRow -= x - newX;
3456 ocean_assert(!(x + 4u < targetWidth));
3462 float x_0123[4] = {float(x + 0u), float(x + 1u), float(x + 2u), float(x + 3u)};
3463 const float32x4_t m128_f_x_0123 = vld1q_f32(x_0123);
3466 const float32x4_t m128_f_sourceX = vmlaq_f32(m128_f_C0, m128_f_X0, m128_f_x_0123);
3467 const float32x4_t m128_f_sourceY = vmlaq_f32(m128_f_C1, m128_f_X1, m128_f_x_0123);
3471 const uint32x4_t m128_u_validPixelX = vandq_u32(vcleq_f32(m128_f_sourceX, m128_f_sourceWidth_1), vcgeq_f32(m128_f_sourceX, m128_f_zero));
3472 const uint32x4_t m128_u_validPixelY = vandq_u32(vcleq_f32(m128_f_sourceY, m128_f_sourceHeight_1), vcgeq_f32(m128_f_sourceY, m128_f_zero));
3474 const uint32x4_t m128_u_validPixel = vandq_u32(m128_u_validPixelX, m128_u_validPixelY);
3478 const uint32x2_t m64_u_validPixel = vorr_u32(vget_low_u32(m128_u_validPixel), vget_high_u32(m128_u_validPixel));
3479 if ((vget_lane_u32(m64_u_validPixel, 0) | vget_lane_u32(m64_u_validPixel, 1)) == 0x00000000u)
3482 OCEAN_ALIGN_DATA(16)
unsigned int debugValidPixels[4];
3483 vst1q_u32(debugValidPixels, m128_u_validPixel);
3484 ocean_assert(!(debugValidPixels[0] || debugValidPixels[1] || debugValidPixels[2] || debugValidPixels[3]));
3487 targetRow[0] = *bColor;
3488 targetRow[1] = *bColor;
3489 targetRow[2] = *bColor;
3490 targetRow[3] = *bColor;
3499 vst1q_u32(validPixels, m128_u_validPixel);
3500 ocean_assert(validPixels[0] || validPixels[1] || validPixels[2] || validPixels[3]);
3505 const uint32x4_t m128_u_left = vcvtq_u32_f32(m128_f_sourceX);
3506 const uint32x4_t m128_u_top = vcvtq_u32_f32(m128_f_sourceY);
3509 const uint32x4_t m128_u_right = vminq_u32(vaddq_u32(m128_u_left, vdupq_n_u32(1u)), m128_u_sourceWidth_1);
3510 const uint32x4_t m128_u_bottom = vminq_u32(vaddq_u32(m128_u_top, vdupq_n_u32(1u)), m128_u_sourceHeight_1);
3513 const uint32x4_t m128_u_topLeftOffsetElements = vmlaq_u32(vmulq_u32(m128_u_left, constantChannels_u_32x4), m128_u_top, m128_u_sourceStrideElements);
3514 const uint32x4_t m128_u_topRightOffsetElements = vmlaq_u32(vmulq_u32(m128_u_right, constantChannels_u_32x4), m128_u_top, m128_u_sourceStrideElements);
3515 const uint32x4_t m128_u_bottomLeftOffsetElements = vmlaq_u32(vmulq_u32(m128_u_left, constantChannels_u_32x4), m128_u_bottom, m128_u_sourceStrideElements);
3516 const uint32x4_t m128_u_bottomRightOffsetElements = vmlaq_u32(vmulq_u32(m128_u_right, constantChannels_u_32x4), m128_u_bottom, m128_u_sourceStrideElements);
3519 vst1q_u32(topLeftOffsetsElements, m128_u_topLeftOffsetElements);
3520 vst1q_u32(topRightOffsetsElements, m128_u_topRightOffsetElements);
3521 vst1q_u32(bottomLeftOffsetsElements, m128_u_bottomLeftOffsetElements);
3522 vst1q_u32(bottomRightOffsetsElements, m128_u_bottomRightOffsetElements);
3528 float32x4_t m128_f_tx = vsubq_f32(m128_f_sourceX, vcvtq_f32_u32(m128_u_left));
3529 float32x4_t m128_f_ty = vsubq_f32(m128_f_sourceY, vcvtq_f32_u32(m128_u_top));
3532 m128_f_tx = vmulq_f32(m128_f_tx, vdupq_n_f32(128.0f));
3533 m128_f_ty = vmulq_f32(m128_f_ty, vdupq_n_f32(128.0f));
3535 const uint32x4_t m128_u_tx = vcvtq_u32_f32(vaddq_f32(m128_f_tx, vdupq_n_f32(0.5)));
3536 const uint32x4_t m128_u_ty = vcvtq_u32_f32(vaddq_f32(m128_f_ty, vdupq_n_f32(0.5)));
3538 if constexpr (tChannels > 4u)
3548 const uint32x4_t m128_u_tx_ = vsubq_u32(vdupq_n_u32(128u), m128_u_tx);
3549 const uint32x4_t m128_u_ty_ = vsubq_u32(vdupq_n_u32(128u), m128_u_ty);
3553 const uint32x4_t m128_u_tx_ty_ = vmulq_u32(m128_u_tx_, m128_u_ty_);
3554 const uint32x4_t m128_u_txty_ = vmulq_u32(m128_u_tx, m128_u_ty_);
3555 const uint32x4_t m128_u_tx_ty = vmulq_u32(m128_u_tx_, m128_u_ty);
3556 const uint32x4_t m128_u_txty = vmulq_u32(m128_u_tx, m128_u_ty);
3558 unsigned int tx_ty_s[4];
3559 unsigned int txty_s[4];
3560 unsigned int tx_tys[4];
3561 unsigned int txtys[4];
3564 vst1q_u32(tx_ty_s, m128_u_tx_ty_);
3565 vst1q_u32(txty_s, m128_u_txty_);
3566 vst1q_u32(tx_tys, m128_u_tx_ty);
3567 vst1q_u32(txtys, m128_u_txty);
3569 for (
unsigned int i = 0u; i < 4u; ++i)
3573 ocean_assert(topLeftOffsetsElements[i] < sourceStrideElements * sourceHeight);
3574 ocean_assert(topRightOffsetsElements[i] < sourceStrideElements * sourceHeight);
3575 ocean_assert(bottomLeftOffsetsElements[i] < sourceStrideElements * sourceHeight);
3576 ocean_assert(bottomRightOffsetsElements[i] < sourceStrideElements * sourceHeight);
3578 const uint8_t* topLeft = source + topLeftOffsetsElements[i];
3579 const uint8_t* topRight = source + topRightOffsetsElements[i];
3581 const uint8_t* bottomLeft = source + bottomLeftOffsetsElements[i];
3582 const uint8_t* bottomRight = source + bottomRightOffsetsElements[i];
3584 const unsigned int tx_ty_ = tx_ty_s[i];
3585 const unsigned int txty_ = txty_s[i];
3586 const unsigned int tx_ty = tx_tys[i];
3587 const unsigned int txty = txtys[i];
3589 ocean_assert(tx_ty_ + txty_ + tx_ty + txty == 128u * 128u);
3591 for (
unsigned int n = 0u; n < tChannels; ++n)
3593 ((uint8_t*)targetRow)[n] = uint8_t((topLeft[n] * tx_ty_ + topRight[n] * txty_ + bottomLeft[n] * tx_ty + bottomRight[n] * txty + 8192u) >> 14u);
3598 *targetRow = *bColor;
3613template <
unsigned int tChannels>
3614void FrameInterpolatorBilinear::homography8BitPerChannelNEONSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output,
const uint8_t* borderColor, uint8_t* output,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows)
3616 static_assert(tChannels >= 1u,
"Invalid channel number!");
3618 ocean_assert(input !=
nullptr && output !=
nullptr);
3619 ocean_assert(inputWidth > 0u && inputHeight > 0u);
3620 ocean_assert_and_suppress_unused(outputWidth >= 4u && outputHeight > 0u, outputHeight);
3621 ocean_assert(input_H_output !=
nullptr);
3623 ocean_assert(firstOutputRow + numberOutputRows <= outputHeight);
3625 const unsigned int inputStrideElements = inputWidth * tChannels + inputPaddingElements;
3626 const unsigned int outputStrideElements = outputWidth * tChannels + outputPaddingElements;
3630 uint8_t zeroColor[tChannels] = {uint8_t(0)};
3631 const PixelType*
const bColor = borderColor ? (PixelType*)borderColor : (PixelType*)zeroColor;
3633 unsigned int validPixels[4];
3635 unsigned int topLeftOffsetsElements[4];
3636 unsigned int topRightOffsetsElements[4];
3637 unsigned int bottomLeftOffsetsElements[4];
3638 unsigned int bottomRightOffsetsElements[4];
3640 const uint32x4_t constantChannels_u_32x4 = vdupq_n_u32(tChannels);
3643 const float32x4_t m128_f_X0 = vdupq_n_f32(
float((*input_H_output)(0, 0)));
3644 const float32x4_t m128_f_X1 = vdupq_n_f32(
float((*input_H_output)(1, 0)));
3645 const float32x4_t m128_f_X2 = vdupq_n_f32(
float((*input_H_output)(2, 0)));
3647 for (
unsigned int y = firstOutputRow; y < firstOutputRow + numberOutputRows; ++y)
3649 PixelType* outputPixelData = (PixelType*)(output + y * outputStrideElements);
3673 const float32x4_t m128_f_C0 = vdupq_n_f32(
float((*input_H_output)(0, 1) *
Scalar(y) + (*input_H_output)(0, 2)));
3674 const float32x4_t m128_f_C1 = vdupq_n_f32(
float((*input_H_output)(1, 1) *
Scalar(y) + (*input_H_output)(1, 2)));
3675 const float32x4_t m128_f_C2 = vdupq_n_f32(
float((*input_H_output)(2, 1) *
Scalar(y) + (*input_H_output)(2, 2)));
3678 const float32x4_t m128_f_zero = vdupq_n_f32(0.0f);
3681 const uint32x4_t m128_u_inputStrideElements = vdupq_n_u32(inputStrideElements);
3684 const uint32x4_t m128_u_inputWidth_1 = vdupq_n_u32(inputWidth - 1u);
3685 const uint32x4_t m128_u_inputHeight_1 = vdupq_n_u32(inputHeight - 1u);
3688 const float32x4_t m128_f_inputWidth_1 = vdupq_n_f32(
float(inputWidth - 1u));
3689 const float32x4_t m128_f_inputHeight_1 = vdupq_n_f32(
float(inputHeight - 1u));
3691 for (
unsigned int x = 0u; x < outputWidth; x += 4u)
3693 if (x + 4u > outputWidth)
3698 ocean_assert(x >= 4u && outputWidth > 4u);
3699 const unsigned int newX = outputWidth - 4u;
3701 ocean_assert(x > newX);
3702 outputPixelData -= x - newX;
3707 ocean_assert(!(x + 4u < outputWidth));
3713 float x_0123[4] = {float(x + 0u), float(x + 1u), float(x + 2u), float(x + 3u)};
3714 const float32x4_t m128_f_x_0123 = vld1q_f32(x_0123);
3717 const float32x4_t m128_f_xx = vmlaq_f32(m128_f_C0, m128_f_X0, m128_f_x_0123);
3718 const float32x4_t m128_f_yy = vmlaq_f32(m128_f_C1, m128_f_X1, m128_f_x_0123);
3719 const float32x4_t m128_f_zz = vmlaq_f32(m128_f_C2, m128_f_X2, m128_f_x_0123);
3721#ifdef USE_DIVISION_ARM64_ARCHITECTURE
3724 const float32x4_t m128_f_inputX = vdivq_f32(m128_f_xx, m128_f_zz);
3725 const float32x4_t m128_f_inputY = vdivq_f32(m128_f_yy, m128_f_zz);
3731 float32x4_t inv_zz_128 = vrecpeq_f32(m128_f_zz);
3732 inv_zz_128 = vmulq_f32(vrecpsq_f32(m128_f_zz, inv_zz_128), inv_zz_128);
3735 const float32x4_t m128_f_inputX = vmulq_f32(m128_f_xx, inv_zz_128);
3736 const float32x4_t m128_f_inputY = vmulq_f32(m128_f_yy, inv_zz_128);
3742 const uint32x4_t m128_u_validPixelX = vandq_u32(vcleq_f32(m128_f_inputX, m128_f_inputWidth_1), vcgeq_f32(m128_f_inputX, m128_f_zero));
3743 const uint32x4_t m128_u_validPixelY = vandq_u32(vcleq_f32(m128_f_inputY, m128_f_inputHeight_1), vcgeq_f32(m128_f_inputY, m128_f_zero));
3745 const uint32x4_t m128_u_validPixel = vandq_u32(m128_u_validPixelX, m128_u_validPixelY);
3749 const uint32x2_t m64_u_validPixel = vorr_u32(vget_low_u32(m128_u_validPixel), vget_high_u32(m128_u_validPixel));
3750 if ((vget_lane_u32(m64_u_validPixel, 0) | vget_lane_u32(m64_u_validPixel, 1)) == 0x00000000u)
3753 OCEAN_ALIGN_DATA(16)
unsigned int debugValidPixels[4];
3754 vst1q_u32(debugValidPixels, m128_u_validPixel);
3755 ocean_assert(!(debugValidPixels[0] || debugValidPixels[1] || debugValidPixels[2] || debugValidPixels[3]));
3758 outputPixelData[0] = *bColor;
3759 outputPixelData[1] = *bColor;
3760 outputPixelData[2] = *bColor;
3761 outputPixelData[3] = *bColor;
3763 outputPixelData += 4;
3770 vst1q_u32(validPixels, m128_u_validPixel);
3771 ocean_assert(validPixels[0] || validPixels[1] || validPixels[2] || validPixels[3]);
3776 const uint32x4_t m128_u_left = vcvtq_u32_f32(m128_f_inputX);
3777 const uint32x4_t m128_u_top = vcvtq_u32_f32(m128_f_inputY);
3780 const uint32x4_t m128_u_right = vminq_u32(vaddq_u32(m128_u_left, vdupq_n_u32(1u)), m128_u_inputWidth_1);
3781 const uint32x4_t m128_u_bottom = vminq_u32(vaddq_u32(m128_u_top, vdupq_n_u32(1u)), m128_u_inputHeight_1);
3784 const uint32x4_t m128_u_topLeftOffsetElements = vmlaq_u32(vmulq_u32(m128_u_left, constantChannels_u_32x4), m128_u_top, m128_u_inputStrideElements);
3785 const uint32x4_t m128_u_topRightOffsetElements = vmlaq_u32(vmulq_u32(m128_u_right, constantChannels_u_32x4), m128_u_top, m128_u_inputStrideElements);
3786 const uint32x4_t m128_u_bottomLeftOffsetElements = vmlaq_u32(vmulq_u32(m128_u_left, constantChannels_u_32x4), m128_u_bottom, m128_u_inputStrideElements);
3787 const uint32x4_t m128_u_bottomRightOffsetElements = vmlaq_u32(vmulq_u32(m128_u_right, constantChannels_u_32x4), m128_u_bottom, m128_u_inputStrideElements);
3790 vst1q_u32(topLeftOffsetsElements, m128_u_topLeftOffsetElements);
3791 vst1q_u32(topRightOffsetsElements, m128_u_topRightOffsetElements);
3792 vst1q_u32(bottomLeftOffsetsElements, m128_u_bottomLeftOffsetElements);
3793 vst1q_u32(bottomRightOffsetsElements, m128_u_bottomRightOffsetElements);
3799 float32x4_t m128_f_tx = vsubq_f32(m128_f_inputX, vcvtq_f32_u32(m128_u_left));
3800 float32x4_t m128_f_ty = vsubq_f32(m128_f_inputY, vcvtq_f32_u32(m128_u_top));
3803 m128_f_tx = vmulq_f32(m128_f_tx, vdupq_n_f32(128.0f));
3804 m128_f_ty = vmulq_f32(m128_f_ty, vdupq_n_f32(128.0f));
3806 const uint32x4_t m128_u_tx = vcvtq_u32_f32(vaddq_f32(m128_f_tx, vdupq_n_f32(0.5)));
3807 const uint32x4_t m128_u_ty = vcvtq_u32_f32(vaddq_f32(m128_f_ty, vdupq_n_f32(0.5)));
3809 if constexpr (tChannels > 4u)
3819 const uint32x4_t m128_u_tx_ = vsubq_u32(vdupq_n_u32(128u), m128_u_tx);
3820 const uint32x4_t m128_u_ty_ = vsubq_u32(vdupq_n_u32(128u), m128_u_ty);
3824 const uint32x4_t m128_u_tx_ty_ = vmulq_u32(m128_u_tx_, m128_u_ty_);
3825 const uint32x4_t m128_u_txty_ = vmulq_u32(m128_u_tx, m128_u_ty_);
3826 const uint32x4_t m128_u_tx_ty = vmulq_u32(m128_u_tx_, m128_u_ty);
3827 const uint32x4_t m128_u_txty = vmulq_u32(m128_u_tx, m128_u_ty);
3829 unsigned int tx_ty_s[4];
3830 unsigned int txty_s[4];
3831 unsigned int tx_tys[4];
3832 unsigned int txtys[4];
3835 vst1q_u32(tx_ty_s, m128_u_tx_ty_);
3836 vst1q_u32(txty_s, m128_u_txty_);
3837 vst1q_u32(tx_tys, m128_u_tx_ty);
3838 vst1q_u32(txtys, m128_u_txty);
3840 for (
unsigned int i = 0u; i < 4u; ++i)
3844 ocean_assert(topLeftOffsetsElements[i] < inputStrideElements * inputHeight);
3845 ocean_assert(topRightOffsetsElements[i] < inputStrideElements * inputHeight);
3846 ocean_assert(bottomLeftOffsetsElements[i] < inputStrideElements * inputHeight);
3847 ocean_assert(bottomRightOffsetsElements[i] < inputStrideElements * inputHeight);
3849 const uint8_t* topLeft = input + topLeftOffsetsElements[i];
3850 const uint8_t* topRight = input + topRightOffsetsElements[i];
3852 const uint8_t* bottomLeft = input + bottomLeftOffsetsElements[i];
3853 const uint8_t* bottomRight = input + bottomRightOffsetsElements[i];
3855 const unsigned int tx_ty_ = tx_ty_s[i];
3856 const unsigned int txty_ = txty_s[i];
3857 const unsigned int tx_ty = tx_tys[i];
3858 const unsigned int txty = txtys[i];
3860 ocean_assert(tx_ty_ + txty_ + tx_ty + txty == 128u * 128u);
3862 for (
unsigned int n = 0u; n < tChannels; ++n)
3864 ((uint8_t*)outputPixelData)[n] = uint8_t((topLeft[n] * tx_ty_ + topRight[n] * txty_ + bottomLeft[n] * tx_ty + bottomRight[n] * txty + 8192u) >> 14u);
3869 *outputPixelData = *bColor;
3878 outputPixelData += 4;
3885OCEAN_FORCE_INLINE
void FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelNEON<1u>(
const uint8_t* source,
const unsigned int offsetsTopLeftElements[4],
const unsigned int offsetsTopRightElements[4],
const unsigned int offsetsBottomLeftElements[4],
const unsigned int offsetsBottomRightElements[4],
const unsigned int validPixels[4],
const DataType<uint8_t, 1u>::Type& borderColor,
const uint32x4_t& m128_factorsRight,
const uint32x4_t& m128_factorsBottom,
typename DataType<uint8_t, 1u>::Type* targetPositionPixels)
3887 ocean_assert(source !=
nullptr);
3888 ocean_assert(targetPositionPixels !=
nullptr);
3900 for (
unsigned int i = 0u; i < 4u; ++i)
3911 pixels[i * 4u + 0u] = borderColor;
3912 pixels[i * 4u + 1u] = borderColor;
3913 pixels[i * 4u + 2u] = borderColor;
3914 pixels[i * 4u + 3u] = borderColor;
3918 static_assert(
sizeof(uint8x16_t) ==
sizeof(pixels),
"Invalid data type!");
3920 const uint8x16_t m128_pixels = vld1q_u8((
const uint8_t*)pixels);
3926 const uint32x4_t m128_factorsLeft = vsubq_u32(vdupq_n_u32(128u), m128_factorsRight);
3927 const uint32x4_t m128_factorsTop = vsubq_u32(vdupq_n_u32(128u), m128_factorsBottom);
3932 const uint32x4_t m128_factorsTopLeft = vmulq_u32(m128_factorsTop, m128_factorsLeft);
3933 const uint32x4_t m128_factorsTopRight = vmulq_u32(m128_factorsTop, m128_factorsRight);
3934 const uint32x4_t m128_factorsBottomLeft = vmulq_u32(m128_factorsBottom, m128_factorsLeft);
3935 const uint32x4_t m128_factorsBottomRight = vmulq_u32(m128_factorsBottom, m128_factorsRight);
3950 const uint32x4_t m128_maskFirstByte = vdupq_n_u32(0x000000FFu);
3952 const uint32x4_t m128_muliplicationA = vmulq_u32(vandq_u32(vreinterpretq_u32_u8(m128_pixels), m128_maskFirstByte), m128_factorsTopLeft);
3953 const uint32x4_t m128_muliplicationB = vmulq_u32(vandq_u32(vshrq_n_u32(vreinterpretq_u32_u8(m128_pixels), 8), m128_maskFirstByte), m128_factorsTopRight);
3954 const uint32x4_t m128_muliplicationC = vmulq_u32(vandq_u32(vshrq_n_u32(vreinterpretq_u32_u8(m128_pixels), 16), m128_maskFirstByte), m128_factorsBottomLeft);
3955 const uint32x4_t m128_muliplicationD = vmulq_u32(vandq_u32(vshrq_n_u32(vreinterpretq_u32_u8(m128_pixels), 24), m128_maskFirstByte), m128_factorsBottomRight);
3957 const uint32x4_t m128_multiplication = vaddq_u32(vaddq_u32(m128_muliplicationA, m128_muliplicationB), vaddq_u32(m128_muliplicationC, m128_muliplicationD));
3961 const uint8x16_t m128_interpolation = vreinterpretq_u8_u32(vshrq_n_u32(vaddq_u32(m128_multiplication, vdupq_n_u32(8192u)), 14));
3971#if defined(__aarch64__)
3976 const uint8x8_t m64_interpolation01 = vtbl1_u8(vget_low_u8(m128_interpolation), m64_mask0);
3977 const uint8x8_t m64_interpolation23 = vtbl1_u8(vget_high_u8(m128_interpolation), m64_mask1);
3979 const uint8x8_t m64_interpolation0123 = vorr_u8(m64_interpolation01, m64_interpolation23);
3981 const uint32_t result = vget_lane_u32(vreinterpret_u32_u8(m64_interpolation0123), 0);
3982 memcpy(targetPositionPixels, &result,
sizeof(uint32_t));
3986 *((uint8_t*)targetPositionPixels + 0) = vgetq_lane_u8(m128_interpolation, 0);
3987 *((uint8_t*)targetPositionPixels + 1) = vgetq_lane_u8(m128_interpolation, 4);
3988 *((uint8_t*)targetPositionPixels + 2) = vgetq_lane_u8(m128_interpolation, 8);
3989 *((uint8_t*)targetPositionPixels + 3) = vgetq_lane_u8(m128_interpolation, 12);
3996 const uint8x16_t factorsLeft_factorsTop_128_u_8x16 = vsubq_u8(vdupq_n_u8(128u), factorsRight_factorsBottom_128_u_8x16);
3998 const uint8x8_t factorsRight_u_8x8 = vget_low_u8(factorsRight_factorsBottom_128_u_8x16);
3999 const uint16x8_t factorsBottom_u_16x8 = vmovl_u8(vget_high_u8(factorsRight_factorsBottom_128_u_8x16));
4001 const uint8x8_t factorsLeft_u_8x8 = vget_low_u8(factorsLeft_factorsTop_128_u_8x16);
4002 const uint16x8_t factorsTop_u_16x8 = vmovl_u8(vget_high_u8(factorsLeft_factorsTop_128_u_8x16));
4004 const uint16x8_t intermediateTop_u_16x8 = vmlal_u8(vmull_u8(topLeft_u_8x8, factorsLeft_u_8x8), topRight_u_8x8, factorsRight_u_8x8);
4005 const uint16x8_t intermediateBottom_u_16x8 = vmlal_u8(vmull_u8(bottomLeft_u_8x8, factorsLeft_u_8x8), bottomRight_u_8x8, factorsRight_u_8x8);
4007 const uint32x4_t resultA_32x4 = vmlal_u16(vmull_u16(vget_low_u16(intermediateTop_u_16x8), vget_low_u16(factorsTop_u_16x8)), vget_low_u16(intermediateBottom_u_16x8), vget_low_u16(factorsBottom_u_16x8));
4008 const uint32x4_t resultB_32x4 = vmlal_u16(vmull_u16(vget_high_u16(intermediateTop_u_16x8), vget_high_u16(factorsTop_u_16x8)), vget_high_u16(intermediateBottom_u_16x8), vget_high_u16(factorsBottom_u_16x8));
4010 const uint16x8_t result_16x8 = vcombine_u16(vrshrn_n_u32(resultA_32x4, 14), vrshrn_n_u32(resultB_32x4, 14));
4012 const uint8x8_t result_8x8 = vmovn_u16(result_16x8);
4014 vst1_u8(targetPositionPixels, result_8x8);
4018OCEAN_FORCE_INLINE
void FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelNEON<2u>(
const uint8_t* source,
const unsigned int offsetsTopLeftElements[4],
const unsigned int offsetsTopRightElements[4],
const unsigned int offsetsBottomLeftElements[4],
const unsigned int offsetsBottomRightElements[4],
const unsigned int validPixels[4],
const DataType<uint8_t, 2u>::Type& borderColor,
const uint32x4_t& m128_factorsRight,
const uint32x4_t& m128_factorsBottom,
typename DataType<uint8_t, 2u>::Type* targetPositionPixels)
4020 ocean_assert(source !=
nullptr);
4021 ocean_assert(targetPositionPixels !=
nullptr);
4027 PixelType topPixels[8];
4028 PixelType bottomPixels[8];
4037 for (
unsigned int i = 0u; i < 4u; ++i)
4041 *(topPixels + i * 2u + 0u) = *((
const PixelType*)(source + offsetsTopLeftElements[i]));
4042 *(topPixels + i * 2u + 1u) = *((
const PixelType*)(source + offsetsTopRightElements[i]));
4043 *(bottomPixels + i * 2u + 0u) = *((
const PixelType*)(source + offsetsBottomLeftElements[i]));
4044 *(bottomPixels + i * 2u + 1u) = *((
const PixelType*)(source + offsetsBottomRightElements[i]));
4048 *(topPixels + i * 2u + 0u) = borderColor;
4049 *(topPixels + i * 2u + 1u) = borderColor;
4050 *(bottomPixels + i * 2u + 0u) = borderColor;
4051 *(bottomPixels + i * 2u + 1u) = borderColor;
4055 static_assert(
sizeof(uint32x4_t) ==
sizeof(topPixels),
"Invalid data type!");
4057 const uint32x4_t m128_topPixels = vreinterpretq_u32_u8(vld1q_u8((
const uint8_t*)topPixels));
4058 const uint32x4_t m128_bottomPixels = vreinterpretq_u32_u8(vld1q_u8((
const uint8_t*)bottomPixels));
4064 const uint32x4_t m128_factorsLeft = vsubq_u32(vdupq_n_u32(128u), m128_factorsRight);
4065 const uint32x4_t m128_factorsTop = vsubq_u32(vdupq_n_u32(128u), m128_factorsBottom);
4070 const uint32x4_t m128_factorsTopLeft = vmulq_u32(m128_factorsTop, m128_factorsLeft);
4071 const uint32x4_t m128_factorsTopRight = vmulq_u32(m128_factorsTop, m128_factorsRight);
4072 const uint32x4_t m128_factorsBottomLeft = vmulq_u32(m128_factorsBottom, m128_factorsLeft);
4073 const uint32x4_t m128_factorsBottomRight = vmulq_u32(m128_factorsBottom, m128_factorsRight);
4076 const uint32x4_t m128_maskFirstByte = vdupq_n_u32(0x000000FFu);
4078 uint32x4_t m128_muliplicationChannel0 = vmulq_u32(vandq_u32(m128_topPixels, m128_maskFirstByte), m128_factorsTopLeft);
4079 uint32x4_t m128_muliplicationChannel1 = vmulq_u32(vandq_u32(vshrq_n_u32(m128_topPixels, 8), m128_maskFirstByte), m128_factorsTopLeft);
4081 m128_muliplicationChannel0 = vaddq_u32(m128_muliplicationChannel0, vmulq_u32(vandq_u32(vshrq_n_u32(m128_topPixels, 16), m128_maskFirstByte), m128_factorsTopRight));
4082 m128_muliplicationChannel1 = vaddq_u32(m128_muliplicationChannel1, vmulq_u32(vandq_u32(vshrq_n_u32(m128_topPixels, 24), m128_maskFirstByte), m128_factorsTopRight));
4084 m128_muliplicationChannel0 = vaddq_u32(m128_muliplicationChannel0, vmulq_u32(vandq_u32(m128_bottomPixels, m128_maskFirstByte), m128_factorsBottomLeft));
4085 m128_muliplicationChannel1 = vaddq_u32(m128_muliplicationChannel1, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomPixels, 8), m128_maskFirstByte), m128_factorsBottomLeft));
4087 m128_muliplicationChannel0 = vaddq_u32(m128_muliplicationChannel0, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomPixels, 16), m128_maskFirstByte), m128_factorsBottomRight));
4088 m128_muliplicationChannel1 = vaddq_u32(m128_muliplicationChannel1, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomPixels, 24), m128_maskFirstByte), m128_factorsBottomRight));
4093 const uint32x4_t m128_interpolation0 = vshrq_n_u32(vaddq_u32(m128_muliplicationChannel0, vdupq_n_u32(8192u)), 14);
4094 const uint32x4_t m128_interpolation1 = vshrq_n_u32(vaddq_u32(m128_muliplicationChannel1, vdupq_n_u32(8192u)), 14);
4100 const uint32x4_t m128_interpolation = vorrq_u32(m128_interpolation0, vshlq_n_u32(m128_interpolation1, 8));
4107 const uint8x8_t m64_interpolation_low = vtbl1_u8(vget_low_u8(vreinterpretq_u8_u32(m128_interpolation)), m64_mask0);
4108 const uint8x8_t m64_interpolation_high = vtbl1_u8(vget_high_u8(vreinterpretq_u8_u32(m128_interpolation)), m64_mask1);
4110 const uint8x8_t m64_interpolation = vorr_u8(m64_interpolation_low, m64_interpolation_high);
4117 vst1_u8((uint8_t*)targetPositionPixels, m64_interpolation);
4121OCEAN_FORCE_INLINE
void FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelNEON<3u>(
const uint8_t* source,
const unsigned int offsetsTopLeftElements[4],
const unsigned int offsetsTopRightElements[4],
const unsigned int offsetsBottomLeftElements[4],
const unsigned int offsetsBottomRightElements[4],
const unsigned int validPixels[4],
const DataType<uint8_t, 3u>::Type& borderColor,
const uint32x4_t& m128_factorsRight,
const uint32x4_t& m128_factorsBottom,
typename DataType<uint8_t, 3u>::Type* targetPositionPixels)
4123 ocean_assert(source !=
nullptr);
4124 ocean_assert(targetPositionPixels !=
nullptr);
4128 uint32_t topLeftPixels[4];
4129 uint32_t topRightPixels[4];
4130 uint32_t bottomLeftPixels[4];
4131 uint32_t bottomRightPixels[4];
4139 for (
unsigned int i = 0u; i < 4u; ++i)
4143 memcpy(topLeftPixels + i, source + offsetsTopLeftElements[i],
sizeof(uint8_t) * 3);
4144 memcpy(topRightPixels + i, source + offsetsTopRightElements[i],
sizeof(uint8_t) * 3);
4145 memcpy(bottomLeftPixels + i, source + offsetsBottomLeftElements[i],
sizeof(uint8_t) * 3);
4146 memcpy(bottomRightPixels + i, source + offsetsBottomRightElements[i],
sizeof(uint8_t) * 3);
4150 memcpy(topLeftPixels + i, &borderColor,
sizeof(uint8_t) * 3);
4151 memcpy(topRightPixels + i, &borderColor,
sizeof(uint8_t) * 3);
4152 memcpy(bottomLeftPixels + i, &borderColor,
sizeof(uint8_t) * 3);
4153 memcpy(bottomRightPixels + i, &borderColor,
sizeof(uint8_t) * 3);
4157 static_assert(
sizeof(uint32x4_t) ==
sizeof(topLeftPixels),
"Invalid data type!");
4159 const uint32x4_t m128_topLeftPixels = vld1q_u32(topLeftPixels);
4160 const uint32x4_t m128_topRightPixels = vld1q_u32(topRightPixels);
4161 const uint32x4_t m128_bottomLeftPixels = vld1q_u32(bottomLeftPixels);
4162 const uint32x4_t m128_bottomRightPixels = vld1q_u32(bottomRightPixels);
4168 const uint32x4_t m128_factorsLeft = vsubq_u32(vdupq_n_u32(128u), m128_factorsRight);
4169 const uint32x4_t m128_factorsTop = vsubq_u32(vdupq_n_u32(128u), m128_factorsBottom);
4174 const uint32x4_t m128_factorsTopLeft = vmulq_u32(m128_factorsTop, m128_factorsLeft);
4175 const uint32x4_t m128_factorsTopRight = vmulq_u32(m128_factorsTop, m128_factorsRight);
4176 const uint32x4_t m128_factorsBottomLeft = vmulq_u32(m128_factorsBottom, m128_factorsLeft);
4177 const uint32x4_t m128_factorsBottomRight = vmulq_u32(m128_factorsBottom, m128_factorsRight);
4180 const uint32x4_t m128_maskFirstByte = vdupq_n_u32(0x000000FFu);
4182 uint32x4_t m128_muliplicationChannel0 = vmulq_u32(vandq_u32(m128_topLeftPixels, m128_maskFirstByte), m128_factorsTopLeft);
4183 uint32x4_t m128_muliplicationChannel1 = vmulq_u32(vandq_u32(vshrq_n_u32(m128_topLeftPixels, 8), m128_maskFirstByte), m128_factorsTopLeft);
4184 uint32x4_t m128_muliplicationChannel2 = vmulq_u32(vandq_u32(vshrq_n_u32(m128_topLeftPixels, 16), m128_maskFirstByte), m128_factorsTopLeft);
4186 m128_muliplicationChannel0 = vaddq_u32(m128_muliplicationChannel0, vmulq_u32(vandq_u32(m128_topRightPixels, m128_maskFirstByte), m128_factorsTopRight));
4187 m128_muliplicationChannel1 = vaddq_u32(m128_muliplicationChannel1, vmulq_u32(vandq_u32(vshrq_n_u32(m128_topRightPixels, 8), m128_maskFirstByte), m128_factorsTopRight));
4188 m128_muliplicationChannel2 = vaddq_u32(m128_muliplicationChannel2, vmulq_u32(vandq_u32(vshrq_n_u32(m128_topRightPixels, 16), m128_maskFirstByte), m128_factorsTopRight));
4190 m128_muliplicationChannel0 = vaddq_u32(m128_muliplicationChannel0, vmulq_u32(vandq_u32(m128_bottomLeftPixels, m128_maskFirstByte), m128_factorsBottomLeft));
4191 m128_muliplicationChannel1 = vaddq_u32(m128_muliplicationChannel1, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomLeftPixels, 8), m128_maskFirstByte), m128_factorsBottomLeft));
4192 m128_muliplicationChannel2 = vaddq_u32(m128_muliplicationChannel2, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomLeftPixels, 16), m128_maskFirstByte), m128_factorsBottomLeft));
4194 m128_muliplicationChannel0 = vaddq_u32(m128_muliplicationChannel0, vmulq_u32(vandq_u32(m128_bottomRightPixels, m128_maskFirstByte), m128_factorsBottomRight));
4195 m128_muliplicationChannel1 = vaddq_u32(m128_muliplicationChannel1, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomRightPixels, 8), m128_maskFirstByte), m128_factorsBottomRight));
4196 m128_muliplicationChannel2 = vaddq_u32(m128_muliplicationChannel2, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomRightPixels, 16), m128_maskFirstByte), m128_factorsBottomRight));
4201 const uint32x4_t m128_interpolation0 = vshrq_n_u32(vaddq_u32(m128_muliplicationChannel0, vdupq_n_u32(8192u)), 14);
4202 const uint32x4_t m128_interpolation1 = vshrq_n_u32(vaddq_u32(m128_muliplicationChannel1, vdupq_n_u32(8192u)), 14);
4203 const uint32x4_t m128_interpolation2 = vshrq_n_u32(vaddq_u32(m128_muliplicationChannel2, vdupq_n_u32(8192u)), 14);
4207 const uint32x4_t m128_interpolation = vorrq_u32(vorrq_u32(m128_interpolation0, vshlq_n_u32(m128_interpolation1, 8)), vshlq_n_u32(m128_interpolation2, 16));
4213 uint32_t intermediateBuffer[4];
4214 vst1q_u32(intermediateBuffer, m128_interpolation);
4216 for (
unsigned int i = 0u; i < 4u; ++i)
4218 memcpy(targetPositionPixels + i, intermediateBuffer + i,
sizeof(uint8_t) * 3);
4223OCEAN_FORCE_INLINE
void FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelNEON<4u>(
const uint8_t* source,
const unsigned int offsetsTopLeftElements[4],
const unsigned int offsetsTopRightElements[4],
const unsigned int offsetsBottomLeftElements[4],
const unsigned int offsetsBottomRightElements[4],
const unsigned int validPixels[4],
const DataType<uint8_t, 4u>::Type& borderColor,
const uint32x4_t& m128_factorsRight,
const uint32x4_t& m128_factorsBottom,
typename DataType<uint8_t, 4u>::Type* targetPositionPixels)
4225 ocean_assert(source !=
nullptr);
4226 ocean_assert(targetPositionPixels !=
nullptr);
4232 PixelType topLeftPixels[4];
4233 PixelType topRightPixels[4];
4234 PixelType bottomLeftPixels[4];
4235 PixelType bottomRightPixels[4];
4243 for (
unsigned int i = 0u; i < 4u; ++i)
4247 *(topLeftPixels + i) = *((
const PixelType*)(source + offsetsTopLeftElements[i]));
4248 *(topRightPixels + i) = *((
const PixelType*)(source + offsetsTopRightElements[i]));
4249 *(bottomLeftPixels + i) = *((
const PixelType*)(source + offsetsBottomLeftElements[i]));
4250 *(bottomRightPixels + i) = *((
const PixelType*)(source + offsetsBottomRightElements[i]));
4254 *(topLeftPixels + i) = borderColor;
4255 *(topRightPixels + i) = borderColor;
4256 *(bottomLeftPixels + i) = borderColor;
4257 *(bottomRightPixels + i) = borderColor;
4261 static_assert(
sizeof(uint32x4_t) ==
sizeof(topLeftPixels),
"Invalid data type!");
4263 const uint32x4_t m128_topLeftPixels = vreinterpretq_u32_u8(vld1q_u8((
const uint8_t*)topLeftPixels));
4264 const uint32x4_t m128_topRightPixels = vreinterpretq_u32_u8(vld1q_u8((
const uint8_t*)topRightPixels));
4265 const uint32x4_t m128_bottomLeftPixels = vreinterpretq_u32_u8(vld1q_u8((
const uint8_t*)bottomLeftPixels));
4266 const uint32x4_t m128_bottomRightPixels = vreinterpretq_u32_u8(vld1q_u8((
const uint8_t*)bottomRightPixels));
4272 const uint32x4_t m128_factorsLeft = vsubq_u32(vdupq_n_u32(128u), m128_factorsRight);
4273 const uint32x4_t m128_factorsTop = vsubq_u32(vdupq_n_u32(128u), m128_factorsBottom);
4278 const uint32x4_t m128_factorsTopLeft = vmulq_u32(m128_factorsTop, m128_factorsLeft);
4279 const uint32x4_t m128_factorsTopRight = vmulq_u32(m128_factorsTop, m128_factorsRight);
4280 const uint32x4_t m128_factorsBottomLeft = vmulq_u32(m128_factorsBottom, m128_factorsLeft);
4281 const uint32x4_t m128_factorsBottomRight = vmulq_u32(m128_factorsBottom, m128_factorsRight);
4284 const uint32x4_t m128_maskFirstByte = vdupq_n_u32(0x000000FFu);
4286 uint32x4_t m128_muliplicationChannel0 = vmulq_u32(vandq_u32(m128_topLeftPixels, m128_maskFirstByte), m128_factorsTopLeft);
4287 uint32x4_t m128_muliplicationChannel1 = vmulq_u32(vandq_u32(vshrq_n_u32(m128_topLeftPixels, 8), m128_maskFirstByte), m128_factorsTopLeft);
4288 uint32x4_t m128_muliplicationChannel2 = vmulq_u32(vandq_u32(vshrq_n_u32(m128_topLeftPixels, 16), m128_maskFirstByte), m128_factorsTopLeft);
4289 uint32x4_t m128_muliplicationChannel3 = vmulq_u32(vandq_u32(vshrq_n_u32(m128_topLeftPixels, 24), m128_maskFirstByte), m128_factorsTopLeft);
4291 m128_muliplicationChannel0 = vaddq_u32(m128_muliplicationChannel0, vmulq_u32(vandq_u32(m128_topRightPixels, m128_maskFirstByte), m128_factorsTopRight));
4292 m128_muliplicationChannel1 = vaddq_u32(m128_muliplicationChannel1, vmulq_u32(vandq_u32(vshrq_n_u32(m128_topRightPixels, 8), m128_maskFirstByte), m128_factorsTopRight));
4293 m128_muliplicationChannel2 = vaddq_u32(m128_muliplicationChannel2, vmulq_u32(vandq_u32(vshrq_n_u32(m128_topRightPixels, 16), m128_maskFirstByte), m128_factorsTopRight));
4294 m128_muliplicationChannel3 = vaddq_u32(m128_muliplicationChannel3, vmulq_u32(vandq_u32(vshrq_n_u32(m128_topRightPixels, 24), m128_maskFirstByte), m128_factorsTopRight));
4296 m128_muliplicationChannel0 = vaddq_u32(m128_muliplicationChannel0, vmulq_u32(vandq_u32(m128_bottomLeftPixels, m128_maskFirstByte), m128_factorsBottomLeft));
4297 m128_muliplicationChannel1 = vaddq_u32(m128_muliplicationChannel1, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomLeftPixels, 8), m128_maskFirstByte), m128_factorsBottomLeft));
4298 m128_muliplicationChannel2 = vaddq_u32(m128_muliplicationChannel2, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomLeftPixels, 16), m128_maskFirstByte), m128_factorsBottomLeft));
4299 m128_muliplicationChannel3 = vaddq_u32(m128_muliplicationChannel3, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomLeftPixels, 24), m128_maskFirstByte), m128_factorsBottomLeft));
4301 m128_muliplicationChannel0 = vaddq_u32(m128_muliplicationChannel0, vmulq_u32(vandq_u32(m128_bottomRightPixels, m128_maskFirstByte), m128_factorsBottomRight));
4302 m128_muliplicationChannel1 = vaddq_u32(m128_muliplicationChannel1, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomRightPixels, 8), m128_maskFirstByte), m128_factorsBottomRight));
4303 m128_muliplicationChannel2 = vaddq_u32(m128_muliplicationChannel2, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomRightPixels, 16), m128_maskFirstByte), m128_factorsBottomRight));
4304 m128_muliplicationChannel3 = vaddq_u32(m128_muliplicationChannel3, vmulq_u32(vandq_u32(vshrq_n_u32(m128_bottomRightPixels, 24), m128_maskFirstByte), m128_factorsBottomRight));
4309 const uint32x4_t m128_interpolation0 = vshrq_n_u32(vaddq_u32(m128_muliplicationChannel0, vdupq_n_u32(8192u)), 14);
4310 const uint32x4_t m128_interpolation1 = vshrq_n_u32(vaddq_u32(m128_muliplicationChannel1, vdupq_n_u32(8192u)), 14);
4311 const uint32x4_t m128_interpolation2 = vshrq_n_u32(vaddq_u32(m128_muliplicationChannel2, vdupq_n_u32(8192u)), 14);
4312 const uint32x4_t m128_interpolation3 = vshrq_n_u32(vaddq_u32(m128_muliplicationChannel3, vdupq_n_u32(8192u)), 14);
4316 const uint32x4_t m128_interpolation = vorrq_u32(vorrq_u32(m128_interpolation0, vshlq_n_u32(m128_interpolation1, 8)), vorrq_u32(vshlq_n_u32(m128_interpolation2, 16), vshlq_n_u32(m128_interpolation3, 24)));
4318 vst1q_u8((uint8_t*)targetPositionPixels, vreinterpretq_u8_u32(m128_interpolation));
4323 ocean_assert(targetPositionPixels !=
nullptr);
4328 uint8x8_t factorsRight_lo;
4329 uint8x8_t factorsRight_hi;
4330 uint8x8_t factorsLeft_lo;
4331 uint8x8_t factorsLeft_hi;
4332 uint8x8_t factorsBottom_lo;
4333 uint8x8_t factorsBottom_hi;
4334 uint8x8_t factorsTop_lo;
4335 uint8x8_t factorsTop_hi;
4337#if defined(__aarch64__)
4339 if (!useOptimizedNEONFactorReplication)
4341 (void)useOptimizedNEONFactorReplication;
4344 const uint8x8_t factorsRight_u8x8 = vmovn_u16(vcombine_u16(vmovn_u32(m128_factorsRight), vmovn_u32(m128_factorsRight)));
4345 const uint8x8x2_t factorsRight_zip1 = vzip_u8(factorsRight_u8x8, factorsRight_u8x8);
4346 const uint8x8x2_t factorsRight_zip2 = vzip_u8(factorsRight_zip1.val[0], factorsRight_zip1.val[0]);
4348 factorsRight_lo = factorsRight_zip2.val[0];
4349 factorsRight_hi = factorsRight_zip2.val[1];
4350 factorsLeft_lo = vsub_u8(vdup_n_u8(128u), factorsRight_lo);
4351 factorsLeft_hi = vsub_u8(vdup_n_u8(128u), factorsRight_hi);
4353 const uint8x8_t factorsBottom_u8x8 = vmovn_u16(vcombine_u16(vmovn_u32(m128_factorsBottom), vmovn_u32(m128_factorsBottom)));
4354 const uint8x8x2_t factorsBottom_zip1 = vzip_u8(factorsBottom_u8x8, factorsBottom_u8x8);
4355 const uint8x8x2_t factorsBottom_zip2 = vzip_u8(factorsBottom_zip1.val[0], factorsBottom_zip1.val[0]);
4357 factorsBottom_lo = factorsBottom_zip2.val[0];
4358 factorsBottom_hi = factorsBottom_zip2.val[1];
4359 factorsTop_lo = vsub_u8(vdup_n_u8(128u), factorsBottom_lo);
4360 factorsTop_hi = vsub_u8(vdup_n_u8(128u), factorsBottom_hi);
4362#if defined(__aarch64__)
4368 static const uint8x16_t replicateU32Idx = {0, 0, 0, 0, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 12, 12};
4370 const uint8x16_t factorsRight_rep = vqtbl1q_u8(vreinterpretq_u8_u32(m128_factorsRight), replicateU32Idx);
4371 const uint8x16_t factorsLeft_rep = vsubq_u8(vdupq_n_u8(128u), factorsRight_rep);
4373 factorsRight_lo = vget_low_u8(factorsRight_rep);
4374 factorsRight_hi = vget_high_u8(factorsRight_rep);
4375 factorsLeft_lo = vget_low_u8(factorsLeft_rep);
4376 factorsLeft_hi = vget_high_u8(factorsLeft_rep);
4378 const uint8x16_t factorsBottom_rep = vqtbl1q_u8(vreinterpretq_u8_u32(m128_factorsBottom), replicateU32Idx);
4379 const uint8x16_t factorsTop_rep = vsubq_u8(vdupq_n_u8(128u), factorsBottom_rep);
4381 factorsBottom_lo = vget_low_u8(factorsBottom_rep);
4382 factorsBottom_hi = vget_high_u8(factorsBottom_rep);
4383 factorsTop_lo = vget_low_u8(factorsTop_rep);
4384 factorsTop_hi = vget_high_u8(factorsTop_rep);
4389 const uint8x8_t topLeft_lo = vget_low_u8(topLeftPixels_u8x16);
4390 const uint8x8_t topLeft_hi = vget_high_u8(topLeftPixels_u8x16);
4391 const uint8x8_t topRight_lo = vget_low_u8(topRightPixels_u8x16);
4392 const uint8x8_t topRight_hi = vget_high_u8(topRightPixels_u8x16);
4393 const uint8x8_t bottomLeft_lo = vget_low_u8(bottomLeftPixels_u8x16);
4394 const uint8x8_t bottomLeft_hi = vget_high_u8(bottomLeftPixels_u8x16);
4395 const uint8x8_t bottomRight_lo = vget_low_u8(bottomRightPixels_u8x16);
4396 const uint8x8_t bottomRight_hi = vget_high_u8(bottomRightPixels_u8x16);
4400 const uint16x8_t topInterp_lo = vmlal_u8(vmull_u8(topLeft_lo, factorsLeft_lo), topRight_lo, factorsRight_lo);
4401 const uint16x8_t botInterp_lo = vmlal_u8(vmull_u8(bottomLeft_lo, factorsLeft_lo), bottomRight_lo, factorsRight_lo);
4404 const uint16x8_t factorsTop_lo_u16 = vmovl_u8(factorsTop_lo);
4405 const uint16x8_t factorsBottom_lo_u16 = vmovl_u8(factorsBottom_lo);
4407 const uint32x4_t result_lo_A = vmlal_u16(vmull_u16(vget_low_u16(topInterp_lo), vget_low_u16(factorsTop_lo_u16)), vget_low_u16(botInterp_lo), vget_low_u16(factorsBottom_lo_u16));
4408 const uint32x4_t result_lo_B = vmlal_u16(vmull_u16(vget_high_u16(topInterp_lo), vget_high_u16(factorsTop_lo_u16)), vget_high_u16(botInterp_lo), vget_high_u16(factorsBottom_lo_u16));
4411 const uint16x8_t topInterp_hi = vmlal_u8(vmull_u8(topLeft_hi, factorsLeft_hi), topRight_hi, factorsRight_hi);
4412 const uint16x8_t botInterp_hi = vmlal_u8(vmull_u8(bottomLeft_hi, factorsLeft_hi), bottomRight_hi, factorsRight_hi);
4414 const uint16x8_t factorsTop_hi_u16 = vmovl_u8(factorsTop_hi);
4415 const uint16x8_t factorsBottom_hi_u16 = vmovl_u8(factorsBottom_hi);
4417 const uint32x4_t result_hi_A = vmlal_u16(vmull_u16(vget_low_u16(topInterp_hi), vget_low_u16(factorsTop_hi_u16)), vget_low_u16(botInterp_hi), vget_low_u16(factorsBottom_hi_u16));
4418 const uint32x4_t result_hi_B = vmlal_u16(vmull_u16(vget_high_u16(topInterp_hi), vget_high_u16(factorsTop_hi_u16)), vget_high_u16(botInterp_hi), vget_high_u16(factorsBottom_hi_u16));
4421 const uint16x4_t narrow_lo_A = vrshrn_n_u32(result_lo_A, 14);
4422 const uint16x4_t narrow_lo_B = vrshrn_n_u32(result_lo_B, 14);
4423 const uint16x4_t narrow_hi_A = vrshrn_n_u32(result_hi_A, 14);
4424 const uint16x4_t narrow_hi_B = vrshrn_n_u32(result_hi_B, 14);
4426 const uint8x8_t result_lo = vmovn_u16(vcombine_u16(narrow_lo_A, narrow_lo_B));
4427 const uint8x8_t result_hi = vmovn_u16(vcombine_u16(narrow_hi_A, narrow_hi_B));
4429 vst1q_u8((uint8_t*)targetPositionPixels, vcombine_u8(result_lo, result_hi));
4432template <
unsigned int tChannels>
4433OCEAN_FORCE_INLINE
void FrameInterpolatorBilinear::interpolate4Pixels8BitPerChannelNEON(
const uint8_t* source,
const unsigned int offsetsTopLeftElements[4],
const unsigned int offsetsTopRightElements[4],
const unsigned int offsetsBottomLeftElements[4],
const unsigned int offsetsBottomRightElements[4],
const unsigned int validPixels[4],
const typename DataType<uint8_t, tChannels>::Type& borderColor,
const uint32x4_t& m128_factorsRight,
const uint32x4_t& m128_factorsBottom,
typename DataType<uint8_t, tChannels>::Type* targetPositionPixels)
4435 ocean_assert(source !=
nullptr);
4436 ocean_assert(targetPositionPixels !=
nullptr);
4440 unsigned int factorsTopLeft[4];
4441 unsigned int factorsTopRight[4];
4442 unsigned int factorsBottomLeft[4];
4443 unsigned int factorsBottomRight[4];
4449 const uint32x4_t m128_factorsLeft = vsubq_u32(vdupq_n_u32(128u), m128_factorsRight);
4450 const uint32x4_t m128_factorsTop = vsubq_u32(vdupq_n_u32(128u), m128_factorsBottom);
4455 const uint32x4_t m128_factorsTopLeft = vmulq_u32(m128_factorsTop, m128_factorsLeft);
4456 const uint32x4_t m128_factorsTopRight = vmulq_u32(m128_factorsTop, m128_factorsRight);
4457 const uint32x4_t m128_factorsBottomLeft = vmulq_u32(m128_factorsBottom, m128_factorsLeft);
4458 const uint32x4_t m128_factorsBottomRight = vmulq_u32(m128_factorsBottom, m128_factorsRight);
4462 vst1q_u32(factorsTopLeft, m128_factorsTopLeft);
4463 vst1q_u32(factorsTopRight, m128_factorsTopRight);
4464 vst1q_u32(factorsBottomLeft, m128_factorsBottomLeft);
4465 vst1q_u32(factorsBottomRight, m128_factorsBottomRight);
4467 for (
unsigned int i = 0u; i < 4u; ++i)
4471 const uint8_t* topLeft = source + offsetsTopLeftElements[i];
4472 const uint8_t* topRight = source + offsetsTopRightElements[i];
4474 const uint8_t* bottomLeft = source + offsetsBottomLeftElements[i];
4475 const uint8_t* bottomRight = source + offsetsBottomRightElements[i];
4477 const unsigned int& factorTopLeft = factorsTopLeft[i];
4478 const unsigned int& factorTopRight = factorsTopRight[i];
4479 const unsigned int& factorBottomLeft = factorsBottomLeft[i];
4480 const unsigned int& factorBottomRight = factorsBottomRight[i];
4482 for (
unsigned int n = 0u; n < tChannels; ++n)
4484 ((uint8_t*)targetPositionPixels)[n] = (topLeft[n] * factorTopLeft + topRight[n] * factorTopRight + bottomLeft[n] * factorBottomLeft + bottomRight[n] * factorBottomRight + 8192u) >> 14u;
4489 *targetPositionPixels = borderColor;
4492 targetPositionPixels++;
4498template <
unsigned int tChannels>
4499inline void FrameInterpolatorBilinear::homographies8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* homographies,
const uint8_t* borderColor, uint8_t* output,
const Scalar outputQuadrantCenterX,
const Scalar outputQuadrantCenterY,
const int outputOriginX,
const int outputOriginY,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows)
4501 static_assert(tChannels >= 1u,
"Invalid channel number!");
4503 ocean_assert(input && output);
4504 ocean_assert(inputWidth > 0u && inputHeight > 0u);
4505 ocean_assert(outputWidth > 0u && outputHeight > 0u);
4507 ocean_assert(outputQuadrantCenterX >= 0 && outputQuadrantCenterX <
Scalar(outputWidth));
4508 ocean_assert(outputQuadrantCenterY >= 0 && outputQuadrantCenterY <
Scalar(outputHeight));
4509 ocean_assert(homographies);
4511 const unsigned int outputStrideElements = outputWidth * tChannels + outputPaddingElements;
4513 const Scalar scalarInputWidth_1 =
Scalar(inputWidth - 1u);
4514 const Scalar scalarInputHeight_1 =
Scalar(inputHeight - 1u);
4516 constexpr uint8_t zeroColor[tChannels] = {uint8_t(0)};
4517 const uint8_t*
const bColor = borderColor ? borderColor : zeroColor;
4519 uint8_t* outputData = output + firstOutputRow * outputStrideElements;
4533 for (
unsigned int y = firstOutputRow; y < firstOutputRow + numberOutputRows; ++y)
4535 for (
unsigned int x = 0; x < outputWidth; ++x)
4544 const Scalar tx = 1 - _tx;
4545 const Scalar ty = 1 - _ty;
4547 const Vector2 inputPositionTopLeft(homographies[0] * outputPosition);
4548 const Vector2 inputPositionTopRight(homographies[1] * outputPosition);
4549 const Vector2 inputPositionBottomLeft(homographies[2] * outputPosition);
4550 const Vector2 inputPositionBottomRight(homographies[3] * outputPosition);
4552 const Scalar tTopLeft = tx * ty;
4553 const Scalar tTopRight = _tx * ty;
4554 const Scalar tBottomLeft = tx * _ty;
4555 const Scalar tBottomRight = _tx * _ty;
4557 const Vector2 inputPosition = inputPositionTopLeft * tTopLeft + inputPositionTopRight * tTopRight
4558 + inputPositionBottomLeft * tBottomLeft + inputPositionBottomRight * tBottomRight;
4560 if (inputPosition.
x() <
Scalar(0) || inputPosition.
x() > scalarInputWidth_1 || inputPosition.
y() <
Scalar(0) || inputPosition.
y() > scalarInputHeight_1)
4562 for (
unsigned int c = 0u; c < tChannels; ++c)
4564 outputData[c] = bColor[c];
4572 outputData += tChannels;
4575 outputData += outputPaddingElements;
4579template <
unsigned int tChannels>
4580void FrameInterpolatorBilinear::homographyMask8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* input_H_output, uint8_t* output, uint8_t* outputMask,
const uint8_t maskValue,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
unsigned int firstOutputRow,
const unsigned int numberOutputRows)
4582 static_assert(tChannels >= 1u,
"Invalid channel number!");
4584 ocean_assert(input !=
nullptr && output !=
nullptr);
4585 ocean_assert(inputWidth > 0u && inputHeight > 0u);
4586 ocean_assert(outputWidth > 0u && outputHeight > 0u);
4587 ocean_assert(input_H_output !=
nullptr);
4589 ocean_assert_and_suppress_unused(firstOutputRow + numberOutputRows <= outputHeight, outputHeight);
4591 const unsigned int outputStrideElements = outputWidth * tChannels + outputPaddingElements;
4592 const unsigned int outputMaskStrideElements = outputWidth + outputMaskPaddingElements;
4594 const Scalar scalarInputWidth_1 =
Scalar(inputWidth - 1u);
4595 const Scalar scalarInputHeight_1 =
Scalar(inputHeight - 1u);
4599 for (
unsigned int y = firstOutputRow; y < firstOutputRow + numberOutputRows; ++y)
4601 PixelType* outputData = (PixelType*)(output + y * outputStrideElements);
4602 uint8_t* outputMaskData = outputMask + y * outputMaskStrideElements;
4626 const Scalar X2 = (*input_H_output)(2, 0);
4627 const Scalar constValue2 = (*input_H_output)(2, 1) *
Scalar(y) + (*input_H_output)(2, 2);
4629 for (
unsigned int x = 0; x < outputWidth; ++x)
4635 ocean_assert(inputPosition.
isEqual(debugInputPosition,
Scalar(0.01)));
4638 if (inputPosition.
x() <
Scalar(0) || inputPosition.
x() > scalarInputWidth_1 || inputPosition.
y() <
Scalar(0) || inputPosition.
y() > scalarInputHeight_1)
4640 *outputMaskData = 0xFF - maskValue;
4645 *outputMaskData = maskValue;
4654template <
unsigned int tChannels>
4655inline void FrameInterpolatorBilinear::homographiesMask8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const SquareMatrix3* homographies, uint8_t* output, uint8_t* outputMask,
const uint8_t maskValue,
const Scalar outputQuadrantCenterX,
const Scalar outputQuadrantCenterY,
const int outputOriginX,
const int outputOriginY,
const unsigned int outputWidth,
const unsigned int outputHeight,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
const unsigned int firstOutputRow,
const unsigned int numberOutputRows)
4657 static_assert(tChannels >= 1u,
"Invalid channel number!");
4659 ocean_assert(input && output);
4660 ocean_assert(inputWidth > 0u && inputHeight > 0u);
4661 ocean_assert(outputWidth > 0u && outputHeight > 0u);
4663 ocean_assert(outputQuadrantCenterX >= 0 && outputQuadrantCenterX <
Scalar(outputWidth));
4664 ocean_assert(outputQuadrantCenterY >= 0 && outputQuadrantCenterY <
Scalar(outputHeight));
4665 ocean_assert(homographies);
4667 const unsigned int outputStrideElements = tChannels * outputWidth + outputPaddingElements;
4668 const unsigned int outputMaskStrideElements = outputWidth + outputMaskPaddingElements;
4670 const Scalar scalarInputWidth_1 =
Scalar(inputWidth - 1u);
4671 const Scalar scalarInputHeight_1 =
Scalar(inputHeight - 1u);
4673 uint8_t* outputData = output + firstOutputRow * outputStrideElements;
4674 outputMask += firstOutputRow * outputMaskStrideElements;
4688 for (
unsigned int y = firstOutputRow; y < firstOutputRow + numberOutputRows; ++y)
4690 for (
unsigned int x = 0u; x < outputWidth; ++x)
4699 const Scalar tx = 1 - _tx;
4700 const Scalar ty = 1 - _ty;
4702 const Vector2 inputPositionTopLeft(homographies[0] * outputPosition);
4703 const Vector2 inputPositionTopRight(homographies[1] * outputPosition);
4704 const Vector2 inputPositionBottomLeft(homographies[2] * outputPosition);
4705 const Vector2 inputPositionBottomRight(homographies[3] * outputPosition);
4707 const Scalar tTopLeft = tx * ty;
4708 const Scalar tTopRight = _tx * ty;
4709 const Scalar tBottomLeft = tx * _ty;
4710 const Scalar tBottomRight = _tx * _ty;
4712 const Vector2 inputPosition = inputPositionTopLeft * tTopLeft + inputPositionTopRight * tTopRight
4713 + inputPositionBottomLeft * tBottomLeft + inputPositionBottomRight * tBottomRight;
4715 if (inputPosition.
x() <
Scalar(0) || inputPosition.
x() > scalarInputWidth_1 || inputPosition.
y() <
Scalar(0) || inputPosition.
y() > scalarInputHeight_1)
4717 *outputMask = 0xFFu - maskValue;
4722 *outputMask = maskValue;
4725 outputData += tChannels;
4729 outputData += outputPaddingElements;
4730 outputMask += outputMaskPaddingElements;
4734template <
unsigned int tChannels>
4735void FrameInterpolatorBilinear::homographyWithCamera8BitPerChannelSubset(
const PinholeCamera* inputCamera,
const PinholeCamera* outputCamera,
const PinholeCamera::DistortionLookup* outputCameraDistortionLookup,
const uint8_t* input,
const SquareMatrix3* normalizedHomography,
const bool useDistortionParameters,
const uint8_t* borderColor, uint8_t* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows)
4737 static_assert(tChannels >= 1u,
"Invalid channel number!");
4739 ocean_assert(inputCamera && outputCamera && normalizedHomography);
4740 ocean_assert(input && output);
4742 ocean_assert(firstRow + numberRows <= outputCamera->height());
4744 const unsigned int outputStrideElements = tChannels * outputCamera->
width() + outputPaddingElements;
4753 const uint8_t zeroColor[tChannels] = {uint8_t(0)};
4754 const PixelType*
const bColor = borderColor ? (PixelType*)borderColor : (PixelType*)zeroColor;
4756 uint8_t* outputData = output + firstRow * outputStrideElements;
4758 for (
unsigned int y = firstRow; y < firstRow + numberRows; ++y)
4760 for (
unsigned int x = 0; x < outputCamera->
width(); ++x)
4764 if (inputPosition.
x() <
Scalar(0) || inputPosition.
x() > scalarInputWidth_1 || inputPosition.
y() <
Scalar(0) || inputPosition.
y() > scalarInputHeight_1)
4766 *((PixelType*)outputData) = *bColor;
4773 outputData += tChannels;
4776 outputData += outputPaddingElements;
4780template <
unsigned int tChannels>
4781void FrameInterpolatorBilinear::homographyWithCameraMask8BitPerChannelSubset(
const PinholeCamera* inputCamera,
const PinholeCamera* outputCamera,
const PinholeCamera::DistortionLookup* outputCameraDistortionLookup,
const uint8_t* input,
const unsigned int inputPaddingElements,
const SquareMatrix3* normalizedHomography, uint8_t* output, uint8_t* outputMask,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
const uint8_t maskValue,
const unsigned int firstRow,
const unsigned int numberRows)
4783 static_assert(tChannels >= 1u,
"Invalid channel number!");
4785 ocean_assert(inputCamera !=
nullptr && outputCamera !=
nullptr && normalizedHomography !=
nullptr);
4786 ocean_assert(input !=
nullptr && output !=
nullptr);
4788 ocean_assert(firstRow + numberRows <= outputCamera->height());
4790 const unsigned int outputStrideElements = outputCamera->
width() * tChannels + outputPaddingElements;
4791 const unsigned int outputMaskStrideElements = outputCamera->
width() + outputMaskPaddingElements;
4798 uint8_t* outputData = output + firstRow * outputStrideElements;
4799 outputMask += firstRow * outputMaskStrideElements;
4801 constexpr bool useDistortionParameters =
true;
4803 for (
unsigned int y = firstRow; y < firstRow + numberRows; ++y)
4805 for (
unsigned int x = 0; x < outputCamera->
width(); ++x)
4809 if (inputPosition.
x() <
Scalar(0) || inputPosition.
x() > scalarInputWidth_1 || inputPosition.
y() <
Scalar(0) || inputPosition.
y() > scalarInputHeight_1)
4811 *outputMask = 0xFF - maskValue;
4816 *outputMask = maskValue;
4819 outputData += tChannels;
4823 outputData += outputPaddingElements;
4824 outputMask += outputMaskPaddingElements;
4828template <
unsigned int tChannels>
4829void FrameInterpolatorBilinear::lookup8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable* input_LT_output,
const bool offset,
const uint8_t* borderColor, uint8_t* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows)
4831 static_assert(tChannels >= 1u,
"Invalid channel number!");
4833 ocean_assert(input_LT_output !=
nullptr);
4834 ocean_assert(input !=
nullptr && output !=
nullptr);
4836 ocean_assert(inputWidth != 0u && inputHeight != 0u);
4837 ocean_assert(firstRow + numberRows <= input_LT_output->sizeY());
4841 const uint8_t zeroColor[tChannels] = {uint8_t(0)};
4842 const PixelType*
const bColor = borderColor ? (PixelType*)borderColor : (PixelType*)zeroColor;
4848 const unsigned int columns = (
unsigned int)(input_LT_output->
sizeX());
4850 if (
size_t(columns) != input_LT_output->
sizeX())
4852 ocean_assert(
false &&
"Lookup table is wider than 32 bits!");
4856 const unsigned int outputStrideElements = tChannels * columns + outputPaddingElements;
4858 static_assert(std::is_same<Vector2, LookupTable::Type>::value,
"Invalid data type!");
4866 if (rowLookupData ==
nullptr)
4870 ocean_assert(
false &&
"Failed to allocate the row lookup buffer!");
4874 for (
unsigned int y = firstRow; y < firstRow + numberRows; ++y)
4878 PixelType* outputData = (PixelType*)(output + y * outputStrideElements);
4880 for (
unsigned int x = 0u; x < columns; ++x)
4882 const Vector2& lookupValue = rowLookupData[x];
4886 if (inputPosition.
x() >=
Scalar(0) && inputPosition.
y() >=
Scalar(0) && inputPosition.
x() <= inputWidth1 && inputPosition.
y() <= inputHeight1)
4892 *outputData = *bColor;
4900template <
typename T,
unsigned int tChannels>
4901void FrameInterpolatorBilinear::lookupSubset(
const T* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable* input_LT_output,
const bool offset,
const T* borderColor, T* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows)
4903 static_assert(tChannels >= 1u,
"Invalid channel number!");
4905 ocean_assert((!std::is_same<uint8_t, T>::value));
4907 ocean_assert(input_LT_output !=
nullptr);
4908 ocean_assert(input !=
nullptr && output !=
nullptr);
4910 ocean_assert(inputWidth != 0u && inputHeight != 0u);
4911 ocean_assert(firstRow + numberRows <= input_LT_output->sizeY());
4915 const T zeroColor[tChannels] = {T(0)};
4916 const PixelType*
const bColor = borderColor ? (PixelType*)borderColor : (PixelType*)zeroColor;
4922 const unsigned int columns = (
unsigned int)(input_LT_output->
sizeX());
4924 if (
size_t(columns) != input_LT_output->
sizeX())
4926 ocean_assert(
false &&
"Lookup table is wider than 32 bits!");
4930 const unsigned int outputStrideElements = tChannels * columns + outputPaddingElements;
4932 static_assert(std::is_same<Vector2, LookupTable::Type>::value,
"Invalid data type!");
4940 if (rowLookupData ==
nullptr)
4944 ocean_assert(
false &&
"Failed to allocate the row lookup buffer!");
4948 for (
unsigned int y = firstRow; y < firstRow + numberRows; ++y)
4952 PixelType* outputData = (PixelType*)(output + y * outputStrideElements);
4954 for (
unsigned int x = 0u; x < columns; ++x)
4956 const Vector2& lookupValue = rowLookupData[x];
4960 if (inputPosition.
x() >=
Scalar(0) && inputPosition.
y() >=
Scalar(0) && inputPosition.
x() <= inputWidth1 && inputPosition.
y() <= inputHeight1)
4966 *outputData = *bColor;
4974#if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
4977inline void FrameInterpolatorBilinear::lookup8BitPerChannelSubsetNEON<1u>(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable* input_LT_output,
const bool offset,
const uint8_t* borderColor, uint8_t* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows,
const bool useOptimizedNEON,
const bool useOptimizedBilinearValuesAndFactorCalculation,
const bool , [[maybe_unused]]
const bool use4ChannelSamplingFastPaths)
4979 ocean_assert(input_LT_output !=
nullptr);
4980 ocean_assert(input !=
nullptr && output !=
nullptr);
4982 ocean_assert(inputWidth != 0u && inputHeight != 0u);
4983 ocean_assert(firstRow + numberRows <= input_LT_output->sizeY());
4985 using PixelType = uint8_t;
4987 const uint8x16_t constantBorderColor_u_8x16 = vdupq_n_u8(borderColor ? *borderColor : 0u);
4993 const unsigned int outputWidth = (
unsigned int)(input_LT_output->
sizeX());
4995 if (
size_t(outputWidth) != input_LT_output->
sizeX())
4997 ocean_assert(
false &&
"Lookup table is wider than 32 bits!");
5001 ocean_assert(outputWidth >= 8u);
5003 static_assert(std::is_same<Vector2, LookupTable::Type>::value,
"Invalid data type!");
5005 const unsigned int inputStrideElements = inputWidth + inputPaddingElements;
5006 const unsigned int outputStrideElements = outputWidth + outputPaddingElements;
5011 if (rowLookupData ==
nullptr)
5015 ocean_assert(
false &&
"Failed to allocate the row lookup buffer!");
5019 const float32x4_t constantZero_f_32x4 = vdupq_n_f32(0.0f);
5020 const float32x4_t constantEight_f_32x4 = vdupq_n_f32(8.0f);
5023 const float f_01234567[8] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f};
5024 const float32x4_t conststant0123_f_32x4 = vld1q_f32(f_01234567 + 0);
5025 const float32x4_t conststant4567_f_32x4 = vld1q_f32(f_01234567 + 4);
5027 const float32x4_t constant128_f_32x4 = vdupq_n_f32(128.0f);
5029 const uint32x4_t constantOne_u_32x4 = vdupq_n_u32(1u);
5031 const uint32x4_t constantChannels_u_32x4 = vdupq_n_u32(1u);
5033 const float32x4_t constantInputWidth1_f_32x4 = vdupq_n_f32(
float(inputWidth - 1u));
5034 const float32x4_t constantInputHeight1_f_32x4 = vdupq_n_f32(
float(inputHeight - 1u));
5036 const uint32x4_t constantInputStrideElements_u_32x4 = vdupq_n_u32(inputStrideElements);
5037 const uint32x4_t constantInputHeight1_u_32x4 = vdupq_n_u32(inputHeight - 1u);
5039 unsigned int validPixels[8];
5041 unsigned int topLeftOffsetsElements[8];
5042 unsigned int bottomLeftOffsetsElements[8];
5046 for (
unsigned int y = firstRow; y < firstRow + numberRows; ++y)
5048 PixelType* outputPixelData = (PixelType*)(output + y * outputStrideElements);
5052 float32x4_t additionalInputOffsetX0123_f_32x4 = conststant0123_f_32x4;
5053 float32x4_t additionalInputOffsetX4567_f_32x4 = conststant4567_f_32x4;
5055 const float32x4_t additionalInputOffsetY_f_32x4 = vdupq_n_f32(
float(y));
5057 for (
unsigned int x = 0u; x < outputWidth; x += 8u)
5059 if (x + 8u > outputWidth)
5064 ocean_assert(x >= 8u && outputWidth > 8u);
5065 const unsigned int newX = outputWidth - 8u;
5067 ocean_assert(x > newX);
5068 const unsigned int xOffset = x - newX;
5070 outputPixelData -= xOffset;
5074 additionalInputOffsetX0123_f_32x4 = vsubq_f32(additionalInputOffsetX0123_f_32x4, vdupq_n_f32(
float(xOffset)));
5075 additionalInputOffsetX4567_f_32x4 = vsubq_f32(additionalInputOffsetX4567_f_32x4, vdupq_n_f32(
float(xOffset)));
5081 ocean_assert(!(x + 8u < outputWidth));
5084 const float32x4x2_t inputPositions0123_f_32x4x2 = vld2q_f32((
const float*)(rowLookupData + x + 0u));
5085 const float32x4x2_t inputPositions4567_f_32x4x2 = vld2q_f32((
const float*)(rowLookupData + x + 4u));
5087 float32x4_t inputPositionsX0123_f_32x4 = inputPositions0123_f_32x4x2.val[0];
5088 float32x4_t inputPositionsY0123_f_32x4 = inputPositions0123_f_32x4x2.val[1];
5090 float32x4_t inputPositionsX4567_f_32x4 = inputPositions4567_f_32x4x2.val[0];
5091 float32x4_t inputPositionsY4567_f_32x4 = inputPositions4567_f_32x4x2.val[1];
5095 inputPositionsX0123_f_32x4 = vaddq_f32(inputPositionsX0123_f_32x4, additionalInputOffsetX0123_f_32x4);
5096 inputPositionsY0123_f_32x4 = vaddq_f32(inputPositionsY0123_f_32x4, additionalInputOffsetY_f_32x4);
5098 inputPositionsX4567_f_32x4 = vaddq_f32(inputPositionsX4567_f_32x4, additionalInputOffsetX4567_f_32x4);
5099 inputPositionsY4567_f_32x4 = vaddq_f32(inputPositionsY4567_f_32x4, additionalInputOffsetY_f_32x4);
5101 additionalInputOffsetX0123_f_32x4 = vaddq_f32(additionalInputOffsetX0123_f_32x4, constantEight_f_32x4);
5102 additionalInputOffsetX4567_f_32x4 = vaddq_f32(additionalInputOffsetX4567_f_32x4, constantEight_f_32x4);
5106 const uint32x4_t validPixelsX0123_u_32x4 = vandq_u32(vcltq_f32(inputPositionsX0123_f_32x4, constantInputWidth1_f_32x4), vcgeq_f32(inputPositionsX0123_f_32x4, constantZero_f_32x4));
5107 const uint32x4_t validPixelsX4567_u_32x4 = vandq_u32(vcltq_f32(inputPositionsX4567_f_32x4, constantInputWidth1_f_32x4), vcgeq_f32(inputPositionsX4567_f_32x4, constantZero_f_32x4));
5109 const uint32x4_t validPixelsY0123_u_32x4 = vandq_u32(vcltq_f32(inputPositionsY0123_f_32x4, constantInputHeight1_f_32x4), vcgeq_f32(inputPositionsY0123_f_32x4, constantZero_f_32x4));
5110 const uint32x4_t validPixelsY4567_u_32x4 = vandq_u32(vcltq_f32(inputPositionsY4567_f_32x4, constantInputHeight1_f_32x4), vcgeq_f32(inputPositionsY4567_f_32x4, constantZero_f_32x4));
5112 const uint32x4_t validPixels0123_u_32x4 = vandq_u32(validPixelsX0123_u_32x4, validPixelsY0123_u_32x4);
5113 const uint32x4_t validPixels4567_u_32x4 = vandq_u32(validPixelsX4567_u_32x4, validPixelsY4567_u_32x4);
5115 vst1q_u32(validPixels + 0, validPixels0123_u_32x4);
5116 vst1q_u32(validPixels + 4, validPixels4567_u_32x4);
5119 const uint32x4_t inputPositionsLeft0123_u_32x4 = vcvtq_u32_f32(inputPositionsX0123_f_32x4);
5120 const uint32x4_t inputPositionsLeft4567_u_32x4 = vcvtq_u32_f32(inputPositionsX4567_f_32x4);
5122 const uint32x4_t inputPositionsTop0123_u_32x4 = vcvtq_u32_f32(inputPositionsY0123_f_32x4);
5123 const uint32x4_t inputPositionsTop4567_u_32x4 = vcvtq_u32_f32(inputPositionsY4567_f_32x4);
5125 const uint32x4_t inputPositionsBottom0123_u_32x4 = vminq_u32(vaddq_u32(inputPositionsTop0123_u_32x4, constantOne_u_32x4), constantInputHeight1_u_32x4);
5126 const uint32x4_t inputPositionsBottom4567_u_32x4 = vminq_u32(vaddq_u32(inputPositionsTop4567_u_32x4, constantOne_u_32x4), constantInputHeight1_u_32x4);
5129 const uint32x4_t topLeftOffsetsElements0123_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsLeft0123_u_32x4, constantChannels_u_32x4), inputPositionsTop0123_u_32x4, constantInputStrideElements_u_32x4);
5130 vst1q_u32(topLeftOffsetsElements + 0, topLeftOffsetsElements0123_u_32x4);
5131 const uint32x4_t topLeftOffsetsElements4567_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsLeft4567_u_32x4, constantChannels_u_32x4), inputPositionsTop4567_u_32x4, constantInputStrideElements_u_32x4);
5132 vst1q_u32(topLeftOffsetsElements + 4, topLeftOffsetsElements4567_u_32x4);
5134 const uint32x4_t bottomLeftOffsetsElements0123_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsLeft0123_u_32x4, constantChannels_u_32x4), inputPositionsBottom0123_u_32x4, constantInputStrideElements_u_32x4);
5135 vst1q_u32(bottomLeftOffsetsElements + 0, bottomLeftOffsetsElements0123_u_32x4);
5136 const uint32x4_t bottomLeftOffsetsElements4567_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsLeft4567_u_32x4, constantChannels_u_32x4), inputPositionsBottom4567_u_32x4, constantInputStrideElements_u_32x4);
5137 vst1q_u32(bottomLeftOffsetsElements + 4, bottomLeftOffsetsElements4567_u_32x4);
5141 float32x4_t tx0123_f_32x4 = vmulq_f32(vsubq_f32(inputPositionsX0123_f_32x4, vcvtq_f32_u32(inputPositionsLeft0123_u_32x4)), constant128_f_32x4);
5142 float32x4_t tx4567_f_32x4 = vmulq_f32(vsubq_f32(inputPositionsX4567_f_32x4, vcvtq_f32_u32(inputPositionsLeft4567_u_32x4)), constant128_f_32x4);
5144 float32x4_t ty0123_f_32x4 = vmulq_f32(vsubq_f32(inputPositionsY0123_f_32x4, vcvtq_f32_u32(inputPositionsTop0123_u_32x4)), constant128_f_32x4);
5145 float32x4_t ty4567_f_32x4 = vmulq_f32(vsubq_f32(inputPositionsY4567_f_32x4, vcvtq_f32_u32(inputPositionsTop4567_u_32x4)), constant128_f_32x4);
5147 const uint32x4_t tx0123_128_u_32x4 = vcvtq_u32_f32(vaddq_f32(tx0123_f_32x4, vdupq_n_f32(0.5)));
5148 const uint32x4_t tx4567_128_u_32x4 = vcvtq_u32_f32(vaddq_f32(tx4567_f_32x4, vdupq_n_f32(0.5)));
5150 const uint32x4_t ty0123_128_u_32x4 = vcvtq_u32_f32(vaddq_f32(ty0123_f_32x4, vdupq_n_f32(0.5)));
5151 const uint32x4_t ty4567_128_u_32x4 = vcvtq_u32_f32(vaddq_f32(ty4567_f_32x4, vdupq_n_f32(0.5)));
5153 const uint16x8_t tx01234567_128_u_16x8 = vcombine_u16(vmovn_u32(tx0123_128_u_32x4), vmovn_u32(tx4567_128_u_32x4));
5154 const uint16x8_t ty01234567_128_u_16x8 = vcombine_u16(vmovn_u32(ty0123_128_u_32x4), vmovn_u32(ty4567_128_u_32x4));
5156 const uint8x16_t tx_ty_128_u_8x16 = vcombine_u8(vmovn_u16(tx01234567_128_u_16x8), vmovn_u16(ty01234567_128_u_16x8));
5159 vst1q_u8(pixels + 0, constantBorderColor_u_8x16);
5160 vst1q_u8(pixels + 16, constantBorderColor_u_8x16);
5162 struct LeftRightPixel
5168 static_assert(
sizeof(LeftRightPixel) == 2,
"Invalid data type!");
5172 for (
unsigned int i = 0u; i < 8u; ++i)
5176 ocean_assert((topLeftOffsetsElements[i] % inputStrideElements) < inputWidth - 1u);
5177 ocean_assert((bottomLeftOffsetsElements[i] % inputStrideElements) < inputWidth - 1u);
5179 ((LeftRightPixel*)pixels)[0u + i] = *(LeftRightPixel*)(input + topLeftOffsetsElements[i]);
5180 ((LeftRightPixel*)pixels)[8u + i] = *(LeftRightPixel*)(input + bottomLeftOffsetsElements[i]);
5184 const uint8x8x2_t topLeft_topRight_u_8x8x2 = vld2_u8(pixels);
5185 const uint8x8x2_t bottomLeft_bottomRight_u_8x8x2 = vld2_u8(pixels + 16);
5187 interpolate8Pixels1Channel8BitNEON(topLeft_topRight_u_8x8x2.val[0], topLeft_topRight_u_8x8x2.val[1], bottomLeft_bottomRight_u_8x8x2.val[0], bottomLeft_bottomRight_u_8x8x2.val[1], tx_ty_128_u_8x16, outputPixelData);
5189 outputPixelData += 8;
5194template <
unsigned int tChannels>
5195void FrameInterpolatorBilinear::lookup8BitPerChannelSubsetNEON(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable* input_LT_output,
const bool offset,
const uint8_t* borderColor, uint8_t* output,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows,
const bool useOptimizedNEON,
const bool useOptimizedBilinearValuesAndFactorCalculation,
const bool useOptimizedNEONFactorReplication, [[maybe_unused]]
const bool use4ChannelSamplingFastPaths)
5197 ocean_assert(input_LT_output !=
nullptr);
5198 ocean_assert(input !=
nullptr && output !=
nullptr);
5200 ocean_assert(inputWidth != 0u && inputHeight != 0u);
5201 ocean_assert(firstRow + numberRows <= input_LT_output->sizeY());
5205 const uint8_t zeroColor[tChannels] = {uint8_t(0)};
5206 const PixelType*
const bColor = borderColor ? (PixelType*)borderColor : (PixelType*)zeroColor;
5212 const unsigned int outputWidth = (
unsigned int)(input_LT_output->
sizeX());
5214 if (
size_t(outputWidth) != input_LT_output->
sizeX())
5216 ocean_assert(
false &&
"Lookup table is wider than 32 bits!");
5220 ocean_assert(outputWidth >= 4u);
5222 static_assert(std::is_same<Vector2, LookupTable::Type>::value,
"Invalid data type!");
5224 const unsigned int inputStrideElements = inputWidth * tChannels + inputPaddingElements;
5225 const unsigned int outputStrideElements = outputWidth * tChannels + outputPaddingElements;
5230 if (rowLookupData ==
nullptr)
5234 ocean_assert(
false &&
"Failed to allocate the row lookup buffer!");
5238 const float32x4_t constantZero_f_32x4 = vdupq_n_f32(0.0f);
5239 const float32x4_t constantFour_f_32x4 = vdupq_n_f32(4.0f);
5242 const float f_0123[4] = {0.0f, 1.0f, 2.0f, 3.0f};
5243 float32x4_t conststant0123_f_32x4 = vld1q_f32(f_0123);
5245 const uint32x4_t constantOne_u_32x4 = vdupq_n_u32(1u);
5247 const uint32x4_t constantChannels_u_32x4 = vdupq_n_u32(tChannels);
5249 const float32x4_t constantInputWidth1_f_32x4 = vdupq_n_f32(
float(inputWidth - 1u));
5250 const float32x4_t constantInputHeight1_f_32x4 = vdupq_n_f32(
float(inputHeight - 1u));
5252#if defined(__aarch64__)
5253 const float32x4_t constant128_f_32x4 = vdupq_n_f32(128.0f);
5256 const uint32x4_t constantInputStrideElements_u_32x4 = vdupq_n_u32(inputStrideElements);
5257 const uint32x4_t constantInputWidth1_u_32x4 = vdupq_n_u32(inputWidth - 1u);
5258 const uint32x4_t constantInputHeight1_u_32x4 = vdupq_n_u32(inputHeight - 1u);
5260 unsigned int validPixels[4];
5262 unsigned int topLeftOffsetsElements[4];
5263 unsigned int topRightOffsetsElements[4];
5264 unsigned int bottomLeftOffsetsElements[4];
5265 unsigned int bottomRightOffsetsElements[4];
5267 for (
unsigned int y = firstRow; y < firstRow + numberRows; ++y)
5269 PixelType* outputPixelData = (PixelType*)(output + y * outputStrideElements);
5271 input_LT_output->
bilinearValues<
VectorF2>(y, rowLookupData, useOptimizedBilinearValuesAndFactorCalculation);
5273 float32x4_t additionalInputOffsetX_f_32x4 = conststant0123_f_32x4;
5274 const float32x4_t additionalInputOffsetY_f_32x4 = vdupq_n_f32(
float(y));
5276 for (
unsigned int x = 0u; x < outputWidth; x += 4u)
5278 if (x + 4u > outputWidth)
5283 ocean_assert(x >= 4u && outputWidth > 4u);
5284 const unsigned int newX = outputWidth - 4u;
5286 ocean_assert(x > newX);
5287 const unsigned int xOffset = x - newX;
5289 outputPixelData -= xOffset;
5293 additionalInputOffsetX_f_32x4 = vsubq_f32(additionalInputOffsetX_f_32x4, vdupq_n_f32(
float(xOffset)));
5299 ocean_assert(!(x + 4u < outputWidth));
5302 const float32x4x2_t inputPositions_f_32x4x2 = vld2q_f32((
const float*)(rowLookupData + x));
5304 float32x4_t inputPositionsX_f_32x4 = inputPositions_f_32x4x2.val[0];
5305 float32x4_t inputPositionsY_f_32x4 = inputPositions_f_32x4x2.val[1];
5309 inputPositionsX_f_32x4 = vaddq_f32(inputPositionsX_f_32x4, additionalInputOffsetX_f_32x4);
5310 inputPositionsY_f_32x4 = vaddq_f32(inputPositionsY_f_32x4, additionalInputOffsetY_f_32x4);
5312 additionalInputOffsetX_f_32x4 = vaddq_f32(additionalInputOffsetX_f_32x4, constantFour_f_32x4);
5316 const uint32x4_t validPixelsX_u_32x4 = vandq_u32(vcleq_f32(inputPositionsX_f_32x4, constantInputWidth1_f_32x4), vcgeq_f32(inputPositionsX_f_32x4, constantZero_f_32x4));
5317 const uint32x4_t validPixelsY_u_32x4 = vandq_u32(vcleq_f32(inputPositionsY_f_32x4, constantInputHeight1_f_32x4), vcgeq_f32(inputPositionsY_f_32x4, constantZero_f_32x4));
5319 const uint32x4_t validPixels_u_32x4 = vandq_u32(validPixelsX_u_32x4, validPixelsY_u_32x4);
5321 vst1q_u32(validPixels, validPixels_u_32x4);
5323 const uint32x4_t inputPositionsLeft_u_32x4 = vcvtq_u32_f32(inputPositionsX_f_32x4);
5324 const uint32x4_t inputPositionsTop_u_32x4 = vcvtq_u32_f32(inputPositionsY_f_32x4);
5326 const uint32x4_t inputPositionsRight_u_32x4 = vminq_u32(vaddq_u32(inputPositionsLeft_u_32x4, constantOne_u_32x4), constantInputWidth1_u_32x4);
5327 const uint32x4_t inputPositionsBottom_u_32x4 = vminq_u32(vaddq_u32(inputPositionsTop_u_32x4, constantOne_u_32x4), constantInputHeight1_u_32x4);
5329 const uint32x4_t topLeftOffsetsElements_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsLeft_u_32x4, constantChannels_u_32x4), inputPositionsTop_u_32x4, constantInputStrideElements_u_32x4);
5330 const uint32x4_t bottomLeftOffsetsElements_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsLeft_u_32x4, constantChannels_u_32x4), inputPositionsBottom_u_32x4, constantInputStrideElements_u_32x4);
5333 uint32x4_t tx_128_u_32x4;
5334 uint32x4_t ty_128_u_32x4;
5336#if defined(__aarch64__)
5338 if (useOptimizedBilinearValuesAndFactorCalculation)
5341 const float32x4_t tx_f_32x4 = vmulq_f32(vsubq_f32(inputPositionsX_f_32x4, vrndmq_f32(inputPositionsX_f_32x4)), constant128_f_32x4);
5342 const float32x4_t ty_f_32x4 = vmulq_f32(vsubq_f32(inputPositionsY_f_32x4, vrndmq_f32(inputPositionsY_f_32x4)), constant128_f_32x4);
5344 tx_128_u_32x4 = vcvtaq_u32_f32(tx_f_32x4);
5345 ty_128_u_32x4 = vcvtaq_u32_f32(ty_f_32x4);
5351 float32x4_t tx_f_32x4 = vsubq_f32(inputPositionsX_f_32x4, vcvtq_f32_u32(inputPositionsLeft_u_32x4));
5352 float32x4_t ty_f_32x4 = vsubq_f32(inputPositionsY_f_32x4, vcvtq_f32_u32(inputPositionsTop_u_32x4));
5355 tx_f_32x4 = vmulq_f32(tx_f_32x4, vdupq_n_f32(128.0f));
5356 ty_f_32x4 = vmulq_f32(ty_f_32x4, vdupq_n_f32(128.0f));
5358 tx_128_u_32x4 = vcvtq_u32_f32(vaddq_f32(tx_f_32x4, vdupq_n_f32(0.5)));
5359 ty_128_u_32x4 = vcvtq_u32_f32(vaddq_f32(ty_f_32x4, vdupq_n_f32(0.5)));
5362 if constexpr (tChannels == 4u)
5364 if (useOptimizedNEON)
5366#if defined(__aarch64__) && defined(__APPLE__)
5367 if (use4ChannelSamplingFastPaths)
5369 const uint32x4_t pairValid_u_32x4 = vandq_u32(validPixels_u_32x4, vcltq_u32(inputPositionsLeft_u_32x4, constantInputWidth1_u_32x4));
5370 if (vminvq_u32(pairValid_u_32x4) == 0xffffffffu)
5372 const auto loadPair = [](
const uint8_t* p) -> uint64_t
5375 __builtin_memcpy(&value, p,
sizeof(value));
5378 const uint64x2_t top01_u_64x2 = {loadPair(input + vgetq_lane_u32(topLeftOffsetsElements_u_32x4, 0)), loadPair(input + vgetq_lane_u32(topLeftOffsetsElements_u_32x4, 1))};
5379 const uint64x2_t top23_u_64x2 = {loadPair(input + vgetq_lane_u32(topLeftOffsetsElements_u_32x4, 2)), loadPair(input + vgetq_lane_u32(topLeftOffsetsElements_u_32x4, 3))};
5380 const uint64x2_t bottom01_u_64x2 = {loadPair(input + vgetq_lane_u32(bottomLeftOffsetsElements_u_32x4, 0)), loadPair(input + vgetq_lane_u32(bottomLeftOffsetsElements_u_32x4, 1))};
5381 const uint64x2_t bottom23_u_64x2 = {loadPair(input + vgetq_lane_u32(bottomLeftOffsetsElements_u_32x4, 2)), loadPair(input + vgetq_lane_u32(bottomLeftOffsetsElements_u_32x4, 3))};
5382 const uint8x16_t topLeftPixels_u_8x16 = vreinterpretq_u8_u32(vuzp1q_u32(vreinterpretq_u32_u64(top01_u_64x2), vreinterpretq_u32_u64(top23_u_64x2)));
5383 const uint8x16_t topRightPixels_u_8x16 = vreinterpretq_u8_u32(vuzp2q_u32(vreinterpretq_u32_u64(top01_u_64x2), vreinterpretq_u32_u64(top23_u_64x2)));
5384 const uint8x16_t bottomLeftPixels_u_8x16 = vreinterpretq_u8_u32(vuzp1q_u32(vreinterpretq_u32_u64(bottom01_u_64x2), vreinterpretq_u32_u64(bottom23_u_64x2)));
5385 const uint8x16_t bottomRightPixels_u_8x16 = vreinterpretq_u8_u32(vuzp2q_u32(vreinterpretq_u32_u64(bottom01_u_64x2), vreinterpretq_u32_u64(bottom23_u_64x2)));
5386 interpolate4Pixels4Channel8BitPerChannelNEON(topLeftPixels_u_8x16, topRightPixels_u_8x16, bottomLeftPixels_u_8x16, bottomRightPixels_u_8x16, tx_128_u_32x4, ty_128_u_32x4, outputPixelData, useOptimizedNEONFactorReplication);
5387 outputPixelData += 4;
5390 if (borderColor ==
nullptr && vmaxvq_u32(validPixels_u_32x4) == 0u)
5392 static_assert(
sizeof(PixelType) == 4u,
"Invalid pixel size!");
5393 vst1q_u8((uint8_t*)outputPixelData, vdupq_n_u8(0u));
5394 outputPixelData += 4;
5404 const uint32x4_t topRightOffsetsElements_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsRight_u_32x4, constantChannels_u_32x4), inputPositionsTop_u_32x4, constantInputStrideElements_u_32x4);
5405 const uint32x4_t bottomRightOffsetsElements_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsRight_u_32x4, constantChannels_u_32x4), inputPositionsBottom_u_32x4, constantInputStrideElements_u_32x4);
5407 PixelType topLeftPixels[4];
5408 PixelType topRightPixels[4];
5409 PixelType bottomLeftPixels[4];
5410 PixelType bottomRightPixels[4];
5412 topLeftPixels[0] = validPixels[0] ? *((
const PixelType*)(input + vgetq_lane_u32(topLeftOffsetsElements_u_32x4, 0))) : *bColor;
5413 topLeftPixels[1] = validPixels[1] ? *((
const PixelType*)(input + vgetq_lane_u32(topLeftOffsetsElements_u_32x4, 1))) : *bColor;
5414 topLeftPixels[2] = validPixels[2] ? *((
const PixelType*)(input + vgetq_lane_u32(topLeftOffsetsElements_u_32x4, 2))) : *bColor;
5415 topLeftPixels[3] = validPixels[3] ? *((
const PixelType*)(input + vgetq_lane_u32(topLeftOffsetsElements_u_32x4, 3))) : *bColor;
5417 topRightPixels[0] = validPixels[0] ? *((
const PixelType*)(input + vgetq_lane_u32(topRightOffsetsElements_u_32x4, 0))) : *bColor;
5418 topRightPixels[1] = validPixels[1] ? *((
const PixelType*)(input + vgetq_lane_u32(topRightOffsetsElements_u_32x4, 1))) : *bColor;
5419 topRightPixels[2] = validPixels[2] ? *((
const PixelType*)(input + vgetq_lane_u32(topRightOffsetsElements_u_32x4, 2))) : *bColor;
5420 topRightPixels[3] = validPixels[3] ? *((
const PixelType*)(input + vgetq_lane_u32(topRightOffsetsElements_u_32x4, 3))) : *bColor;
5422 bottomLeftPixels[0] = validPixels[0] ? *((
const PixelType*)(input + vgetq_lane_u32(bottomLeftOffsetsElements_u_32x4, 0))) : *bColor;
5423 bottomLeftPixels[1] = validPixels[1] ? *((
const PixelType*)(input + vgetq_lane_u32(bottomLeftOffsetsElements_u_32x4, 1))) : *bColor;
5424 bottomLeftPixels[2] = validPixels[2] ? *((
const PixelType*)(input + vgetq_lane_u32(bottomLeftOffsetsElements_u_32x4, 2))) : *bColor;
5425 bottomLeftPixels[3] = validPixels[3] ? *((
const PixelType*)(input + vgetq_lane_u32(bottomLeftOffsetsElements_u_32x4, 3))) : *bColor;
5427 bottomRightPixels[0] = validPixels[0] ? *((
const PixelType*)(input + vgetq_lane_u32(bottomRightOffsetsElements_u_32x4, 0))) : *bColor;
5428 bottomRightPixels[1] = validPixels[1] ? *((
const PixelType*)(input + vgetq_lane_u32(bottomRightOffsetsElements_u_32x4, 1))) : *bColor;
5429 bottomRightPixels[2] = validPixels[2] ? *((
const PixelType*)(input + vgetq_lane_u32(bottomRightOffsetsElements_u_32x4, 2))) : *bColor;
5430 bottomRightPixels[3] = validPixels[3] ? *((
const PixelType*)(input + vgetq_lane_u32(bottomRightOffsetsElements_u_32x4, 3))) : *bColor;
5432 const uint8x16_t topLeftPixels_u8x16 = vld1q_u8((
const uint8_t*)topLeftPixels);
5433 const uint8x16_t topRightPixels_u8x16 = vld1q_u8((
const uint8_t*)topRightPixels);
5434 const uint8x16_t bottomLeftPixels_u8x16 = vld1q_u8((
const uint8_t*)bottomLeftPixels);
5435 const uint8x16_t bottomRightPixels_u8x16 = vld1q_u8((
const uint8_t*)bottomRightPixels);
5437 interpolate4Pixels4Channel8BitPerChannelNEON(topLeftPixels_u8x16, topRightPixels_u8x16, bottomLeftPixels_u8x16, bottomRightPixels_u8x16, tx_128_u_32x4, ty_128_u_32x4, outputPixelData, useOptimizedNEONFactorReplication);
5441 const uint32x4_t topRightOffsetsElements_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsRight_u_32x4, constantChannels_u_32x4), inputPositionsTop_u_32x4, constantInputStrideElements_u_32x4);
5442 const uint32x4_t bottomRightOffsetsElements_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsRight_u_32x4, constantChannels_u_32x4), inputPositionsBottom_u_32x4, constantInputStrideElements_u_32x4);
5444 vst1q_u32(topLeftOffsetsElements, topLeftOffsetsElements_u_32x4);
5445 vst1q_u32(topRightOffsetsElements, topRightOffsetsElements_u_32x4);
5446 vst1q_u32(bottomLeftOffsetsElements, bottomLeftOffsetsElements_u_32x4);
5447 vst1q_u32(bottomRightOffsetsElements, bottomRightOffsetsElements_u_32x4);
5454 const uint32x4_t topRightOffsetsElements_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsRight_u_32x4, constantChannels_u_32x4), inputPositionsTop_u_32x4, constantInputStrideElements_u_32x4);
5455 const uint32x4_t bottomRightOffsetsElements_u_32x4 = vmlaq_u32(vmulq_u32(inputPositionsRight_u_32x4, constantChannels_u_32x4), inputPositionsBottom_u_32x4, constantInputStrideElements_u_32x4);
5457 vst1q_u32(topLeftOffsetsElements, topLeftOffsetsElements_u_32x4);
5458 vst1q_u32(topRightOffsetsElements, topRightOffsetsElements_u_32x4);
5459 vst1q_u32(bottomLeftOffsetsElements, bottomLeftOffsetsElements_u_32x4);
5460 vst1q_u32(bottomRightOffsetsElements, bottomRightOffsetsElements_u_32x4);
5465 outputPixelData += 4;
5472template <
unsigned int tChannels>
5473void FrameInterpolatorBilinear::lookupMask8BitPerChannelSubset(
const uint8_t* input,
const unsigned int inputWidth,
const unsigned int inputHeight,
const LookupTable* input_LT_output,
const bool offset, uint8_t* output, uint8_t* outputMask,
const uint8_t maskValue,
const unsigned int inputPaddingElements,
const unsigned int outputPaddingElements,
const unsigned int outputMaskPaddingElements,
const unsigned int firstRow,
const unsigned int numberRows)
5475 ocean_assert(input_LT_output !=
nullptr);
5476 ocean_assert(input !=
nullptr && output !=
nullptr);
5478 ocean_assert(inputWidth != 0u && inputHeight != 0u);
5479 ocean_assert(firstRow + numberRows <= input_LT_output->sizeY());
5487 const unsigned int columns = (
unsigned int)(input_LT_output->
sizeX());
5489 if (
size_t(columns) != input_LT_output->
sizeX())
5491 ocean_assert(
false &&
"Lookup table is wider than 32 bits!");
5495 const unsigned int outputStrideElements = tChannels * columns + outputPaddingElements;
5496 const unsigned int outputMaskStrideElements = columns + outputMaskPaddingElements;
5498 static_assert(std::is_same<Vector2, LookupTable::Type>::value,
"Invalid data type!");
5506 if (rowLookupData ==
nullptr)
5510 ocean_assert(
false &&
"Failed to allocate the row lookup buffer!");
5514 for (
unsigned int y = firstRow; y < firstRow + numberRows; ++y)
5518 PixelType* outputData = (PixelType*)(output + y * outputStrideElements);
5519 uint8_t* outputMaskData = outputMask + y * outputMaskStrideElements;
5521 for (
unsigned int x = 0u; x < columns; ++x)
5523 const Vector2& lookupValue = rowLookupData[x];
5527 if (inputPosition.
x() >= 0 && inputPosition.
y() >= 0 && inputPosition.
x() <= inputWidth1 && inputPosition.
y() <= inputHeight1)
5530 *outputMaskData = maskValue;
5534 *outputMaskData = 0xFFu - maskValue;
5543template <
unsigned int tChannels>
5544void FrameInterpolatorBilinear::scale8BitPerChannel(
const uint8_t* source, uint8_t* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
Worker* worker)
5546 ocean_assert(source !=
nullptr && target !=
nullptr);
5547 ocean_assert(sourceWidth >= 1u && sourceHeight >= 1u);
5548 ocean_assert(targetWidth >= 1u && targetHeight >= 1u);
5549 ocean_assert(sourceX_s_targetX > 0.0);
5550 ocean_assert(sourceY_s_targetY > 0.0);
5552 if (sourceWidth == targetWidth && sourceHeight == targetHeight && sourceX_s_targetX == 1.0 && sourceY_s_targetY == 1.0)
5554 FrameConverter::subFrame<uint8_t>(source, target, sourceWidth, sourceHeight, targetWidth, targetHeight, tChannels, 0u, 0u, 0u, 0u, sourceWidth, sourceHeight, sourcePaddingElements, targetPaddingElements);
5558 if (worker && sourceWidth * tChannels >= 16u && targetWidth >= 8u)
5560#if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
5561 if (sourceWidth <= 65535u && sourceHeight <= 65535u && targetWidth <= 65535u && targetHeight <= 65535u)
5563 worker->
executeFunction(
Worker::Function::createStatic(&
scale8BitPerChannelSubset7BitPrecisionNEON, source, target, sourceWidth, sourceHeight, targetWidth, targetHeight, tChannels, sourceX_s_targetX, sourceY_s_targetY, sourcePaddingElements, targetPaddingElements, 0u, 0u), 0u, targetHeight);
5567 worker->
executeFunction(
Worker::Function::createStatic(&
scale8BitPerChannelSubset<tChannels>, source, target, sourceWidth, sourceHeight, targetWidth, targetHeight, sourceX_s_targetX, sourceY_s_targetY, sourcePaddingElements, targetPaddingElements, 0u, 0u), 0u, targetHeight);
5572 if (sourceWidth * tChannels >= 16u && targetWidth >= 8u)
5574#if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
5575 if (sourceWidth <= 65535u && sourceHeight <= 65535u && targetWidth <= 65535u && targetHeight <= 65535u)
5577 scale8BitPerChannelSubset7BitPrecisionNEON(source, target, sourceWidth, sourceHeight, targetWidth, targetHeight, tChannels, sourceX_s_targetX, sourceY_s_targetY, sourcePaddingElements, targetPaddingElements, 0u, targetHeight);
5583 scale8BitPerChannelSubset<tChannels>(source, target, sourceWidth, sourceHeight, targetWidth, targetHeight, sourceX_s_targetX, sourceY_s_targetY, sourcePaddingElements, targetPaddingElements, 0u, targetHeight);
5587template <
unsigned int tChannels>
5588void FrameInterpolatorBilinear::scale8BitPerChannelSubset(
const uint8_t* source, uint8_t* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows)
5590 ocean_assert(source !=
nullptr && target !=
nullptr);
5591 ocean_assert(sourceWidth != 0u && sourceHeight != 0u);
5592 ocean_assert_and_suppress_unused(targetWidth >= 1u && targetHeight >= 1u, targetHeight);
5593 ocean_assert(sourceX_s_targetX > 0.0 && sourceY_s_targetY > 0.0);
5595 const Scalar sourceX_T_targetX =
Scalar(sourceX_s_targetX);
5596 const Scalar sourceY_T_targetY =
Scalar(sourceY_s_targetY);
5644 const unsigned int sourceStrideElements = sourceWidth * tChannels + sourcePaddingElements;
5646 const Scalar sourceX_T_targetXOffset = sourceX_T_targetX *
Scalar(0.5) -
Scalar(0.5);
5647 const Scalar sourceY_T_targetYOffset = sourceY_T_targetY *
Scalar(0.5) -
Scalar(0.5);
5650 const Scalar sourceHeight_1 =
Scalar(sourceHeight - 1u);
5652 target += (targetWidth * tChannels + targetPaddingElements) * firstTargetRow;
5654 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
5657 ocean_assert(sy >=
Scalar(0) && sy <
Scalar(sourceHeight));
5659 const unsigned int sTop = (
unsigned int)sy;
5660 ocean_assert(sy >=
Scalar(sTop));
5663 ocean_assert(ty >= 0 && ty <= 1);
5665 const unsigned int factorBottom = (
unsigned int)(ty *
Scalar(128) +
Scalar(0.5));
5666 const unsigned int factorTop = 128u - factorBottom;
5668 const uint8_t*
const sourceTop = source + sourceStrideElements * sTop;
5669 const uint8_t*
const sourceBottom = (sTop + 1u < sourceHeight) ? sourceTop + sourceStrideElements : sourceTop;
5671 for (
unsigned int x = 0; x < targetWidth; ++x)
5674 ocean_assert(sx >=
Scalar(0) && sx <
Scalar(sourceWidth));
5676 const unsigned int sLeft = (
unsigned int)sx;
5677 ocean_assert(sx >=
Scalar(sLeft));
5680 ocean_assert(tx >= 0 && tx <= 1);
5682 const unsigned int factorRight = (
unsigned int)(tx *
Scalar(128) +
Scalar(0.5));
5683 const unsigned int factorLeft = 128u - factorRight;
5685 const unsigned int sourceRightOffset = sLeft + 1u < sourceWidth ? tChannels : 0u;
5687 const uint8_t*
const sourceTopLeft = sourceTop + sLeft * tChannels;
5688 const uint8_t*
const sourceBottomLeft = sourceBottom + sLeft * tChannels;
5690 const unsigned int factorTopLeft = factorTop * factorLeft;
5691 const unsigned int factorTopRight = factorTop * factorRight;
5692 const unsigned int factorBottomLeft = factorBottom * factorLeft;
5693 const unsigned int factorBottomRight = factorBottom * factorRight;
5695 for (
unsigned int n = 0u; n < tChannels; ++n)
5697 target[n] = (uint8_t)((sourceTopLeft[n] * factorTopLeft + sourceTopLeft[sourceRightOffset + n] * factorTopRight
5698 + sourceBottomLeft[n] * factorBottomLeft + sourceBottomLeft[sourceRightOffset + n] * factorBottomRight + 8192u) >> 14u);
5701 target += tChannels;
5704 target += targetPaddingElements;
5708template <
typename T>
5711 ocean_assert(sourceRowTop !=
nullptr);
5712 ocean_assert(sourceRowBottom !=
nullptr);
5713 ocean_assert(targetRow !=
nullptr);
5714 ocean_assert(elements >= 1u);
5715 ocean_assert(factorBottom >= 0.0f && factorBottom <= 1.0f);
5719 const FloatType internalFactorBottom = FloatType(factorBottom);
5720 const FloatType internalFactorTop = FloatType(1.0f - factorBottom);
5722 for (
unsigned int n = 0u; n < elements; ++n)
5724 targetRow[n] = T(FloatType(sourceRowTop[n]) * internalFactorTop + FloatType(sourceRowBottom[n]) * internalFactorBottom);
5728template <
typename T,
unsigned int tChannels>
5731 static_assert(tChannels != 0u,
"Invalid channel number!");
5733 ocean_assert(extendedSourceRow !=
nullptr);
5734 ocean_assert(targetRow !=
nullptr);
5735 ocean_assert(targetWidth >= 1u);
5736 ocean_assert(interpolationLocations !=
nullptr);
5737 ocean_assert(interpolationFactorsRight !=
nullptr);
5738 ocean_assert_and_suppress_unused(channels == tChannels, channels);
5742 for (
unsigned int x = 0u; x < targetWidth; ++x)
5744 const FloatType internalFactorRight = FloatType(interpolationFactorsRight[x]);
5745 ocean_assert(internalFactorRight >= FloatType(0) && internalFactorRight <= FloatType(1));
5747 const FloatType internalFactorLeft = FloatType(1.0f - interpolationFactorsRight[x]);
5749 const unsigned int& leftLocation = interpolationLocations[x];
5750 const unsigned int rightLocation = leftLocation + tChannels;
5752 for (
unsigned int n = 0u; n < tChannels; ++n)
5754 targetRow[x * tChannels + n] = T(FloatType(extendedSourceRow[leftLocation + n]) * internalFactorLeft + FloatType(extendedSourceRow[rightLocation + n]) * internalFactorRight);
5759#if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
5761#ifdef OCEAN_WE_KEEP_THIS_IMPLEMENTATION_AS_WE_NEED_THIS_TO_FOR_A_NEW_NEON_IMPLEMENTATION
5764inline void FrameInterpolatorBilinear::scale8BitPerChannelSubset7BitPrecisionNEON<2u, 8u>(
const uint8_t* source, uint8_t* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows)
5766 ocean_assert(source !=
nullptr && target !=
nullptr);
5767 ocean_assert(sourceWidth >= 2u && sourceWidth <= 65535u);
5768 ocean_assert(sourceHeight >= 1u && sourceHeight <= 65535u);
5769 ocean_assert(targetWidth >= 8u && targetWidth <= 65535u);
5770 ocean_assert(targetHeight >= 1u && targetHeight <= 65535u);
5771 ocean_assert(sourceX_s_targetX > 0.0 && sourceY_s_targetY > 0.0);
5773 ocean_assert(sourcePaddingElements == 0u);
5774 ocean_assert(targetPaddingElements == 0u);
5778 PixelType* targetPixelData = (PixelType*)target + firstTargetRow * targetWidth;
5779 const PixelType*
const sourcePixelData = (
const PixelType*)source;
5782 unsigned int leftOffsets[8];
5795 const unsigned int sourceX_T_targetX_fixed16 = (
unsigned int)(
double(0x10000u) * sourceX_s_targetX + 0.5);
5796 const unsigned int sourceY_T_targetY_fixed16 = (
unsigned int)(
double(0x10000u) * sourceY_s_targetY + 0.5);
5798 const int targetOffsetX_fixed16 = (int)(
double(0x10000u) * ((sourceX_s_targetX * 0.5) - 0.5) + 0.5);
5799 const int targetOffsetY_fixed16 = (int)(
double(0x10000u) * ((sourceY_s_targetY * 0.5) - 0.5) + 0.5);
5802 const uint32x4_t m128_u_sourceX_T_targetX_fixed16 = vdupq_n_u32(sourceX_T_targetX_fixed16);
5805 const int32x4_t m128_s_targetOffsetX_fixed16 = vdupq_n_s32(targetOffsetX_fixed16);
5808 const uint32x4_t m128_u_sourceWidth_2 = vdupq_n_u32(sourceWidth - 2u);
5811 const int32x4_t m128_s_zero = vdupq_n_s32(0);
5813 const unsigned int u_0123[4] = {0u, 1u, 2u, 3u};
5814 const uint32x4_t m128_u_0123 = vld1q_u32(u_0123);
5816 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
5818 const unsigned int sourceY_fixed16 =
minmax<int>(0, targetOffsetY_fixed16 +
int(sourceY_T_targetY_fixed16 * y), (sourceHeight - 1u) << 16u);
5820 const unsigned int sourceRowTop = sourceY_fixed16 >> 16u;
5821 const unsigned int factorBottom_fixed16 = sourceY_fixed16 & 0x0000FFFFu;
5822 const unsigned int factorBottom = factorBottom_fixed16 >> 9u;
5824 const uint8x8_t m64_u_factorsBottom = vdup_n_u8(factorBottom);
5826 const uint8x8_t m64_u_factorsTop = vdup_n_u8(128u - factorBottom);
5828 const unsigned int sourceRowBottom = min(sourceRowTop + 1u, sourceHeight - 1u);
5830 const PixelType*
const sourceTopRowPixelData = sourcePixelData + sourceRowTop * sourceWidth;
5831 const PixelType*
const sourceBottomRowPixelData = sourcePixelData + sourceRowBottom * sourceWidth;
5833 for (
unsigned int x = 0; x < targetWidth; x += 8u)
5835 if (x + 8u > targetWidth)
5840 ocean_assert(x >= 8u && targetWidth > 8u);
5841 const unsigned int newX = targetWidth - 8u;
5843 ocean_assert(x > newX);
5844 targetPixelData -= x - newX;
5849 ocean_assert(!(x + 8u < targetWidth));
5855 const uint32x4_t m128_u_x_0123 = vaddq_u32(vdupq_n_u32(x), m128_u_0123);
5856 const uint32x4_t m128_u_x_4567 = vaddq_u32(vdupq_n_u32(x + 4u), m128_u_0123);
5859 const int32x4_t m128_s_sourceX_0123_fixed16 = vmaxq_s32(m128_s_zero, vaddq_s32(m128_s_targetOffsetX_fixed16, vreinterpretq_s32_u32(vmulq_u32(m128_u_sourceX_T_targetX_fixed16, m128_u_x_0123))));
5860 const uint32x4_t m128_u_sourceX_0123_fixed16 = vreinterpretq_u32_s32(m128_s_sourceX_0123_fixed16);
5862 const int32x4_t m128_s_sourceX_4567_fixed16 = vmaxq_s32(m128_s_zero, vaddq_s32(m128_s_targetOffsetX_fixed16, vreinterpretq_s32_u32(vmulq_u32(m128_u_sourceX_T_targetX_fixed16, m128_u_x_4567))));
5863 const uint32x4_t m128_u_sourceX_4567_fixed16 = vreinterpretq_u32_s32(m128_s_sourceX_4567_fixed16);
5867 const uint32x4_t m128_u_left_0123 = vminq_u32(vshrq_n_u32(m128_u_sourceX_0123_fixed16, 16), m128_u_sourceWidth_2);
5868 const uint32x4_t m128_u_left_4567 = vminq_u32(vshrq_n_u32(m128_u_sourceX_4567_fixed16, 16), m128_u_sourceWidth_2);
5871 vst1q_u32(leftOffsets + 0, m128_u_left_0123);
5872 vst1q_u32(leftOffsets + 4, m128_u_left_4567);
5879 uint8x8x2_t topLeftPixels;
5880 uint8x8x2_t topRightPixels;
5882 topLeftPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[0u] + 0), topLeftPixels, 0);
5883 topRightPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[0u] + 1), topRightPixels, 0);
5885 topLeftPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[1u] + 0), topLeftPixels, 1);
5886 topRightPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[1u] + 1), topRightPixels, 1);
5888 topLeftPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[2u] + 0), topLeftPixels, 2);
5889 topRightPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[2u] + 1), topRightPixels, 2);
5891 topLeftPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[3u] + 0), topLeftPixels, 3);
5892 topRightPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[3u] + 1), topRightPixels, 3);
5894 topLeftPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[4u] + 0), topLeftPixels, 4);
5895 topRightPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[4u] + 1), topRightPixels, 4);
5897 topLeftPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[5u] + 0), topLeftPixels, 5);
5898 topRightPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[5u] + 1), topRightPixels, 5);
5900 topLeftPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[6u] + 0), topLeftPixels, 6);
5901 topRightPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[6u] + 1), topRightPixels, 6);
5903 topLeftPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[7u] + 0), topLeftPixels, 7);
5904 topRightPixels = vld2_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[7u] + 1), topRightPixels, 7);
5909 uint8x8x2_t bottomLeftPixels;
5910 uint8x8x2_t bottomRightPixels;
5912 bottomLeftPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[0u] + 0), bottomLeftPixels, 0);
5913 bottomRightPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[0u] + 1), bottomRightPixels, 0);
5915 bottomLeftPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[1u] + 0), bottomLeftPixels, 1);
5916 bottomRightPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[1u] + 1), bottomRightPixels, 1);
5918 bottomLeftPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[2u] + 0), bottomLeftPixels, 2);
5919 bottomRightPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[2u] + 1), bottomRightPixels, 2);
5921 bottomLeftPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[3u] + 0), bottomLeftPixels, 3);
5922 bottomRightPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[3u] + 1), bottomRightPixels, 3);
5924 bottomLeftPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[4u] + 0), bottomLeftPixels, 4);
5925 bottomRightPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[4u] + 1), bottomRightPixels, 4);
5927 bottomLeftPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[5u] + 0), bottomLeftPixels, 5);
5928 bottomRightPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[5u] + 1), bottomRightPixels, 5);
5930 bottomLeftPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[6u] + 0), bottomLeftPixels, 6);
5931 bottomRightPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[6u] + 1), bottomRightPixels, 6);
5933 bottomLeftPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[7u] + 0), bottomLeftPixels, 7);
5934 bottomRightPixels = vld2_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[7u] + 1), bottomRightPixels, 7);
5942 const uint16x4_t m64_u_factorsRight_0123 = vrshrn_n_u32(vandq_u32(m128_u_sourceX_0123_fixed16, vdupq_n_u32(0x0000FFFFu)), 9);
5943 const uint16x4_t m64_u_factorsRight_4567 = vrshrn_n_u32(vandq_u32(m128_u_sourceX_4567_fixed16, vdupq_n_u32(0x0000FFFFu)), 9);
5946 const uint16x8_t m128_u_factorsRight = vcombine_u16(m64_u_factorsRight_0123, m64_u_factorsRight_4567);
5947 const uint8x8_t m64_u_factorsRight = vqmovn_u16(m128_u_factorsRight);
5948 const uint8x8_t m64_u_factorsLeft = vsub_u8(vdup_n_u8(128u), m64_u_factorsRight);
5953 uint16x8_t m128_muliplicationChannel_0 = vmull_u8(topLeftPixels.val[0], m64_u_factorsLeft);
5954 uint16x8_t m128_muliplicationChannel_1 = vmull_u8(topLeftPixels.val[1], m64_u_factorsLeft);
5956 m128_muliplicationChannel_0 = vmlal_u8(m128_muliplicationChannel_0, topRightPixels.val[0], m64_u_factorsRight);
5957 m128_muliplicationChannel_1 = vmlal_u8(m128_muliplicationChannel_1, topRightPixels.val[1], m64_u_factorsRight);
5959 uint8x8_t m64_topRowChannel_0 = vrshrn_n_u16(m128_muliplicationChannel_0, 7);
5960 uint8x8_t m64_topRowChannel_1 = vrshrn_n_u16(m128_muliplicationChannel_1, 7);
5965 m128_muliplicationChannel_0 = vmull_u8(bottomLeftPixels.val[0], m64_u_factorsLeft);
5966 m128_muliplicationChannel_1 = vmull_u8(bottomLeftPixels.val[1], m64_u_factorsLeft);
5968 m128_muliplicationChannel_0 = vmlal_u8(m128_muliplicationChannel_0, bottomRightPixels.val[0], m64_u_factorsRight);
5969 m128_muliplicationChannel_1 = vmlal_u8(m128_muliplicationChannel_1, bottomRightPixels.val[1], m64_u_factorsRight);
5971 uint8x8_t m64_bottomRowChannel_0 = vrshrn_n_u16(m128_muliplicationChannel_0, 7);
5972 uint8x8_t m64_bottomRowChannel_1 = vrshrn_n_u16(m128_muliplicationChannel_1, 7);
5977 m128_muliplicationChannel_0 = vmull_u8(m64_topRowChannel_0, m64_u_factorsTop);
5978 m128_muliplicationChannel_1 = vmull_u8(m64_topRowChannel_1, m64_u_factorsTop);
5980 m128_muliplicationChannel_0 = vmlal_u8(m128_muliplicationChannel_0, m64_bottomRowChannel_0, m64_u_factorsBottom);
5981 m128_muliplicationChannel_1 = vmlal_u8(m128_muliplicationChannel_1, m64_bottomRowChannel_1, m64_u_factorsBottom);
5986 result.val[0] = vrshrn_n_u16(m128_muliplicationChannel_0, 7);
5987 result.val[1] = vrshrn_n_u16(m128_muliplicationChannel_1, 7);
5990 vst2_u8((uint8_t*)targetPixelData, result);
5992 targetPixelData += 8;
5998 const unsigned int firstInvalidTargetX = (((sourceWidth - 1u) << 16u) - targetOffsetX_fixed16) / sourceX_T_targetX_fixed16;
6000 for (
unsigned int x = firstInvalidTargetX; x < targetWidth; ++x)
6002 const unsigned int lastSourcePixelPosition_fixed16 =
minmax<int>(0, targetOffsetX_fixed16 +
int(sourceX_T_targetX_fixed16 * x), (sourceWidth - 1u) << 16u);
6004 const unsigned int lastSourcePixelLeft = lastSourcePixelPosition_fixed16 >> 16u;
6005 ocean_assert(lastSourcePixelLeft < sourceWidth);
6006 const unsigned int lastSourcePixelRight = min(lastSourcePixelLeft + 1u, sourceWidth - 1u);
6008 const unsigned int factorRight_fixed16 = lastSourcePixelPosition_fixed16 & 0x0000FFFFu;
6010 const unsigned int factorRight = factorRight_fixed16 >> 9u;
6011 const unsigned int factorLeft = 128u - factorRight;
6013 for (
unsigned int c = 0u; c < 2u; ++c)
6015 ((uint8_t*)(targetPixelData - (targetWidth - x)))[c] = ((((
const uint8_t*)(sourceTopRowPixelData + lastSourcePixelLeft))[c] * factorLeft + ((
const uint8_t*)(sourceTopRowPixelData + lastSourcePixelRight))[c] * factorRight) * (128u - factorBottom)
6016 + (((
const uint8_t*)(sourceBottomRowPixelData + lastSourcePixelLeft))[c] * factorLeft + ((
const uint8_t*)(sourceBottomRowPixelData + lastSourcePixelRight))[c] * factorRight) * factorBottom + 8192u) >> 14u;
6024#ifdef OCEAN_WE_KEEP_ALSO_THIS_SLOW_IMPLEMENTATION_SHOWING_A_SLIGHTLY_DIFFERENT_APPROACH
6027inline void FrameInterpolatorBilinear::scale8BitPerChannelSubset7BitPrecisionNEON<2u, 8u>(
const uint8_t* source, uint8_t* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows)
6029 ocean_assert(source !=
nullptr && target !=
nullptr);
6030 ocean_assert(sourceWidth >= 2u && sourceWidth <= 65535u);
6031 ocean_assert(sourceHeight >= 0u && sourceHeight <= 65535u);
6032 ocean_assert(targetWidth >= 8u && targetWidth <= 65535u)
6033 ocean_assert(targetHeight >= 1u && targetHeight <= 65535u);
6034 ocean_assert(sourceX_s_targetX > 0.0 && sourceY_s_targetY > 0.0);
6036 ocean_assert(sourcePaddingElements == 0u);
6037 ocean_assert(targetPaddingElements == 0u);
6039 using PixelType = typename
DataType<uint8_t, 2u>::
Type;
6041 PixelType* targetPixelData = (PixelType*)target + firstTargetRow * targetWidth;
6042 const PixelType* const sourcePixelData = (const PixelType*)source;
6045 unsigned int leftOffsets[8];
6048 unsigned int topPixels[8];
6049 unsigned int bottomPixels[8];
6062 const
unsigned int sourceX_T_targetX_fixed16 = (
unsigned int)(
double(0x10000u) * sourceX_s_targetX + 0.5);
6063 const
unsigned int sourceY_T_targetY_fixed16 = (
unsigned int)(
double(0x10000u) * sourceY_s_targetY + 0.5);
6065 const
int targetOffsetX_fixed16 = (
int)(
double(0x10000u) * ((sourceX_s_targetX * 0.5) - 0.5) + 0.5);
6066 const
int targetOffsetY_fixed16 = (
int)(
double(0x10000u) * ((sourceY_s_targetY * 0.5) - 0.5) + 0.5);
6069 const uint32x4_t m128_u_sourceX_T_targetX_fixed16 = vdupq_n_u32(sourceX_T_targetX_fixed16);
6072 const int32x4_t m128_s_targetOffsetX_fixed16 = vdupq_n_s32(targetOffsetX_fixed16);
6075 const uint32x4_t m128_u_sourceWidth_2 = vdupq_n_u32(sourceWidth - 2u);
6078 const int32x4_t m128_s_zero = vdupq_n_s32(0);
6080 const
unsigned int u_0123[4] = {0u, 1u, 2u, 3u};
6081 const uint32x4_t m128_u_0123 = vld1q_u32(u_0123);
6083 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
6085 const unsigned int sourceY_fixed16 =
minmax<int>(0, targetOffsetY_fixed16 +
int(sourceY_T_targetY_fixed16 * y), (sourceHeight - 1u) << 16u);
6087 const unsigned int sourceRowTop = sourceY_fixed16 >> 16u;
6088 const unsigned int factorBottom_fixed16 = sourceY_fixed16 & 0x0000FFFFu;
6089 const unsigned int factorBottom = factorBottom_fixed16 >> 9u;
6091 const uint8x8_t m64_u_factorsBottom = vdup_n_u8(factorBottom);
6093 const uint8x8_t m64_u_factorsTop = vdup_n_u8(128u - factorBottom);
6095 const unsigned int sourceRowBottom = min(sourceRowTop + 1u, sourceHeight - 1u);
6097 const PixelType*
const sourceTopRowPixelData = sourcePixelData + sourceRowTop * sourceWidth;
6098 const PixelType*
const sourceBottomRowPixelData = sourcePixelData + sourceRowBottom * sourceWidth;
6100 for (
unsigned int x = 0; x < targetWidth; x += 8u)
6102 if (x + 8u > targetWidth)
6107 ocean_assert(x >= 8u && targetWidth > 8u);
6108 const unsigned int newX = targetWidth - 8u;
6110 ocean_assert(x > newX);
6111 targetPixelData -= x - newX;
6116 ocean_assert(!(x + 8u < targetWidth));
6122 const uint32x4_t m128_u_x_0123 = vaddq_u32(vdupq_n_u32(x), m128_u_0123);
6123 const uint32x4_t m128_u_x_4567 = vaddq_u32(vdupq_n_u32(x + 4u), m128_u_0123);
6126 const int32x4_t m128_s_sourceX_0123_fixed16 = vmaxq_s32(m128_s_zero, vaddq_s32(m128_s_targetOffsetX_fixed16, vreinterpretq_s32_u32(vmulq_u32(m128_u_sourceX_T_targetX_fixed16, m128_u_x_0123))));
6127 const uint32x4_t m128_u_sourceX_0123_fixed16 = vreinterpretq_u32_s32(m128_s_sourceX_0123_fixed16);
6129 const int32x4_t m128_s_sourceX_4567_fixed16 = vmaxq_s32(m128_s_zero, vaddq_s32(m128_s_targetOffsetX_fixed16, vreinterpretq_s32_u32(vmulq_u32(m128_u_sourceX_T_targetX_fixed16, m128_u_x_4567))));
6130 const uint32x4_t m128_u_sourceX_4567_fixed16 = vreinterpretq_u32_s32(m128_s_sourceX_4567_fixed16);
6134 const uint32x4_t m128_u_left_0123 = vminq_u32(vshrq_n_u32(m128_u_sourceX_0123_fixed16, 16), m128_u_sourceWidth_2);
6135 const uint32x4_t m128_u_left_4567 = vminq_u32(vshrq_n_u32(m128_u_sourceX_4567_fixed16, 16), m128_u_sourceWidth_2);
6138 vst1q_u32(leftOffsets + 0, m128_u_left_0123);
6139 vst1q_u32(leftOffsets + 4, m128_u_left_4567);
6149 for (
unsigned int n = 0u; n < 8u; ++n)
6151 topPixels[n] = *(
unsigned int*)(sourceTopRowPixelData + leftOffsets[n]);
6154 const uint16x8_t m128_topPixels_0123 = vreinterpretq_u16_u32(vld1q_u32(topPixels + 0));
6155 const uint16x8_t m128_topPixels_4567 = vreinterpretq_u16_u32(vld1q_u32(topPixels + 4));
6157 for (
unsigned int n = 0u; n < 8u; ++n)
6159 bottomPixels[n] = *(
unsigned int*)(sourceBottomRowPixelData + leftOffsets[n]);
6162 const uint16x8_t m128_bottomPixels_0123 = vreinterpretq_u16_u32(vld1q_u32(bottomPixels + 0));
6163 const uint16x8_t m128_bottomPixels_4567 = vreinterpretq_u16_u32(vld1q_u32(bottomPixels + 4));
6170 const uint16x4_t m64_u_factorsRight_0123 = vrshrn_n_u32(vandq_u32(m128_u_sourceX_0123_fixed16, vdupq_n_u32(0x0000FFFFu)), 9);
6171 const uint16x4_t m64_u_factorsRight_4567 = vrshrn_n_u32(vandq_u32(m128_u_sourceX_4567_fixed16, vdupq_n_u32(0x0000FFFFu)), 9);
6174 const uint16x8_t m128_u_factorsRight = vcombine_u16(m64_u_factorsRight_0123, m64_u_factorsRight_4567);
6175 const uint8x8_t m64_u_factorsRight = vqmovn_u16(m128_u_factorsRight);
6180 const uint8x8_t m64_u_factorsLeft = vsub_u8(vdup_n_u8(128u), m64_u_factorsRight);
6187 const uint16x8x2_t m2_128_topPixelsLeftRight = vuzpq_u16(m128_topPixels_0123, m128_topPixels_4567);
6193 const uint8x8x2_t m2_64_topPixelsLeft_channels_01 = vuzp_u8(vget_low_u8(vreinterpretq_u8_u16(m2_128_topPixelsLeftRight.val[0])), vget_high_u8(vreinterpretq_u8_u16(m2_128_topPixelsLeftRight.val[0])));
6194 const uint8x8x2_t m2_64_topPixelsRight_channels_01 = vuzp_u8(vget_low_u8(vreinterpretq_u8_u16(m2_128_topPixelsLeftRight.val[1])), vget_high_u8(vreinterpretq_u8_u16(m2_128_topPixelsLeftRight.val[1])));
6196 const uint8x8_t& m64_topPixelsLeft_channel_0 = m2_64_topPixelsLeft_channels_01.val[0];
6197 const uint8x8_t& m64_topPixelsLeft_channel_1 = m2_64_topPixelsLeft_channels_01.val[1];
6199 const uint8x8_t& m64_topPixelsRight_channel_0 = m2_64_topPixelsRight_channels_01.val[0];
6200 const uint8x8_t& m64_topPixelsRight_channel_1 = m2_64_topPixelsRight_channels_01.val[1];
6204 uint16x8_t m128_muliplication_channel_0 = vmull_u8(m64_topPixelsLeft_channel_0, m64_u_factorsLeft);
6205 uint16x8_t m128_muliplication_channel_1 = vmull_u8(m64_topPixelsLeft_channel_1, m64_u_factorsLeft);
6207 m128_muliplication_channel_0 = vmlal_u8(m128_muliplication_channel_0, m64_topPixelsRight_channel_0, m64_u_factorsRight);
6208 m128_muliplication_channel_1 = vmlal_u8(m128_muliplication_channel_1, m64_topPixelsRight_channel_1, m64_u_factorsRight);
6210 const uint8x8_t m64_topRow_channel_0 = vrshrn_n_u16(m128_muliplication_channel_0, 7);
6211 const uint8x8_t m64_topRow_channel_1 = vrshrn_n_u16(m128_muliplication_channel_1, 7);
6215 const uint16x8x2_t m2_128_bottomPixelsLeftRight = vuzpq_u16(m128_bottomPixels_0123, m128_bottomPixels_4567);
6217 const uint8x8x2_t m2_64_bottomPixelsLeft_channels_01 = vuzp_u8(vget_low_u8(vreinterpretq_u8_u16(m2_128_bottomPixelsLeftRight.val[0])), vget_high_u8(vreinterpretq_u8_u16(m2_128_bottomPixelsLeftRight.val[0])));
6218 const uint8x8x2_t m2_64_bottomPixelsRight_channels_01 = vuzp_u8(vget_low_u8(vreinterpretq_u8_u16(m2_128_bottomPixelsLeftRight.val[1])), vget_high_u8(vreinterpretq_u8_u16(m2_128_bottomPixelsLeftRight.val[1])));
6220 const uint8x8_t& m64_bottomPixelsLeft_channel_0 = m2_64_bottomPixelsLeft_channels_01.val[0];
6221 const uint8x8_t& m64_bottomPixelsLeft_channel_1 = m2_64_bottomPixelsLeft_channels_01.val[1];
6223 const uint8x8_t& m64_bottomPixelsRight_channel_0 = m2_64_bottomPixelsRight_channels_01.val[0];
6224 const uint8x8_t& m64_bottomPixelsRight_channel_1 = m2_64_bottomPixelsRight_channels_01.val[1];
6228 m128_muliplication_channel_0 = vmull_u8(m64_bottomPixelsLeft_channel_0, m64_u_factorsLeft);
6229 m128_muliplication_channel_1 = vmull_u8(m64_bottomPixelsLeft_channel_1, m64_u_factorsLeft);
6231 m128_muliplication_channel_0 = vmlal_u8(m128_muliplication_channel_0, m64_bottomPixelsRight_channel_0, m64_u_factorsRight);
6232 m128_muliplication_channel_1 = vmlal_u8(m128_muliplication_channel_1, m64_bottomPixelsRight_channel_1, m64_u_factorsRight);
6234 const uint8x8_t m64_bottomRow_channel_0 = vrshrn_n_u16(m128_muliplication_channel_0, 7);
6235 const uint8x8_t m64_bottomRow_channel_1 = vrshrn_n_u16(m128_muliplication_channel_1, 7);
6239 m128_muliplication_channel_0 = vmull_u8(m64_topRow_channel_0, m64_u_factorsTop);
6240 m128_muliplication_channel_1 = vmull_u8(m64_topRow_channel_1, m64_u_factorsTop);
6242 m128_muliplication_channel_0 = vmlal_u8(m128_muliplication_channel_0, m64_bottomRow_channel_0, m64_u_factorsBottom);
6243 m128_muliplication_channel_1 = vmlal_u8(m128_muliplication_channel_1, m64_bottomRow_channel_1, m64_u_factorsBottom);
6247 uint8x8x2_t m2_64_result;
6248 m2_64_result.val[0] = vrshrn_n_u16(m128_muliplication_channel_0, 7);
6249 m2_64_result.val[1] = vrshrn_n_u16(m128_muliplication_channel_1, 7);
6252 vst2_u8((uint8_t*)targetPixelData, m2_64_result);
6254 targetPixelData += 8;
6260 const unsigned int firstInvalidTargetX = (((sourceWidth - 1u) << 16u) - targetOffsetX_fixed16) / sourceX_T_targetX_fixed16;
6262 for (
unsigned int x = firstInvalidTargetX; x < targetWidth; ++x)
6264 const unsigned int lastSourcePixelPosition_fixed16 =
minmax<int>(0, targetOffsetX_fixed16 +
int(sourceX_T_targetX_fixed16 * x), (sourceWidth - 1u) << 16u);
6266 const unsigned int lastSourcePixelLeft = lastSourcePixelPosition_fixed16 >> 16u;
6267 ocean_assert(lastSourcePixelLeft < sourceWidth);
6268 const unsigned int lastSourcePixelRight = min(lastSourcePixelLeft + 1u, sourceWidth - 1u);
6270 const unsigned int factorRight_fixed16 = lastSourcePixelPosition_fixed16 & 0x0000FFFFu;
6272 const unsigned int factorRight = factorRight_fixed16 >> 9u;
6273 const unsigned int factorLeft = 128u - factorRight;
6275 for (
unsigned int c = 0u; c < 2u; ++c)
6277 ((uint8_t*)(targetPixelData - (targetWidth - x)))[c] = ((((
const uint8_t*)(sourceTopRowPixelData + lastSourcePixelLeft))[c] * factorLeft + ((
const uint8_t*)(sourceTopRowPixelData + lastSourcePixelRight))[c] * factorRight) * (128u - factorBottom)
6278 + (((
const uint8_t*)(sourceBottomRowPixelData + lastSourcePixelLeft))[c] * factorLeft + ((
const uint8_t*)(sourceBottomRowPixelData + lastSourcePixelRight))[c] * factorRight) * factorBottom + 8192u) >> 14u;
6286#ifdef OCEAN_WE_KEEP_THIS_IMPLEMENTATION_AS_WE_NEED_THIS_TO_FOR_A_NEW_NEON_IMPLEMENTATION
6289inline void FrameInterpolatorBilinear::scale8BitPerChannelSubset7BitPrecisionNEON<3u, 8u>(
const uint8_t* source, uint8_t* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows)
6291 ocean_assert(source !=
nullptr && target !=
nullptr);
6292 ocean_assert(sourceWidth >= 2u && sourceWidth <= 65535u);
6293 ocean_assert(sourceHeight >= 1u && sourceHeight <= 65535u);
6294 ocean_assert(targetWidth >= 8u && targetWidth <= 65535u);
6295 ocean_assert(targetHeight >= 1u && targetHeight <= 65535u);
6296 ocean_assert(sourceX_s_targetX > 0.0 && sourceY_s_targetY > 0.0);
6298 ocean_assert(sourcePaddingElements == 0u);
6299 ocean_assert(targetPaddingElements == 0u);
6301 using PixelType =
typename DataType<uint8_t, 3u>::Type;
6303 PixelType* targetPixelData = (PixelType*)target + firstTargetRow * targetWidth;
6304 const PixelType*
const sourcePixelData = (
const PixelType*)source;
6307 unsigned int leftOffsets[8];
6320 const unsigned int sourceX_T_targetX_fixed16 = (
unsigned int)(
double(0x10000u) * sourceX_s_targetX + 0.5);
6321 const unsigned int sourceY_T_targetY_fixed16 = (
unsigned int)(
double(0x10000u) * sourceY_s_targetY + 0.5);
6323 const int targetOffsetX_fixed16 = (int)(
double(0x10000u) * ((sourceX_s_targetX * 0.5) - 0.5) + 0.5);
6324 const int targetOffsetY_fixed16 = (int)(
double(0x10000u) * ((sourceY_s_targetY * 0.5) - 0.5) + 0.5);
6327 const uint32x4_t m128_u_sourceX_T_targetX_fixed16 = vdupq_n_u32(sourceX_T_targetX_fixed16);
6330 const int32x4_t m128_s_targetOffsetX_fixed16 = vdupq_n_s32(targetOffsetX_fixed16);
6333 const uint32x4_t m128_u_sourceWidth_2 = vdupq_n_u32(sourceWidth - 2u);
6336 const int32x4_t m128_s_zero = vdupq_n_s32(0);
6338 const unsigned int u_0123[4] = {0u, 1u, 2u, 3u};
6339 const uint32x4_t m128_u_0123 = vld1q_u32(u_0123);
6341 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
6343 const unsigned int sourceY_fixed16 =
minmax<int>(0, targetOffsetY_fixed16 +
int(sourceY_T_targetY_fixed16 * y), (sourceHeight - 1u) << 16u);
6345 const unsigned int sourceRowTop = sourceY_fixed16 >> 16u;
6346 const unsigned int factorBottom_fixed16 = sourceY_fixed16 & 0x0000FFFFu;
6347 const unsigned int factorBottom = factorBottom_fixed16 >> 9u;
6349 const uint8x8_t m64_u_factorsBottom = vdup_n_u8(factorBottom);
6351 const uint8x8_t m64_u_factorsTop = vdup_n_u8(128u - factorBottom);
6353 const unsigned int sourceRowBottom = min(sourceRowTop + 1u, sourceHeight - 1u);
6355 const PixelType*
const sourceTopRowPixelData = sourcePixelData + sourceRowTop * sourceWidth;
6356 const PixelType*
const sourceBottomRowPixelData = sourcePixelData + sourceRowBottom * sourceWidth;
6358 for (
unsigned int x = 0; x < targetWidth; x += 8u)
6360 if (x + 8u > targetWidth)
6365 ocean_assert(x >= 8u && targetWidth > 8u);
6366 const unsigned int newX = targetWidth - 8u;
6368 ocean_assert(x > newX);
6369 targetPixelData -= x - newX;
6374 ocean_assert(!(x + 8u < targetWidth));
6380 const uint32x4_t m128_u_x_0123 = vaddq_u32(vdupq_n_u32(x), m128_u_0123);
6381 const uint32x4_t m128_u_x_4567 = vaddq_u32(vdupq_n_u32(x + 4u), m128_u_0123);
6384 const int32x4_t m128_s_sourceX_0123_fixed16 = vmaxq_s32(m128_s_zero, vaddq_s32(m128_s_targetOffsetX_fixed16, vreinterpretq_s32_u32(vmulq_u32(m128_u_sourceX_T_targetX_fixed16, m128_u_x_0123))));
6385 const uint32x4_t m128_u_sourceX_0123_fixed16 = vreinterpretq_u32_s32(m128_s_sourceX_0123_fixed16);
6387 const int32x4_t m128_s_sourceX_4567_fixed16 = vmaxq_s32(m128_s_zero, vaddq_s32(m128_s_targetOffsetX_fixed16, vreinterpretq_s32_u32(vmulq_u32(m128_u_sourceX_T_targetX_fixed16, m128_u_x_4567))));
6388 const uint32x4_t m128_u_sourceX_4567_fixed16 = vreinterpretq_u32_s32(m128_s_sourceX_4567_fixed16);
6392 const uint32x4_t m128_u_left_0123 = vminq_u32(vshrq_n_u32(m128_u_sourceX_0123_fixed16, 16), m128_u_sourceWidth_2);
6393 const uint32x4_t m128_u_left_4567 = vminq_u32(vshrq_n_u32(m128_u_sourceX_4567_fixed16, 16), m128_u_sourceWidth_2);
6396 vst1q_u32(leftOffsets + 0, m128_u_left_0123);
6397 vst1q_u32(leftOffsets + 4, m128_u_left_4567);
6404 uint8x8x3_t topLeftPixels;
6405 uint8x8x3_t topRightPixels;
6407 topLeftPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[0u] + 0), topLeftPixels, 0);
6408 topRightPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[0u] + 1), topRightPixels, 0);
6410 topLeftPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[1u] + 0), topLeftPixels, 1);
6411 topRightPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[1u] + 1), topRightPixels, 1);
6413 topLeftPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[2u] + 0), topLeftPixels, 2);
6414 topRightPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[2u] + 1), topRightPixels, 2);
6416 topLeftPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[3u] + 0), topLeftPixels, 3);
6417 topRightPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[3u] + 1), topRightPixels, 3);
6419 topLeftPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[4u] + 0), topLeftPixels, 4);
6420 topRightPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[4u] + 1), topRightPixels, 4);
6422 topLeftPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[5u] + 0), topLeftPixels, 5);
6423 topRightPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[5u] + 1), topRightPixels, 5);
6425 topLeftPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[6u] + 0), topLeftPixels, 6);
6426 topRightPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[6u] + 1), topRightPixels, 6);
6428 topLeftPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[7u] + 0), topLeftPixels, 7);
6429 topRightPixels = vld3_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[7u] + 1), topRightPixels, 7);
6434 uint8x8x3_t bottomLeftPixels;
6435 uint8x8x3_t bottomRightPixels;
6437 bottomLeftPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[0u] + 0), bottomLeftPixels, 0);
6438 bottomRightPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[0u] + 1), bottomRightPixels, 0);
6440 bottomLeftPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[1u] + 0), bottomLeftPixels, 1);
6441 bottomRightPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[1u] + 1), bottomRightPixels, 1);
6443 bottomLeftPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[2u] + 0), bottomLeftPixels, 2);
6444 bottomRightPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[2u] + 1), bottomRightPixels, 2);
6446 bottomLeftPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[3u] + 0), bottomLeftPixels, 3);
6447 bottomRightPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[3u] + 1), bottomRightPixels, 3);
6449 bottomLeftPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[4u] + 0), bottomLeftPixels, 4);
6450 bottomRightPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[4u] + 1), bottomRightPixels, 4);
6452 bottomLeftPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[5u] + 0), bottomLeftPixels, 5);
6453 bottomRightPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[5u] + 1), bottomRightPixels, 5);
6455 bottomLeftPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[6u] + 0), bottomLeftPixels, 6);
6456 bottomRightPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[6u] + 1), bottomRightPixels, 6);
6458 bottomLeftPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[7u] + 0), bottomLeftPixels, 7);
6459 bottomRightPixels = vld3_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[7u] + 1), bottomRightPixels, 7);
6467 const uint16x4_t m64_u_factorsRight_0123 = vrshrn_n_u32(vandq_u32(m128_u_sourceX_0123_fixed16, vdupq_n_u32(0x0000FFFFu)), 9);
6468 const uint16x4_t m64_u_factorsRight_4567 = vrshrn_n_u32(vandq_u32(m128_u_sourceX_4567_fixed16, vdupq_n_u32(0x0000FFFFu)), 9);
6471 const uint16x8_t m128_u_factorsRight = vcombine_u16(m64_u_factorsRight_0123, m64_u_factorsRight_4567);
6472 const uint8x8_t m64_u_factorsRight = vqmovn_u16(m128_u_factorsRight);
6473 const uint8x8_t m64_u_factorsLeft = vsub_u8(vdup_n_u8(128u), m64_u_factorsRight);
6478 uint16x8_t m128_muliplicationChannel_0 = vmull_u8(topLeftPixels.val[0], m64_u_factorsLeft);
6479 uint16x8_t m128_muliplicationChannel_1 = vmull_u8(topLeftPixels.val[1], m64_u_factorsLeft);
6480 uint16x8_t m128_muliplicationChannel_2 = vmull_u8(topLeftPixels.val[2], m64_u_factorsLeft);
6482 m128_muliplicationChannel_0 = vmlal_u8(m128_muliplicationChannel_0, topRightPixels.val[0], m64_u_factorsRight);
6483 m128_muliplicationChannel_1 = vmlal_u8(m128_muliplicationChannel_1, topRightPixels.val[1], m64_u_factorsRight);
6484 m128_muliplicationChannel_2 = vmlal_u8(m128_muliplicationChannel_2, topRightPixels.val[2], m64_u_factorsRight);
6486 uint8x8_t m64_topRowChannel_0 = vrshrn_n_u16(m128_muliplicationChannel_0, 7);
6487 uint8x8_t m64_topRowChannel_1 = vrshrn_n_u16(m128_muliplicationChannel_1, 7);
6488 uint8x8_t m64_topRowChannel_2 = vrshrn_n_u16(m128_muliplicationChannel_2, 7);
6493 m128_muliplicationChannel_0 = vmull_u8(bottomLeftPixels.val[0], m64_u_factorsLeft);
6494 m128_muliplicationChannel_1 = vmull_u8(bottomLeftPixels.val[1], m64_u_factorsLeft);
6495 m128_muliplicationChannel_2 = vmull_u8(bottomLeftPixels.val[2], m64_u_factorsLeft);
6497 m128_muliplicationChannel_0 = vmlal_u8(m128_muliplicationChannel_0, bottomRightPixels.val[0], m64_u_factorsRight);
6498 m128_muliplicationChannel_1 = vmlal_u8(m128_muliplicationChannel_1, bottomRightPixels.val[1], m64_u_factorsRight);
6499 m128_muliplicationChannel_2 = vmlal_u8(m128_muliplicationChannel_2, bottomRightPixels.val[2], m64_u_factorsRight);
6501 uint8x8_t m64_bottomRowChannel_0 = vrshrn_n_u16(m128_muliplicationChannel_0, 7);
6502 uint8x8_t m64_bottomRowChannel_1 = vrshrn_n_u16(m128_muliplicationChannel_1, 7);
6503 uint8x8_t m64_bottomRowChannel_2 = vrshrn_n_u16(m128_muliplicationChannel_2, 7);
6508 m128_muliplicationChannel_0 = vmull_u8(m64_topRowChannel_0, m64_u_factorsTop);
6509 m128_muliplicationChannel_1 = vmull_u8(m64_topRowChannel_1, m64_u_factorsTop);
6510 m128_muliplicationChannel_2 = vmull_u8(m64_topRowChannel_2, m64_u_factorsTop);
6512 m128_muliplicationChannel_0 = vmlal_u8(m128_muliplicationChannel_0, m64_bottomRowChannel_0, m64_u_factorsBottom);
6513 m128_muliplicationChannel_1 = vmlal_u8(m128_muliplicationChannel_1, m64_bottomRowChannel_1, m64_u_factorsBottom);
6514 m128_muliplicationChannel_2 = vmlal_u8(m128_muliplicationChannel_2, m64_bottomRowChannel_2, m64_u_factorsBottom);
6519 result.val[0] = vrshrn_n_u16(m128_muliplicationChannel_0, 7);
6520 result.val[1] = vrshrn_n_u16(m128_muliplicationChannel_1, 7);
6521 result.val[2] = vrshrn_n_u16(m128_muliplicationChannel_2, 7);
6524 vst3_u8((uint8_t*)targetPixelData, result);
6526 targetPixelData += 8;
6532 const unsigned int firstInvalidTargetX = (((sourceWidth - 1u) << 16u) - targetOffsetX_fixed16) / sourceX_T_targetX_fixed16;
6534 for (
unsigned int x = firstInvalidTargetX; x < targetWidth; ++x)
6536 const unsigned int lastSourcePixelPosition_fixed16 =
minmax<int>(0, targetOffsetX_fixed16 +
int(sourceX_T_targetX_fixed16 * x), (sourceWidth - 1u) << 16u);
6538 const unsigned int lastSourcePixelLeft = lastSourcePixelPosition_fixed16 >> 16u;
6539 ocean_assert(lastSourcePixelLeft < sourceWidth);
6540 const unsigned int lastSourcePixelRight = min(lastSourcePixelLeft + 1u, sourceWidth - 1u);
6542 const unsigned int factorRight_fixed16 = lastSourcePixelPosition_fixed16 & 0x0000FFFFu;
6544 const unsigned int factorRight = factorRight_fixed16 >> 9u;
6545 const unsigned int factorLeft = 128u - factorRight;
6547 for (
unsigned int c = 0u; c < 3u; ++c)
6549 ((uint8_t*)(targetPixelData - (targetWidth - x)))[c] = ((((
const uint8_t*)(sourceTopRowPixelData + lastSourcePixelLeft))[c] * factorLeft + ((
const uint8_t*)(sourceTopRowPixelData + lastSourcePixelRight))[c] * factorRight) * (128u - factorBottom)
6550 + (((
const uint8_t*)(sourceBottomRowPixelData + lastSourcePixelLeft))[c] * factorLeft + ((
const uint8_t*)(sourceBottomRowPixelData + lastSourcePixelRight))[c] * factorRight) * factorBottom + 8192u) >> 14u;
6558#ifdef OCEAN_WE_KEEP_ALSO_THIS_SLOW_IMPLEMENTATION_SHOWING_A_MORE_GENERIC_APPROACH
6563inline void FrameInterpolatorBilinear::resize8BitPerChannelSubset7BitPrecisionNEON<4u, 8u>(
const uint8_t* source, uint8_t* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows)
6565 ocean_assert(source !=
nullptr && target !=
nullptr);
6566 ocean_assert(sourceWidth >= 2u && sourceWidth <= 65535u);
6567 ocean_assert(sourceHeight >= 1u && sourceHeight <= 65535u);
6568 ocean_assert(targetWidth >= 8u && targetWidth <= 65535u);
6569 ocean_assert(targetHeight >= 1u && targetHeight <= 65535u);
6570 ocean_assert(sourceX_s_targetX > 0.0 && sourceY_s_targetY > 0.0);
6572 ocean_assert(sourcePaddingElements == 0u);
6573 ocean_assert(targetPaddingElements == 0u);
6575 using PixelType =
typename DataType<uint8_t, 4u>::Type;
6577 PixelType* targetPixelData = (PixelType*)target + firstTargetRow * targetWidth;
6578 const PixelType*
const sourcePixelData = (
const PixelType*)source;
6581 unsigned int leftOffsets[8];
6584 const unsigned int sourceY_T_targetY_fixed16 = (
unsigned int)(
double(0x10000u) * sourceY_s_targetY + 0.5);
6597 const unsigned int sourceX_T_targetX_fixed16 = (
unsigned int)(
double(0x10000u) * sourceX_s_targetX + 0.5);
6598 const unsigned int sourceY_T_targetY_fixed16 = (
unsigned int)(
double(0x10000u) * sourceY_s_targetY + 0.5);
6600 const int targetOffsetX_fixed16 = (int)(
double(0x10000u) * ((sourceX_s_targetX * 0.5) - 0.5) + 0.5);
6601 const int targetOffsetY_fixed16 = (int)(
double(0x10000u) * ((sourceY_s_targetY * 0.5) - 0.5) + 0.5);
6604 const uint32x4_t m128_u_sourceX_T_targetX_fixed16 = vdupq_n_u32(sourceX_T_targetX_fixed16);
6607 const int32x4_t m128_s_targetOffsetX_fixed16 = vdupq_n_s32(targetOffsetX_fixed16);
6610 const uint32x4_t m128_u_sourceWidth_2 = vdupq_n_u32(sourceWidth - 2u);
6613 const int32x4_t m128_s_zero = vdupq_n_s32(0);
6615 const unsigned int u_0123[4] = {0u, 1u, 2u, 3u};
6616 const uint32x4_t m128_u_0123 = vld1q_u32(u_0123);
6618 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
6620 const unsigned int sourceY_fixed16 =
minmax<int>(0, targetOffsetY_fixed16 +
int(sourceY_T_targetY_fixed16 * y), (sourceHeight - 1u) << 16u);
6622 const unsigned int sourceRowTop = sourceY_fixed16 >> 16u;
6623 const unsigned int factorBottom_fixed16 = sourceY_fixed16 & 0x0000FFFFu;
6624 const unsigned int factorBottom = factorBottom_fixed16 >> 9u;
6626 const uint8x8_t m64_u_factorsBottom = vdup_n_u8(factorBottom);
6628 const uint8x8_t m64_u_factorsTop = vdup_n_u8(128u - factorBottom);
6630 const unsigned int sourceRowBottom = min(sourceRowTop + 1u, sourceHeight - 1u);
6632 const PixelType*
const sourceTopRowPixelData = sourcePixelData + sourceRowTop * sourceWidth;
6633 const PixelType*
const sourceBottomRowPixelData = sourcePixelData + sourceRowBottom * sourceWidth;
6635 for (
unsigned int x = 0; x < targetWidth; x += 8u)
6637 if (x + 8u > targetWidth)
6642 ocean_assert(x >= 8u && targetWidth > 8u);
6643 const unsigned int newX = targetWidth - 8u;
6645 ocean_assert(x > newX);
6646 targetPixelData -= x - newX;
6651 ocean_assert(!(x + 8u < targetWidth));
6657 const uint32x4_t m128_u_x_0123 = vaddq_u32(vdupq_n_u32(x), m128_u_0123);
6658 const uint32x4_t m128_u_x_4567 = vaddq_u32(vdupq_n_u32(x + 4u), m128_u_0123);
6661 const int32x4_t m128_s_sourceX_0123_fixed16 = vmaxq_s32(m128_s_zero, vaddq_s32(m128_s_targetOffsetX_fixed16, vreinterpretq_s32_u32(vmulq_u32(m128_u_sourceX_T_targetX_fixed16, m128_u_x_0123))));
6662 const uint32x4_t m128_u_sourceX_0123_fixed16 = vreinterpretq_u32_s32(m128_s_sourceX_0123_fixed16);
6664 const int32x4_t m128_s_sourceX_4567_fixed16 = vmaxq_s32(m128_s_zero, vaddq_s32(m128_s_targetOffsetX_fixed16, vreinterpretq_s32_u32(vmulq_u32(m128_u_sourceX_T_targetX_fixed16, m128_u_x_4567))));
6665 const uint32x4_t m128_u_sourceX_4567_fixed16 = vreinterpretq_u32_s32(m128_s_sourceX_4567_fixed16);
6669 const uint32x4_t m128_u_left_0123 = vminq_u32(vshrq_n_u32(m128_u_sourceX_0123_fixed16, 16), m128_u_sourceWidth_2);
6670 const uint32x4_t m128_u_left_4567 = vminq_u32(vshrq_n_u32(m128_u_sourceX_4567_fixed16, 16), m128_u_sourceWidth_2);
6673 vst1q_u32(leftOffsets + 0, m128_u_left_0123);
6674 vst1q_u32(leftOffsets + 4, m128_u_left_4567);
6681 uint8x8x4_t topLeftPixels;
6682 uint8x8x4_t topRightPixels;
6684 topLeftPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[0u] + 0), topLeftPixels, 0);
6685 topRightPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[0u] + 1), topRightPixels, 0);
6687 topLeftPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[1u] + 0), topLeftPixels, 1);
6688 topRightPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[1u] + 1), topRightPixels, 1);
6690 topLeftPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[2u] + 0), topLeftPixels, 2);
6691 topRightPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[2u] + 1), topRightPixels, 2);
6693 topLeftPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[3u] + 0), topLeftPixels, 3);
6694 topRightPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[3u] + 1), topRightPixels, 3);
6696 topLeftPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[4u] + 0), topLeftPixels, 4);
6697 topRightPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[4u] + 1), topRightPixels, 4);
6699 topLeftPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[5u] + 0), topLeftPixels, 5);
6700 topRightPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[5u] + 1), topRightPixels, 5);
6702 topLeftPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[6u] + 0), topLeftPixels, 6);
6703 topRightPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[6u] + 1), topRightPixels, 6);
6705 topLeftPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[7u] + 0), topLeftPixels, 7);
6706 topRightPixels = vld4_lane_u8((uint8_t*)(sourceTopRowPixelData + leftOffsets[7u] + 1), topRightPixels, 7);
6711 uint8x8x4_t bottomLeftPixels;
6712 uint8x8x4_t bottomRightPixels;
6714 bottomLeftPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[0u] + 0), bottomLeftPixels, 0);
6715 bottomRightPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[0u] + 1), bottomRightPixels, 0);
6717 bottomLeftPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[1u] + 0), bottomLeftPixels, 1);
6718 bottomRightPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[1u] + 1), bottomRightPixels, 1);
6720 bottomLeftPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[2u] + 0), bottomLeftPixels, 2);
6721 bottomRightPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[2u] + 1), bottomRightPixels, 2);
6723 bottomLeftPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[3u] + 0), bottomLeftPixels, 3);
6724 bottomRightPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[3u] + 1), bottomRightPixels, 3);
6726 bottomLeftPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[4u] + 0), bottomLeftPixels, 4);
6727 bottomRightPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[4u] + 1), bottomRightPixels, 4);
6729 bottomLeftPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[5u] + 0), bottomLeftPixels, 5);
6730 bottomRightPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[5u] + 1), bottomRightPixels, 5);
6732 bottomLeftPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[6u] + 0), bottomLeftPixels, 6);
6733 bottomRightPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[6u] + 1), bottomRightPixels, 6);
6735 bottomLeftPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[7u] + 0), bottomLeftPixels, 7);
6736 bottomRightPixels = vld4_lane_u8((uint8_t*)(sourceBottomRowPixelData + leftOffsets[7u] + 1), bottomRightPixels, 7);
6744 const uint16x4_t m64_u_factorsRight_0123 = vrshrn_n_u32(vandq_u32(m128_u_sourceX_0123_fixed16, vdupq_n_u32(0x0000FFFFu)), 9);
6745 const uint16x4_t m64_u_factorsRight_4567 = vrshrn_n_u32(vandq_u32(m128_u_sourceX_4567_fixed16, vdupq_n_u32(0x0000FFFFu)), 9);
6748 const uint16x8_t m128_u_factorsRight = vcombine_u16(m64_u_factorsRight_0123, m64_u_factorsRight_4567);
6749 const uint8x8_t m64_u_factorsRight = vqmovn_u16(m128_u_factorsRight);
6750 const uint8x8_t m64_u_factorsLeft = vsub_u8(vdup_n_u8(128u), m64_u_factorsRight);
6755 uint16x8_t m128_muliplicationChannel_0 = vmull_u8(topLeftPixels.val[0], m64_u_factorsLeft);
6756 uint16x8_t m128_muliplicationChannel_1 = vmull_u8(topLeftPixels.val[1], m64_u_factorsLeft);
6757 uint16x8_t m128_muliplicationChannel_2 = vmull_u8(topLeftPixels.val[2], m64_u_factorsLeft);
6758 uint16x8_t m128_muliplicationChannel_3 = vmull_u8(topLeftPixels.val[3], m64_u_factorsLeft);
6760 m128_muliplicationChannel_0 = vmlal_u8(m128_muliplicationChannel_0, topRightPixels.val[0], m64_u_factorsRight);
6761 m128_muliplicationChannel_1 = vmlal_u8(m128_muliplicationChannel_1, topRightPixels.val[1], m64_u_factorsRight);
6762 m128_muliplicationChannel_2 = vmlal_u8(m128_muliplicationChannel_2, topRightPixels.val[2], m64_u_factorsRight);
6763 m128_muliplicationChannel_3 = vmlal_u8(m128_muliplicationChannel_3, topRightPixels.val[3], m64_u_factorsRight);
6765 uint8x8_t m64_topRowChannel_0 = vrshrn_n_u16(m128_muliplicationChannel_0, 7);
6766 uint8x8_t m64_topRowChannel_1 = vrshrn_n_u16(m128_muliplicationChannel_1, 7);
6767 uint8x8_t m64_topRowChannel_2 = vrshrn_n_u16(m128_muliplicationChannel_2, 7);
6768 uint8x8_t m64_topRowChannel_3 = vrshrn_n_u16(m128_muliplicationChannel_3, 7);
6773 m128_muliplicationChannel_0 = vmull_u8(bottomLeftPixels.val[0], m64_u_factorsLeft);
6774 m128_muliplicationChannel_1 = vmull_u8(bottomLeftPixels.val[1], m64_u_factorsLeft);
6775 m128_muliplicationChannel_2 = vmull_u8(bottomLeftPixels.val[2], m64_u_factorsLeft);
6776 m128_muliplicationChannel_3 = vmull_u8(bottomLeftPixels.val[3], m64_u_factorsLeft);
6778 m128_muliplicationChannel_0 = vmlal_u8(m128_muliplicationChannel_0, bottomRightPixels.val[0], m64_u_factorsRight);
6779 m128_muliplicationChannel_1 = vmlal_u8(m128_muliplicationChannel_1, bottomRightPixels.val[1], m64_u_factorsRight);
6780 m128_muliplicationChannel_2 = vmlal_u8(m128_muliplicationChannel_2, bottomRightPixels.val[2], m64_u_factorsRight);
6781 m128_muliplicationChannel_3 = vmlal_u8(m128_muliplicationChannel_3, bottomRightPixels.val[3], m64_u_factorsRight);
6783 uint8x8_t m64_bottomRowChannel_0 = vrshrn_n_u16(m128_muliplicationChannel_0, 7);
6784 uint8x8_t m64_bottomRowChannel_1 = vrshrn_n_u16(m128_muliplicationChannel_1, 7);
6785 uint8x8_t m64_bottomRowChannel_2 = vrshrn_n_u16(m128_muliplicationChannel_2, 7);
6786 uint8x8_t m64_bottomRowChannel_3 = vrshrn_n_u16(m128_muliplicationChannel_3, 7);
6791 m128_muliplicationChannel_0 = vmull_u8(m64_topRowChannel_0, m64_u_factorsTop);
6792 m128_muliplicationChannel_1 = vmull_u8(m64_topRowChannel_1, m64_u_factorsTop);
6793 m128_muliplicationChannel_2 = vmull_u8(m64_topRowChannel_2, m64_u_factorsTop);
6794 m128_muliplicationChannel_3 = vmull_u8(m64_topRowChannel_3, m64_u_factorsTop);
6796 m128_muliplicationChannel_0 = vmlal_u8(m128_muliplicationChannel_0, m64_bottomRowChannel_0, m64_u_factorsBottom);
6797 m128_muliplicationChannel_1 = vmlal_u8(m128_muliplicationChannel_1, m64_bottomRowChannel_1, m64_u_factorsBottom);
6798 m128_muliplicationChannel_2 = vmlal_u8(m128_muliplicationChannel_2, m64_bottomRowChannel_2, m64_u_factorsBottom);
6799 m128_muliplicationChannel_3 = vmlal_u8(m128_muliplicationChannel_3, m64_bottomRowChannel_3, m64_u_factorsBottom);
6804 result.val[0] = vrshrn_n_u16(m128_muliplicationChannel_0, 7);
6805 result.val[1] = vrshrn_n_u16(m128_muliplicationChannel_1, 7);
6806 result.val[2] = vrshrn_n_u16(m128_muliplicationChannel_2, 7);
6807 result.val[3] = vrshrn_n_u16(m128_muliplicationChannel_3, 7);
6810 vst4_u8((uint8_t*)targetPixelData, result);
6812 targetPixelData += 8;
6818 const unsigned int firstInvalidTargetX = (((sourceWidth - 1u) << 16u) - targetOffsetX_fixed16) / sourceX_T_targetX_fixed16;
6820 for (
unsigned int x = firstInvalidTargetX; x < targetWidth; ++x)
6822 const unsigned int lastSourcePixelPosition_fixed16 =
minmax<int>(0, targetOffsetX_fixed16 +
int(sourceX_T_targetX_fixed16 * x), (sourceWidth - 1u) << 16u);
6824 const unsigned int lastSourcePixelLeft = lastSourcePixelPosition_fixed16 >> 16u;
6825 ocean_assert(lastSourcePixelLeft < sourceWidth);
6826 const unsigned int lastSourcePixelRight = min(lastSourcePixelLeft + 1u, sourceWidth - 1u);
6828 const unsigned int factorRight_fixed16 = lastSourcePixelPosition_fixed16 & 0x0000FFFFu;
6830 const unsigned int factorRight = factorRight_fixed16 >> 9u;
6831 const unsigned int factorLeft = 128u - factorRight;
6833 for (
unsigned int c = 0u; c < 4u; ++c)
6835 ((uint8_t*)(targetPixelData - (targetWidth - x)))[c] = ((((
const uint8_t*)(sourceTopRowPixelData + lastSourcePixelLeft))[c] * factorLeft + ((
const uint8_t*)(sourceTopRowPixelData + lastSourcePixelRight))[c] * factorRight) * factorTop
6836 + (((
const uint8_t*)(sourceBottomRowPixelData + lastSourcePixelLeft))[c] * factorLeft + ((
const uint8_t*)(sourceBottomRowPixelData + lastSourcePixelRight))[c] * factorRight) * factorBottom + 8192u) >> 14u;
6849 ocean_assert(sourceRowTop !=
nullptr);
6850 ocean_assert(sourceRowBottom !=
nullptr);
6851 ocean_assert(targetRow !=
nullptr);
6852 ocean_assert(elements >= 16u);
6853 ocean_assert(factorBottom >= 0.0f && factorBottom <= 1.0f);
6856 const float32x4_t constant_1_f_32x4 = vdupq_n_f32(1.0f);
6858 const float32x4_t factorsBottom_f_32x4 = vdupq_n_f32(factorBottom);
6859 const float32x4_t factorsTop_f_32x4 = vsubq_f32(constant_1_f_32x4, factorsBottom_f_32x4);
6861 for (
unsigned int n = 0u; n < elements; n += 16u)
6863 if (n + 16u > elements)
6868 ocean_assert(n >= 16u && elements > 16u);
6869 const unsigned int offset = n - (elements - 16u);
6870 ocean_assert(offset < 16u);
6872 sourceRowTop -= offset;
6873 sourceRowBottom -= offset;
6874 targetRow -= offset;
6877 ocean_assert(!(n + 16u < elements));
6881 const float32x4_t top_03_32x4 = vld1q_f32(sourceRowTop + 0);
6882 const float32x4_t top_47_32x4 = vld1q_f32(sourceRowTop + 4);
6883 const float32x4_t top_8B_32x4 = vld1q_f32(sourceRowTop + 8);
6884 const float32x4_t top_CF_32x4 = vld1q_f32(sourceRowTop + 12);
6886 const float32x4_t bottom_03_32x4 = vld1q_f32(sourceRowBottom + 0);
6887 const float32x4_t bottom_47_32x4 = vld1q_f32(sourceRowBottom + 4);
6888 const float32x4_t bottom_8B_32x4 = vld1q_f32(sourceRowBottom + 8);
6889 const float32x4_t bottom_CF_32x4 = vld1q_f32(sourceRowBottom + 12);
6892 float32x4_t interpolatedRow_03_32x4 = vmulq_f32(top_03_32x4, factorsTop_f_32x4);
6893 float32x4_t interpolatedRow_47_32x4 = vmulq_f32(top_47_32x4, factorsTop_f_32x4);
6894 float32x4_t interpolatedRow_8B_32x4 = vmulq_f32(top_8B_32x4, factorsTop_f_32x4);
6895 float32x4_t interpolatedRow_CF_32x4 = vmulq_f32(top_CF_32x4, factorsTop_f_32x4);
6897 interpolatedRow_03_32x4 = vmlaq_f32(interpolatedRow_03_32x4, bottom_03_32x4, factorsBottom_f_32x4);
6898 interpolatedRow_47_32x4 = vmlaq_f32(interpolatedRow_47_32x4, bottom_47_32x4, factorsBottom_f_32x4);
6899 interpolatedRow_8B_32x4 = vmlaq_f32(interpolatedRow_8B_32x4, bottom_8B_32x4, factorsBottom_f_32x4);
6900 interpolatedRow_CF_32x4 = vmlaq_f32(interpolatedRow_CF_32x4, bottom_CF_32x4, factorsBottom_f_32x4);
6903 vst1q_f32(targetRow + 0, interpolatedRow_03_32x4);
6904 vst1q_f32(targetRow + 4, interpolatedRow_47_32x4);
6905 vst1q_f32(targetRow + 8, interpolatedRow_8B_32x4);
6906 vst1q_f32(targetRow + 12, interpolatedRow_CF_32x4);
6909 sourceRowBottom += 16;
6917 ocean_assert(extendedSourceRow !=
nullptr);
6918 ocean_assert(targetRow !=
nullptr);
6919 ocean_assert(targetWidth >= 8u);
6920 ocean_assert(interpolationLocations !=
nullptr);
6921 ocean_assert(interpolationFactorsRight !=
nullptr);
6923 ocean_assert_and_suppress_unused(channels == 1u, channels);
6926 const float32x4_t constant_1_f_32x4 = vdupq_n_f32(1.0f);
6928 for (
unsigned int x = 0; x < targetWidth; x += 8u)
6930 if (x + 8u > targetWidth)
6935 ocean_assert(x >= 8u && targetWidth > 8u);
6936 const unsigned int newX = targetWidth - 8u;
6938 ocean_assert(x > newX);
6939 const unsigned int offset = x - newX;
6941 targetRow -= offset;
6942 interpolationLocations -= offset;
6943 interpolationFactorsRight -= offset;
6948 ocean_assert(!(x + 8u < targetWidth));
6953 const float32x2_t pixel_0_f_32x2 = vld1_f32(extendedSourceRow + interpolationLocations[0]);
6954 const float32x2_t pixel_1_f_32x2 = vld1_f32(extendedSourceRow + interpolationLocations[1]);
6955 const float32x4_t pixel_01_f_32x4 = vcombine_f32(pixel_0_f_32x2, pixel_1_f_32x2);
6957 const float32x2_t pixel_2_f_32x2 = vld1_f32(extendedSourceRow + interpolationLocations[2]);
6958 const float32x2_t pixel_3_f_32x2 = vld1_f32(extendedSourceRow + interpolationLocations[3]);
6959 const float32x4_t pixel_23_f_32x4 = vcombine_f32(pixel_2_f_32x2, pixel_3_f_32x2);
6961 const float32x2_t pixel_4_f_32x2 = vld1_f32(extendedSourceRow + interpolationLocations[4]);
6962 const float32x2_t pixel_5_f_32x2 = vld1_f32(extendedSourceRow + interpolationLocations[5]);
6963 const float32x4_t pixel_45_f_32x4 = vcombine_f32(pixel_4_f_32x2, pixel_5_f_32x2);
6965 const float32x2_t pixel_6_f_32x2 = vld1_f32(extendedSourceRow + interpolationLocations[6]);
6966 const float32x2_t pixel_7_f_32x2 = vld1_f32(extendedSourceRow + interpolationLocations[7]);
6967 const float32x4_t pixel_67_f_32x4 = vcombine_f32(pixel_6_f_32x2, pixel_7_f_32x2);
6969 const float32x4_t factorsRight_0123_f_32x4 = vld1q_f32(interpolationFactorsRight + 0);
6970 const float32x4_t factorsLeft_0123_f_32x4 = vsubq_f32(constant_1_f_32x4, factorsRight_0123_f_32x4);
6971 const float32x4x2_t factorsLeftRight_0123_f_32x4_2 = vzipq_f32(factorsLeft_0123_f_32x4, factorsRight_0123_f_32x4);
6973 const float32x4_t factorsRight_4567_f_32x4 = vld1q_f32(interpolationFactorsRight + 4);
6974 const float32x4_t factorsLeft_4567_f_32x4 = vsubq_f32(constant_1_f_32x4, factorsRight_4567_f_32x4);
6975 const float32x4x2_t factorsLeftRight_4567_f_32x4_2 = vzipq_f32(factorsLeft_4567_f_32x4, factorsRight_4567_f_32x4);
6977 const float32x4_t multiplied_01_f_32x4 = vmulq_f32(pixel_01_f_32x4, factorsLeftRight_0123_f_32x4_2.val[0]);
6978 const float32x4_t multiplied_23_f_32x4 = vmulq_f32(pixel_23_f_32x4, factorsLeftRight_0123_f_32x4_2.val[1]);
6980 const float32x4_t multiplied_45_f_32x4 = vmulq_f32(pixel_45_f_32x4, factorsLeftRight_4567_f_32x4_2.val[0]);
6981 const float32x4_t multiplied_67_f_32x4 = vmulq_f32(pixel_67_f_32x4, factorsLeftRight_4567_f_32x4_2.val[1]);
6983 const float32x2_t result_01_f_32x2 = vpadd_f32(vget_low_f32(multiplied_01_f_32x4), vget_high_f32(multiplied_01_f_32x4));
6984 const float32x2_t result_23_f_32x2 = vpadd_f32(vget_low_f32(multiplied_23_f_32x4), vget_high_f32(multiplied_23_f_32x4));
6986 const float32x2_t result_45_f_32x2 = vpadd_f32(vget_low_f32(multiplied_45_f_32x4), vget_high_f32(multiplied_45_f_32x4));
6987 const float32x2_t result_67_f_32x2 = vpadd_f32(vget_low_f32(multiplied_67_f_32x4), vget_high_f32(multiplied_67_f_32x4));
6989 const float32x4_t result_0123_f_32x4 = vcombine_f32(result_01_f_32x2, result_23_f_32x2);
6990 const float32x4_t result_4567_f_32x4 = vcombine_f32(result_45_f_32x2, result_67_f_32x2);
6992 vst1q_f32(targetRow + 0, result_0123_f_32x4);
6993 vst1q_f32(targetRow + 4, result_4567_f_32x4);
6996 interpolationLocations += 8;
6997 interpolationFactorsRight += 8;
7002inline void FrameInterpolatorBilinear::scaleSubset<float, float, 1u>(
const float* source,
float* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows)
7004 ocean_assert(source !=
nullptr && target !=
nullptr);
7005 ocean_assert(sourceWidth >= 1u && sourceHeight >= 1u);
7006 ocean_assert(targetWidth >= 1u && targetHeight >= 1u);
7007 ocean_assert(sourceX_s_targetX > 0.0 && sourceY_s_targetY > 0.0);
7009 ocean_assert(sourceWidth != targetWidth || sourceHeight != targetHeight || sourceX_s_targetX != 1.0 || sourceY_s_targetY != 1.0);
7011 const unsigned int sourceStrideElements = sourceWidth * 1u + sourcePaddingElements;
7012 const unsigned int targetStrideElements = targetWidth * 1u + targetPaddingElements;
7014 using InterpolateRowVerticalFunction = void (*)(
const float*,
const float*,
float*,
const unsigned int,
const float);
7015 using InterpolateRowHorizontalFunction = void (*)(
const float*,
float*,
const unsigned int,
const unsigned int,
const unsigned int*,
const float*);
7020 if (sourceWidth * 1u >= 16u)
7025 if (targetWidth >= 8u)
7030 target += targetStrideElements * firstTargetRow;
7032 const float sourceX_T_targetX = float(sourceX_s_targetX);
7033 const float sourceY_T_targetY = float(sourceY_s_targetY);
7037 Memory memoryIntermediateExtendedRow;
7038 Memory memoryHorizontalInterpolationLocations;
7039 Memory memoryHorizontalInterpolationFactorsRight;
7041 if (sourceWidth != targetWidth || sourceX_T_targetX != 1.0f)
7052 if (memoryHorizontalInterpolationLocations)
7054 ocean_assert(memoryHorizontalInterpolationFactorsRight);
7056 if (targetWidth >= 4u)
7058 const float32x4_t sourceX_T_targetX_f_32x4 = vdupq_n_f32(sourceX_T_targetX);
7059 const float32x4_t targetOffsetX_f_32x4 = vdupq_n_f32(sourceX_T_targetX * 0.5f - 0.5f);
7062 const float32x4_t constant_0_f_32x4 = vdupq_n_f32(0);
7065 const float32x4_t constant_4_f_32x4 = vdupq_n_f32(4.0f);
7068 const uint32x4_t sourceWidth_1_u_32x4 = vdupq_n_u32(sourceWidth - 1u);
7071 const float f_0123[4] = {0.0f, 1.0f, 2.0f, 3.0f};
7072 float32x4_t x_0123_f_32x4 = vld1q_f32(f_0123);
7076 for (
unsigned int x = 0u; x < targetWidth; x += 4u)
7078 if (x + 4u > targetWidth)
7083 ocean_assert(x >= 4u && targetWidth > 4u);
7084 const unsigned int newX = targetWidth - 4u;
7086 ocean_assert(x > newX);
7087 const unsigned int offset = x - newX;
7091 x_0123_f_32x4 = vsubq_f32(x_0123_f_32x4, vdupq_n_f32(
float(offset)));
7094 ocean_assert(!(x + 4u < targetWidth));
7098 const float32x4_t sourceX_0123_f_32x4 = vmaxq_f32(constant_0_f_32x4, vaddq_f32(targetOffsetX_f_32x4, vmulq_f32(sourceX_T_targetX_f_32x4, x_0123_f_32x4)));
7102 uint32x4_t left_0123_u_32x4 = vminq_u32(vcvtq_u32_f32(sourceX_0123_f_32x4), sourceWidth_1_u_32x4);
7105 vst1q_u32(memoryHorizontalInterpolationLocations.
data<
unsigned int>() + x, left_0123_u_32x4);
7108 const float32x4_t factorsRight_f_32x4 = vsubq_f32(sourceX_0123_f_32x4, vcvtq_f32_u32(left_0123_u_32x4));
7110 vst1q_f32(memoryHorizontalInterpolationFactorsRight.
data<
float>() + x, factorsRight_f_32x4);
7113 x_0123_f_32x4 = vaddq_f32(x_0123_f_32x4, constant_4_f_32x4);
7118 const float targetOffsetX = sourceX_T_targetX * 0.5f - 0.5f;
7122 for (
unsigned int x = 0u; x < targetWidth; ++x)
7124 const float sourceX = max(0.0f, targetOffsetX +
float(x) * sourceX_T_targetX);
7126 const unsigned int left = min((
unsigned int)sourceX, sourceWidth - 1u);
7128 memoryHorizontalInterpolationLocations.
data<
unsigned int>()[x] = left;
7130 const float factorRight = sourceX - float(left);
7131 ocean_assert(factorRight >= 0.0f && factorRight <= 1.0f);
7133 memoryHorizontalInterpolationFactorsRight.
data<
float>()[x] = factorRight;
7138 const float targetOffsetY = sourceY_T_targetY * 0.5f - 0.5f;
7140 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
7142 const float sourceY =
minmax<float>(0.0f, targetOffsetY + sourceY_T_targetY *
float(y),
float(sourceHeight) - 1.0f);
7144 const unsigned int sourceRowTop = (
unsigned int)sourceY;
7145 const float factorBottom = sourceY - float(sourceRowTop);
7146 ocean_assert(factorBottom >= 0.0f && factorBottom <= 1.0f);
7148 const unsigned int sourceRowBottom = min(sourceRowTop + 1u, sourceHeight - 1u);
7150 const float*
const sourceTopRow = source + sourceStrideElements * sourceRowTop;
7151 const float*
const sourceBottomRow = source + sourceStrideElements * sourceRowBottom;
7153 float* targetRow =
nullptr;
7155 if (memoryIntermediateExtendedRow && factorBottom == 0.0f)
7157 ocean_assert(sourceWidth != targetWidth);
7160 memcpy(memoryIntermediateExtendedRow.
data<
float>(), sourceTopRow, sourceWidth *
sizeof(
float));
7165 targetRow = memoryIntermediateExtendedRow.
isNull() ? target : memoryIntermediateExtendedRow.
data<
float>();
7167 ocean_assert(targetRow !=
nullptr);
7168 ocean_assert(interpolateRowVerticalFunction !=
nullptr);
7169 interpolateRowVerticalFunction(sourceTopRow, sourceBottomRow, targetRow, sourceWidth * 1u, factorBottom);
7172 if (memoryIntermediateExtendedRow)
7176 memoryIntermediateExtendedRow.
data<
float>()[sourceWidth] = memoryIntermediateExtendedRow.
data<
float>()[sourceWidth - 1u];
7178 interpolateRowHorizontalFunction(memoryIntermediateExtendedRow.
data<
float>(), target, targetWidth, 1u, memoryHorizontalInterpolationLocations.
data<
unsigned int>(), memoryHorizontalInterpolationFactorsRight.
data<
float>());
7181 target += targetStrideElements;
7187template <
typename T,
typename TScale,
unsigned int tChannels>
7188void FrameInterpolatorBilinear::scaleSubset(
const T* source, T* target,
const unsigned int sourceWidth,
const unsigned int sourceHeight,
const unsigned int targetWidth,
const unsigned int targetHeight,
const double sourceX_s_targetX,
const double sourceY_s_targetY,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows)
7190 static_assert((std::is_same<float, TScale>::value || std::is_same<double, TScale>::value),
"Invalid TScale type");
7192 ocean_assert(source !=
nullptr && target !=
nullptr);
7193 ocean_assert(sourceWidth != 0u && sourceHeight != 0u);
7194 ocean_assert_and_suppress_unused(targetWidth >= 1u && targetHeight >= 1u, targetHeight);
7195 ocean_assert(sourceX_s_targetX > 0.0 && sourceY_s_targetY > 0.0);
7197 const unsigned int sourceStrideElements = sourceWidth * tChannels + sourcePaddingElements;
7198 const unsigned int targetStrideElements = targetWidth * tChannels + targetPaddingElements;
7200 const TScale sourceX_T_targetX = TScale(sourceX_s_targetX);
7201 const TScale sourceY_T_targetY = TScale(sourceY_s_targetY);
7249 const TScale sourceX_T_targetXOffset = sourceX_T_targetX * TScale(0.5) - TScale(0.5);
7250 const TScale sourceY_T_targetYOffset = sourceY_T_targetY * TScale(0.5) - TScale(0.5);
7252 const TScale sourceWidth_1 = TScale(sourceWidth - 1u);
7253 const TScale sourceHeight_1 = TScale(sourceHeight - 1u);
7255 target += targetStrideElements * firstTargetRow;
7257 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
7259 const TScale sy =
minmax(TScale(0), sourceY_T_targetYOffset + sourceY_T_targetY * TScale(y), sourceHeight_1);
7260 ocean_assert(sy >= TScale(0) && sy < TScale(sourceHeight));
7262 const unsigned int sTop = (
unsigned int)sy;
7263 ocean_assert(sy >= TScale(sTop));
7265 const TScale factorBottom = sy - TScale(sTop);
7266 ocean_assert(factorBottom >= TScale(0) && factorBottom <= TScale(1));
7268 const TScale factorTop = TScale(1) - factorBottom;
7269 ocean_assert(factorTop >= TScale(0) && factorTop <= TScale(1));
7271 const T*
const sourceTop = source + sTop * sourceStrideElements;
7272 const T*
const sourceBottom = (sTop + 1u < sourceHeight) ? sourceTop + sourceStrideElements : sourceTop;
7274 for (
unsigned int x = 0; x < targetWidth; ++x)
7276 const TScale sx =
minmax(TScale(0), sourceX_T_targetXOffset + sourceX_T_targetX * TScale(x), sourceWidth_1);
7277 ocean_assert(sx >= TScale(0) && sx < TScale(sourceWidth));
7279 const unsigned int sLeft = (
unsigned int)sx;
7280 ocean_assert(sx >= TScale(sLeft));
7282 const TScale factorRight = sx - TScale(sLeft);
7283 ocean_assert(factorRight >= TScale(0) && factorRight <= TScale(1));
7285 const TScale factorLeft = TScale(1) - factorRight;
7286 ocean_assert(factorLeft >= TScale(0) && factorLeft <= TScale(1));
7288 const unsigned int sourceRightOffset = sLeft + 1u < sourceWidth ? tChannels : 0u;
7290 const T*
const sourceTopLeft = sourceTop + sLeft * tChannels;
7291 const T*
const sourceBottomLeft = sourceBottom + sLeft * tChannels;
7293 const TScale factorTopLeft = factorTop * factorLeft;
7294 const TScale factorTopRight = factorTop * factorRight;
7295 const TScale factorBottomLeft = factorBottom * factorLeft;
7296 const TScale factorBottomRight = factorBottom * factorRight;
7298 for (
unsigned int n = 0u; n < tChannels; ++n)
7300 target[n] = T(TScale(sourceTopLeft[n]) * factorTopLeft + TScale(sourceTopLeft[sourceRightOffset + n]) * factorTopRight
7301 + TScale(sourceBottomLeft[n]) * factorBottomLeft + TScale(sourceBottomLeft[sourceRightOffset + n]) * factorBottomRight);
7304 target += tChannels;
7307 target += targetPaddingElements;
7311template <
unsigned int tChannels>
7312void FrameInterpolatorBilinear::rotate8BitPerChannelSubset(
const uint8_t* source, uint8_t* target,
const unsigned int width,
const unsigned int height,
const Scalar horizontalAnchorPosition,
const Scalar verticalAnchorPosition,
const Scalar angle,
const uint8_t* borderColor,
const unsigned int sourcePaddingElements,
const unsigned int targetPaddingElements,
const unsigned int firstTargetRow,
const unsigned int numberTargetRows)
7314 static_assert(tChannels != 0u,
"Invalid channel number!");
7316 ocean_assert(firstTargetRow + numberTargetRows <= height);
7320 const unsigned int targetStrideElements = width * tChannels + targetPaddingElements;
7322 uint8_t zeroColor[tChannels] = {uint8_t(0)};
7323 const PixelType bColor = borderColor ? *(
const PixelType*)borderColor : *(
const PixelType*)zeroColor;
7326 const SquareMatrix2 rotationMatrix2(rotationMatrix3(0, 0), rotationMatrix3(1, 0), rotationMatrix3(0, 1), rotationMatrix3(1, 1));
7330 const Vector2 anchorPosition(horizontalAnchorPosition, verticalAnchorPosition);
7332 for (
unsigned int y = firstTargetRow; y < firstTargetRow + numberTargetRows; ++y)
7334 PixelType* targetPixel = (PixelType*)(target + y * targetStrideElements);
7338 for (
unsigned int x = 0; x < width; ++x)
7340 const Vector2 sourceLocation(anchorPosition + rotationMatrix2 * (
Vector2(
Scalar(x), floatY) - anchorPosition));
7342 if (sourceLocation.
x() >= 0 && sourceLocation.
y() >= 0 && sourceLocation.
x() <= width_1 && sourceLocation.
y() <= height_1)
7348 *targetPixel = bColor;
virtual VectorT3< T > vector(const VectorT2< T > &distortedImagePoint, const bool makeUnitVector=true) const =0
Returns a vector starting at the camera's center and intersecting a given 2D point in the image.
virtual unsigned int width() const =0
Returns the width of the camera image.
virtual unsigned int height() const =0
Returns the height of the camera image.
virtual VectorT2< T > projectToImageIF(const VectorT3< T > &objectPoint) const =0
Projects a 3D object point into the camera frame.
virtual bool isValid() const =0
Returns whether this camera is valid.
Helper class allowing to determine the offset that is necessary to access the alpha channel.
Definition FrameBlender.h:60
static constexpr unsigned int data()
Returns the offset that is applied to access the first data channel.
Definition FrameBlender.h:1171
static uint8_t fullTransparent8Bit()
Returns the alpha value for a fully transparent pixel.
Definition FrameBlender.h:906
static bool subFrame(const T *source, T *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int channels, const unsigned int sourceLeft, const unsigned int sourceTop, const unsigned int targetLeft, const unsigned int targetTop, const unsigned int width, const unsigned int height, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Copies a sub-frame of a given frame into a second frame while both frames might have an individual nu...
Definition FrameConverter.h:3325
The following comfort class provides comfortable functions simplifying prototyping applications but a...
Definition FrameInterpolatorBilinear.h:65
static bool homographies(const Frame &input, Frame &output, const SquareMatrix3 homographies[4], const Vector2 &outputQuadrantCenter, const uint8_t *borderColor=nullptr, Worker *worker=nullptr, const PixelPositionI &outputOrigin=PixelPositionI(0, 0))
Transforms a given input frame into an output frame (with arbitrary frame dimension) by application o...
static bool zoom(const Frame &source, Frame &target, const Scalar zoomFactor, Worker *worker=nullptr)
Zooms into a given input frame (or zooms out) and stores the zoomed image content in an output frame.
static bool homographyMask(const Frame &input, Frame &output, Frame &outputMask, const SquareMatrix3 &input_H_output, Worker *worker=nullptr, const uint8_t maskValue=0xFF, const PixelPositionI &outputOrigin=PixelPositionI(0, 0))
Transforms a given input frame into an output frame (with arbitrary frame dimension) by application o...
static bool lookupMask(const Frame &input, Frame &output, Frame &outputMask, const LookupTable &input_LT_output, const bool offset, Worker *worker=nullptr, const uint8_t maskValue=0xFF)
Transforms a given input frame into an output frame by application of an interpolation lookup table a...
static bool homographyWithCameraMask(const AnyCamera &inputCamera, const AnyCamera &outputCamera, const Frame &input, Frame &output, Frame &outputMask, const SquareMatrix3 &homography, Worker *worker=nullptr, const uint8_t maskValue=0xFFu)
Transforms a given input frame into an output frame by application of a homography.
static bool rotate(const Frame &source, Frame &target, const Scalar horizontalAnchorPosition, const Scalar verticalAnchorPosition, const Scalar angle, Worker *worker=nullptr, const uint8_t *borderColor=nullptr)
Rotates a given frame by a bilinear interpolation.
static bool resize(const Frame &source, Frame &target, Worker *worker=nullptr)
Resizes/rescales a given frame by application of a bilinear interpolation.
static bool homographiesMask(const Frame &input, Frame &output, Frame &outputMask, const SquareMatrix3 *homographies, const Vector2 &outputQuadrantCenter, Worker *worker=nullptr, const uint8_t maskValue=0xFF, const PixelPositionI &outputOrigin=PixelPositionI(0, 0))
Transforms a given input frame into an output frame (with arbitrary frame dimension) by application o...
static bool interpolatePixel(const TSource *frame, const unsigned int channels, const unsigned int width, const unsigned int height, const unsigned int framePaddingElements, const PixelCenter pixelCenter, const VectorT2< TScalar > &position, TTarget *result, const TIntermediate &resultBias=TIntermediate(0))
Determines the interpolated pixel values for a given pixel position in a frame with arbitrary data ty...
Definition FrameInterpolatorBilinear.h:1552
static bool resampleCameraImage(const Frame &sourceFrame, const AnyCamera &sourceCamera, const SquareMatrix3 &source_R_target, const AnyCamera &targetCamera, Frame &targetFrame, LookupCorner2< Vector2 > *source_OLT_target=nullptr, Worker *worker=nullptr, const unsigned int binSizeInPixel=8u, const void *borderColor=nullptr)
Re-samples a camera image which has been captured with a camera profile as if the image would have be...
static bool homographyWithCamera(const PinholeCamera &inputCamera, const PinholeCamera &outputCamera, const Frame &input, Frame &output, const SquareMatrix3 &homography, const bool useDistortionParameters, const uint8_t *borderColor=nullptr, Worker *worker=nullptr)
Transforms a given input frame into an output frame by application of a homography.
static bool lookup(const Frame &input, Frame &output, const LookupTable &input_LT_output, const bool offset, const void *borderColor, Worker *worker=nullptr)
Transforms a given input frame into an output frame by application of an interpolation lookup table.
static bool affine(const Frame &source, Frame &target, const SquareMatrix3 &source_A_target, const uint8_t *borderColor=nullptr, Worker *worker=nullptr, const PixelPositionI &targetOrigin=PixelPositionI(0, 0))
Applies an affine transformation to an image.
static bool interpolatePixel8BitPerChannel(const uint8_t *frame, const unsigned int channels, const unsigned int width, const unsigned int height, const unsigned int framePaddingElements, const PixelCenter pixelCenter, const VectorT2< TScalar > &position, uint8_t *result)
Determines the interpolated pixel values for a given pixel position in an 8 bit per channel frame.
Definition FrameInterpolatorBilinear.h:1459
static bool homography(const Frame &input, Frame &output, const SquareMatrix3 &input_H_output, const void *borderColor=nullptr, Worker *worker=nullptr, const PixelPositionI &outputOrigin=PixelPositionI(0, 0))
Transforms a given input frame into an output frame (with arbitrary frame dimension) by application o...
This class implements highly optimized interpolation functions with fixed properties.
Definition FrameInterpolatorBilinear.h:346
static void resize400x400To256x256_8BitPerChannel(const uint8_t *const source, uint8_t *const target, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Resizes a given FORMAT_Y8 frame with resolution 400x400 to a FORMAT_Y8 frame with resolution 256x256 ...
static void resize400x400To224x224_8BitPerChannel(const uint8_t *const source, uint8_t *const target, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Resizes a given FORMAT_Y8 frame with resolution 400x400 to a FORMAT_Y8 frame with resolution 224x224 ...
This class implements bilinear frame interpolator functions.
Definition FrameInterpolatorBilinear.h:47
static OCEAN_FORCE_INLINE void interpolate4Pixels8BitPerChannelNEON(const uint8_t *source, const unsigned int offsetsTopLeftElements[4], const unsigned int offsetsTopRightElements[4], const unsigned int offsetsBottomLeftElements[4], const unsigned int offsetsBottomRightElements[4], const unsigned int validPixels[4], const typename DataType< uint8_t, tChannels >::Type &borderColor, const uint32x4_t &m128_factorsRight, const uint32x4_t &m128_factorsBottom, typename DataType< uint8_t, tChannels >::Type *targetPositionPixels)
Interpolates 4 independent pixels concurrently based on already known locations (top-left,...
Definition FrameInterpolatorBilinear.h:4433
static void homography(const T *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 &input_H_output, const T *borderColor, T *output, const PixelPositionI &outputOrigin, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, Worker *worker=nullptr)
Transforms a input frame with (almost) arbitrary pixel format into an output frame by application of ...
Definition FrameInterpolatorBilinear.h:1770
static void resampleCameraImage(const T *sourceFrame, const AnyCamera &sourceCamera, const SquareMatrix3 &source_R_target, const AnyCamera &targetCamera, T *targetFrame, const unsigned int sourceFramePaddingElements, const unsigned int targetFramePaddingElements, LookupCorner2< Vector2 > *source_OLT_target=nullptr, Worker *worker=nullptr, const unsigned int binSizeInPixel=8u, const T *borderColor=nullptr)
Re-samples a camera image which has been captured with a camera profile as if the image would have be...
Definition FrameInterpolatorBilinear.h:1930
static void interpolateRowVerticalNEON(const T *sourceRowTop, const T *sourceRowBottom, T *targetRow, const unsigned int elements, const float factorBottom)
Applies a (vertical) linear interpolation between two rows with arbitrary data types.
static void homographyWithCamera8BitPerChannel(const PinholeCamera &inputCamera, const PinholeCamera &outputCamera, const uint8_t *input, const SquareMatrix3 &homography, const bool useDistortionParameters, const uint8_t *borderColor, uint8_t *output, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, Worker *worker=nullptr)
Transforms a given 8 bit per channel input frame into an output frame by application of a homography.
Definition FrameInterpolatorBilinear.h:1836
static void interpolatePixel8BitPerChannel(const uint8_t *frame, const unsigned int width, const unsigned int height, const unsigned int framePaddingElements, const VectorT2< TScalar > &position, uint8_t *result)
Determines the interpolated pixel values for a given pixel position in an 8 bit per channel frame.
Definition FrameInterpolatorBilinear.h:1997
static void affine8BitPerChannelSSESubset(const uint8_t *source, const unsigned int sourceWidth, const unsigned int sourceHeight, const SquareMatrix3 *source_A_target, const uint8_t *borderColor, uint8_t *target, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int firstTargetRow, const unsigned int numberTargetRows, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Subset function to apply an affine transform to an N-channel, 8-bit unsigned image (using SSE).
Definition FrameInterpolatorBilinear.h:2501
static Scalar patchIntensitySum1Channel(const uint32_t *linedIntegralFrame, const unsigned int frameWidth, const unsigned int frameHeight, const unsigned int lineIntegralFramePaddingElements, const Vector2 ¢er, const CV::PixelCenter pixelCenter, const unsigned int patchWidth, const unsigned int patchHeight)
Interpolate the sum of intensity values of an image patch in a frame, while the frame is provided as ...
static void homographyWithCameraMask8BitPerChannel(const PinholeCamera &inputCamera, const PinholeCamera &outputCamera, const uint8_t *input, const unsigned int inputPaddingElements, const SquareMatrix3 &homography, uint8_t *output, uint8_t *outputMask, const unsigned int outputPaddingElements, const unsigned int outputMaskPaddingElements, Worker *worker=nullptr, const uint8_t maskValue=0xFF)
Transforms a given 8 bit per channel input frame into an output frame by application of a homography.
Definition FrameInterpolatorBilinear.h:1853
static void homographiesMask8BitPerChannelSubset(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 *homographies, uint8_t *output, uint8_t *outputMask, const uint8_t maskValue, const Scalar outputQuadrantCenterX, const Scalar outputQuadrantCenterY, const int outputOriginX, const int outputOriginY, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int outputMaskPaddingElements, const unsigned int firstOutputRow, const unsigned int numberOutputRows)
Transforms an 8 bit per channel frame using the given homography.
Definition FrameInterpolatorBilinear.h:4655
static void homographiesMask8BitPerChannel(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 homographies[4], uint8_t *output, uint8_t *outputMask, const Vector2 &outputQuadrantCenter, const PixelPositionI &outputOrigin, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int outputMaskPaddingElements, Worker *worker=nullptr, const uint8_t maskValue=0xFF)
Transforms a given 8 bit per channel input frame into an output frame by application of four homograp...
Definition FrameInterpolatorBilinear.h:1823
static void interpolateRowHorizontal8BitPerChannel7BitPrecision(const uint8_t *extendedSourceRow, uint8_t *targetRow, const unsigned int targetWidth, const unsigned int channels, const unsigned int *interpolationLocations, const uint8_t *interpolationFactors)
Applies a (horizontal) linear interpolation for one row with 8 bit per channel.
static void homography8BitPerChannelNEONSubset(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 *input_H_output, const uint8_t *borderColor, uint8_t *output, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int firstOutputRow, const unsigned int numberOutputRows)
Transforms an 8 bit per channel frame using the given homography.
Definition FrameInterpolatorBilinear.h:3614
static OCEAN_FORCE_INLINE void interpolate4Pixels4Channel8BitPerChannelNEON(const uint8x16_t &topLeftPixels_u8x16, const uint8x16_t &topRightPixels_u8x16, const uint8x16_t &bottomLeftPixels_u8x16, const uint8x16_t &bottomRightPixels_u8x16, const uint32x4_t &m128_factorsRight, const uint32x4_t &m128_factorsBottom, typename DataType< uint8_t, 4u >::Type *targetPositionPixels, const bool useOptimizedNEONFactorReplication=false)
Interpolates 4 independent 4-channel pixels using widening byte multiply.
Definition FrameInterpolatorBilinear.h:4321
static void interpolateRowVertical8BitPerChannel7BitPrecisionNEON(const uint8_t *sourceRowTop, const uint8_t *sourceRowBottom, uint8_t *targetRow, const unsigned int elements, const unsigned int factorBottom)
Applies a (vertical) linear interpolation between two rows with 8 bit per channel.
static void homographySubset(const T *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 *input_H_output, const T *borderColor, T *output, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int firstOutputRow, const unsigned int numberOutputRows)
Transforms a frame with (almost) arbitrary pixel format using the given homography.
Definition FrameInterpolatorBilinear.h:2417
static void homographyMask8BitPerChannel(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 &input_H_output, uint8_t *output, uint8_t *outputMask, const PixelPositionI &outputOrigin, const unsigned int outputWidth, const unsigned int outputHeight, const uint8_t maskValue, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int outputMaskPaddingElements, Worker *worker=nullptr)
Transforms a given 8 bit per channel input frame into an output frame by application of a homography.
Definition FrameInterpolatorBilinear.h:1807
static OCEAN_FORCE_INLINE void interpolate8Pixels1Channel8BitNEON(const uint8x8_t &topLeft_u_8x8, const uint8x8_t &topRight_u_8x8, const uint8x8_t &bottomLeft_u_8x8, const uint8x8_t &bottomRight_u_8x8, const uint8x16_t &factorsRight_factorsBottom_128_u_8x16, uint8_t *targetPositionPixels)
Interpolates 8 independent pixels concurrently of a 1 channel frame, the source pixel locations must ...
Definition FrameInterpolatorBilinear.h:3994
static void homographies8BitPerChannelSubset(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 *homographies, const uint8_t *borderColor, uint8_t *output, const Scalar outputQuadrantCenterX, const Scalar outputQuadrantCenterY, const int outputOriginX, const int outputOriginY, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int firstOutputRow, const unsigned int numberOutputRows)
Transforms an 8 bit per channel frame using the given homographies.
Definition FrameInterpolatorBilinear.h:4499
static void homographyWithCamera8BitPerChannelSubset(const PinholeCamera *inputCamera, const PinholeCamera *outputCamera, const PinholeCamera::DistortionLookup *outputCameraDistortionLookup, const uint8_t *input, const SquareMatrix3 *normalizedHomography, const bool useDistortionParameters, const uint8_t *borderColor, uint8_t *output, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int firstRow, const unsigned int numberRows)
Transforms an 8 bit per channel frame using the given homography.
Definition FrameInterpolatorBilinear.h:4735
static void affine8BitPerChannel(const uint8_t *source, const unsigned int sourceWidth, const unsigned int sourceHeight, const SquareMatrix3 &source_A_target, const uint8_t *borderColor, uint8_t *target, const PixelPositionI &targetOrigin, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Apply an affine transforms to a N-channel, 8-bit frame The target frame must have the same pixel form...
Definition FrameInterpolatorBilinear.h:1694
static void homographyWithCameraMask8BitPerChannelSubset(const PinholeCamera *inputCamera, const PinholeCamera *outputCamera, const PinholeCamera::DistortionLookup *outputCameraDistortionLookup, const uint8_t *input, const unsigned int inputPaddingElements, const SquareMatrix3 *normalizedHomography, uint8_t *output, uint8_t *outputMask, const unsigned int outputPaddingElements, const unsigned int outputMaskPaddingElements, const uint8_t maskValue, const unsigned int firstRow, const unsigned int numberRows)
Transforms an 8 bit per channel frame using the given homography.
Definition FrameInterpolatorBilinear.h:4781
static void affine8BitPerChannelNEONSubset(const uint8_t *source, const unsigned int sourceWidth, const unsigned int sourceHeight, const SquareMatrix3 *source_A_target, const uint8_t *borderColor, uint8_t *target, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int firstTargetRow, const unsigned int numberTargetRows, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Subset function to apply an affine transform to an N-channel, 8-bit unsigned image (using NEON).
Definition FrameInterpolatorBilinear.h:3364
static void lookup(const T *input, const unsigned int inputWidth, const unsigned int inputHeight, const LookupTable &input_LT_output, const bool offset, const T *borderColor, T *output, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, Worker *worker=nullptr, const bool useOptimizedNEON=false, const bool useOptimizedBilinearValuesAndFactorCalculation=false, const bool useOptimizedNEONFactorReplication=false, const bool use4ChannelSamplingFastPaths=false)
Transforms a given input frame into an output frame by application of an interpolation lookup table.
Definition FrameInterpolatorBilinear.h:1870
static void interpolateRowHorizontalNEON(const T *extendedSourceRow, T *targetRow, const unsigned int targetWidth, const unsigned int channels, const unsigned int *interpolationLocations, const float *interpolationFactorsRight)
Applies a (horizontal) linear interpolation for one row with arbitrary data type.
static void scale8BitPerChannelSubset7BitPrecisionNEON(const uint8_t *source, uint8_t *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int channels, const double sourceX_s_targetX, const double sourceY_s_targetY, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const unsigned int firstTargetRow, const unsigned int numberTargetRows)
Rescales a subset of a given frame with 8 bit per channel by a bilinear interpolation.
Definition FrameInterpolatorBilinear.h:5764
static OCEAN_FORCE_INLINE __m128i interpolate4Pixels8BitPerChannelSSE(const __m128i &m128_sourcesTopLeft, const __m128i &m128_sourcesTopRight, const __m128i &m128_sourcesBottomLeft, const __m128i &m128_sourcesBottomRight, const __m128i &m128_factorsTopLeft, const __m128i &m128_factorsTopRight, const __m128i &m128_factorsBottomLeft, const __m128i &m128_factorsBottomRight)
Interpolates 4 independent pixels concurrently based on already known locations (top-left,...
static void interpolateRowHorizontal(const T *extendedSourceRow, T *targetRow, const unsigned int targetWidth, const unsigned int channels, const unsigned int *interpolationLocations, const float *interpolationFactorsRight)
Applies a (horizontal) linear interpolation for one row with arbitrary data type.
Definition FrameInterpolatorBilinear.h:5729
static void rotate8BitPerChannelSubset(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const Scalar horizontalAnchorPosition, const Scalar verticalAnchorPosition, const Scalar angle, const uint8_t *borderColor, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const unsigned int firstTargetRow, const unsigned int numberTargetRows)
Rotates a subset of a given frame by a bilinear interpolation.
Definition FrameInterpolatorBilinear.h:7312
static void lookupMask8BitPerChannel(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const LookupTable &input_LT_output, const bool offset, uint8_t *output, uint8_t *outputMask, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int outputMaskPaddingElements, Worker *worker=nullptr, const uint8_t maskValue=0xFF)
Transforms a given input frame into an output frame by application of an interpolation lookup table.
Definition FrameInterpolatorBilinear.h:1917
static OCEAN_FORCE_INLINE void interpolate4Pixels8BitPerChannelSSE(const uint8_t *source, const unsigned int offsetsTopLeft[4], const unsigned int offsetsTopRight[4], const unsigned int offsetsBottomLeft[4], const unsigned int offsetsBottomRight[4], const unsigned int validPixels[4], const typename DataType< uint8_t, tChannels >::Type &borderColor, const __m128i &m128_factorsRight, const __m128i &m128_factorsBottom, typename DataType< uint8_t, tChannels >::Type *targetPositionPixels)
Interpolates 4 independent pixels concurrently based on already known locations (top-left,...
Definition FrameInterpolatorBilinear.h:3296
static void homographies8BitPerChannel(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 homographies[4], const uint8_t *borderColor, uint8_t *output, const Vector2 &outputQuadrantCenter, const PixelPositionI &outputOrigin, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, Worker *worker=nullptr)
Transforms a given 8 bit per channel input frame into an output frame by application of four homograp...
Definition FrameInterpolatorBilinear.h:1794
static void lookup8BitPerChannelSubset(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const LookupTable *input_LT_output, const bool offset, const uint8_t *borderColor, uint8_t *output, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int firstRow, const unsigned int numberRows)
Transforms a subset of a given input frame with uint8_t as element type into an output frame by appli...
Definition FrameInterpolatorBilinear.h:4829
static void resize(const T *source, T *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Resizes a given frame with (almost) arbitrary data type (e.g., float, double, int) by using a bilinea...
Definition FrameInterpolatorBilinear.h:1645
static bool coversHomographyInputFrame(const unsigned int inputWidth, const unsigned int inputHeight, const unsigned int outputWidth, const unsigned int outputHeight, const SquareMatrix3 &input_H_output, const int outputOriginX=0, const int outputOriginY=0)
Checks whether the application of a given homography for a specified input frame and output frame cov...
static void scale(const T *source, T *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int targetWidth, const unsigned int targetHeight, const double sourceX_s_targetX, const double sourceY_s_targetY, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Rescales a given frame with arbitrary data type (e.g., float, double, int) by using a bilinear interp...
Definition FrameInterpolatorBilinear.h:1658
static void lookupSubset(const T *input, const unsigned int inputWidth, const unsigned int inputHeight, const LookupTable *input_LT_output, const bool offset, const T *borderColor, T *output, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int firstRow, const unsigned int numberRows)
Transforms a subset of a given input frame with arbitrary element type into an output frame by applic...
Definition FrameInterpolatorBilinear.h:4901
static void scale8BitPerChannelSubset(const uint8_t *source, uint8_t *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int targetWidth, const unsigned int targetHeight, const double sourceX_s_targetX, const double sourceY_s_targetY, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const unsigned int firstTargetRow, const unsigned int numberTargetRows)
Resizes a subset of a given frame with 8 bit per channel by a bilinear interpolation.
Definition FrameInterpolatorBilinear.h:5588
static void rotate8BitPerChannel(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const Scalar horizontalAnchorPosition, const Scalar verticalAnchorPosition, const Scalar angle, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr, const uint8_t *borderColor=nullptr)
Rotates a given frame by a bilinear interpolation.
Definition FrameInterpolatorBilinear.h:1979
static void interpolateRowVertical(const T *sourceRowTop, const T *sourceRowBottom, T *targetRow, const unsigned int elements, const float factorBottom)
Applies a (vertical) linear interpolation between two rows with arbitrary data types.
Definition FrameInterpolatorBilinear.h:5709
static void homography8BitPerChannel(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 &input_H_output, const uint8_t *borderColor, uint8_t *output, const PixelPositionI &outputOrigin, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, Worker *worker=nullptr)
Transforms a given 8 bit per channel input frame into an output frame by application of a homography.
Definition FrameInterpolatorBilinear.h:1732
static void interpolate1PixelFullAlphaBorder8BitPerChannel(const uint8_t *frame, const unsigned int width, const unsigned int height, const Vector2 &position, uint8_t *result, const unsigned int framePaddingElements)
Determines the interpolated pixel values for a given pixel position in an 8 bit per channel frame wit...
Definition FrameInterpolatorBilinear.h:2176
static void lookupMask8BitPerChannelSubset(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const LookupTable *input_LT_output, const bool offset, uint8_t *output, uint8_t *outputMask, const uint8_t maskValue, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int outputMaskPaddingElements, const unsigned int firstRow, const unsigned int numberRows)
Transforms a given input frame into an output frame by application of an interpolation lookup table.
Definition FrameInterpolatorBilinear.h:5473
static void affine8BitPerChannelSubset(const uint8_t *source, const unsigned int sourceWidth, const unsigned int sourceHeight, const SquareMatrix3 *source_A_target, const uint8_t *borderColor, uint8_t *target, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int firstTargetRow, const unsigned int numberTargetRows, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Subset function to apply an affine transform to an N-channel, 8-bit unsigned image.
Definition FrameInterpolatorBilinear.h:2265
static void homography8BitPerChannelSSESubset(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 *input_H_output, const uint8_t *borderColor, uint8_t *output, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int firstOutputRow, const unsigned int numberOutputRows)
Transforms an 8 bit per channel frame using the given homography.
Definition FrameInterpolatorBilinear.h:2686
static void interpolateRowHorizontal8BitPerChannel7BitPrecisionNEON(const uint8_t *extendedSourceRow, uint8_t *targetRow, const unsigned int targetWidth, const unsigned int channels, const unsigned int *interpolationLocations, const uint8_t *interpolationFactors)
Applies a (horizontal) linear interpolation for one row with 8 bit per channel.
static void scale8BitPerChannel(const uint8_t *source, uint8_t *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int targetWidth, const unsigned int targetHeight, const double sourceX_s_targetX, const double sourceY_s_targetY, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Rescales a given frame with 8 bit per data channel by using a bilinear interpolation with user-define...
Definition FrameInterpolatorBilinear.h:5544
LookupCorner2< Vector2 > LookupTable
Definition of a lookup table for 2D vectors.
Definition FrameInterpolatorBilinear.h:55
static void homographyMask8BitPerChannelSubset(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 *input_H_output, uint8_t *output, uint8_t *outputMask, const uint8_t maskValue, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int outputMaskPaddingElements, const unsigned int firstOutputRow, const unsigned int numberOutputRows)
Transforms an 8 bit per channel frame using the given homography.
Definition FrameInterpolatorBilinear.h:4580
static void scaleSubset(const T *source, T *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int targetWidth, const unsigned int targetHeight, const double sourceX_s_targetX, const double sourceY_s_targetY, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const unsigned int firstTargetRow, const unsigned int numberTargetRows)
Resizes a subset of a given frame with arbitrary data type by a bilinear interpolation.
Definition FrameInterpolatorBilinear.h:7188
static void homography8BitPerChannelSubset(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const SquareMatrix3 *input_H_output, const uint8_t *borderColor, uint8_t *output, const unsigned int outputWidth, const unsigned int outputHeight, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int firstOutputRow, const unsigned int numberOutputRows)
Transforms an 8 bit per channel frame using the given homography.
Definition FrameInterpolatorBilinear.h:2340
static void interpolatePixel(const TSource *frame, const unsigned int width, const unsigned int height, const unsigned int framePaddingElements, const VectorT2< TScalar > &position, TTarget *result, const TIntermediate &resultBias=TIntermediate(0))
Determines the interpolated pixel values for a given pixel position in a frame with arbitrary data ty...
Definition FrameInterpolatorBilinear.h:2090
static void lookup8BitPerChannelSubsetNEON(const uint8_t *input, const unsigned int inputWidth, const unsigned int inputHeight, const LookupTable *input_LT_output, const bool offset, const uint8_t *borderColor, uint8_t *output, const unsigned int inputPaddingElements, const unsigned int outputPaddingElements, const unsigned int firstRow, const unsigned int numberRows, const bool useOptimizedNEON=false, const bool useOptimizedBilinearValuesAndFactorCalculation=false, const bool useOptimizedNEONFactorReplication=false, const bool use4ChannelSamplingFastPaths=false)
Transforms a subset of a given input frame into an output frame by application of an interpolation lo...
Definition FrameInterpolatorBilinear.h:5195
static constexpr uint8x8_t create_uint8x8(const uint8_t v0, const uint8_t v1, const uint8_t v2, const uint8_t v3, const uint8_t v4, const uint8_t v5, const uint8_t v6, const uint8_t v7)
Creates a uint8x8_t vector from 8 individual uint8_t values.
Definition NEON.h:591
T y() const
Returns the vertical coordinate position of this object.
Definition PixelPosition.h:468
T x() const
Returns the horizontal coordinate position of this object.
Definition PixelPosition.h:456
static __m128i set128i(const unsigned long long high64, const unsigned long long low64)
Sets a 128i value by two 64 bit values.
Definition SSE.h:3874
static Caller< void > createStatic(typename StaticFunctionPointerMaker< void, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass >::Type function)
Template class allowing to define an array of data types.
Definition DataType.h:27
This class implements Ocean's image class.
Definition Frame.h:1969
void setRelativeTimestamp(const Timestamp &relative)
Sets the relative timestamp of this frame.
Definition Frame.h:4410
bool isValid() const
Returns whether this frame is valid.
Definition Frame.h:4705
void setTimestamp(const Timestamp ×tamp)
Sets the timestamp of this frame.
Definition Frame.h:4405
const Timestamp & timestamp() const
Returns the timestamp of this frame.
Definition Frame.h:4395
const Timestamp & relativeTimestamp() const
Returns the relative timestamp of this frame.
Definition Frame.h:4400
Definition of a frame type composed by the frame dimension, pixel format and pixel origin.
Definition Frame.h:30
size_t sizeY() const
Returns the vertical dimension of this lookup object.
Definition Lookup2.h:960
size_t sizeX() const
Returns the horizontal dimension of this lookup object.
Definition Lookup2.h:954
size_t binsY() const
Returns the number of vertical bins of this lookup object.
Definition Lookup2.h:972
size_t binsX() const
Returns the number of horizontal bins of this lookup object.
Definition Lookup2.h:966
This class implements a 2D lookup object with values at the bins' corners defining the individual loo...
Definition Lookup2.h:636
Vector2 binTopLeftCornerPosition(const size_t binX, const size_t binY) const
Returns the corner position (the top left corner) of a specific bin in relation to the dimension of t...
Definition Lookup2.h:1799
void setBinTopLeftCornerValue(const size_t binX, const size_t binY, const T &value)
Sets the value of one specific lookup bin's top left corner.
Definition Lookup2.h:2215
void bilinearValues(const size_t y, TTarget *values) const
Applies a lookup for an entire row in this lookup object.
Definition Lookup2.h:1877
This class implements an object able to allocate memory.
Definition base/Memory.h:22
static Memory create(const size_t elements)
Creates a new object and allocates enough memory necessary for 'elements' of type T.
Definition base/Memory.h:436
bool isNull() const
Returns whether this object holds any memory.
Definition base/Memory.h:401
void * data()
Returns the pointer to the writable memory which is allocated by this object.
Definition base/Memory.h:303
static constexpr Scalar eps()
static bool isEqual(const T first, const T second)
Returns whether two values are equal up to a small epsilon.
Definition Numeric.h:2395
static Scalar floor(const Scalar value)
static constexpr bool isEqualEps(const Scalar value)
static constexpr bool isNotEqualEps(const Scalar value)
unsigned int width() const
Returns the width of the camera image.
Definition PinholeCamera.h:1452
const SquareMatrixT3< T > & invertedIntrinsic() const
Returns the inverted intrinsic camera matrix.
Definition PinholeCamera.h:1333
const SquareMatrixT3< T > & intrinsic() const
Returns the intrinsic camera matrix.
Definition PinholeCamera.h:1327
unsigned int height() const
Returns the height of the camera image.
Definition PinholeCamera.h:1458
VectorT2< T > normalizedImagePoint2imagePoint(const VectorT2< T > &normalizedImagePoint, const bool distortImagePoint) const
Calculates the image point corresponding to a given normalized image point.
Definition PinholeCamera.h:1792
bool isNull() const
Returns whether this matrix is a zero matrix.
Definition SquareMatrix3.h:1334
const T * data() const
Returns a pointer to the internal values.
Definition SquareMatrix3.h:1047
bool isOrthonormal(const T epsilon=NumericT< T >::eps()) const
Returns whether this matrix is an orthonormal matrix.
Definition SquareMatrix3.h:1366
This class implements tests for the NEON-accelerated bilinear interpolation functions.
Definition TestFrameInterpolatorBilinearNEON.h:27
This class implements a vector with two elements.
Definition Vector2.h:96
const T & x() const noexcept
Returns the x value.
Definition Vector2.h:703
const T & y() const noexcept
Returns the y value.
Definition Vector2.h:715
bool isEqual(const VectorT2< T > &vector, const T eps) const
Returns whether two vectors are equal up to a specified epsilon.
Definition Vector2.h:751
const T & y() const noexcept
Returns the y value.
Definition Vector3.h:816
const T & x() const noexcept
Returns the x value.
Definition Vector3.h:804
const T & z() const noexcept
Returns the z value.
Definition Vector3.h:828
This class implements a worker able to distribute function calls over different threads.
Definition Worker.h:33
bool executeFunction(const Function &function, const unsigned int first, const unsigned int size, const unsigned int firstIndex=(unsigned int)(-1), const unsigned int sizeIndex=(unsigned int)(-1), const unsigned int minimalIterations=1u, const unsigned int threadIndex=(unsigned int)(-1))
Executes a callback function separable by two function parameters.
T minmax(const T &lowerBoundary, const T &value, const T &upperBoundary)
This function fits a given parameter into a specified value range.
Definition base/Utilities.h:973
PixelCenter
Definition of individual centers of pixels.
Definition CV.h:117
PixelPositionT< int > PixelPositionI
Definition of a PixelPosition object with a data type allowing positive and negative coordinate value...
Definition PixelPosition.h:39
@ PC_TOP_LEFT
The center of a pixel is in the upper-left corner of each pixel's square.
Definition CV.h:133
@ PC_CENTER
The center of a pixel is located in the center of each pixel's square (with an offset of 0....
Definition CV.h:150
PinholeCameraT< Scalar > PinholeCamera
Definition of an pinhole camera object with Scalar precision.
Definition PinholeCamera.h:39
VectorT2< float > VectorF2
Definition of a 2D vector with float values.
Definition Vector2.h:42
VectorT2< Scalar > Vector2
Definition of a 2D vector.
Definition Vector2.h:28
AnyCameraT< Scalar > AnyCamera
Definition of an AnyCamera object with Scalar precision.
Definition AnyCamera.h:31
SquareMatrixT2< Scalar > SquareMatrix2
Definition of the SquareMatrix2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with ...
Definition SquareMatrix2.h:29
VectorT3< Scalar > Vector3
Definition of a 3D vector.
Definition Vector3.h:29
RotationT< Scalar > Rotation
Definition of the Rotation object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION flag either with ...
Definition Rotation.h:32
SquareMatrixT3< Scalar > SquareMatrix3
Definition of the SquareMatrix3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with ...
Definition SquareMatrix3.h:43
float Scalar
Definition of a scalar type.
Definition Math.h:129
Namespace of the CV library.
Definition Advanced.h:17
Namespace of the CV Test library.
Definition LineDetectorHough.h:28
Namespace of the Test library.
Definition LineDetectorHough.h:28
The namespace covering the entire Ocean framework.
Definition Accessor.h:15
Default definition of a type with tBytes bytes.
Definition DataType.h:32
float Type
The 32 bit floating point data type for any data type T but 'double'.
Definition DataType.h:373