downsample_2x() [1/3]

MAYAFLUX_API void MayaFlux::Kinesis::Vision::downsample_2x	(	std::span< const float >	src,
		std::span< float >	dst,
		uint32_t	w,
		uint32_t	h,
		uint32_t &	new_w,
		uint32_t &	new_h
	)

2x box-filter downsample writing into a caller-supplied buffer.

Parameters

src	Input span, size w * h.
dst	Output span, size must be >= floor(w/2) * floor(h/2).
w	Input width in pixels.
h	Input height in pixels.
new_w	Receives output width.
new_h	Receives output height.

Definition at line 423 of file PixelOps.cpp.

{
    new_w = w / 2;
    new_h = h / 2;
 
    std::for_each(std::execution::par_unseq,
        std::views::iota(uint32_t { 0 }, new_h).begin(),
        std::views::iota(uint32_t { 0 }, new_h).end(),
        [&](uint32_t oy) {
            const float* row0 = src.data() + static_cast<size_t>(oy * 2) * w;
            const float* row1 = src.data() + static_cast<size_t>(oy * 2 + 1) * w;
            float* drow = dst.data() + static_cast<size_t>(oy) * new_w;
 
#ifdef MAYAFLUX_ARCH_X64
            const __m256 quarter = _mm256_set1_ps(0.25F);
            uint32_t ox = 0;
            for (; ox + 8 <= new_w; ox += 8) {
 
                __m256 r0a = _mm256_loadu_ps(row0 + ox * 2); // px 0..7  of row0
                __m256 r0b = _mm256_loadu_ps(row0 + ox * 2 + 8); // px 8..15 of row0
                __m256 r1a = _mm256_loadu_ps(row1 + ox * 2);
                __m256 r1b = _mm256_loadu_ps(row1 + ox * 2 + 8);
 
                // horizontal add pairs: hadd gains (a0+a1, a2+a3, b0+b1, b2+b3 | ...)
                __m256 sum0 = _mm256_hadd_ps(r0a, r0b); // (r00+r01, r02+r03, r08+r09, r010+r011 | ...)
                __m256 sum1 = _mm256_hadd_ps(r1a, r1b);
                __m256 sum = _mm256_add_ps(sum0, sum1);
 
                __m256d perm_d = _mm256_permute4x64_pd(_mm256_castps_pd(sum), _MM_SHUFFLE(3, 1, 2, 0));
                __m256 result = _mm256_mul_ps(_mm256_castpd_ps(perm_d), quarter);
                _mm256_storeu_ps(drow + ox, result);
            }
            for (; ox < new_w; ++ox) {
                drow[ox] = (row0[ox * 2] + row0[ox * 2 + 1]
                               + row1[ox * 2] + row1[ox * 2 + 1])
                    * 0.25F;
            }
 
#elif defined(MAYAFLUX_ARCH_ARM64)
        const float32x4_t quarter = vdupq_n_f32(0.25F);
        uint32_t ox = 0;
        for (; ox + 4 <= new_w; ox += 4) {
            // vld2q_f32 loads 8 floats deinterleaved into 2 registers:
            // val[0] = even elements, val[1] = odd elements
            float32x4x2_t r0 = vld2q_f32(row0 + ox * 2);
            float32x4x2_t r1 = vld2q_f32(row1 + ox * 2);
            // r0.val[0] = [row0[0], row0[2], row0[4], row0[6]]
            // r0.val[1] = [row0[1], row0[3], row0[5], row0[7]]
            float32x4_t sum = vaddq_f32(
                vaddq_f32(r0.val[0], r0.val[1]),
                vaddq_f32(r1.val[0], r1.val[1]));
            vst1q_f32(drow + ox, vmulq_f32(sum, quarter));
        }
        for (; ox < new_w; ++ox) {
            drow[ox] = (row0[ox * 2] + row0[ox * 2 + 1]
                           + row1[ox * 2] + row1[ox * 2 + 1])
                * 0.25F;
        }
 
#else
        for (uint32_t ox = 0; ox < new_w; ++ox) {
            drow[ox] = (row0[ox * 2] + row0[ox * 2 + 1]
                           + row1[ox * 2] + row1[ox * 2 + 1])
                * 0.25F;
        }
#endif
        });
}

References dst, h, and src.

Referenced by downsample_2x(), downsample_2x(), and MayaFlux::Kinesis::Vision::VisionExecutor::run().

Here is the caller graph for this function: