/* * Copyright 2011 The LibYuv Project Authors. All rights reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "libyuv/row.h" #ifdef __cplusplus namespace libyuv { extern "C" { #endif // This module is for GCC x86 and x64. #if !defined(LIBYUV_DISABLE_X86) && (defined(__x86_64__) || defined(__i386__)) #if defined(HAS_ARGBTOYROW_SSSE3) || defined(HAS_ARGBGRAYROW_SSSE3) // Constants for ARGB static const uvec8 kARGBToY = …; // JPeg full range. static const uvec8 kARGBToYJ = …; static const uvec8 kABGRToYJ = …; static const uvec8 kRGBAToYJ = …; #endif // defined(HAS_ARGBTOYROW_SSSE3) || defined(HAS_ARGBGRAYROW_SSSE3) #if defined(HAS_ARGBTOYROW_SSSE3) || defined(HAS_I422TOARGBROW_SSSE3) static const vec8 kARGBToU = …; static const vec8 kARGBToUJ = …; static const vec8 kABGRToUJ = …; static const vec8 kARGBToV = …; static const vec8 kARGBToVJ = …; static const vec8 kABGRToVJ = …; // Constants for BGRA static const uvec8 kBGRAToY = …; static const vec8 kBGRAToU = …; static const vec8 kBGRAToV = …; // Constants for ABGR static const uvec8 kABGRToY = …; static const vec8 kABGRToU = …; static const vec8 kABGRToV = …; // Constants for RGBA. static const uvec8 kRGBAToY = …; static const vec8 kRGBAToU = …; static const vec8 kRGBAToV = …; static const uvec16 kAddY16 = …; static const uvec8 kAddUV128 = …; static const uvec16 kSub128 = …; #endif // defined(HAS_ARGBTOYROW_SSSE3) || defined(HAS_I422TOARGBROW_SSSE3) #ifdef HAS_RGB24TOARGBROW_SSSE3 // Shuffle table for converting RGB24 to ARGB. static const uvec8 kShuffleMaskRGB24ToARGB = …; // Shuffle table for converting RAW to ARGB. static const uvec8 kShuffleMaskRAWToARGB = …; // Shuffle table for converting RAW to RGBA. static const uvec8 kShuffleMaskRAWToRGBA = …; // Shuffle table for converting RAW to RGB24. First 8. static const uvec8 kShuffleMaskRAWToRGB24_0 = …; // Shuffle table for converting RAW to RGB24. Middle 8. static const uvec8 kShuffleMaskRAWToRGB24_1 = …; // Shuffle table for converting RAW to RGB24. Last 8. static const uvec8 kShuffleMaskRAWToRGB24_2 = …; // Shuffle table for converting ARGB to RGB24. static const uvec8 kShuffleMaskARGBToRGB24 = …; // Shuffle table for converting ARGB to RAW. static const uvec8 kShuffleMaskARGBToRAW = …; // Shuffle table for converting ARGBToRGB24 for I422ToRGB24. First 8 + next 4 static const uvec8 kShuffleMaskARGBToRGB24_0 = …; // YUY2 shuf 16 Y to 32 Y. static const vec8 kShuffleYUY2Y = …; // YUY2 shuf 8 UV to 16 UV. static const vec8 kShuffleYUY2UV = …; // UYVY shuf 16 Y to 32 Y. static const vec8 kShuffleUYVYY = …; // UYVY shuf 8 UV to 16 UV. static const vec8 kShuffleUYVYUV = …; // NV21 shuf 8 VU to 16 UV. static const lvec8 kShuffleNV21 = …; #endif // HAS_RGB24TOARGBROW_SSSE3 #ifdef HAS_J400TOARGBROW_SSE2 void J400ToARGBRow_SSE2(const uint8_t* src_y, uint8_t* dst_argb, int width) { … } #endif // HAS_J400TOARGBROW_SSE2 #ifdef HAS_RGB24TOARGBROW_SSSE3 void RGB24ToARGBRow_SSSE3(const uint8_t* src_rgb24, uint8_t* dst_argb, int width) { … } void RAWToARGBRow_SSSE3(const uint8_t* src_raw, uint8_t* dst_argb, int width) { … } // Same code as RAWToARGB with different shuffler and A in low bits void RAWToRGBARow_SSSE3(const uint8_t* src_raw, uint8_t* dst_rgba, int width) { … } void RAWToRGB24Row_SSSE3(const uint8_t* src_raw, uint8_t* dst_rgb24, int width) { … } void RGB565ToARGBRow_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } void ARGB1555ToARGBRow_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } void ARGB4444ToARGBRow_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } void ARGBToRGB24Row_SSSE3(const uint8_t* src, uint8_t* dst, int width) { … } void ARGBToRAWRow_SSSE3(const uint8_t* src, uint8_t* dst, int width) { … } #ifdef HAS_ARGBTORGB24ROW_AVX2 // vpermd for 12+12 to 24 static const lvec32 kPermdRGB24_AVX = …; void ARGBToRGB24Row_AVX2(const uint8_t* src, uint8_t* dst, int width) { … } #endif #ifdef HAS_ARGBTORGB24ROW_AVX512VBMI // Shuffle table for converting ARGBToRGB24 static const ulvec8 kPermARGBToRGB24_0 = …; static const ulvec8 kPermARGBToRGB24_1 = …; static const ulvec8 kPermARGBToRGB24_2 = …; void ARGBToRGB24Row_AVX512VBMI(const uint8_t* src, uint8_t* dst, int width) { … } #endif #ifdef HAS_ARGBTORAWROW_AVX2 void ARGBToRAWRow_AVX2(const uint8_t* src, uint8_t* dst, int width) { … } #endif void ARGBToRGB565Row_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } void ARGBToRGB565DitherRow_SSE2(const uint8_t* src, uint8_t* dst, uint32_t dither4, int width) { … } #ifdef HAS_ARGBTORGB565DITHERROW_AVX2 void ARGBToRGB565DitherRow_AVX2(const uint8_t* src, uint8_t* dst, uint32_t dither4, int width) { … } #endif // HAS_ARGBTORGB565DITHERROW_AVX2 void ARGBToARGB1555Row_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } void ARGBToARGB4444Row_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_RGB24TOARGBROW_SSSE3 /* ARGBToAR30Row: Red Blue With the 8 bit value in the upper bits of a short, vpmulhuw by (1024+4) will produce a 10 bit value in the low 10 bits of each 16 bit value. This is whats wanted for the blue channel. The red needs to be shifted 4 left, so multiply by (1024+4)*16 for red. Alpha Green Alpha and Green are already in the high bits so vpand can zero out the other bits, keeping just 2 upper bits of alpha and 8 bit green. The same multiplier could be used for Green - (1024+4) putting the 10 bit green in the lsb. Alpha would be a simple multiplier to shift it into position. It wants a gap of 10 above the green. Green is 10 bits, so there are 6 bits in the low short. 4 more are needed, so a multiplier of 4 gets the 2 bits into the upper 16 bits, and then a shift of 4 is a multiply of 16, so (4*16) = 64. Then shift the result left 10 to position the A and G channels. */ // Shuffle table for converting RAW to RGB24. Last 8. static const uvec8 kShuffleRB30 = …; static const uvec8 kShuffleBR30 = …; static const uint32_t kMulRB10 = …; static const uint32_t kMaskRB10 = …; static const uint32_t kMaskAG10 = …; static const uint32_t kMulAG10 = …; void ARGBToAR30Row_SSSE3(const uint8_t* src, uint8_t* dst, int width) { … } void ABGRToAR30Row_SSSE3(const uint8_t* src, uint8_t* dst, int width) { … } #ifdef HAS_ARGBTOAR30ROW_AVX2 void ARGBToAR30Row_AVX2(const uint8_t* src, uint8_t* dst, int width) { … } #endif #ifdef HAS_ABGRTOAR30ROW_AVX2 void ABGRToAR30Row_AVX2(const uint8_t* src, uint8_t* dst, int width) { … } #endif static const uvec8 kShuffleARGBToABGR = …; static const uvec8 kShuffleARGBToAB64Lo = …; static const uvec8 kShuffleARGBToAB64Hi = …; void ARGBToAR64Row_SSSE3(const uint8_t* src_argb, uint16_t* dst_ar64, int width) { … } void ARGBToAB64Row_SSSE3(const uint8_t* src_argb, uint16_t* dst_ab64, int width) { … } void AR64ToARGBRow_SSSE3(const uint16_t* src_ar64, uint8_t* dst_argb, int width) { … } void AB64ToARGBRow_SSSE3(const uint16_t* src_ab64, uint8_t* dst_argb, int width) { … } #ifdef HAS_ARGBTOAR64ROW_AVX2 void ARGBToAR64Row_AVX2(const uint8_t* src_argb, uint16_t* dst_ar64, int width) { … } #endif #ifdef HAS_ARGBTOAB64ROW_AVX2 void ARGBToAB64Row_AVX2(const uint8_t* src_argb, uint16_t* dst_ab64, int width) { … } #endif #ifdef HAS_AR64TOARGBROW_AVX2 void AR64ToARGBRow_AVX2(const uint16_t* src_ar64, uint8_t* dst_argb, int width) { … } #endif #ifdef HAS_AB64TOARGBROW_AVX2 void AB64ToARGBRow_AVX2(const uint16_t* src_ab64, uint8_t* dst_argb, int width) { … } #endif // TODO(mraptis): Consider passing R, G, B multipliers as parameter. // round parameter is register containing value to add before shift. #define RGBTOY(round) … #define RGBTOY_AVX2(round) … #ifdef HAS_ARGBTOYROW_SSSE3 // Convert 16 ARGB pixels (64 bytes) to 16 Y values. void ARGBToYRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_y, int width) { … } #endif // HAS_ARGBTOYROW_SSSE3 #ifdef HAS_ARGBTOYJROW_SSSE3 // Convert 16 ARGB pixels (64 bytes) to 16 YJ values. // Same as ARGBToYRow but different coefficients, no add 16. void ARGBToYJRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_y, int width) { … } #endif // HAS_ARGBTOYJROW_SSSE3 #ifdef HAS_ABGRTOYJROW_SSSE3 // Convert 16 ABGR pixels (64 bytes) to 16 YJ values. // Same as ABGRToYRow but different coefficients, no add 16. void ABGRToYJRow_SSSE3(const uint8_t* src_abgr, uint8_t* dst_y, int width) { … } #endif // HAS_ABGRTOYJROW_SSSE3 #ifdef HAS_RGBATOYJROW_SSSE3 // Convert 16 ARGB pixels (64 bytes) to 16 YJ values. // Same as ARGBToYRow but different coefficients, no add 16. void RGBAToYJRow_SSSE3(const uint8_t* src_rgba, uint8_t* dst_y, int width) { … } #endif // HAS_RGBATOYJROW_SSSE3 #if defined(HAS_ARGBTOYROW_AVX2) || defined(HAS_ABGRTOYROW_AVX2) || \ defined(HAS_ARGBEXTRACTALPHAROW_AVX2) // vpermd for vphaddw + vpackuswb vpermd. static const lvec32 kPermdARGBToY_AVX = …; #endif #ifdef HAS_ARGBTOYROW_AVX2 // Convert 32 ARGB pixels (128 bytes) to 32 Y values. void ARGBToYRow_AVX2(const uint8_t* src_argb, uint8_t* dst_y, int width) { … } #endif // HAS_ARGBTOYROW_AVX2 #ifdef HAS_ABGRTOYROW_AVX2 // Convert 32 ABGR pixels (128 bytes) to 32 Y values. void ABGRToYRow_AVX2(const uint8_t* src_abgr, uint8_t* dst_y, int width) { … } #endif // HAS_ABGRTOYROW_AVX2 #ifdef HAS_ARGBTOYJROW_AVX2 // Convert 32 ARGB pixels (128 bytes) to 32 Y values. void ARGBToYJRow_AVX2(const uint8_t* src_argb, uint8_t* dst_y, int width) { … } #endif // HAS_ARGBTOYJROW_AVX2 #ifdef HAS_ABGRTOYJROW_AVX2 // Convert 32 ABGR pixels (128 bytes) to 32 Y values. void ABGRToYJRow_AVX2(const uint8_t* src_abgr, uint8_t* dst_y, int width) { … } #endif // HAS_ABGRTOYJROW_AVX2 #ifdef HAS_RGBATOYJROW_AVX2 // Convert 32 ARGB pixels (128 bytes) to 32 Y values. void RGBAToYJRow_AVX2(const uint8_t* src_rgba, uint8_t* dst_y, int width) { … } #endif // HAS_RGBATOYJROW_AVX2 #ifdef HAS_ARGBTOUVROW_SSSE3 void ARGBToUVRow_SSSE3(const uint8_t* src_argb, int src_stride_argb, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_ARGBTOUVROW_SSSE3 #if defined(HAS_ARGBTOUVROW_AVX2) || defined(HAS_ABGRTOUVROW_AVX2) || \ defined(HAS_ARGBTOUVJROW_AVX2) || defined(HAS_ABGRTOUVJROW_AVX2) // vpshufb for vphaddw + vpackuswb packed to shorts. static const lvec8 kShufARGBToUV_AVX = …; #endif #if defined(HAS_ARGBTOUVROW_AVX2) void ARGBToUVRow_AVX2(const uint8_t* src_argb, int src_stride_argb, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_ARGBTOUVROW_AVX2 #ifdef HAS_ABGRTOUVROW_AVX2 void ABGRToUVRow_AVX2(const uint8_t* src_abgr, int src_stride_abgr, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_ABGRTOUVROW_AVX2 #ifdef HAS_ARGBTOUVJROW_AVX2 void ARGBToUVJRow_AVX2(const uint8_t* src_argb, int src_stride_argb, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_ARGBTOUVJROW_AVX2 // TODO(fbarchard): Pass kABGRToVJ / kABGRToUJ as matrix #ifdef HAS_ABGRTOUVJROW_AVX2 void ABGRToUVJRow_AVX2(const uint8_t* src_abgr, int src_stride_abgr, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_ABGRTOUVJROW_AVX2 #ifdef HAS_ARGBTOUVJROW_SSSE3 void ARGBToUVJRow_SSSE3(const uint8_t* src_argb, int src_stride_argb, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_ARGBTOUVJROW_SSSE3 #ifdef HAS_ABGRTOUVJROW_SSSE3 void ABGRToUVJRow_SSSE3(const uint8_t* src_abgr, int src_stride_abgr, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_ABGRTOUVJROW_SSSE3 #ifdef HAS_ARGBTOUV444ROW_SSSE3 void ARGBToUV444Row_SSSE3(const uint8_t* src_argb, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_ARGBTOUV444ROW_SSSE3 void BGRAToYRow_SSSE3(const uint8_t* src_bgra, uint8_t* dst_y, int width) { … } void BGRAToUVRow_SSSE3(const uint8_t* src_bgra, int src_stride_bgra, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void ABGRToYRow_SSSE3(const uint8_t* src_abgr, uint8_t* dst_y, int width) { … } void RGBAToYRow_SSSE3(const uint8_t* src_rgba, uint8_t* dst_y, int width) { … } void ABGRToUVRow_SSSE3(const uint8_t* src_abgr, int src_stride_abgr, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void RGBAToUVRow_SSSE3(const uint8_t* src_rgba, int src_stride_rgba, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #if defined(HAS_I422TOARGBROW_SSSE3) || defined(HAS_I422TOARGBROW_AVX2) // Read 8 UV from 444 #define READYUV444 … // Read 4 UV from 422, upsample to 8 UV #define READYUV422 … // Read 4 UV from 422 10 bit, upsample to 8 UV #define READYUV210 … #define READYUVA210 … // Read 8 UV from 444 10 bit #define READYUV410 … // Read 8 UV from 444 10 bit. With 8 Alpha. #define READYUVA410 … // Read 4 UV from 422 12 bit, upsample to 8 UV #define READYUV212 … // Read 4 UV from 422, upsample to 8 UV. With 8 Alpha. #define READYUVA422 … // Read 8 UV from 444. With 8 Alpha. #define READYUVA444 … // Read 4 UV from NV12, upsample to 8 UV #define READNV12 … // Read 4 VU from NV21, upsample to 8 UV #define READNV21 … // Read 4 YUY2 with 8 Y and upsample 4 UV to 8 UV. // xmm6 kShuffleYUY2Y, // xmm7 kShuffleYUY2UV #define READYUY2 … // Read 4 UYVY with 8 Y and upsample 4 UV to 8 UV. // xmm6 kShuffleUYVYY, // xmm7 kShuffleUYVYUV #define READUYVY … // Read 4 UV from P210, upsample to 8 UV #define READP210 … // Read 8 UV from P410 #define READP410 … #if defined(__x86_64__) #define YUVTORGB_SETUP(yuvconstants) … // Convert 8 pixels: 8 UV and 8 Y #define YUVTORGB16(yuvconstants) … #define YUVTORGB_REGS … #else #define YUVTORGB_SETUP … // Convert 8 pixels: 8 UV and 8 Y #define YUVTORGB16 … #define YUVTORGB_REGS #endif #define YUVTORGB(yuvconstants) … // Store 8 ARGB values. #define STOREARGB … // Store 8 RGBA values. #define STORERGBA … // Store 8 RGB24 values. #define STORERGB24 … // Store 8 AR30 values. #define STOREAR30 … void OMITFP I444ToARGBRow_SSSE3(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #ifdef HAS_I444ALPHATOARGBROW_SSSE3 void OMITFP I444AlphaToARGBRow_SSSE3(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, const uint8_t* a_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I444ALPHATOARGBROW_SSSE3 void OMITFP I422ToRGB24Row_SSSE3(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_rgb24, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP I444ToRGB24Row_SSSE3(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_rgb24, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP I422ToARGBRow_SSSE3(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP I422ToAR30Row_SSSE3(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } // 10 bit YUV to ARGB void OMITFP I210ToARGBRow_SSSE3(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } // 12 bit YUV to ARGB void OMITFP I212ToARGBRow_SSSE3(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } // 10 bit YUV to AR30 void OMITFP I210ToAR30Row_SSSE3(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } // 12 bit YUV to AR30 void OMITFP I212ToAR30Row_SSSE3(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } // 10 bit YUV to ARGB void OMITFP I410ToARGBRow_SSSE3(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #ifdef HAS_I210ALPHATOARGBROW_SSSE3 // 10 bit YUVA to ARGB void OMITFP I210AlphaToARGBRow_SSSE3(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, const uint16_t* a_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif #ifdef HAS_I410ALPHATOARGBROW_SSSE3 // 10 bit YUVA to ARGB void OMITFP I410AlphaToARGBRow_SSSE3(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, const uint16_t* a_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // 10 bit YUV to AR30 void OMITFP I410ToAR30Row_SSSE3(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } #ifdef HAS_I422ALPHATOARGBROW_SSSE3 void OMITFP I422AlphaToARGBRow_SSSE3(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, const uint8_t* a_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I422ALPHATOARGBROW_SSSE3 void OMITFP NV12ToARGBRow_SSSE3(const uint8_t* y_buf, const uint8_t* uv_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP NV21ToARGBRow_SSSE3(const uint8_t* y_buf, const uint8_t* vu_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP YUY2ToARGBRow_SSSE3(const uint8_t* yuy2_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP UYVYToARGBRow_SSSE3(const uint8_t* uyvy_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP P210ToARGBRow_SSSE3(const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP P410ToARGBRow_SSSE3(const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP P210ToAR30Row_SSSE3(const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP P410ToAR30Row_SSSE3(const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } void OMITFP I422ToRGBARow_SSSE3(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_rgba, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I422TOARGBROW_SSSE3 // Read 16 UV from 444 #define READYUV444_AVX2 … // Read 8 UV from 422, upsample to 16 UV. #define READYUV422_AVX2 … #define READYUV422_AVX512BW … // Read 8 UV from 210, upsample to 16 UV // TODO(fbarchard): Consider vshufb to replace pack/unpack // TODO(fbarchard): Consider vunpcklpd to combine the 2 registers into 1. #define READYUV210_AVX2 … // Read 8 UV from 210, upsample to 16 UV. With 16 Alpha. #define READYUVA210_AVX2 … // Read 16 UV from 410 #define READYUV410_AVX2 … // Read 8 UV from 212 12 bit, upsample to 16 UV #define READYUV212_AVX2 … // Read 16 UV from 410. With 16 Alpha. #define READYUVA410_AVX2 … // Read 16 UV from 444. With 16 Alpha. #define READYUVA444_AVX2 … // Read 8 UV from 422, upsample to 16 UV. With 16 Alpha. #define READYUVA422_AVX2 … // Read 8 UV from NV12, upsample to 16 UV. #define READNV12_AVX2 … // Read 8 VU from NV21, upsample to 16 UV. #define READNV21_AVX2 … // Read 4 UV from P210, upsample to 8 UV #define READP210_AVX2 … // Read 8 UV from P410 #define READP410_AVX2 … // Read 8 YUY2 with 16 Y and upsample 8 UV to 16 UV. // ymm6 kShuffleYUY2Y, // ymm7 kShuffleYUY2UV #define READYUY2_AVX2 … // Read 8 UYVY with 16 Y and upsample 8 UV to 16 UV. // ymm6 kShuffleUYVYY, // ymm7 kShuffleUYVYUV #define READUYVY_AVX2 … // TODO(fbarchard): Remove broadcastb #if defined(__x86_64__) #define YUVTORGB_SETUP_AVX2(yuvconstants) … #define YUVTORGB_SETUP_AVX512BW(yuvconstants) … #define YUVTORGB16_AVX2(yuvconstants) … #define YUVTORGB16_AVX512BW(yuvconstants) … #define YUVTORGB_REGS_AVX2 … #define YUVTORGB_REGS_AVX512BW … #else // Convert 16 pixels: 16 UV and 16 Y. #define YUVTORGB_SETUP_AVX2 … #define YUVTORGB16_AVX2 … #define YUVTORGB_REGS_AVX2 #endif #define YUVTORGB_AVX2(yuvconstants) … #define YUVTORGB_AVX512BW(yuvconstants) … // Store 16 ARGB values. #define STOREARGB_AVX2 … // Store 32 ARGB values. #define STOREARGB_AVX512BW … // Store 16 AR30 values. #define STOREAR30_AVX2 … #ifdef HAS_I444TOARGBROW_AVX2 // 16 pixels // 16 UV values with 16 Y producing 16 ARGB (64 bytes). void OMITFP I444ToARGBRow_AVX2(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I444TOARGBROW_AVX2 #if defined(HAS_I422TOARGBROW_AVX2) // 16 pixels // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes). void OMITFP I422ToARGBRow_AVX2(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I422TOARGBROW_AVX2 #if defined(HAS_I422TOARGBROW_AVX512BW) static const uint64_t kSplitQuadWords[8] = …; static const uint64_t kSplitDoubleQuadWords[8] = …; static const uint64_t kUnpermuteAVX512[8] = …; // 32 pixels // 16 UV values upsampled to 32 UV, mixed with 32 Y producing 32 ARGB (128 // bytes). void OMITFP I422ToARGBRow_AVX512BW(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I422TOARGBROW_AVX512BW #if defined(HAS_I422TOAR30ROW_AVX2) // 16 pixels // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 AR30 (64 bytes). void OMITFP I422ToAR30Row_AVX2(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I422TOAR30ROW_AVX2 #if defined(HAS_I210TOARGBROW_AVX2) // 16 pixels // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes). void OMITFP I210ToARGBRow_AVX2(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I210TOARGBROW_AVX2 #if defined(HAS_I212TOARGBROW_AVX2) // 16 pixels // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes). void OMITFP I212ToARGBRow_AVX2(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I212TOARGBROW_AVX2 #if defined(HAS_I210TOAR30ROW_AVX2) // 16 pixels // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 AR30 (64 bytes). void OMITFP I210ToAR30Row_AVX2(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I210TOAR30ROW_AVX2 #if defined(HAS_I212TOAR30ROW_AVX2) // 16 pixels // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 AR30 (64 bytes). void OMITFP I212ToAR30Row_AVX2(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I212TOAR30ROW_AVX2 #if defined(HAS_I410TOARGBROW_AVX2) // 16 pixels // 16 UV values with 16 Y producing 16 ARGB (64 bytes). void OMITFP I410ToARGBRow_AVX2(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I410TOARGBROW_AVX2 #if defined(HAS_I210ALPHATOARGBROW_AVX2) // 16 pixels // 8 UV, 16 Y and 16 A producing 16 ARGB (64 bytes). void OMITFP I210AlphaToARGBRow_AVX2(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, const uint16_t* a_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I210TOARGBROW_AVX2 #if defined(HAS_I410ALPHATOARGBROW_AVX2) // 16 pixels // 16 UV, 16 Y and 16 A producing 16 ARGB (64 bytes). void OMITFP I410AlphaToARGBRow_AVX2(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, const uint16_t* a_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I410TOARGBROW_AVX2 #if defined(HAS_I410TOAR30ROW_AVX2) // 16 pixels // 16 UV values with 16 Y producing 16 AR30 (64 bytes). void OMITFP I410ToAR30Row_AVX2(const uint16_t* y_buf, const uint16_t* u_buf, const uint16_t* v_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I410TOAR30ROW_AVX2 #if defined(HAS_I444ALPHATOARGBROW_AVX2) // 16 pixels // 16 UV values with 16 Y and 16 A producing 16 ARGB. void OMITFP I444AlphaToARGBRow_AVX2(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, const uint8_t* a_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I444ALPHATOARGBROW_AVX2 #if defined(HAS_I422ALPHATOARGBROW_AVX2) // 16 pixels // 8 UV values upsampled to 16 UV, mixed with 16 Y and 16 A producing 16 ARGB. void OMITFP I422AlphaToARGBRow_AVX2(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, const uint8_t* a_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I422ALPHATOARGBROW_AVX2 #if defined(HAS_I422TORGBAROW_AVX2) // 16 pixels // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 RGBA (64 bytes). void OMITFP I422ToRGBARow_AVX2(const uint8_t* y_buf, const uint8_t* u_buf, const uint8_t* v_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I422TORGBAROW_AVX2 #if defined(HAS_NV12TOARGBROW_AVX2) // 16 pixels. // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes). void OMITFP NV12ToARGBRow_AVX2(const uint8_t* y_buf, const uint8_t* uv_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_NV12TOARGBROW_AVX2 #if defined(HAS_NV21TOARGBROW_AVX2) // 16 pixels. // 8 VU values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes). void OMITFP NV21ToARGBRow_AVX2(const uint8_t* y_buf, const uint8_t* vu_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_NV21TOARGBROW_AVX2 #if defined(HAS_YUY2TOARGBROW_AVX2) // 16 pixels. // 8 YUY2 values with 16 Y and 8 UV producing 16 ARGB (64 bytes). void OMITFP YUY2ToARGBRow_AVX2(const uint8_t* yuy2_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_YUY2TOARGBROW_AVX2 #if defined(HAS_UYVYTOARGBROW_AVX2) // 16 pixels. // 8 UYVY values with 16 Y and 8 UV producing 16 ARGB (64 bytes). void OMITFP UYVYToARGBRow_AVX2(const uint8_t* uyvy_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_UYVYTOARGBROW_AVX2 #if defined(HAS_P210TOARGBROW_AVX2) // 16 pixels. // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes). void OMITFP P210ToARGBRow_AVX2(const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_P210TOARGBROW_AVX2 #if defined(HAS_P410TOARGBROW_AVX2) // 16 pixels. // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes). void OMITFP P410ToARGBRow_AVX2(const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_P410TOARGBROW_AVX2 #if defined(HAS_P210TOAR30ROW_AVX2) // 16 pixels // 16 UV values with 16 Y producing 16 AR30 (64 bytes). void OMITFP P210ToAR30Row_AVX2(const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_P210TOAR30ROW_AVX2 #if defined(HAS_P410TOAR30ROW_AVX2) // 16 pixels // 16 UV values with 16 Y producing 16 AR30 (64 bytes). void OMITFP P410ToAR30Row_AVX2(const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_P410TOAR30ROW_AVX2 #ifdef HAS_I400TOARGBROW_SSE2 void I400ToARGBRow_SSE2(const uint8_t* y_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I400TOARGBROW_SSE2 #ifdef HAS_I400TOARGBROW_AVX2 // 16 pixels of Y converted to 16 pixels of ARGB (64 bytes). // note: vpunpcklbw mutates and vpackuswb unmutates. void I400ToARGBRow_AVX2(const uint8_t* y_buf, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } #endif // HAS_I400TOARGBROW_AVX2 #ifdef HAS_MIRRORROW_SSSE3 // Shuffle table for reversing the bytes. static const uvec8 kShuffleMirror = …; void MirrorRow_SSSE3(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_MIRRORROW_SSSE3 #ifdef HAS_MIRRORROW_AVX2 void MirrorRow_AVX2(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_MIRRORROW_AVX2 #ifdef HAS_MIRRORUVROW_SSSE3 // Shuffle table for reversing the UV. static const uvec8 kShuffleMirrorUV = …; void MirrorUVRow_SSSE3(const uint8_t* src_uv, uint8_t* dst_uv, int width) { … } #endif // HAS_MIRRORUVROW_SSSE3 #ifdef HAS_MIRRORUVROW_AVX2 void MirrorUVRow_AVX2(const uint8_t* src_uv, uint8_t* dst_uv, int width) { … } #endif // HAS_MIRRORUVROW_AVX2 #ifdef HAS_MIRRORSPLITUVROW_SSSE3 // Shuffle table for reversing the bytes of UV channels. static const uvec8 kShuffleMirrorSplitUV = …; void MirrorSplitUVRow_SSSE3(const uint8_t* src, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_MIRRORSPLITUVROW_SSSE3 #ifdef HAS_RGB24MIRRORROW_SSSE3 // Shuffle first 5 pixels to last 5 mirrored. first byte zero static const uvec8 kShuffleMirrorRGB0 = …; // Shuffle last 5 pixels to first 5 mirrored. last byte zero static const uvec8 kShuffleMirrorRGB1 = …; // Shuffle 5 pixels at a time (15 bytes) void RGB24MirrorRow_SSSE3(const uint8_t* src_rgb24, uint8_t* dst_rgb24, int width) { … } #endif // HAS_RGB24MIRRORROW_SSSE3 #ifdef HAS_ARGBMIRRORROW_SSE2 void ARGBMirrorRow_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_ARGBMIRRORROW_SSE2 #ifdef HAS_ARGBMIRRORROW_AVX2 // Shuffle table for reversing the bytes. static const ulvec32 kARGBShuffleMirror_AVX2 = …; void ARGBMirrorRow_AVX2(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_ARGBMIRRORROW_AVX2 #ifdef HAS_SPLITUVROW_AVX2 void SplitUVRow_AVX2(const uint8_t* src_uv, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_SPLITUVROW_AVX2 #ifdef HAS_SPLITUVROW_SSE2 void SplitUVRow_SSE2(const uint8_t* src_uv, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_SPLITUVROW_SSE2 #ifdef HAS_DETILEROW_SSE2 void DetileRow_SSE2(const uint8_t* src, ptrdiff_t src_tile_stride, uint8_t* dst, int width) { … } #endif // HAS_DETILEROW_SSE2 #ifdef HAS_DETILEROW_16_SSE2 void DetileRow_16_SSE2(const uint16_t* src, ptrdiff_t src_tile_stride, uint16_t* dst, int width) { … } #endif // HAS_DETILEROW_SSE2 #ifdef HAS_DETILEROW_16_AVX void DetileRow_16_AVX(const uint16_t* src, ptrdiff_t src_tile_stride, uint16_t* dst, int width) { … } #endif // HAS_DETILEROW_AVX #ifdef HAS_DETILETOYUY2_SSE2 // Read 16 Y, 8 UV, and write 8 YUYV. void DetileToYUY2_SSE2(const uint8_t* src_y, ptrdiff_t src_y_tile_stride, const uint8_t* src_uv, ptrdiff_t src_uv_tile_stride, uint8_t* dst_yuy2, int width) { … } #endif #ifdef HAS_DETILESPLITUVROW_SSSE3 // TODO(greenjustin): Look into generating these constants instead of loading // them since this can cause branch mispredicts for fPIC code on 32-bit // machines. static const uvec8 kDeinterlaceUV = …; // TODO(greenjustin): Research alternatives to pshufb, since pshufb can be very // slow on older SSE2 processors. void DetileSplitUVRow_SSSE3(const uint8_t* src_uv, ptrdiff_t src_tile_stride, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_DETILESPLITUVROW_SSSE3 #ifdef HAS_MERGEUVROW_AVX512BW void MergeUVRow_AVX512BW(const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_uv, int width) { … } #endif // HAS_MERGEUVROW_AVX512BW #ifdef HAS_MERGEUVROW_AVX2 void MergeUVRow_AVX2(const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_uv, int width) { … } #endif // HAS_MERGEUVROW_AVX2 #ifdef HAS_MERGEUVROW_SSE2 void MergeUVRow_SSE2(const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_uv, int width) { … } #endif // HAS_MERGEUVROW_SSE2 #ifdef HAS_MERGEUVROW_16_AVX2 void MergeUVRow_16_AVX2(const uint16_t* src_u, const uint16_t* src_v, uint16_t* dst_uv, int depth, int width) { … } #endif // HAS_MERGEUVROW_AVX2 #ifdef HAS_SPLITUVROW_16_AVX2 const uvec8 kSplitUVShuffle16 = …; void SplitUVRow_16_AVX2(const uint16_t* src_uv, uint16_t* dst_u, uint16_t* dst_v, int depth, int width) { … } #endif // HAS_SPLITUVROW_16_AVX2 // Use scale to convert lsb formats to msb, depending how many bits there are: // 128 = 9 bits // 64 = 10 bits // 16 = 12 bits // 1 = 16 bits #ifdef HAS_MULTIPLYROW_16_AVX2 void MultiplyRow_16_AVX2(const uint16_t* src_y, uint16_t* dst_y, int scale, int width) { … } #endif // HAS_MULTIPLYROW_16_AVX2 // Use scale to convert msb formats to lsb, depending how many bits there are: // 512 = 9 bits // 1024 = 10 bits // 4096 = 12 bits // 65536 = 16 bits #ifdef HAS_DIVIDEROW_16_AVX2 void DivideRow_16_AVX2(const uint16_t* src_y, uint16_t* dst_y, int scale, int width) { … } #endif // HAS_MULTIPLYROW_16_AVX2 // Use scale to convert lsb formats to msb, depending how many bits there are: // 32768 = 9 bits // 16384 = 10 bits // 4096 = 12 bits // 256 = 16 bits void Convert16To8Row_SSSE3(const uint16_t* src_y, uint8_t* dst_y, int scale, int width) { … } #ifdef HAS_CONVERT16TO8ROW_AVX2 void Convert16To8Row_AVX2(const uint16_t* src_y, uint8_t* dst_y, int scale, int width) { … } #endif // HAS_CONVERT16TO8ROW_AVX2 #ifdef HAS_CONVERT16TO8ROW_AVX512BW void Convert16To8Row_AVX512BW(const uint16_t* src_y, uint8_t* dst_y, int scale, int width) { … } #endif // HAS_CONVERT16TO8ROW_AVX2 // Use scale to convert to lsb formats depending how many bits there are: // 512 = 9 bits // 1024 = 10 bits // 4096 = 12 bits void Convert8To16Row_SSE2(const uint8_t* src_y, uint16_t* dst_y, int scale, int width) { … } #ifdef HAS_CONVERT8TO16ROW_AVX2 void Convert8To16Row_AVX2(const uint8_t* src_y, uint16_t* dst_y, int scale, int width) { … } #endif // HAS_CONVERT8TO16ROW_AVX2 #ifdef HAS_SPLITRGBROW_SSSE3 // Shuffle table for converting RGB to Planar. static const uvec8 kSplitRGBShuffle[9] = …; void SplitRGBRow_SSSE3(const uint8_t* src_rgb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, int width) { … } #endif // HAS_SPLITRGBROW_SSSE3 #ifdef HAS_MERGERGBROW_SSSE3 // Shuffle table for converting Planar to RGB. static const uvec8 kMergeRGBShuffle[9] = …; void MergeRGBRow_SSSE3(const uint8_t* src_r, const uint8_t* src_g, const uint8_t* src_b, uint8_t* dst_rgb, int width) { … } #endif // HAS_MERGERGBROW_SSSE3 #ifdef HAS_MERGEARGBROW_SSE2 void MergeARGBRow_SSE2(const uint8_t* src_r, const uint8_t* src_g, const uint8_t* src_b, const uint8_t* src_a, uint8_t* dst_argb, int width) { … } #endif #ifdef HAS_MERGEXRGBROW_SSE2 void MergeXRGBRow_SSE2(const uint8_t* src_r, const uint8_t* src_g, const uint8_t* src_b, uint8_t* dst_argb, int width) { … } #endif // HAS_MERGEARGBROW_SSE2 #ifdef HAS_MERGEARGBROW_AVX2 void MergeARGBRow_AVX2(const uint8_t* src_r, const uint8_t* src_g, const uint8_t* src_b, const uint8_t* src_a, uint8_t* dst_argb, int width) { … } #endif #ifdef HAS_MERGEXRGBROW_AVX2 void MergeXRGBRow_AVX2(const uint8_t* src_r, const uint8_t* src_g, const uint8_t* src_b, uint8_t* dst_argb, int width) { … } #endif // HAS_MERGEARGBROW_AVX2 #ifdef HAS_SPLITARGBROW_SSE2 void SplitARGBRow_SSE2(const uint8_t* src_argb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, uint8_t* dst_a, int width) { … } #endif #ifdef HAS_SPLITXRGBROW_SSE2 void SplitXRGBRow_SSE2(const uint8_t* src_argb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, int width) { … } #endif static const uvec8 kShuffleMaskARGBSplit = …; #ifdef HAS_SPLITARGBROW_SSSE3 void SplitARGBRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, uint8_t* dst_a, int width) { … } #endif #ifdef HAS_SPLITXRGBROW_SSSE3 void SplitXRGBRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, int width) { … } #endif #ifdef HAS_SPLITARGBROW_AVX2 static const ulvec32 kShuffleMaskARGBPermute = …; void SplitARGBRow_AVX2(const uint8_t* src_argb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, uint8_t* dst_a, int width) { … } #endif #ifdef HAS_SPLITXRGBROW_AVX2 void SplitXRGBRow_AVX2(const uint8_t* src_argb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, int width) { … } #endif #ifdef HAS_MERGEXR30ROW_AVX2 void MergeXR30Row_AVX2(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, uint8_t* dst_ar30, int depth, int width) { … } #endif #ifdef HAS_MERGEAR64ROW_AVX2 static const lvec32 MergeAR64Permute = …; void MergeAR64Row_AVX2(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, const uint16_t* src_a, uint16_t* dst_ar64, int depth, int width) { … } #endif #ifdef HAS_MERGEXR64ROW_AVX2 void MergeXR64Row_AVX2(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, uint16_t* dst_ar64, int depth, int width) { … } #endif #ifdef HAS_MERGEARGB16TO8ROW_AVX2 static const uvec8 MergeARGB16To8Shuffle = …; void MergeARGB16To8Row_AVX2(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, const uint16_t* src_a, uint8_t* dst_argb, int depth, int width) { … } #endif #ifdef HAS_MERGEXRGB16TO8ROW_AVX2 void MergeXRGB16To8Row_AVX2(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, uint8_t* dst_argb, int depth, int width) { … } #endif #ifdef HAS_COPYROW_SSE2 void CopyRow_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_COPYROW_SSE2 #ifdef HAS_COPYROW_AVX void CopyRow_AVX(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_COPYROW_AVX #ifdef HAS_COPYROW_ERMS // Multiple of 1. void CopyRow_ERMS(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_COPYROW_ERMS #ifdef HAS_ARGBCOPYALPHAROW_SSE2 // width in pixels void ARGBCopyAlphaRow_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_ARGBCOPYALPHAROW_SSE2 #ifdef HAS_ARGBCOPYALPHAROW_AVX2 // width in pixels void ARGBCopyAlphaRow_AVX2(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_ARGBCOPYALPHAROW_AVX2 #ifdef HAS_ARGBEXTRACTALPHAROW_SSE2 // width in pixels void ARGBExtractAlphaRow_SSE2(const uint8_t* src_argb, uint8_t* dst_a, int width) { … } #endif // HAS_ARGBEXTRACTALPHAROW_SSE2 #ifdef HAS_ARGBEXTRACTALPHAROW_AVX2 static const uvec8 kShuffleAlphaShort_AVX2 = …; void ARGBExtractAlphaRow_AVX2(const uint8_t* src_argb, uint8_t* dst_a, int width) { … } #endif // HAS_ARGBEXTRACTALPHAROW_AVX2 #ifdef HAS_ARGBCOPYYTOALPHAROW_SSE2 // width in pixels void ARGBCopyYToAlphaRow_SSE2(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_ARGBCOPYYTOALPHAROW_SSE2 #ifdef HAS_ARGBCOPYYTOALPHAROW_AVX2 // width in pixels void ARGBCopyYToAlphaRow_AVX2(const uint8_t* src, uint8_t* dst, int width) { … } #endif // HAS_ARGBCOPYYTOALPHAROW_AVX2 #ifdef HAS_SETROW_X86 void SetRow_X86(uint8_t* dst, uint8_t v8, int width) { … } void SetRow_ERMS(uint8_t* dst, uint8_t v8, int width) { … } void ARGBSetRow_X86(uint8_t* dst_argb, uint32_t v32, int width) { … } #endif // HAS_SETROW_X86 #ifdef HAS_YUY2TOYROW_SSE2 void YUY2ToYRow_SSE2(const uint8_t* src_yuy2, uint8_t* dst_y, int width) { … } void YUY2ToNVUVRow_SSE2(const uint8_t* src_yuy2, int stride_yuy2, uint8_t* dst_uv, int width) { … } void YUY2ToUVRow_SSE2(const uint8_t* src_yuy2, int stride_yuy2, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void YUY2ToUV422Row_SSE2(const uint8_t* src_yuy2, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void UYVYToYRow_SSE2(const uint8_t* src_uyvy, uint8_t* dst_y, int width) { … } void UYVYToUVRow_SSE2(const uint8_t* src_uyvy, int stride_uyvy, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void UYVYToUV422Row_SSE2(const uint8_t* src_uyvy, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_YUY2TOYROW_SSE2 #ifdef HAS_YUY2TOYROW_AVX2 void YUY2ToYRow_AVX2(const uint8_t* src_yuy2, uint8_t* dst_y, int width) { … } void YUY2ToNVUVRow_AVX2(const uint8_t* src_yuy2, int stride_yuy2, uint8_t* dst_uv, int width) { … } void YUY2ToUVRow_AVX2(const uint8_t* src_yuy2, int stride_yuy2, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void YUY2ToUV422Row_AVX2(const uint8_t* src_yuy2, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void UYVYToYRow_AVX2(const uint8_t* src_uyvy, uint8_t* dst_y, int width) { … } void UYVYToUVRow_AVX2(const uint8_t* src_uyvy, int stride_uyvy, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void UYVYToUV422Row_AVX2(const uint8_t* src_uyvy, uint8_t* dst_u, uint8_t* dst_v, int width) { … } #endif // HAS_YUY2TOYROW_AVX2 #ifdef HAS_ARGBBLENDROW_SSSE3 // Shuffle table for isolating alpha. static const uvec8 kShuffleAlpha = …; // Blend 8 pixels at a time void ARGBBlendRow_SSSE3(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBBLENDROW_SSSE3 #ifdef HAS_BLENDPLANEROW_SSSE3 // Blend 8 pixels at a time. // unsigned version of math // =((A2*C2)+(B2*(255-C2))+255)/256 // signed version of math // =(((A2-128)*C2)+((B2-128)*(255-C2))+32768+127)/256 void BlendPlaneRow_SSSE3(const uint8_t* src0, const uint8_t* src1, const uint8_t* alpha, uint8_t* dst, int width) { … } #endif // HAS_BLENDPLANEROW_SSSE3 #ifdef HAS_BLENDPLANEROW_AVX2 // Blend 32 pixels at a time. // unsigned version of math // =((A2*C2)+(B2*(255-C2))+255)/256 // signed version of math // =(((A2-128)*C2)+((B2-128)*(255-C2))+32768+127)/256 void BlendPlaneRow_AVX2(const uint8_t* src0, const uint8_t* src1, const uint8_t* alpha, uint8_t* dst, int width) { … } #endif // HAS_BLENDPLANEROW_AVX2 #ifdef HAS_ARGBATTENUATEROW_SSSE3 // Shuffle table duplicating alpha. static const vec8 kAttenuateShuffle = …; // Attenuate 4 pixels at a time. void ARGBAttenuateRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBATTENUATEROW_SSSE3 #ifdef HAS_ARGBATTENUATEROW_AVX2 // Shuffle table duplicating alpha. static const lvec8 kAttenuateShuffle_AVX2 = …; // Attenuate 8 pixels at a time. void ARGBAttenuateRow_AVX2(const uint8_t* src_argb, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBATTENUATEROW_AVX2 #ifdef HAS_ARGBUNATTENUATEROW_SSE2 // Unattenuate 4 pixels at a time. void ARGBUnattenuateRow_SSE2(const uint8_t* src_argb, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBUNATTENUATEROW_SSE2 #ifdef HAS_ARGBUNATTENUATEROW_AVX2 // Shuffle table duplicating alpha. static const uvec8 kUnattenShuffleAlpha_AVX2 = …; // Unattenuate 8 pixels at a time. void ARGBUnattenuateRow_AVX2(const uint8_t* src_argb, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBUNATTENUATEROW_AVX2 #ifdef HAS_ARGBGRAYROW_SSSE3 // Convert 8 ARGB pixels (64 bytes) to 8 Gray ARGB pixels void ARGBGrayRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBGRAYROW_SSSE3 #ifdef HAS_ARGBSEPIAROW_SSSE3 // b = (r * 35 + g * 68 + b * 17) >> 7 // g = (r * 45 + g * 88 + b * 22) >> 7 // r = (r * 50 + g * 98 + b * 24) >> 7 // Constant for ARGB color to sepia tone static const vec8 kARGBToSepiaB = …; static const vec8 kARGBToSepiaG = …; static const vec8 kARGBToSepiaR = …; // Convert 8 ARGB pixels (32 bytes) to 8 Sepia ARGB pixels. void ARGBSepiaRow_SSSE3(uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBSEPIAROW_SSSE3 #ifdef HAS_ARGBCOLORMATRIXROW_SSSE3 // Tranform 8 ARGB pixels (32 bytes) with color matrix. // Same as Sepia except matrix is provided. void ARGBColorMatrixRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_argb, const int8_t* matrix_argb, int width) { … } #endif // HAS_ARGBCOLORMATRIXROW_SSSE3 #ifdef HAS_ARGBQUANTIZEROW_SSE2 // Quantize 4 ARGB pixels (16 bytes). void ARGBQuantizeRow_SSE2(uint8_t* dst_argb, int scale, int interval_size, int interval_offset, int width) { … } #endif // HAS_ARGBQUANTIZEROW_SSE2 #ifdef HAS_ARGBSHADEROW_SSE2 // Shade 4 pixels at a time by specified value. void ARGBShadeRow_SSE2(const uint8_t* src_argb, uint8_t* dst_argb, int width, uint32_t value) { … } #endif // HAS_ARGBSHADEROW_SSE2 #ifdef HAS_ARGBMULTIPLYROW_SSE2 // Multiply 2 rows of ARGB pixels together, 4 pixels at a time. void ARGBMultiplyRow_SSE2(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBMULTIPLYROW_SSE2 #ifdef HAS_ARGBMULTIPLYROW_AVX2 // Multiply 2 rows of ARGB pixels together, 8 pixels at a time. void ARGBMultiplyRow_AVX2(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBMULTIPLYROW_AVX2 #ifdef HAS_ARGBADDROW_SSE2 // Add 2 rows of ARGB pixels together, 4 pixels at a time. void ARGBAddRow_SSE2(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBADDROW_SSE2 #ifdef HAS_ARGBADDROW_AVX2 // Add 2 rows of ARGB pixels together, 4 pixels at a time. void ARGBAddRow_AVX2(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBADDROW_AVX2 #ifdef HAS_ARGBSUBTRACTROW_SSE2 // Subtract 2 rows of ARGB pixels, 4 pixels at a time. void ARGBSubtractRow_SSE2(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBSUBTRACTROW_SSE2 #ifdef HAS_ARGBSUBTRACTROW_AVX2 // Subtract 2 rows of ARGB pixels, 8 pixels at a time. void ARGBSubtractRow_AVX2(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #endif // HAS_ARGBSUBTRACTROW_AVX2 #ifdef HAS_SOBELXROW_SSE2 // SobelX as a matrix is // -1 0 1 // -2 0 2 // -1 0 1 void SobelXRow_SSE2(const uint8_t* src_y0, const uint8_t* src_y1, const uint8_t* src_y2, uint8_t* dst_sobelx, int width) { … } #endif // HAS_SOBELXROW_SSE2 #ifdef HAS_SOBELYROW_SSE2 // SobelY as a matrix is // -1 -2 -1 // 0 0 0 // 1 2 1 void SobelYRow_SSE2(const uint8_t* src_y0, const uint8_t* src_y1, uint8_t* dst_sobely, int width) { … } #endif // HAS_SOBELYROW_SSE2 #ifdef HAS_SOBELROW_SSE2 // Adds Sobel X and Sobel Y and stores Sobel into ARGB. // A = 255 // R = Sobel // G = Sobel // B = Sobel void SobelRow_SSE2(const uint8_t* src_sobelx, const uint8_t* src_sobely, uint8_t* dst_argb, int width) { … } #endif // HAS_SOBELROW_SSE2 #ifdef HAS_SOBELTOPLANEROW_SSE2 // Adds Sobel X and Sobel Y and stores Sobel into a plane. void SobelToPlaneRow_SSE2(const uint8_t* src_sobelx, const uint8_t* src_sobely, uint8_t* dst_y, int width) { … } #endif // HAS_SOBELTOPLANEROW_SSE2 #ifdef HAS_SOBELXYROW_SSE2 // Mixes Sobel X, Sobel Y and Sobel into ARGB. // A = 255 // R = Sobel X // G = Sobel // B = Sobel Y void SobelXYRow_SSE2(const uint8_t* src_sobelx, const uint8_t* src_sobely, uint8_t* dst_argb, int width) { … } #endif // HAS_SOBELXYROW_SSE2 #ifdef HAS_COMPUTECUMULATIVESUMROW_SSE2 // Creates a table of cumulative sums where each value is a sum of all values // above and to the left of the value, inclusive of the value. void ComputeCumulativeSumRow_SSE2(const uint8_t* row, int32_t* cumsum, const int32_t* previous_cumsum, int width) { … } #endif // HAS_COMPUTECUMULATIVESUMROW_SSE2 #ifdef HAS_CUMULATIVESUMTOAVERAGEROW_SSE2 void CumulativeSumToAverageRow_SSE2(const int32_t* topleft, const int32_t* botleft, int width, int area, uint8_t* dst, int count) { … } #endif // HAS_CUMULATIVESUMTOAVERAGEROW_SSE2 #ifdef HAS_ARGBAFFINEROW_SSE2 // Copy ARGB pixels from source image with slope to a row of destination. LIBYUV_API void ARGBAffineRow_SSE2(const uint8_t* src_argb, int src_argb_stride, uint8_t* dst_argb, const float* src_dudv, int width) { … } #endif // HAS_ARGBAFFINEROW_SSE2 #ifdef HAS_INTERPOLATEROW_SSSE3 // Bilinear filter 16x2 -> 16x1 void InterpolateRow_SSSE3(uint8_t* dst_ptr, const uint8_t* src_ptr, ptrdiff_t src_stride, int width, int source_y_fraction) { … } #endif // HAS_INTERPOLATEROW_SSSE3 #ifdef HAS_INTERPOLATEROW_AVX2 // Bilinear filter 32x2 -> 32x1 void InterpolateRow_AVX2(uint8_t* dst_ptr, const uint8_t* src_ptr, ptrdiff_t src_stride, int width, int source_y_fraction) { … } #endif // HAS_INTERPOLATEROW_AVX2 #ifdef HAS_ARGBSHUFFLEROW_SSSE3 // For BGRAToARGB, ABGRToARGB, RGBAToARGB, and ARGBToRGBA. void ARGBShuffleRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_argb, const uint8_t* shuffler, int width) { … } #endif // HAS_ARGBSHUFFLEROW_SSSE3 #ifdef HAS_ARGBSHUFFLEROW_AVX2 // For BGRAToARGB, ABGRToARGB, RGBAToARGB, and ARGBToRGBA. void ARGBShuffleRow_AVX2(const uint8_t* src_argb, uint8_t* dst_argb, const uint8_t* shuffler, int width) { … } #endif // HAS_ARGBSHUFFLEROW_AVX2 #ifdef HAS_I422TOYUY2ROW_SSE2 void I422ToYUY2Row_SSE2(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_yuy2, int width) { … } #endif // HAS_I422TOYUY2ROW_SSE2 #ifdef HAS_I422TOUYVYROW_SSE2 void I422ToUYVYRow_SSE2(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_uyvy, int width) { … } #endif // HAS_I422TOUYVYROW_SSE2 #ifdef HAS_I422TOYUY2ROW_AVX2 void I422ToYUY2Row_AVX2(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_yuy2, int width) { … } #endif // HAS_I422TOYUY2ROW_AVX2 #ifdef HAS_I422TOUYVYROW_AVX2 void I422ToUYVYRow_AVX2(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_uyvy, int width) { … } #endif // HAS_I422TOUYVYROW_AVX2 #ifdef HAS_ARGBPOLYNOMIALROW_SSE2 void ARGBPolynomialRow_SSE2(const uint8_t* src_argb, uint8_t* dst_argb, const float* poly, int width) { … } #endif // HAS_ARGBPOLYNOMIALROW_SSE2 #ifdef HAS_ARGBPOLYNOMIALROW_AVX2 void ARGBPolynomialRow_AVX2(const uint8_t* src_argb, uint8_t* dst_argb, const float* poly, int width) { … } #endif // HAS_ARGBPOLYNOMIALROW_AVX2 #ifdef HAS_HALFFLOATROW_SSE2 static float kScaleBias = …; void HalfFloatRow_SSE2(const uint16_t* src, uint16_t* dst, float scale, int width) { … } #endif // HAS_HALFFLOATROW_SSE2 #ifdef HAS_HALFFLOATROW_AVX2 void HalfFloatRow_AVX2(const uint16_t* src, uint16_t* dst, float scale, int width) { … } #endif // HAS_HALFFLOATROW_AVX2 #ifdef HAS_HALFFLOATROW_F16C void HalfFloatRow_F16C(const uint16_t* src, uint16_t* dst, float scale, int width) { asm volatile ( "vbroadcastss %3, %%ymm4 \n" "sub %0,%1 \n" // 16 pixel loop. LABELALIGN "1: \n" "vpmovzxwd (%0),%%ymm2 \n" // 16 shorts -> 16 ints "vpmovzxwd 0x10(%0),%%ymm3 \n" "vcvtdq2ps %%ymm2,%%ymm2 \n" "vcvtdq2ps %%ymm3,%%ymm3 \n" "vmulps %%ymm2,%%ymm4,%%ymm2 \n" "vmulps %%ymm3,%%ymm4,%%ymm3 \n" "vcvtps2ph $3, %%ymm2, %%xmm2 \n" "vcvtps2ph $3, %%ymm3, %%xmm3 \n" "vmovdqu %%xmm2,0x00(%0,%1,1) \n" "vmovdqu %%xmm3,0x10(%0,%1,1) \n" "add $0x20,%0 \n" "sub $0x10,%2 \n" "jg 1b \n" "vzeroupper \n" : "+r"(src), // %0 "+r"(dst), // %1 "+r"(width) // %2 #if defined(__x86_64__) : "x"(scale) // %3 #else : "m"(scale) // %3 #endif : "memory", "cc", "xmm2", "xmm3", "xmm4"); } #endif // HAS_HALFFLOATROW_F16C #ifdef HAS_HALFFLOATROW_F16C void HalfFloat1Row_F16C(const uint16_t* src, uint16_t* dst, float, int width) { asm volatile ( "sub %0,%1 \n" // 16 pixel loop. LABELALIGN "1: \n" "vpmovzxwd (%0),%%ymm2 \n" // 16 shorts -> 16 ints "vpmovzxwd 0x10(%0),%%ymm3 \n" "vcvtdq2ps %%ymm2,%%ymm2 \n" "vcvtdq2ps %%ymm3,%%ymm3 \n" "vcvtps2ph $3, %%ymm2, %%xmm2 \n" "vcvtps2ph $3, %%ymm3, %%xmm3 \n" "vmovdqu %%xmm2,0x00(%0,%1,1) \n" "vmovdqu %%xmm3,0x10(%0,%1,1) \n" "add $0x20,%0 \n" "sub $0x10,%2 \n" "jg 1b \n" "vzeroupper \n" : "+r"(src), // %0 "+r"(dst), // %1 "+r"(width) // %2 : : "memory", "cc", "xmm2", "xmm3"); } #endif // HAS_HALFFLOATROW_F16C #ifdef HAS_ARGBCOLORTABLEROW_X86 // Tranform ARGB pixels with color table. void ARGBColorTableRow_X86(uint8_t* dst_argb, const uint8_t* table_argb, int width) { … } #endif // HAS_ARGBCOLORTABLEROW_X86 #ifdef HAS_RGBCOLORTABLEROW_X86 // Tranform RGB pixels with color table. void RGBColorTableRow_X86(uint8_t* dst_argb, const uint8_t* table_argb, int width) { … } #endif // HAS_RGBCOLORTABLEROW_X86 #ifdef HAS_ARGBLUMACOLORTABLEROW_SSSE3 // Tranform RGB pixels with luma table. void ARGBLumaColorTableRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_argb, int width, const uint8_t* luma, uint32_t lumacoeff) { … } #endif // HAS_ARGBLUMACOLORTABLEROW_SSSE3 static const uvec8 kYUV24Shuffle[3] = …; // Convert biplanar NV21 to packed YUV24 // NV21 has VU in memory for chroma. // YUV24 is VUY in memory void NV21ToYUV24Row_SSSE3(const uint8_t* src_y, const uint8_t* src_vu, uint8_t* dst_yuv24, int width) { … } // Convert biplanar NV21 to packed YUV24 // NV21 has VU in memory for chroma. // YUV24 is VUY in memory void NV21ToYUV24Row_AVX2(const uint8_t* src_y, const uint8_t* src_vu, uint8_t* dst_yuv24, int width) { … } #ifdef HAS_NV21ToYUV24ROW_AVX512 // The following VMBI VEX256 code tests okay with the intelsde emulator. static const lvec8 kYUV24Perm[3] = { {32, 33, 0, 32, 33, 1, 34, 35, 2, 34, 35, 3, 36, 37, 4, 36, 37, 5, 38, 39, 6, 38, 39, 7, 40, 41, 8, 40, 41, 9, 42, 43}, {10, 42, 43, 11, 44, 45, 12, 44, 45, 13, 46, 47, 14, 46, 47, 15, 48, 49, 16, 48, 49, 17, 50, 51, 18, 50, 51, 19, 52, 53, 20, 52}, {53, 21, 54, 55, 22, 54, 55, 23, 56, 57, 24, 56, 57, 25, 58, 59, 26, 58, 59, 27, 60, 61, 28, 60, 61, 29, 62, 63, 30, 62, 63, 31}}; void NV21ToYUV24Row_AVX512(const uint8_t* src_y, const uint8_t* src_vu, uint8_t* dst_yuv24, int width) { asm volatile ( "sub %0,%1 \n" "vmovdqa (%4),%%ymm4 \n" // 3 shuffler constants "vmovdqa 32(%4),%%ymm5 \n" "vmovdqa 64(%4),%%ymm6 \n" LABELALIGN "1: \n" "vmovdqu (%0),%%ymm2 \n" // load 32 Y values "vmovdqu (%0,%1),%%ymm3 \n" // load 16 VU values "lea 32(%0),%0 \n" "vmovdqa %%ymm2, %%ymm0 \n" "vmovdqa %%ymm2, %%ymm1 \n" "vpermt2b %%ymm3,%%ymm4,%%ymm0 \n" "vpermt2b %%ymm3,%%ymm5,%%ymm1 \n" "vpermt2b %%ymm3,%%ymm6,%%ymm2 \n" "vmovdqu %%ymm0,(%2) \n" "vmovdqu %%ymm1,32(%2) \n" "vmovdqu %%ymm2,64(%2) \n" "lea 96(%2),%2 \n" "sub $32,%3 \n" "jg 1b \n" "vzeroupper \n" : "+r"(src_y), // %0 "+r"(src_vu), // %1 "+r"(dst_yuv24), // %2 "+r"(width) // %3 : "r"(&kYUV24Perm[0]) // %4 : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6"); } #endif // HAS_NV21ToYUV24ROW_AVX512 #ifdef HAS_SWAPUVROW_SSSE3 // Shuffle table for reversing the bytes. static const uvec8 kShuffleUVToVU = …; // Convert UV plane of NV12 to VU of NV21. void SwapUVRow_SSSE3(const uint8_t* src_uv, uint8_t* dst_vu, int width) { … } #endif // HAS_SWAPUVROW_SSSE3 #ifdef HAS_SWAPUVROW_AVX2 void SwapUVRow_AVX2(const uint8_t* src_uv, uint8_t* dst_vu, int width) { … } #endif // HAS_SWAPUVROW_AVX2 void HalfMergeUVRow_SSSE3(const uint8_t* src_u, int src_stride_u, const uint8_t* src_v, int src_stride_v, uint8_t* dst_uv, int width) { … } void HalfMergeUVRow_AVX2(const uint8_t* src_u, int src_stride_u, const uint8_t* src_v, int src_stride_v, uint8_t* dst_uv, int width) { … } void ClampFloatToZero_SSE2(const float* src_x, float* dst_y, int width) { … } #endif // defined(__x86_64__) || defined(__i386__) #ifdef __cplusplus } // extern "C" } // namespace libyuv #endif
Codebase Browser
chromium