Changeset 5708


Ignore:
Timestamp:
Dec 4, 2017 7:23:36 AM (7 years ago)
Author:
riza
Message:

Re #2065: We still need to modify some source code to avoid build error on
Visual Studio 2005.

Location:
pjproject/trunk/third_party
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/third_party/build/yuv/Notes.txt

    r5699 r5708  
    33* Source code for libyuv from https://chromium.googlesource.com/libyuv/libyuv/ dated 17 November 2017. 
    44 
     5* All code is compilable, except for compare_win.cc 
     6  - Use older version (https://chromium.googlesource.com/libyuv/libyuv/+/baf6a3c1bd385e7ffe6b7634560e71fb49e4f589%5E%21/) 
     7    Since there's a compiler error on (VS2005): 
     8    -------------------------------------------------------------------------------------- 
     9    pmulld      xmm0,xmm6 
     10    -------------------------------------------------------------------------------------- 
     11 
     12  - On VS2015, error C2024: 'alignas' attribute applies to variables, data members and tag types only 
     13    -------------------------------------------------------------------------------------- 
     14    __declspec(naked) __declspec(align(16)) 
     15 
     16    Change to : 
     17 
     18    __declspec(naked) 
     19    -------------------------------------------------------------------------------------- 
     20 
     21* Added these lines to file include/libyuv/basic_types.h: 
     22  -- 
     23  #if _MSC_VER==1400 
     24  #   include <stdint.h>  // for uint8_t 
     25  #endif 
     26  ... 
     27  #if defined(_MSC_VER) 
     28  #  pragma warning(disable:4996) // This function or variable may be unsafe. 
     29  #endif 
     30  -- 
     31 
     32* Modify compare_row.h: 
     33  - VS2005 doesn't support SSE42, resulting error on HammingDistance_SSE42(). 
     34    -------------------------------------------------------------------------------------- 
     35    diff += __popcnt(x); 
     36    -------------------------------------------------------------------------------------- 
     37    So, we use the default method HammingDistance_C() to calculate Hamming Distance. 
     38     

  • pjproject/trunk/third_party/yuv/include/libyuv/basic_types.h

    r5699 r5708  
    1515 
    1616#if defined(_MSC_VER) && (_MSC_VER < 1600) 
     17#if _MSC_VER==1400 
     18#   include <stdint.h>  // for uint8_t 
     19#endif 
    1720#include <sys/types.h>  // for uintptr_t on x86 
    1821#else 
    1922#include <stdint.h>  // for uintptr_t 
     23#endif 
     24 
     25#if defined(_MSC_VER) 
     26#  pragma warning(disable:4996) // This function or variable may be unsafe. 
    2027#endif 
    2128 

  • pjproject/trunk/third_party/yuv/include/libyuv/compare_row.h

    r5699 r5708  
    5454#define HAS_HASHDJB2_SSE41 
    5555#define HAS_SUMSQUAREERROR_SSE2 
    56 #define HAS_HAMMINGDISTANCE_SSE42 
     56#  if (MSC_VER >= 1400) 
     57// Visual Studio 2005 doesn't support sse42 
     58#    define HAS_HAMMINGDISTANCE_SSE42 
     59#  endif 
    5760#endif 
    5861 

  • pjproject/trunk/third_party/yuv/source/compare_win.cc

    r5699 r5708  
    1010 
    1111#include "libyuv/basic_types.h" 
    12  
    13 #include "libyuv/compare_row.h" 
    1412#include "libyuv/row.h" 
    1513 
    … …  
    2321#endif 
    2422 
    25 // This module is for 32 bit Visual C x86 and clangcl 
    2623#if !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86) && defined(_MSC_VER) 
    2724 
     25/* Visual Studio 2005 doesn't support __popcnt(). */ 
     26#if (_MSC_VER > 1400) 
    2827uint32 HammingDistance_SSE42(const uint8* src_a, 
    2928                             const uint8* src_b, 
    … …  
    4039  return diff; 
    4140} 
    42  
    43 __declspec(naked) uint32 
    44     SumSquareError_SSE2(const uint8* src_a, const uint8* src_b, int count) { 
    45   __asm { 
    46     mov        eax, [esp + 4]  // src_a 
    47     mov        edx, [esp + 8]  // src_b 
    48     mov        ecx, [esp + 12]  // count 
     41#endif 
     42 
     43#if (_MSC_VER >= 1900) 
     44__declspec(naked) 
     45#else 
     46__declspec(naked) __declspec(align(16)) 
     47#endif 
     48uint32 SumSquareError_SSE2(const uint8* src_a, const uint8* src_b, int count) { 
     49  __asm { 
     50    mov        eax, [esp + 4]    // src_a 
     51    mov        edx, [esp + 8]    // src_b 
     52    mov        ecx, [esp + 12]   // count 
    4953    pxor       xmm0, xmm0 
    5054    pxor       xmm5, xmm5 
    5155 
    52   wloop: 
    53     movdqu     xmm1, [eax] 
     56    align      4 
     57  wloop: 
     58    movdqa     xmm1, [eax] 
    5459    lea        eax,  [eax + 16] 
    55     movdqu     xmm2, [edx] 
     60    movdqa     xmm2, [edx] 
    5661    lea        edx,  [edx + 16] 
     62    sub        ecx, 16 
    5763    movdqa     xmm3, xmm1  // abs trick 
    5864    psubusb    xmm1, xmm2 
    … …  
    6672    paddd      xmm0, xmm1 
    6773    paddd      xmm0, xmm2 
    68     sub        ecx, 16 
    6974    jg         wloop 
    7075 
    … …  
    8186#if _MSC_VER >= 1700 
    8287// C4752: found Intel(R) Advanced Vector Extensions; consider using /arch:AVX. 
    83 #pragma warning(disable : 4752) 
    84 __declspec(naked) uint32 
    85     SumSquareError_AVX2(const uint8* src_a, const uint8* src_b, int count) { 
    86   __asm { 
    87     mov        eax, [esp + 4]  // src_a 
    88     mov        edx, [esp + 8]  // src_b 
    89     mov        ecx, [esp + 12]  // count 
     88#pragma warning(disable: 4752) 
     89#if (_MSC_VER >= 1900) 
     90__declspec(naked) 
     91#else 
     92__declspec(naked) __declspec(align(16)) 
     93#endif 
     94uint32 SumSquareError_AVX2(const uint8* src_a, const uint8* src_b, int count) { 
     95  __asm { 
     96    mov        eax, [esp + 4]    // src_a 
     97    mov        edx, [esp + 8]    // src_b 
     98    mov        ecx, [esp + 12]   // count 
    9099    vpxor      ymm0, ymm0, ymm0  // sum 
    91100    vpxor      ymm5, ymm5, ymm5  // constant 0 for unpck 
    92101    sub        edx, eax 
    93102 
     103    align      4 
    94104  wloop: 
    95105    vmovdqu    ymm1, [eax] 
    96106    vmovdqu    ymm2, [eax + edx] 
    97107    lea        eax,  [eax + 32] 
     108    sub        ecx, 32 
    98109    vpsubusb   ymm3, ymm1, ymm2  // abs difference trick 
    99110    vpsubusb   ymm2, ymm2, ymm1 
    … …  
    105116    vpaddd     ymm0, ymm0, ymm1 
    106117    vpaddd     ymm0, ymm0, ymm2 
    107     sub        ecx, 32 
    108118    jg         wloop 
    109119 
    … …  
    121131#endif  // _MSC_VER >= 1700 
    122132 
    123 uvec32 kHash16x33 = {0x92d9e201, 0, 0, 0};  // 33 ^ 16 
    124 uvec32 kHashMul0 = { 
    125     0x0c3525e1,  // 33 ^ 15 
    126     0xa3476dc1,  // 33 ^ 14 
    127     0x3b4039a1,  // 33 ^ 13 
    128     0x4f5f0981,  // 33 ^ 12 
    129 }; 
    130 uvec32 kHashMul1 = { 
    131     0x30f35d61,  // 33 ^ 11 
    132     0x855cb541,  // 33 ^ 10 
    133     0x040a9121,  // 33 ^ 9 
    134     0x747c7101,  // 33 ^ 8 
    135 }; 
    136 uvec32 kHashMul2 = { 
    137     0xec41d4e1,  // 33 ^ 7 
    138     0x4cfa3cc1,  // 33 ^ 6 
    139     0x025528a1,  // 33 ^ 5 
    140     0x00121881,  // 33 ^ 4 
    141 }; 
    142 uvec32 kHashMul3 = { 
    143     0x00008c61,  // 33 ^ 3 
    144     0x00000441,  // 33 ^ 2 
    145     0x00000021,  // 33 ^ 1 
    146     0x00000001,  // 33 ^ 0 
    147 }; 
    148  
    149 __declspec(naked) uint32 
    150     HashDjb2_SSE41(const uint8* src, int count, uint32 seed) { 
    151   __asm { 
    152     mov        eax, [esp + 4]  // src 
    153     mov        ecx, [esp + 8]  // count 
     133#define HAS_HASHDJB2_SSE41 
     134static uvec32 kHash16x33 = { 0x92d9e201, 0, 0, 0 };  // 33 ^ 16 
     135static uvec32 kHashMul0 = { 
     136  0x0c3525e1,  // 33 ^ 15 
     137  0xa3476dc1,  // 33 ^ 14 
     138  0x3b4039a1,  // 33 ^ 13 
     139  0x4f5f0981,  // 33 ^ 12 
     140}; 
     141static uvec32 kHashMul1 = { 
     142  0x30f35d61,  // 33 ^ 11 
     143  0x855cb541,  // 33 ^ 10 
     144  0x040a9121,  // 33 ^ 9 
     145  0x747c7101,  // 33 ^ 8 
     146}; 
     147static uvec32 kHashMul2 = { 
     148  0xec41d4e1,  // 33 ^ 7 
     149  0x4cfa3cc1,  // 33 ^ 6 
     150  0x025528a1,  // 33 ^ 5 
     151  0x00121881,  // 33 ^ 4 
     152}; 
     153static uvec32 kHashMul3 = { 
     154  0x00008c61,  // 33 ^ 3 
     155  0x00000441,  // 33 ^ 2 
     156  0x00000021,  // 33 ^ 1 
     157  0x00000001,  // 33 ^ 0 
     158}; 
     159 
     160// 27: 66 0F 38 40 C6     pmulld      xmm0,xmm6 
     161// 44: 66 0F 38 40 DD     pmulld      xmm3,xmm5 
     162// 59: 66 0F 38 40 E5     pmulld      xmm4,xmm5 
     163// 72: 66 0F 38 40 D5     pmulld      xmm2,xmm5 
     164// 83: 66 0F 38 40 CD     pmulld      xmm1,xmm5 
     165#define pmulld(reg) _asm _emit 0x66 _asm _emit 0x0F _asm _emit 0x38 \ 
     166    _asm _emit 0x40 _asm _emit reg 
     167 
     168#if (_MSC_VER >= 1900) 
     169__declspec(naked) 
     170#else 
     171__declspec(naked) __declspec(align(16)) 
     172#endif 
     173uint32 HashDjb2_SSE41(const uint8* src, int count, uint32 seed) { 
     174  __asm { 
     175    mov        eax, [esp + 4]    // src 
     176    mov        ecx, [esp + 8]    // count 
    154177    movd       xmm0, [esp + 12]  // seed 
    155178 
    156     pxor       xmm7, xmm7  // constant 0 for unpck 
    157     movdqa     xmm6, xmmword ptr kHash16x33 
    158  
    159   wloop: 
    160     movdqu     xmm1, [eax]  // src[0-15] 
     179    pxor       xmm7, xmm7        // constant 0 for unpck 
     180    movdqa     xmm6, kHash16x33 
     181 
     182    align      4 
     183  wloop: 
     184    movdqu     xmm1, [eax]       // src[0-15] 
    161185    lea        eax, [eax + 16] 
    162     pmulld     xmm0, xmm6  // hash *= 33 ^ 16 
    163     movdqa     xmm5, xmmword ptr kHashMul0 
     186    pmulld(0xc6)                 // pmulld      xmm0,xmm6 hash *= 33 ^ 16 
     187    movdqa     xmm5, kHashMul0 
    164188    movdqa     xmm2, xmm1 
    165     punpcklbw  xmm2, xmm7  // src[0-7] 
     189    punpcklbw  xmm2, xmm7        // src[0-7] 
    166190    movdqa     xmm3, xmm2 
    167     punpcklwd  xmm3, xmm7  // src[0-3] 
    168     pmulld     xmm3, xmm5 
    169     movdqa     xmm5, xmmword ptr kHashMul1 
     191    punpcklwd  xmm3, xmm7        // src[0-3] 
     192    pmulld(0xdd)                 // pmulld     xmm3, xmm5 
     193    movdqa     xmm5, kHashMul1 
    170194    movdqa     xmm4, xmm2 
    171     punpckhwd  xmm4, xmm7  // src[4-7] 
    172     pmulld     xmm4, xmm5 
    173     movdqa     xmm5, xmmword ptr kHashMul2 
    174     punpckhbw  xmm1, xmm7  // src[8-15] 
     195    punpckhwd  xmm4, xmm7        // src[4-7] 
     196    pmulld(0xe5)                 // pmulld     xmm4, xmm5 
     197    movdqa     xmm5, kHashMul2 
     198    punpckhbw  xmm1, xmm7        // src[8-15] 
    175199    movdqa     xmm2, xmm1 
    176     punpcklwd  xmm2, xmm7  // src[8-11] 
    177     pmulld     xmm2, xmm5 
    178     movdqa     xmm5, xmmword ptr kHashMul3 
    179     punpckhwd  xmm1, xmm7  // src[12-15] 
    180     pmulld     xmm1, xmm5 
    181     paddd      xmm3, xmm4  // add 16 results 
    182     paddd      xmm1, xmm2 
     200    punpcklwd  xmm2, xmm7        // src[8-11] 
     201    pmulld(0xd5)                 // pmulld     xmm2, xmm5 
     202    movdqa     xmm5, kHashMul3 
     203    punpckhwd  xmm1, xmm7        // src[12-15] 
     204    pmulld(0xcd)                 // pmulld     xmm1, xmm5 
     205    paddd      xmm3, xmm4        // add 16 results 
     206    paddd      xmm1, xmm2 
     207    sub        ecx, 16 
    183208    paddd      xmm1, xmm3 
    184209 
    … …  
    188213    paddd      xmm1, xmm2 
    189214    paddd      xmm0, xmm1 
    190     sub        ecx, 16 
    191     jg         wloop 
    192  
    193     movd       eax, xmm0  // return hash 
     215    jg         wloop 
     216 
     217    movd       eax, xmm0         // return hash 
    194218    ret 
    195219  } 
    … …  
    198222// Visual C 2012 required for AVX2. 
    199223#if _MSC_VER >= 1700 
    200 __declspec(naked) uint32 
    201     HashDjb2_AVX2(const uint8* src, int count, uint32 seed) { 
    202   __asm { 
    203     mov        eax, [esp + 4]  // src 
    204     mov        ecx, [esp + 8]  // count 
    205     vmovd      xmm0, [esp + 12]  // seed 
    206  
    207   wloop: 
    208     vpmovzxbd  xmm3, [eax]  // src[0-3] 
    209     vpmulld    xmm0, xmm0, xmmword ptr kHash16x33  // hash *= 33 ^ 16 
    210     vpmovzxbd  xmm4, [eax + 4]  // src[4-7] 
    211     vpmulld    xmm3, xmm3, xmmword ptr kHashMul0 
    212     vpmovzxbd  xmm2, [eax + 8]  // src[8-11] 
    213     vpmulld    xmm4, xmm4, xmmword ptr kHashMul1 
    214     vpmovzxbd  xmm1, [eax + 12]  // src[12-15] 
    215     vpmulld    xmm2, xmm2, xmmword ptr kHashMul2 
     224#if (_MSC_VER >= 1900) 
     225__declspec(naked) 
     226#else 
     227__declspec(naked) __declspec(align(16)) 
     228#endif 
     229uint32 HashDjb2_AVX2(const uint8* src, int count, uint32 seed) { 
     230  __asm { 
     231    mov        eax, [esp + 4]    // src 
     232    mov        ecx, [esp + 8]    // count 
     233    movd       xmm0, [esp + 12]  // seed 
     234    movdqa     xmm6, kHash16x33 
     235 
     236    align      4 
     237  wloop: 
     238    vpmovzxbd  xmm3, dword ptr [eax]  // src[0-3] 
     239    pmulld     xmm0, xmm6  // hash *= 33 ^ 16 
     240    vpmovzxbd  xmm4, dword ptr [eax + 4]  // src[4-7] 
     241    pmulld     xmm3, kHashMul0 
     242    vpmovzxbd  xmm2, dword ptr [eax + 8]  // src[8-11] 
     243    pmulld     xmm4, kHashMul1 
     244    vpmovzxbd  xmm1, dword ptr [eax + 12]  // src[12-15] 
     245    pmulld     xmm2, kHashMul2 
    216246    lea        eax, [eax + 16] 
    217     vpmulld    xmm1, xmm1, xmmword ptr kHashMul3 
    218     vpaddd     xmm3, xmm3, xmm4  // add 16 results 
    219     vpaddd     xmm1, xmm1, xmm2 
    220     vpaddd     xmm1, xmm1, xmm3 
    221     vpshufd    xmm2, xmm1, 0x0e  // upper 2 dwords 
    222     vpaddd     xmm1, xmm1,xmm2 
    223     vpshufd    xmm2, xmm1, 0x01 
    224     vpaddd     xmm1, xmm1, xmm2 
    225     vpaddd     xmm0, xmm0, xmm1 
     247    pmulld     xmm1, kHashMul3 
     248    paddd      xmm3, xmm4        // add 16 results 
     249    paddd      xmm1, xmm2 
    226250    sub        ecx, 16 
    227     jg         wloop 
    228  
    229     vmovd      eax, xmm0  // return hash 
    230     vzeroupper 
     251    paddd      xmm1, xmm3 
     252    pshufd     xmm2, xmm1, 0x0e  // upper 2 dwords 
     253    paddd      xmm1, xmm2 
     254    pshufd     xmm2, xmm1, 0x01 
     255    paddd      xmm1, xmm2 
     256    paddd      xmm0, xmm1 
     257    jg         wloop 
     258 
     259    movd       eax, xmm0         // return hash 
    231260    ret 
    232261  } 
    … …  
    234263#endif  // _MSC_VER >= 1700 
    235264 
    236 #endif  // !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86) 
     265#endif  // !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86) && defined(_MSC_VER) 
    237266 
    238267#ifdef __cplusplus 
Note: See TracChangeset for help on using the changeset viewer.