CImage_SSE2.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "img-precomp.h"  // Precompiled headers
 
#if MRPT_HAS_SSE2
// ---------------------------------------------------------------------------
//   This file contains the SSE2 optimized functions for mrpt::img::CImage
//    See the sources and the doxygen documentation page "sse_optimizations" for
//    more details.
//
//  Some functions here are derived from sources in libcvd, released
//   under BSD. https://www.edwardrosten.com/cvd/
//
// ---------------------------------------------------------------------------
 
#include <mrpt/img/CImage.h>
#include <mrpt/core/SSE_types.h>
#include <mrpt/core/SSE_macros.h>
#include "CImage_SSEx.h"
 
/** \addtogroup sse_optimizations
 *  SSE optimized functions
 *  @{
 */
 
/** Subsample each 2x2 pixel block into 1x1 pixel, taking the first pixel &
 * ignoring the other 3
 *  - <b>Input format:</b> uint8_t, 1 channel
 *  - <b>Output format:</b> uint8_t, 1 channel
 *  - <b>Preconditions:</b> in & out aligned to 16bytes, w = k*16 (w=width in
 * pixels), widthStep=w*1
 *  - <b>Notes:</b>
 *  - <b>Requires:</b> SSE2
 *  - <b>Invoked from:</b> mrpt::img::CImage::scaleHalf()
 */
void image_SSE2_scale_half_1c8u(const uint8_t* in, uint8_t* out, int w, int h)
{
        alignas(32) const unsigned long long mask[2] = {0x00FF00FF00FF00FFull,
                                                                                                        0x00FF00FF00FF00FFull};
        const __m128i m = _mm_load_si128((const __m128i*)mask);
 
        int sw = w >> 4;
        int sh = h >> 1;
 
        for (int i = 0; i < sh; i++)
        {
                for (int j = 0; j < sw; j++)
                {
                        const __m128i here_sampled =
                                _mm_and_si128(_mm_load_si128((const __m128i*)in), m);
                        _mm_storel_epi64(
                                (__m128i*)out, _mm_packus_epi16(here_sampled, here_sampled));
                        in += 16;
                        out += 8;
                }
                in += w;
        }
}
 
/** Average each 2x2 pixels into 1x1 pixel (arithmetic average)
 *  - <b>Input format:</b> uint8_t, 1 channel
 *  - <b>Output format:</b> uint8_t, 1 channel
 *  - <b>Preconditions:</b> in & out aligned to 16bytes, w = k*16 (w=width in
 * pixels), widthStep=w*1
 *  - <b>Notes:</b>
 *  - <b>Requires:</b> SSE2
 *  - <b>Invoked from:</b> mrpt::img::CImage::scaleHalfSmooth()
 */
void image_SSE2_scale_half_smooth_1c8u(
        const uint8_t* in, uint8_t* out, int w, int h)
{
        alignas(MRPT_MAX_ALIGN_BYTES) const unsigned long long mask[2] = {0x00FF00FF00FF00FFull,
                                                                                                        0x00FF00FF00FF00FFull};
        const uint8_t* nextRow = in + w;
        __m128i m = _mm_load_si128((const __m128i*)mask);
        int sw = w >> 4;
        int sh = h >> 1;
 
        for (int i = 0; i < sh; i++)
        {
                for (int j = 0; j < sw; j++)
                {
                        __m128i here = _mm_load_si128((const __m128i*)in);
                        __m128i next = _mm_load_si128((const __m128i*)nextRow);
                        here = _mm_avg_epu8(here, next);
                        next = _mm_and_si128(_mm_srli_si128(here, 1), m);
                        here = _mm_and_si128(here, m);
                        here = _mm_avg_epu16(here, next);
                        _mm_storel_epi64((__m128i*)out, _mm_packus_epi16(here, here));
                        in += 16;
                        nextRow += 16;
                        out += 8;
                }
 
                in += w;
                nextRow += w;
        }
}
 
/** KLT score at a given point of a grayscale image.
 *  - <b>Requires:</b> SSE2
 *  - <b>Invoked from:</b> mrpt::img::CImage::KLT_response()
 *
 *  This function is not manually optimized for SSE2 but templatized for
 * different
 *   window sizes such as the compiler can optimize automatically for that
 * size.
 *
 *  Only for the most common window sizes this templates are instantiated
 * (W=[2-16] and W=32 ),
 *   falling back to
 *   a generic implementation otherwise. The next figure shows the performance
 * (time for
 *   KLT_response() to compute the score for one single pixel) for different
 * window sizes.
 *
 *  <img src="KLT_response_performance_SSE2.png" >
 *
 */
float KLT_response_optimized();
 
// TODO:
// Sum of absolute differences: Use  _mm_sad_epu8
 
/**  @} */
 
#endif  // end if MRPT_HAS_SSE2