switch from ebp to ebx.

source/row_win.cc

 /*
  *  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.
  */
 
@@ skipping 22 matching lines @@
     xmm0 = _mm_cvtsi32_si128(*(uint32*)u_buf);                                 \
     xmm1 = _mm_cvtsi32_si128(*(uint32*)(u_buf + offset));                      \
     xmm0 = _mm_unpacklo_epi8(xmm0, xmm1);                                      \
     xmm0 = _mm_unpacklo_epi16(xmm0, xmm0);                                     \
     u_buf += 4;                                                                \
     xmm4 = _mm_loadl_epi64((__m128i*)y_buf);                                   \
     xmm4 = _mm_unpacklo_epi8(xmm4, xmm4);                                      \
     y_buf += 8;                                                                \
 
 // Convert 8 pixels: 8 UV and 8 Y.
-#define YUVTORGB(YuvConstants)                                                 \
+#define YUVTORGB(yuvconstants)                                                 \
     xmm1 = _mm_loadu_si128(&xmm0);                                             \
     xmm2 = _mm_loadu_si128(&xmm0);                                             \
-    xmm0 = _mm_maddubs_epi16(xmm0, *(__m128i*)YuvConstants->kUVToB);           \
-    xmm1 = _mm_maddubs_epi16(xmm1, *(__m128i*)YuvConstants->kUVToG);           \
-    xmm2 = _mm_maddubs_epi16(xmm2, *(__m128i*)YuvConstants->kUVToR);           \
-    xmm0 = _mm_sub_epi16(*(__m128i*)YuvConstants->kUVBiasB, xmm0);             \
-    xmm1 = _mm_sub_epi16(*(__m128i*)YuvConstants->kUVBiasG, xmm1);             \
-    xmm2 = _mm_sub_epi16(*(__m128i*)YuvConstants->kUVBiasR, xmm2);             \
-    xmm4 = _mm_mulhi_epu16(xmm4, *(__m128i*)YuvConstants->kYToRgb);            \
+    xmm0 = _mm_maddubs_epi16(xmm0, *(__m128i*)yuvconstants->kUVToB);           \
+    xmm1 = _mm_maddubs_epi16(xmm1, *(__m128i*)yuvconstants->kUVToG);           \
+    xmm2 = _mm_maddubs_epi16(xmm2, *(__m128i*)yuvconstants->kUVToR);           \
+    xmm0 = _mm_sub_epi16(*(__m128i*)yuvconstants->kUVBiasB, xmm0);             \
+    xmm1 = _mm_sub_epi16(*(__m128i*)yuvconstants->kUVBiasG, xmm1);             \
+    xmm2 = _mm_sub_epi16(*(__m128i*)yuvconstants->kUVBiasR, xmm2);             \
+    xmm4 = _mm_mulhi_epu16(xmm4, *(__m128i*)yuvconstants->kYToRgb);            \
     xmm0 = _mm_adds_epi16(xmm0, xmm4);                                         \
     xmm1 = _mm_adds_epi16(xmm1, xmm4);                                         \
     xmm2 = _mm_adds_epi16(xmm2, xmm4);                                         \
     xmm0 = _mm_srai_epi16(xmm0, 6);                                            \
     xmm1 = _mm_srai_epi16(xmm1, 6);                                            \
     xmm2 = _mm_srai_epi16(xmm2, 6);                                            \
     xmm0 = _mm_packus_epi16(xmm0, xmm0);                                       \
     xmm1 = _mm_packus_epi16(xmm1, xmm1);                                       \
     xmm2 = _mm_packus_epi16(xmm2, xmm2);
 
@@ skipping 1960 matching lines @@
 __declspec(naked)
 void I422ToARGBRow_AVX2(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV422_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STOREARGB_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     vzeroupper
     ret
   }
 }
 #endif  // HAS_I422TOARGBROW_AVX2
 
 #ifdef HAS_I444TOARGBROW_AVX2
 // 16 pixels
 // 16 UV values with 16 Y producing 16 ARGB (64 bytes).
 __declspec(naked)
 void I444ToARGBRow_AVX2(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
  convertloop:
     READYUV444_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STOREARGB_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     vzeroupper
     ret
   }
 }
 #endif  // HAS_I444TOARGBROW_AVX2
 
 #ifdef HAS_I444TOABGRROW_AVX2
 // 16 pixels
 // 16 UV values with 16 Y producing 16 ABGR (64 bytes).
 __declspec(naked)
 void I444ToABGRRow_AVX2(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* dst_abgr,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
  convertloop:
     READYUV444_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STOREABGR_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     vzeroupper
     ret
   }
 }
 #endif  // HAS_I444TOABGRROW_AVX2
 
 #ifdef HAS_I411TOARGBROW_AVX2
 // 16 pixels
 // 4 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
 __declspec(naked)
 void I411ToARGBRow_AVX2(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV411_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STOREARGB_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     vzeroupper
     ret
   }
 }
 #endif  // HAS_I411TOARGBROW_AVX2
 
 #ifdef HAS_NV12TOARGBROW_AVX2
 // 16 pixels.
 // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
 __declspec(naked)
 void NV12ToARGBRow_AVX2(const uint8* y_buf,
                         const uint8* uv_buf,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 8 + 4]   // Y
     mov        esi, [esp + 8 + 8]   // UV
     mov        edx, [esp + 8 + 12]  // argb
-    mov        ebp, [esp + 8 + 16]  // yuvconstants
+    mov        ebx, [esp + 8 + 16]  // yuvconstants
     mov        ecx, [esp + 8 + 20]  // width
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READNV12_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STOREARGB_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        esi
     vzeroupper
     ret
   }
 }
 #endif  // HAS_NV12TOARGBROW_AVX2
 
 // 16 pixels.
 // 8 YUY2 values with 16 Y and 8 UV producing 16 ARGB (64 bytes).
 __declspec(naked)
 void YUY2ToARGBRow_AVX2(const uint8* src_yuy2,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
-    push       ebp
+    push       ebx
     mov        eax, [esp + 4 + 4]   // yuy2
     mov        edx, [esp + 4 + 8]   // argb
-    mov        ebp, [esp + 4 + 12]  // yuvconstants
+    mov        ebx, [esp + 4 + 12]  // yuvconstants
     mov        ecx, [esp + 4 + 16]  // width
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUY2_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STOREARGB_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     vzeroupper
     ret
   }
 }
 
 // 16 pixels.
 // 8 UYVY values with 16 Y and 8 UV producing 16 ARGB (64 bytes).
 __declspec(naked)
 void UYVYToARGBRow_AVX2(const uint8* src_uyvy,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
-    push       ebp
+    push       ebx
     mov        eax, [esp + 4 + 4]   // uyvy
     mov        edx, [esp + 4 + 8]   // argb
-    mov        ebp, [esp + 4 + 12]  // yuvconstants
+    mov        ebx, [esp + 4 + 12]  // yuvconstants
     mov        ecx, [esp + 4 + 16]  // width
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READUYVY_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STOREARGB_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     vzeroupper
     ret
   }
 }
 
 
 #ifdef HAS_I422TOBGRAROW_AVX2
 // 16 pixels
 // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 BGRA (64 bytes).
 // TODO(fbarchard): Use macros to reduce duplicate code.  See SSSE3.
 __declspec(naked)
 void I422ToBGRARow_AVX2(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV422_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STOREBGRA_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     vzeroupper
     ret
   }
 }
 #endif  // HAS_I422TOBGRAROW_AVX2
 
 #ifdef HAS_I422TORGBAROW_AVX2
 // 16 pixels
 // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 RGBA (64 bytes).
 __declspec(naked)
 void I422ToRGBARow_AVX2(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV422_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STORERGBA_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     vzeroupper
     ret
   }
 }
 #endif  // HAS_I422TORGBAROW_AVX2
 
 #ifdef HAS_I422TOABGRROW_AVX2
 // 16 pixels
 // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ABGR (64 bytes).
 __declspec(naked)
 void I422ToABGRRow_AVX2(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV422_AVX2
-    YUVTORGB_AVX2(ebp)
+    YUVTORGB_AVX2(ebx)
     STOREABGR_AVX2
 
     sub        ecx, 16
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     vzeroupper
     ret
   }
 }
 #endif  // HAS_I422TOABGRROW_AVX2
 
 #if defined(HAS_I422TOARGBROW_SSSE3)
 // TODO(fbarchard): Read that does half size on Y and treats 420 as 444.
@@ skipping 213 matching lines @@
 __declspec(naked)
 void I444ToARGBRow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_argb,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5            // generate 0xffffffff for alpha
 
  convertloop:
     READYUV444
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STOREARGB
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 
 // 8 pixels.
 // 8 UV values, mixed with 8 Y producing 8 ABGR (32 bytes).
 __declspec(naked)
 void I444ToABGRRow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_abgr,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5            // generate 0xffffffff for alpha
 
  convertloop:
     READYUV444
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STOREABGR
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 
 // 8 pixels.
 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 RGB24 (24 bytes).
 __declspec(naked)
 void I422ToRGB24Row_SSSE3(const uint8* y_buf,
                           const uint8* u_buf,
                           const uint8* v_buf,
                           uint8* dst_rgb24,
                           struct YuvConstants* yuvconstants,
                           int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     movdqa     xmm5, xmmword ptr kShuffleMaskARGBToRGB24_0
     movdqa     xmm6, xmmword ptr kShuffleMaskARGBToRGB24
 
  convertloop:
     READYUV422
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STORERGB24
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 
 // 8 pixels.
 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 RAW (24 bytes).
 __declspec(naked)
 void I422ToRAWRow_SSSE3(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* dst_raw,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     movdqa     xmm5, xmmword ptr kShuffleMaskARGBToRAW_0
     movdqa     xmm6, xmmword ptr kShuffleMaskARGBToRAW
 
  convertloop:
     READYUV422
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STORERAW
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 
 // 8 pixels
 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 RGB565 (16 bytes).
 __declspec(naked)
 void I422ToRGB565Row_SSSE3(const uint8* y_buf,
                            const uint8* u_buf,
                            const uint8* v_buf,
                            uint8* rgb565_buf,
                            struct YuvConstants* yuvconstants,
                            int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5       // generate mask 0x0000001f
     psrld      xmm5, 27
     pcmpeqb    xmm6, xmm6       // generate mask 0x000007e0
     psrld      xmm6, 26
     pslld      xmm6, 5
     pcmpeqb    xmm7, xmm7       // generate mask 0xfffff800
     pslld      xmm7, 11
 
  convertloop:
     READYUV422
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STORERGB565
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 
 // 8 pixels.
 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).
 __declspec(naked)
 void I422ToARGBRow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_argb,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
 
  convertloop:
     READYUV422
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STOREARGB
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 
 // 8 pixels.
 // 2 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).
 // Similar to I420 but duplicate UV once more.
 __declspec(naked)
 void I411ToARGBRow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_argb,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5            // generate 0xffffffff for alpha
 
  convertloop:
     READYUV411
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STOREARGB
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 
 // 8 pixels.
 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).
 __declspec(naked)
 void NV12ToARGBRow_SSSE3(const uint8* y_buf,
                          const uint8* uv_buf,
                          uint8* dst_argb,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 8 + 4]   // Y
     mov        esi, [esp + 8 + 8]   // UV
     mov        edx, [esp + 8 + 12]  // argb
-    mov        ebp, [esp + 8 + 16]  // yuvconstants
+    mov        ebx, [esp + 8 + 16]  // yuvconstants
     mov        ecx, [esp + 8 + 20]  // width
     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
 
  convertloop:
     READNV12
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STOREARGB
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        esi
     ret
   }
 }
 
 // 8 pixels.
 // 4 YUY2 values with 8 Y and 4 UV producing 8 ARGB (32 bytes).
 __declspec(naked)
 void YUY2ToARGBRow_SSSE3(const uint8* src_yuy2,
                          uint8* dst_argb,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
-    push       ebp
+    push       ebx
     mov        eax, [esp + 4 + 4]   // yuy2
     mov        edx, [esp + 4 + 8]   // argb
-    mov        ebp, [esp + 4 + 12]  // yuvconstants
+    mov        ebx, [esp + 4 + 12]  // yuvconstants
     mov        ecx, [esp + 4 + 16]  // width
     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
 
  convertloop:
     READYUY2
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STOREARGB
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     ret
   }
 }
 
 // 8 pixels.
 // 4 UYVY values with 8 Y and 4 UV producing 8 ARGB (32 bytes).
 __declspec(naked)
 void UYVYToARGBRow_SSSE3(const uint8* src_uyvy,
                          uint8* dst_argb,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
-    push       ebp
+    push       ebx
     mov        eax, [esp + 4 + 4]   // uyvy
     mov        edx, [esp + 4 + 8]   // argb
-    mov        ebp, [esp + 4 + 12]  // yuvconstants
+    mov        ebx, [esp + 4 + 12]  // yuvconstants
     mov        ecx, [esp + 4 + 16]  // width
     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
 
  convertloop:
     READUYVY
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STOREARGB
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     ret
   }
 }
 
 __declspec(naked)
 void I422ToBGRARow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_bgra,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
 
  convertloop:
     READYUV422
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STOREBGRA
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 
 __declspec(naked)
 void I422ToABGRRow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_abgr,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
 
  convertloop:
     READYUV422
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STOREABGR
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 
 __declspec(naked)
 void I422ToRGBARow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_rgba,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
-    push       ebp
+    push       ebx
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // yuvconstants
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
 
  convertloop:
     READYUV422
-    YUVTORGB(ebp)
+    YUVTORGB(ebx)
     STORERGBA
 
     sub        ecx, 8
     jg         convertloop
 
-    pop        ebp
+    pop        ebx
     pop        edi
     pop        esi
     ret
   }
 }
 #endif  // HAS_I422TOARGBROW_SSSE3
 
 #ifdef HAS_I400TOARGBROW_SSE2
 // 8 pixels of Y converted to 8 pixels of ARGB (32 bytes).
 __declspec(naked)
@@ skipping 3386 matching lines @@
 }
 #endif  // HAS_ARGBLUMACOLORTABLEROW_SSSE3
 
 #endif  // defined(_M_X64)
 #endif  // !defined(LIBYUV_DISABLE_X86) && (defined(_M_IX86) || defined(_M_X64))
 
 #ifdef __cplusplus
 }  // extern "C"
 }  // namespace libyuv
 #endif