row_any.cc File Reference

#include "libyuv/row.h"
#include <string.h>
#include "libyuv/basic_types.h"

Macros
#define	SS(width, shift)   (((width) + (1 << (shift)) - 1) >> (shift))
#define	ANY41C(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, BPP, MASK)
#define	ANY31(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, BPP, MASK)
#define	ANY31C(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, BPP, MASK)
#define	ANY21(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, SBPP2, BPP, MASK)
#define	ANY21C(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, SBPP2, BPP, MASK)
#define	ANY11(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, BPP, MASK)
#define	ANY11B(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, BPP, MASK)
#define	ANY11P(NAMEANY, ANY_SIMD, T, SBPP, BPP, MASK)
#define	ANY11P16(NAMEANY, ANY_SIMD, T, SBPP, BPP, MASK)
#define	ANY11C(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, BPP, MASK)
#define	ANY11T(NAMEANY, ANY_SIMD, SBPP, BPP, MASK)
#define	ANY11M(NAMEANY, ANY_SIMD, BPP, MASK)
#define	ANY1(NAMEANY, ANY_SIMD, T, BPP, MASK)
#define	ANY12(NAMEANY, ANY_SIMD, UVSHIFT, BPP, DUVSHIFT, MASK)
#define	ANY12S(NAMEANY, ANY_SIMD, UVSHIFT, BPP, MASK)

Macro Definition Documentation

ANY1

#define ANY1	(		NAMEANY,
			ANY_SIMD,
			T,
			BPP,
			MASK
	)

Value:

void NAMEANY(uint8* dst_ptr, T v32, int width) {                           \
      SIMD_ALIGNED(uint8 temp[64]);                                            \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(dst_ptr, v32, n);                                             \
      }                                                                        \
      ANY_SIMD(temp, v32, MASK + 1);                                           \
      memcpy(dst_ptr + n * BPP, temp, r * BPP);                                \
    }

ANY11

#define ANY11	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			SBPP,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* src_ptr, uint8* dst_ptr, int width) {            \
      SIMD_ALIGNED(uint8 temp[128 * 2]);                                       \
      memset(temp, 0, 128);  /* for YUY2 and msan */                           \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(src_ptr, dst_ptr, n);                                         \
      }                                                                        \
      memcpy(temp, src_ptr + (n >> UVSHIFT) * SBPP, SS(r, UVSHIFT) * SBPP);    \
      ANY_SIMD(temp, temp + 128, MASK + 1);                                    \
      memcpy(dst_ptr + n * BPP, temp + 128, r * BPP);                          \
    }

ANY11B

#define ANY11B	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			SBPP,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* src_ptr, uint8* dst_ptr, int width) {            \
      SIMD_ALIGNED(uint8 temp[128 * 2]);                                       \
      memset(temp, 0, 128 * 2);  /* for YUY2 and msan */                       \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(src_ptr, dst_ptr, n);                                         \
      }                                                                        \
      memcpy(temp, src_ptr + (n >> UVSHIFT) * SBPP, SS(r, UVSHIFT) * SBPP);    \
      memcpy(temp + 128, dst_ptr + n * BPP, r * BPP);                          \
      ANY_SIMD(temp, temp + 128, MASK + 1);                                    \
      memcpy(dst_ptr + n * BPP, temp + 128, r * BPP);                          \
    }

ANY11C

#define ANY11C	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			SBPP,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* src_ptr, uint8* dst_ptr,                         \
                 const struct YuvConstants* yuvconstants, int width) {         \
      SIMD_ALIGNED(uint8 temp[128 * 2]);                                       \
      memset(temp, 0, 128);  /* for YUY2 and msan */                           \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(src_ptr, dst_ptr, yuvconstants, n);                           \
      }                                                                        \
      memcpy(temp, src_ptr + (n >> UVSHIFT) * SBPP, SS(r, UVSHIFT) * SBPP);    \
      ANY_SIMD(temp, temp + 128, yuvconstants, MASK + 1);                      \
      memcpy(dst_ptr + n * BPP, temp + 128, r * BPP);                          \
    }

ANY11M

#define ANY11M	(		NAMEANY,
			ANY_SIMD,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* src_ptr, uint8* dst_ptr, int width) {            \
      SIMD_ALIGNED(uint8 temp[64 * 2]);                                        \
      memset(temp, 0, 64);  /* for msan */                                     \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(src_ptr + r * BPP, dst_ptr, n);                               \
      }                                                                        \
      memcpy(temp, src_ptr, r * BPP);                                          \
      ANY_SIMD(temp, temp + 64, MASK + 1);                                     \
      memcpy(dst_ptr + n * BPP, temp + 64 + (MASK + 1 - r) * BPP, r * BPP);    \
    }

ANY11P

#define ANY11P	(		NAMEANY,
			ANY_SIMD,
			T,
			SBPP,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* src_ptr, uint8* dst_ptr,                         \
                 T shuffler, int width) {                                      \
      SIMD_ALIGNED(uint8 temp[64 * 2]);                                        \
      memset(temp, 0, 64);  /* for msan */                                     \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(src_ptr, dst_ptr, shuffler, n);                               \
      }                                                                        \
      memcpy(temp, src_ptr + n * SBPP, r * SBPP);                              \
      ANY_SIMD(temp, temp + 64, shuffler, MASK + 1);                           \
      memcpy(dst_ptr + n * BPP, temp + 64, r * BPP);                           \
    }

ANY11P16

#define ANY11P16	(		NAMEANY,
			ANY_SIMD,
			T,
			SBPP,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint16* src_ptr, uint16* dst_ptr,                       \
                 T shuffler, int width) {                                      \
      SIMD_ALIGNED(uint16 temp[32 * 2]);                                       \
      memset(temp, 0, 64);  /* for msan */                                     \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(src_ptr, dst_ptr, shuffler, n);                               \
      }                                                                        \
      memcpy(temp, src_ptr + n * SBPP, r * SBPP);                              \
      ANY_SIMD(temp, temp + 64, shuffler, MASK + 1);                           \
      memcpy(dst_ptr + n * BPP, temp + 64, r * BPP);                           \
    }

ANY11T

#define ANY11T	(		NAMEANY,
			ANY_SIMD,
			SBPP,
			BPP,
			MASK
	)

Value:

void NAMEANY(uint8* dst_ptr, const uint8* src_ptr,                         \
                 ptrdiff_t src_stride_ptr, int width,                          \
                 int source_y_fraction) {                                      \
      SIMD_ALIGNED(uint8 temp[64 * 3]);                                        \
      memset(temp, 0, 64 * 2);  /* for msan */                                 \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(dst_ptr, src_ptr, src_stride_ptr, n, source_y_fraction);      \
      }                                                                        \
      memcpy(temp, src_ptr + n * SBPP, r * SBPP);                              \
      memcpy(temp + 64, src_ptr + src_stride_ptr + n * SBPP, r * SBPP);        \
      ANY_SIMD(temp + 128, temp, 64, MASK + 1, source_y_fraction);             \
      memcpy(dst_ptr + n * BPP, temp + 128, r * BPP);                          \
    }

ANY12

#define ANY12	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			BPP,
			DUVSHIFT,
			MASK
	)

Value:

void NAMEANY(const uint8* src_ptr, uint8* dst_u, uint8* dst_v, int width) {\
      SIMD_ALIGNED(uint8 temp[128 * 3]);                                       \
      memset(temp, 0, 128);  /* for msan */                                    \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(src_ptr, dst_u, dst_v, n);                                    \
      }                                                                        \
      memcpy(temp, src_ptr  + (n >> UVSHIFT) * BPP, SS(r, UVSHIFT) * BPP);     \
      ANY_SIMD(temp, temp + 128, temp + 256, MASK + 1);                        \
      memcpy(dst_u + (n >> DUVSHIFT), temp + 128, SS(r, DUVSHIFT));            \
      memcpy(dst_v + (n >> DUVSHIFT), temp + 256, SS(r, DUVSHIFT));            \
    }

ANY12S

#define ANY12S	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* src_ptr, int src_stride_ptr,                     \
                 uint8* dst_u, uint8* dst_v, int width) {                      \
      SIMD_ALIGNED(uint8 temp[128 * 4]);                                       \
      memset(temp, 0, 128 * 2);  /* for msan */                                \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(src_ptr, src_stride_ptr, dst_u, dst_v, n);                    \
      }                                                                        \
      memcpy(temp, src_ptr  + (n >> UVSHIFT) * BPP, SS(r, UVSHIFT) * BPP);     \
      memcpy(temp + 128, src_ptr  + src_stride_ptr + (n >> UVSHIFT) * BPP,     \
             SS(r, UVSHIFT) * BPP);                                            \
      if ((width & 1) && UVSHIFT == 0) {  /* repeat last pixel for subsample */\
        memcpy(temp + SS(r, UVSHIFT) * BPP,                                    \
               temp + SS(r, UVSHIFT) * BPP - BPP, BPP);                        \
        memcpy(temp + 128 + SS(r, UVSHIFT) * BPP,                              \
               temp + 128 + SS(r, UVSHIFT) * BPP - BPP, BPP);                  \
      }                                                                        \
      ANY_SIMD(temp, 128, temp + 256, temp + 384, MASK + 1);                   \
      memcpy(dst_u + (n >> 1), temp + 256, SS(r, 1));                          \
      memcpy(dst_v + (n >> 1), temp + 384, SS(r, 1));                          \
    }

ANY21

#define ANY21	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			SBPP,
			SBPP2,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* y_buf, const uint8* uv_buf,                      \
                 uint8* dst_ptr, int width) {                                  \
      SIMD_ALIGNED(uint8 temp[64 * 3]);                                        \
      memset(temp, 0, 64 * 2);  /* for msan */                                 \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(y_buf, uv_buf, dst_ptr, n);                                   \
      }                                                                        \
      memcpy(temp, y_buf + n * SBPP, r * SBPP);                                \
      memcpy(temp + 64, uv_buf + (n >> UVSHIFT) * SBPP2,                       \
             SS(r, UVSHIFT) * SBPP2);                                          \
      ANY_SIMD(temp, temp + 64, temp + 128, MASK + 1);                         \
      memcpy(dst_ptr + n * BPP, temp + 128, r * BPP);                          \
    }

ANY21C

#define ANY21C	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			SBPP,
			SBPP2,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* y_buf, const uint8* uv_buf,                      \
                 uint8* dst_ptr, const struct YuvConstants* yuvconstants,      \
                 int width) {                                                  \
      SIMD_ALIGNED(uint8 temp[64 * 3]);                                        \
      memset(temp, 0, 64 * 2);  /* for msan */                                 \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(y_buf, uv_buf, dst_ptr, yuvconstants, n);                     \
      }                                                                        \
      memcpy(temp, y_buf + n * SBPP, r * SBPP);                                \
      memcpy(temp + 64, uv_buf + (n >> UVSHIFT) * SBPP2,                       \
             SS(r, UVSHIFT) * SBPP2);                                          \
      ANY_SIMD(temp, temp + 64, temp + 128, yuvconstants, MASK + 1);           \
      memcpy(dst_ptr + n * BPP, temp + 128, r * BPP);                          \
    }

ANY31

#define ANY31	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			DUVSHIFT,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* y_buf, const uint8* u_buf, const uint8* v_buf,   \
                 uint8* dst_ptr, int width) {                                  \
      SIMD_ALIGNED(uint8 temp[64 * 4]);                                        \
      memset(temp, 0, 64 * 3);  /* for YUY2 and msan */                        \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(y_buf, u_buf, v_buf, dst_ptr, n);                             \
      }                                                                        \
      memcpy(temp, y_buf + n, r);                                              \
      memcpy(temp + 64, u_buf + (n >> UVSHIFT), SS(r, UVSHIFT));               \
      memcpy(temp + 128, v_buf + (n >> UVSHIFT), SS(r, UVSHIFT));              \
      ANY_SIMD(temp, temp + 64, temp + 128, temp + 192, MASK + 1);             \
      memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, temp + 192,                      \
             SS(r, DUVSHIFT) * BPP);                                           \
    }

ANY31C

#define ANY31C	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			DUVSHIFT,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* y_buf, const uint8* u_buf, const uint8* v_buf,   \
                 uint8* dst_ptr, const struct YuvConstants* yuvconstants,      \
                 int width) {                                                  \
      SIMD_ALIGNED(uint8 temp[64 * 4]);                                        \
      memset(temp, 0, 64 * 3);  /* for YUY2 and msan */                        \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(y_buf, u_buf, v_buf, dst_ptr, yuvconstants, n);               \
      }                                                                        \
      memcpy(temp, y_buf + n, r);                                              \
      memcpy(temp + 64, u_buf + (n >> UVSHIFT), SS(r, UVSHIFT));               \
      memcpy(temp + 128, v_buf + (n >> UVSHIFT), SS(r, UVSHIFT));              \
      if (width & 1) {                                                         \
        temp[64 + SS(r, UVSHIFT)] = temp[64 + SS(r, UVSHIFT) - 1];             \
        temp[128 + SS(r, UVSHIFT)] = temp[128 + SS(r, UVSHIFT) - 1];           \
      }                                                                        \
      ANY_SIMD(temp, temp + 64, temp + 128, temp + 192,                        \
               yuvconstants, MASK + 1);                                        \
      memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, temp + 192,                      \
             SS(r, DUVSHIFT) * BPP);                                           \
    }

ANY41C

#define ANY41C	(		NAMEANY,
			ANY_SIMD,
			UVSHIFT,
			DUVSHIFT,
			BPP,
			MASK
	)

Value:

void NAMEANY(const uint8* y_buf, const uint8* u_buf, const uint8* v_buf,   \
                 const uint8* a_buf, uint8* dst_ptr,                           \
                 const struct YuvConstants* yuvconstants,  int width) {        \
      SIMD_ALIGNED(uint8 temp[64 * 5]);                                        \
      memset(temp, 0, 64 * 4);  /* for msan */                                 \
      int r = width & MASK;                                                    \
      int n = width & ~MASK;                                                   \
      if (n > 0) {                                                             \
        ANY_SIMD(y_buf, u_buf, v_buf, a_buf, dst_ptr, yuvconstants, n);        \
      }                                                                        \
      memcpy(temp, y_buf + n, r);                                              \
      memcpy(temp + 64, u_buf + (n >> UVSHIFT), SS(r, UVSHIFT));               \
      memcpy(temp + 128, v_buf + (n >> UVSHIFT), SS(r, UVSHIFT));              \
      memcpy(temp + 192, a_buf + n, r);                                        \
      ANY_SIMD(temp, temp + 64, temp + 128, temp + 192, temp + 256,            \
               yuvconstants, MASK + 1);                                        \
      memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, temp + 256,                      \
             SS(r, DUVSHIFT) * BPP);                                           \
    }

SS

#define SS	(		width,
			shift
	)		(((width) + (1 << (shift)) - 1) >> (shift))