Ignore:
Timestamp:
Nov 21, 2017 9:25:11 AM (3 years ago)
Author:
riza
Message:

Close #2065: Update libyuv to fix linker error when building libyuv as dll on Visual Studio 2015.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/third_party/yuv/source/row_neon64.cc

    r5633 r5699  
    274274  asm volatile( 
    275275      YUVTORGB_SETUP 
    276       "1:                                          \n" READYUV422 YUVTORGB( 
     276      "1:                                        \n" READYUV422 YUVTORGB( 
    277277          v22, v21, 
    278278          v20) "subs       %w4, %w4, #8                   \n" ARGBTORGB565 
     
    311311      YUVTORGB_SETUP 
    312312      "movi       v23.8b, #255                   \n" 
    313       "1:                                          \n" READYUV422 YUVTORGB( 
     313      "1:                                        \n" READYUV422 YUVTORGB( 
    314314          v22, v21, 
    315315          v20) "subs       %w4, %w4, #8                   \n" ARGBTOARGB1555 
     
    396396  asm volatile( 
    397397      "movi       v23.8b, #255                   \n" 
    398       "1:                                          \n" 
     398      "1:                                        \n" 
    399399      "ld1        {v20.8b}, [%0], #8             \n" 
    400400      "orr        v21.8b, v20.8b, v20.8b         \n" 
     
    471471  asm volatile( 
    472472      YUVTORGB_SETUP 
    473       "1:                                          \n" READNV12 YUVTORGB( 
     473      "1:                                        \n" READNV12 YUVTORGB( 
    474474          v22, v21, 
    475475          v20) "subs       %w3, %w3, #8                   \n" ARGBTORGB565 
     
    545545                     int width) { 
    546546  asm volatile( 
    547       "1:                                          \n" 
     547      "1:                                        \n" 
    548548      "ld2        {v0.16b,v1.16b}, [%0], #32     \n"  // load 16 pairs of UV 
    549549      "subs       %w3, %w3, #16                  \n"  // 16 processed per loop 
     
    566566                     int width) { 
    567567  asm volatile( 
    568       "1:                                          \n" 
     568      "1:                                        \n" 
    569569      "ld1        {v0.16b}, [%0], #16            \n"  // load U 
    570570      "ld1        {v1.16b}, [%1], #16            \n"  // load V 
     
    581581} 
    582582 
    583 // Copy multiple of 32.  vld4.8  allow unaligned and is fastest on a15. 
     583// Reads 16 packed RGB and write to planar dst_r, dst_g, dst_b. 
     584void SplitRGBRow_NEON(const uint8* src_rgb, 
     585                      uint8* dst_r, 
     586                      uint8* dst_g, 
     587                      uint8* dst_b, 
     588                      int width) { 
     589  asm volatile( 
     590      "1:                                        \n" 
     591      "ld3        {v0.16b,v1.16b,v2.16b}, [%0], #48 \n"  // load 16 RGB 
     592      "subs       %w4, %w4, #16                  \n"  // 16 processed per loop 
     593      "st1        {v0.16b}, [%1], #16            \n"  // store R 
     594      "st1        {v1.16b}, [%2], #16            \n"  // store G 
     595      "st1        {v2.16b}, [%3], #16            \n"  // store B 
     596      "b.gt       1b                             \n" 
     597      : "+r"(src_rgb),                    // %0 
     598        "+r"(dst_r),                      // %1 
     599        "+r"(dst_g),                      // %2 
     600        "+r"(dst_b),                      // %3 
     601        "+r"(width)                       // %4 
     602      :                                   // Input registers 
     603      : "cc", "memory", "v0", "v1", "v2"  // Clobber List 
     604      ); 
     605} 
     606 
     607// Reads 16 planar R's, G's and B's and writes out 16 packed RGB at a time 
     608void MergeRGBRow_NEON(const uint8* src_r, 
     609                      const uint8* src_g, 
     610                      const uint8* src_b, 
     611                      uint8* dst_rgb, 
     612                      int width) { 
     613  asm volatile( 
     614      "1:                                        \n" 
     615      "ld1        {v0.16b}, [%0], #16            \n"  // load R 
     616      "ld1        {v1.16b}, [%1], #16            \n"  // load G 
     617      "ld1        {v2.16b}, [%2], #16            \n"  // load B 
     618      "subs       %w4, %w4, #16                  \n"  // 16 processed per loop 
     619      "st3        {v0.16b,v1.16b,v2.16b}, [%3], #48 \n"  // store 16 RGB 
     620      "b.gt       1b                             \n" 
     621      : "+r"(src_r),                      // %0 
     622        "+r"(src_g),                      // %1 
     623        "+r"(src_b),                      // %2 
     624        "+r"(dst_rgb),                    // %3 
     625        "+r"(width)                       // %4 
     626      :                                   // Input registers 
     627      : "cc", "memory", "v0", "v1", "v2"  // Clobber List 
     628      ); 
     629} 
     630 
     631// Copy multiple of 32. 
    584632void CopyRow_NEON(const uint8* src, uint8* dst, int count) { 
    585633  asm volatile( 
    586       "1:                                          \n" 
    587       "ld1        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32       \n"  // load 32 
     634      "1:                                        \n" 
     635      "ldp        q0, q1, [%0], #32              \n" 
    588636      "subs       %w2, %w2, #32                  \n"  // 32 processed per loop 
    589       "st1        {v0.8b,v1.8b,v2.8b,v3.8b}, [%1], #32       \n"  // store 32 
    590       "b.gt       1b                             \n" 
    591       : "+r"(src),                              // %0 
    592         "+r"(dst),                              // %1 
    593         "+r"(count)                             // %2  // Output registers 
    594       :                                         // Input registers 
    595       : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List 
     637      "stp        q0, q1, [%1], #32              \n" 
     638      "b.gt       1b                             \n" 
     639      : "+r"(src),                  // %0 
     640        "+r"(dst),                  // %1 
     641        "+r"(count)                 // %2  // Output registers 
     642      :                             // Input registers 
     643      : "cc", "memory", "v0", "v1"  // Clobber List 
    596644      ); 
    597645} 
     
    601649  asm volatile( 
    602650      "dup        v0.16b, %w2                    \n"  // duplicate 16 bytes 
    603       "1:                                          \n" 
     651      "1:                                        \n" 
    604652      "subs       %w1, %w1, #16                  \n"  // 16 bytes per loop 
    605653      "st1        {v0.16b}, [%0], #16            \n"  // store 
     
    614662  asm volatile( 
    615663      "dup        v0.4s, %w2                     \n"  // duplicate 4 ints 
    616       "1:                                          \n" 
     664      "1:                                        \n" 
    617665      "subs       %w1, %w1, #4                   \n"  // 4 ints per loop 
    618666      "st1        {v0.16b}, [%0], #16            \n"  // store 
     
    629677      "add        %0, %0, %w2, sxtw              \n" 
    630678      "sub        %0, %0, #16                    \n" 
    631       "1:                                          \n" 
     679      "1:                                        \n" 
    632680      "ld1        {v0.16b}, [%0], %3             \n"  // src -= 16 
    633681      "subs       %w2, %w2, #16                  \n"  // 16 pixels per loop. 
     
    651699      "add        %0, %0, %w3, sxtw #1           \n" 
    652700      "sub        %0, %0, #16                    \n" 
    653       "1:                                          \n" 
     701      "1:                                        \n" 
    654702      "ld2        {v0.8b, v1.8b}, [%0], %4       \n"  // src -= 16 
    655703      "subs       %w3, %w3, #8                   \n"  // 8 pixels per loop. 
     
    672720      "add        %0, %0, %w2, sxtw #2           \n" 
    673721      "sub        %0, %0, #16                    \n" 
    674       "1:                                          \n" 
     722      "1:                                        \n" 
    675723      "ld1        {v0.16b}, [%0], %3             \n"  // src -= 16 
    676724      "subs       %w2, %w2, #4                   \n"  // 4 pixels per loop. 
     
    689737  asm volatile( 
    690738      "movi       v4.8b, #255                    \n"  // Alpha 
    691       "1:                                          \n" 
     739      "1:                                        \n" 
    692740      "ld3        {v1.8b,v2.8b,v3.8b}, [%0], #24 \n"  // load 8 pixels of RGB24. 
    693741      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
    694742      "st4        {v1.8b,v2.8b,v3.8b,v4.8b}, [%1], #32 \n"  // store 8 ARGB 
    695                                                             // pixels 
    696743      "b.gt       1b                             \n" 
    697744      : "+r"(src_rgb24),  // %0 
     
    706753  asm volatile( 
    707754      "movi       v5.8b, #255                    \n"  // Alpha 
    708       "1:                                          \n" 
     755      "1:                                        \n" 
    709756      "ld3        {v0.8b,v1.8b,v2.8b}, [%0], #24 \n"  // read r g b 
    710757      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    723770void RAWToRGB24Row_NEON(const uint8* src_raw, uint8* dst_rgb24, int width) { 
    724771  asm volatile( 
    725       "1:                                          \n" 
     772      "1:                                        \n" 
    726773      "ld3        {v0.8b,v1.8b,v2.8b}, [%0], #24 \n"  // read r g b 
    727774      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    754801  asm volatile( 
    755802      "movi       v3.8b, #255                    \n"  // Alpha 
    756       "1:                                          \n" 
     803      "1:                                        \n" 
    757804      "ld1        {v0.16b}, [%0], #16            \n"  // load 8 RGB565 pixels. 
    758805      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
    759806      RGB565TOARGB 
    760807      "st4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%1], #32 \n"  // store 8 ARGB 
    761                                                             // pixels 
    762808      "b.gt       1b                             \n" 
    763809      : "+r"(src_rgb565),  // %0 
     
    811857  asm volatile( 
    812858      "movi       v3.8b, #255                    \n"  // Alpha 
    813       "1:                                          \n" 
     859      "1:                                        \n" 
    814860      "ld1        {v0.16b}, [%0], #16            \n"  // load 8 ARGB1555 pixels. 
    815861      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    842888                            int width) { 
    843889  asm volatile( 
    844       "1:                                          \n" 
     890      "1:                                        \n" 
    845891      "ld1        {v0.16b}, [%0], #16            \n"  // load 8 ARGB4444 pixels. 
    846892      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    859905void ARGBToRGB24Row_NEON(const uint8* src_argb, uint8* dst_rgb24, int width) { 
    860906  asm volatile( 
    861       "1:                                          \n" 
     907      "1:                                        \n" 
    862908      "ld4        {v1.8b,v2.8b,v3.8b,v4.8b}, [%0], #32 \n"  // load 8 ARGB 
    863                                                             // pixels 
    864909      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
    865910      "st3        {v1.8b,v2.8b,v3.8b}, [%1], #24 \n"  // store 8 pixels of 
     
    876921void ARGBToRAWRow_NEON(const uint8* src_argb, uint8* dst_raw, int width) { 
    877922  asm volatile( 
    878       "1:                                          \n" 
     923      "1:                                        \n" 
    879924      "ld4        {v1.8b,v2.8b,v3.8b,v4.8b}, [%0], #32 \n"  // load b g r a 
    880925      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    893938void YUY2ToYRow_NEON(const uint8* src_yuy2, uint8* dst_y, int width) { 
    894939  asm volatile( 
    895       "1:                                          \n" 
     940      "1:                                        \n" 
    896941      "ld2        {v0.16b,v1.16b}, [%0], #32     \n"  // load 16 pixels of YUY2. 
    897942      "subs       %w2, %w2, #16                  \n"  // 16 processed per loop. 
     
    908953void UYVYToYRow_NEON(const uint8* src_uyvy, uint8* dst_y, int width) { 
    909954  asm volatile( 
    910       "1:                                          \n" 
     955      "1:                                        \n" 
    911956      "ld2        {v0.16b,v1.16b}, [%0], #32     \n"  // load 16 pixels of UYVY. 
    912957      "subs       %w2, %w2, #16                  \n"  // 16 processed per loop. 
     
    926971                         int width) { 
    927972  asm volatile( 
    928       "1:                                          \n" 
     973      "1:                                        \n" 
    929974      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 16 YUY2 
    930                                                             // pixels 
    931975      "subs       %w3, %w3, #16                  \n"  // 16 pixels = 8 UVs. 
    932976      "st1        {v1.8b}, [%1], #8              \n"  // store 8 U. 
     
    947991                         int width) { 
    948992  asm volatile( 
    949       "1:                                          \n" 
     993      "1:                                        \n" 
    950994      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 16 UYVY 
    951                                                             // pixels 
    952995      "subs       %w3, %w3, #16                  \n"  // 16 pixels = 8 UVs. 
    953996      "st1        {v0.8b}, [%1], #8              \n"  // store 8 U. 
     
    9701013  const uint8* src_yuy2b = src_yuy2 + stride_yuy2; 
    9711014  asm volatile( 
    972       "1:                                          \n" 
     1015      "1:                                        \n" 
    9731016      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 16 pixels 
    9741017      "subs       %w4, %w4, #16                  \n"  // 16 pixels = 8 UVs. 
     
    9971040  const uint8* src_uyvyb = src_uyvy + stride_uyvy; 
    9981041  asm volatile( 
    999       "1:                                          \n" 
     1042      "1:                                        \n" 
    10001043      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 16 pixels 
    10011044      "subs       %w4, %w4, #16                  \n"  // 16 pixels = 8 UVs. 
     
    10241067  asm volatile( 
    10251068      "ld1        {v2.16b}, [%3]                 \n"  // shuffler 
    1026       "1:                                          \n" 
     1069      "1:                                        \n" 
    10271070      "ld1        {v0.16b}, [%0], #16            \n"  // load 4 pixels. 
    10281071      "subs       %w2, %w2, #4                   \n"  // 4 processed per loop 
     
    10441087                        int width) { 
    10451088  asm volatile( 
    1046       "1:                                          \n" 
     1089      "1:                                        \n" 
    10471090      "ld2        {v0.8b, v1.8b}, [%0], #16      \n"  // load 16 Ys 
    10481091      "orr        v2.8b, v1.8b, v1.8b            \n" 
     
    10671110                        int width) { 
    10681111  asm volatile( 
    1069       "1:                                          \n" 
     1112      "1:                                        \n" 
    10701113      "ld2        {v1.8b,v2.8b}, [%0], #16       \n"  // load 16 Ys 
    10711114      "orr        v3.8b, v2.8b, v2.8b            \n" 
     
    10861129void ARGBToRGB565Row_NEON(const uint8* src_argb, uint8* dst_rgb565, int width) { 
    10871130  asm volatile( 
    1088       "1:                                          \n" 
     1131      "1:                                        \n" 
    10891132      "ld4        {v20.8b,v21.8b,v22.8b,v23.8b}, [%0], #32 \n"  // load 8 pixels 
    10901133      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    11051148  asm volatile( 
    11061149      "dup        v1.4s, %w2                     \n"  // dither4 
    1107       "1:                                          \n" 
     1150      "1:                                        \n" 
    11081151      "ld4        {v20.8b,v21.8b,v22.8b,v23.8b}, [%1], #32 \n"  // load 8 pixels 
    11091152      "subs       %w3, %w3, #8                   \n"  // 8 processed per loop. 
     
    11241167                            int width) { 
    11251168  asm volatile( 
    1126       "1:                                          \n" 
     1169      "1:                                        \n" 
    11271170      "ld4        {v20.8b,v21.8b,v22.8b,v23.8b}, [%0], #32 \n"  // load 8 pixels 
    11281171      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    11441187      "movi       v4.16b, #0x0f                  \n"  // bits to clear with 
    11451188                                                      // vbic. 
    1146       "1:                                          \n" 
     1189      "1:                                        \n" 
    11471190      "ld4        {v20.8b,v21.8b,v22.8b,v23.8b}, [%0], #32 \n"  // load 8 pixels 
    11481191      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    11641207      "movi       v6.8b, #33                     \n"  // R * 0.2578 coefficient 
    11651208      "movi       v7.8b, #16                     \n"  // Add 16 constant 
    1166       "1:                                          \n" 
     1209      "1:                                        \n" 
    11671210      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB 
    1168                                                             // pixels. 
    11691211      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
    11701212      "umull      v3.8h, v0.8b, v4.8b            \n"  // B 
     
    11841226void ARGBExtractAlphaRow_NEON(const uint8* src_argb, uint8* dst_a, int width) { 
    11851227  asm volatile( 
    1186       "1:                                          \n" 
     1228      "1:                                        \n" 
    11871229      "ld4        {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load row 16 
    11881230                                                                // pixels 
     
    12031245      "movi       v5.8b, #75                     \n"  // G * 0.58700 coefficient 
    12041246      "movi       v6.8b, #38                     \n"  // R * 0.29900 coefficient 
    1205       "1:                                          \n" 
     1247      "1:                                        \n" 
    12061248      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB 
    1207                                                             // pixels. 
    12081249      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
    12091250      "umull      v3.8h, v0.8b, v4.8b            \n"  // B 
     
    12331274      "movi       v28.8b, #94                    \n"  // VG -0.7344 coefficient 
    12341275      "movi       v29.16b,#0x80                  \n"  // 128.5 
    1235       "1:                                          \n" 
     1276      "1:                                        \n" 
    12361277      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB 
    12371278                                                            // pixels. 
     
    12711312 
    12721313// 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16. 
     1314// clang-format off 
    12731315#define RGBTOUV(QB, QG, QR)                                                 \ 
    1274   "mul        v3.8h, " #QB                                                  \ 
    1275   ",v20.8h          \n" /* B                    */                          \ 
    1276   "mul        v4.8h, " #QR                                                  \ 
    1277   ",v20.8h          \n" /* R                    */                          \ 
    1278   "mls        v3.8h, " #QG                                                  \ 
    1279   ",v21.8h          \n" /* G                    */                          \ 
    1280   "mls        v4.8h, " #QG                                                  \ 
    1281   ",v24.8h          \n" /* G                    */                          \ 
    1282   "mls        v3.8h, " #QR                                                  \ 
    1283   ",v22.8h          \n" /* R                    */                          \ 
    1284   "mls        v4.8h, " #QB                                                  \ 
    1285   ",v23.8h          \n"                          /* B                    */ \ 
     1316  "mul        v3.8h, " #QB ",v20.8h          \n" /* B                    */ \ 
     1317  "mul        v4.8h, " #QR ",v20.8h          \n" /* R                    */ \ 
     1318  "mls        v3.8h, " #QG ",v21.8h          \n" /* G                    */ \ 
     1319  "mls        v4.8h, " #QG ",v24.8h          \n" /* G                    */ \ 
     1320  "mls        v3.8h, " #QR ",v22.8h          \n" /* R                    */ \ 
     1321  "mls        v4.8h, " #QB ",v23.8h          \n" /* B                    */ \ 
    12861322  "add        v3.8h, v3.8h, v25.8h           \n" /* +128 -> unsigned     */ \ 
    12871323  "add        v4.8h, v4.8h, v25.8h           \n" /* +128 -> unsigned     */ \ 
    12881324  "uqshrn     v0.8b, v3.8h, #8               \n" /* 16 bit to 8 bit U    */ \ 
    12891325  "uqshrn     v1.8b, v4.8h, #8               \n" /* 16 bit to 8 bit V    */ 
     1326// clang-format on 
    12901327 
    12911328// TODO(fbarchard): Consider vhadd vertical, then vpaddl horizontal, avoid shr. 
     
    15791616      "movi       v25.8h, #9 , lsl #0            \n"  // VB coeff (-0.1406) / 2 
    15801617      "movi       v26.8h, #47, lsl #0            \n"  // VG coeff (-0.7344) / 2 
    1581       "movi       v27.16b, #0x80                 \n"  // 128.5 (0x8080 in 
    1582                                                       // 16-bit) 
    1583       "1:                                          \n" 
     1618      "movi       v27.16b, #0x80                 \n"  // 128.5 0x8080 in 16bit 
     1619      "1:                                        \n" 
    15841620      "ld1        {v0.16b}, [%0], #16            \n"  // load 8 RGB565 pixels. 
    15851621      RGB565TOARGB 
     
    16461682  asm volatile( 
    16471683      RGBTOUV_SETUP_REG 
    1648       "1:                                          \n" 
     1684      "1:                                        \n" 
    16491685      "ld1        {v0.16b}, [%0], #16            \n"  // load 8 ARGB1555 pixels. 
    16501686      RGB555TOARGB 
     
    17111747  asm volatile( 
    17121748      RGBTOUV_SETUP_REG 
    1713       "1:                                          \n" 
     1749      "1:                                        \n" 
    17141750      "ld1        {v0.16b}, [%0], #16            \n"  // load 8 ARGB4444 pixels. 
    17151751      ARGB4444TOARGB 
     
    17751811      "movi       v26.8b, #33                    \n"  // R * 0.2578 coefficient 
    17761812      "movi       v27.8b, #16                    \n"  // Add 16 constant 
    1777       "1:                                          \n" 
     1813      "1:                                        \n" 
    17781814      "ld1        {v0.16b}, [%0], #16            \n"  // load 8 RGB565 pixels. 
    17791815      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    18001836      "movi       v6.8b, #33                     \n"  // R * 0.2578 coefficient 
    18011837      "movi       v7.8b, #16                     \n"  // Add 16 constant 
    1802       "1:                                          \n" 
     1838      "1:                                        \n" 
    18031839      "ld1        {v0.16b}, [%0], #16            \n"  // load 8 ARGB1555 pixels. 
    18041840      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    18241860      "movi       v26.8b, #33                    \n"  // R * 0.2578 coefficient 
    18251861      "movi       v27.8b, #16                    \n"  // Add 16 constant 
    1826       "1:                                          \n" 
     1862      "1:                                        \n" 
    18271863      "ld1        {v0.16b}, [%0], #16            \n"  // load 8 ARGB4444 pixels. 
    18281864      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    18481884      "movi       v6.8b, #13                     \n"  // B * 0.1016 coefficient 
    18491885      "movi       v7.8b, #16                     \n"  // Add 16 constant 
    1850       "1:                                          \n" 
     1886      "1:                                        \n" 
    18511887      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 pixels. 
    18521888      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    18711907      "movi       v6.8b, #13                     \n"  // B * 0.1016 coefficient 
    18721908      "movi       v7.8b, #16                     \n"  // Add 16 constant 
    1873       "1:                                          \n" 
     1909      "1:                                        \n" 
    18741910      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 pixels. 
    18751911      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    18941930      "movi       v6.8b, #33                     \n"  // R * 0.2578 coefficient 
    18951931      "movi       v7.8b, #16                     \n"  // Add 16 constant 
    1896       "1:                                          \n" 
     1932      "1:                                        \n" 
    18971933      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 pixels. 
    18981934      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    19171953      "movi       v6.8b, #33                     \n"  // R * 0.2578 coefficient 
    19181954      "movi       v7.8b, #16                     \n"  // Add 16 constant 
    1919       "1:                                          \n" 
     1955      "1:                                        \n" 
    19201956      "ld3        {v0.8b,v1.8b,v2.8b}, [%0], #24 \n"  // load 8 pixels. 
    19211957      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    19401976      "movi       v6.8b, #13                     \n"  // B * 0.1016 coefficient 
    19411977      "movi       v7.8b, #16                     \n"  // Add 16 constant 
    1942       "1:                                          \n" 
     1978      "1:                                        \n" 
    19431979      "ld3        {v0.8b,v1.8b,v2.8b}, [%0], #24 \n"  // load 8 pixels. 
    19441980      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
     
    19752011      "dup        v4.16b, %w5                    \n" 
    19762012      // General purpose row blend. 
    1977       "1:                                          \n" 
     2013      "1:                                        \n" 
    19782014      "ld1        {v0.16b}, [%1], #16            \n" 
    19792015      "ld1        {v1.16b}, [%2], #16            \n" 
     
    19902026 
    19912027      // Blend 50 / 50. 
    1992       "50:                                         \n" 
     2028      "50:                                       \n" 
    19932029      "ld1        {v0.16b}, [%1], #16            \n" 
    19942030      "ld1        {v1.16b}, [%2], #16            \n" 
     
    20002036 
    20012037      // Blend 100 / 0 - Copy row unchanged. 
    2002       "100:                                        \n" 
     2038      "100:                                      \n" 
    20032039      "ld1        {v0.16b}, [%1], #16            \n" 
    20042040      "subs       %w3, %w3, #16                  \n" 
     
    20062042      "b.gt       100b                           \n" 
    20072043 
    2008       "99:                                         \n" 
     2044      "99:                                       \n" 
    20092045      : "+r"(dst_ptr),      // %0 
    20102046        "+r"(src_ptr),      // %1 
     
    20262062      "b.lt       89f                            \n" 
    20272063      // Blend 8 pixels. 
    2028       "8:                                          \n" 
     2064      "8:                                        \n" 
    20292065      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB0 
    20302066                                                            // pixels 
     
    20492085      "b.ge       8b                             \n" 
    20502086 
    2051       "89:                                         \n" 
     2087      "89:                                       \n" 
    20522088      "adds       %w3, %w3, #8-1                 \n" 
    20532089      "b.lt       99f                            \n" 
    20542090 
    20552091      // Blend 1 pixels. 
    2056       "1:                                          \n" 
     2092      "1:                                        \n" 
    20572093      "ld4        {v0.b,v1.b,v2.b,v3.b}[0], [%0], #4 \n"  // load 1 pixel ARGB0. 
    20582094      "ld4        {v4.b,v5.b,v6.b,v7.b}[0], [%1], #4 \n"  // load 1 pixel ARGB1. 
     
    20742110      "b.ge       1b                             \n" 
    20752111 
    2076       "99:                                         \n" 
     2112      "99:                                       \n" 
    20772113 
    20782114      : "+r"(src_argb0),  // %0 
     
    20892125  asm volatile( 
    20902126      // Attenuate 8 pixels. 
    2091       "1:                                          \n" 
     2127      "1:                                        \n" 
    20922128      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB 
    2093                                                             // pixels 
    20942129      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
    20952130      "umull      v4.8h, v0.8b, v3.8b            \n"  // b * a 
     
    21232158 
    21242159      // 8 pixel loop. 
    2125       "1:                                          \n" 
    2126       "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0]  \n"  // load 8 pixels of 
    2127                                                         // ARGB. 
     2160      "1:                                        \n" 
     2161      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0]  \n"  // load 8  ARGB. 
    21282162      "subs       %w1, %w1, #8                   \n"    // 8 processed per loop. 
    21292163      "uxtl       v0.8h, v0.8b                   \n"    // b (0 .. 255) 
     
    21432177      "uqxtn      v2.8b, v2.8h                   \n" 
    21442178      "st4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // store 8 ARGB 
    2145                                                             // pixels 
    21462179      "b.gt       1b                             \n" 
    21472180      : "+r"(dst_argb),       // %0 
     
    21662199 
    21672200      // 8 pixel loop. 
    2168       "1:                                          \n" 
     2201      "1:                                        \n" 
    21692202      "ld4        {v4.8b,v5.8b,v6.8b,v7.8b}, [%0], #32 \n"  // load 8 ARGB 
    2170                                                             // pixels. 
    21712203      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
    21722204      "uxtl       v4.8h, v4.8b                   \n"  // b (0 .. 255) 
     
    21832215      "uqxtn      v7.8b, v7.8h                   \n" 
    21842216      "st4        {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // store 8 ARGB 
    2185                                                             // pixels 
    21862217      "b.gt       1b                             \n" 
    21872218      : "+r"(src_argb),  // %0 
     
    22002231      "movi       v25.8b, #75                    \n"  // G * 0.58700 coefficient 
    22012232      "movi       v26.8b, #38                    \n"  // R * 0.29900 coefficient 
    2202       "1:                                          \n" 
     2233      "1:                                        \n" 
    22032234      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB 
    2204                                                             // pixels. 
    22052235      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
    22062236      "umull      v4.8h, v0.8b, v24.8b           \n"  // B 
     
    22352265      "movi       v29.8b, #98                    \n"  // BG coefficient 
    22362266      "movi       v30.8b, #50                    \n"  // BR coefficient 
    2237       "1:                                          \n" 
     2267      "1:                                        \n" 
    22382268      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0] \n"  // load 8 ARGB pixels. 
    22392269      "subs       %w1, %w1, #8                   \n"   // 8 processed per loop. 
     
    22712301      "sxtl2      v1.8h, v2.16b                  \n"  // R,A coefficients s16. 
    22722302 
    2273       "1:                                          \n" 
    2274       "ld4        {v16.8b,v17.8b,v18.8b,v19.8b}, [%0], #32 \n"  // load 8 
    2275                                                                 // pixels. 
     2303      "1:                                        \n" 
     2304      "ld4        {v16.8b,v17.8b,v18.8b,v19.8b}, [%0], #32 \n"  // load 8 ARGB 
    22762305      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop. 
    22772306      "uxtl       v16.8h, v16.8b                 \n"  // b (0 .. 255) 16 bit 
     
    23112340      "sqshrun    v18.8b, v24.8h, #6             \n"  // 16 bit to 8 bit R 
    23122341      "sqshrun    v19.8b, v25.8h, #6             \n"  // 16 bit to 8 bit A 
    2313       "st4        {v16.8b,v17.8b,v18.8b,v19.8b}, [%1], #32 \n"  // store 8 
    2314                                                                 // pixels. 
     2342      "st4        {v16.8b,v17.8b,v18.8b,v19.8b}, [%1], #32 \n"  // store 8 ARGB 
    23152343      "b.gt       1b                             \n" 
    23162344      : "+r"(src_argb),   // %0 
     
    23302358  asm volatile( 
    23312359      // 8 pixel loop. 
    2332       "1:                                          \n" 
     2360      "1:                                        \n" 
    23332361      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB 
    2334                                                             // pixels. 
    23352362      "ld4        {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // load 8 more 
    2336                                                             // pixels. 
    23372363      "subs       %w3, %w3, #8                   \n"  // 8 processed per loop. 
    23382364      "umull      v0.8h, v0.8b, v4.8b            \n"  // multiply B 
     
    23452371      "rshrn      v3.8b, v3.8h, #8               \n"  // 16 bit to 8 bit A 
    23462372      "st4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB 
    2347                                                             // pixels 
    2348       "b.gt       1b                             \n" 
    2349  
     2373      "b.gt       1b                             \n" 
    23502374      : "+r"(src_argb0),  // %0 
    23512375        "+r"(src_argb1),  // %1 
     
    23632387  asm volatile( 
    23642388      // 8 pixel loop. 
    2365       "1:                                          \n" 
     2389      "1:                                        \n" 
    23662390      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB 
    2367                                                             // pixels. 
    23682391      "ld4        {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // load 8 more 
    2369                                                             // pixels. 
    23702392      "subs       %w3, %w3, #8                   \n"  // 8 processed per loop. 
    23712393      "uqadd      v0.8b, v0.8b, v4.8b            \n" 
     
    23742396      "uqadd      v3.8b, v3.8b, v7.8b            \n" 
    23752397      "st4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB 
    2376                                                             // pixels 
    2377       "b.gt       1b                             \n" 
    2378  
     2398      "b.gt       1b                             \n" 
    23792399      : "+r"(src_argb0),  // %0 
    23802400        "+r"(src_argb1),  // %1 
     
    23922412  asm volatile( 
    23932413      // 8 pixel loop. 
    2394       "1:                                          \n" 
     2414      "1:                                        \n" 
    23952415      "ld4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB 
    2396                                                             // pixels. 
    23972416      "ld4        {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // load 8 more 
    2398                                                             // pixels. 
    23992417      "subs       %w3, %w3, #8                   \n"  // 8 processed per loop. 
    24002418      "uqsub      v0.8b, v0.8b, v4.8b            \n" 
     
    24032421      "uqsub      v3.8b, v3.8b, v7.8b            \n" 
    24042422      "st4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB 
    2405                                                             // pixels 
    2406       "b.gt       1b                             \n" 
    2407  
     2423      "b.gt       1b                             \n" 
    24082424      : "+r"(src_argb0),  // %0 
    24092425        "+r"(src_argb1),  // %1 
     
    24262442      "movi       v3.8b, #255                    \n"  // alpha 
    24272443      // 8 pixel loop. 
    2428       "1:                                          \n" 
     2444      "1:                                        \n" 
    24292445      "ld1        {v0.8b}, [%0], #8              \n"  // load 8 sobelx. 
    24302446      "ld1        {v1.8b}, [%1], #8              \n"  // load 8 sobely. 
     
    24342450      "orr        v2.8b, v0.8b, v0.8b            \n" 
    24352451      "st4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB 
    2436                                                             // pixels 
    24372452      "b.gt       1b                             \n" 
    24382453      : "+r"(src_sobelx),  // %0 
     
    24512466  asm volatile( 
    24522467      // 16 pixel loop. 
    2453       "1:                                          \n" 
     2468      "1:                                        \n" 
    24542469      "ld1        {v0.16b}, [%0], #16            \n"  // load 16 sobelx. 
    24552470      "ld1        {v1.16b}, [%1], #16            \n"  // load 16 sobely. 
     
    24782493      "movi       v3.8b, #255                    \n"  // alpha 
    24792494      // 8 pixel loop. 
    2480       "1:                                          \n" 
     2495      "1:                                        \n" 
    24812496      "ld1        {v2.8b}, [%0], #8              \n"  // load 8 sobelx. 
    24822497      "ld1        {v0.8b}, [%1], #8              \n"  // load 8 sobely. 
     
    24842499      "uqadd      v1.8b, v0.8b, v2.8b            \n"  // add 
    24852500      "st4        {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB 
    2486                                                             // pixels 
    24872501      "b.gt       1b                             \n" 
    24882502      : "+r"(src_sobelx),  // %0 
     
    25042518                    int width) { 
    25052519  asm volatile( 
    2506       "1:                                          \n" 
     2520      "1:                                        \n" 
    25072521      "ld1        {v0.8b}, [%0],%5               \n"  // top 
    25082522      "ld1        {v1.8b}, [%0],%6               \n" 
     
    25422556                    int width) { 
    25432557  asm volatile( 
    2544       "1:                                          \n" 
     2558      "1:                                        \n" 
    25452559      "ld1        {v0.8b}, [%0],%4               \n"  // left 
    25462560      "ld1        {v1.8b}, [%1],%4               \n" 
     
    25732587void HalfFloat1Row_NEON(const uint16* src, uint16* dst, float, int width) { 
    25742588  asm volatile( 
    2575       "1:                                          \n" 
     2589      "1:                                        \n" 
    25762590      "ld1        {v1.16b}, [%0], #16            \n"  // load 8 shorts 
    25772591      "subs       %w2, %w2, #8                   \n"  // 8 pixels per loop 
     
    25932607void HalfFloatRow_NEON(const uint16* src, uint16* dst, float scale, int width) { 
    25942608  asm volatile( 
    2595       "1:                                          \n" 
     2609      "1:                                        \n" 
    25962610      "ld1        {v1.16b}, [%0], #16            \n"  // load 8 shorts 
    25972611      "subs       %w2, %w2, #8                   \n"  // 8 pixels per loop 
     
    26132627} 
    26142628 
     2629float ScaleMaxSamples_NEON(const float* src, 
     2630                           float* dst, 
     2631                           float scale, 
     2632                           int width) { 
     2633  float fmax; 
     2634  asm volatile( 
     2635      "movi       v5.4s, #0                      \n"  // max 
     2636      "movi       v6.4s, #0                      \n" 
     2637 
     2638      "1:                                        \n" 
     2639      "ld1        {v1.4s, v2.4s}, [%0], #32      \n"  // load 8 samples 
     2640      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop 
     2641      "fmul       v3.4s, v1.4s, %4.s[0]          \n"  // scale 
     2642      "fmul       v4.4s, v2.4s, %4.s[0]          \n"  // scale 
     2643      "fmax       v5.4s, v5.4s, v1.4s            \n"  // max 
     2644      "fmax       v6.4s, v6.4s, v2.4s            \n" 
     2645      "st1        {v3.4s, v4.4s}, [%1], #32      \n"  // store 8 samples 
     2646      "b.gt       1b                             \n" 
     2647      "fmax       v5.4s, v5.4s, v6.4s            \n"  // max 
     2648      "fmaxv      %s3, v5.4s                     \n"  // signed max acculator 
     2649      : "+r"(src),                                    // %0 
     2650        "+r"(dst),                                    // %1 
     2651        "+r"(width),                                  // %2 
     2652        "=w"(fmax)                                    // %3 
     2653      : "w"(scale)                                    // %4 
     2654      : "cc", "memory", "v1", "v2", "v3", "v4", "v5", "v6"); 
     2655  return fmax; 
     2656} 
     2657 
     2658float ScaleSumSamples_NEON(const float* src, 
     2659                           float* dst, 
     2660                           float scale, 
     2661                           int width) { 
     2662  float fsum; 
     2663  asm volatile( 
     2664      "movi       v5.4s, #0                      \n"  // max 
     2665      "movi       v6.4s, #0                      \n"  // max 
     2666 
     2667      "1:                                        \n" 
     2668      "ld1        {v1.4s, v2.4s}, [%0], #32      \n"  // load 8 samples 
     2669      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop 
     2670      "fmul       v3.4s, v1.4s, %4.s[0]          \n"  // scale 
     2671      "fmul       v4.4s, v2.4s, %4.s[0]          \n" 
     2672      "fmla       v5.4s, v1.4s, v1.4s            \n"  // sum of squares 
     2673      "fmla       v6.4s, v2.4s, v2.4s            \n" 
     2674      "st1        {v3.4s, v4.4s}, [%1], #32      \n"  // store 8 samples 
     2675      "b.gt       1b                             \n" 
     2676      "faddp      v5.4s, v5.4s, v6.4s            \n" 
     2677      "faddp      v5.4s, v5.4s, v5.4s            \n" 
     2678      "faddp      %3.4s, v5.4s, v5.4s            \n"  // sum 
     2679      : "+r"(src),                                    // %0 
     2680        "+r"(dst),                                    // %1 
     2681        "+r"(width),                                  // %2 
     2682        "=w"(fsum)                                    // %3 
     2683      : "w"(scale)                                    // %4 
     2684      : "cc", "memory", "v1", "v2", "v3", "v4", "v5", "v6"); 
     2685  return fsum; 
     2686} 
     2687 
     2688void ScaleSamples_NEON(const float* src, float* dst, float scale, int width) { 
     2689  asm volatile( 
     2690      "1:                                        \n" 
     2691      "ld1        {v1.4s, v2.4s}, [%0], #32      \n"  // load 8 samples 
     2692      "subs       %w2, %w2, #8                   \n"  // 8 processed per loop 
     2693      "fmul       v1.4s, v1.4s, %3.s[0]          \n"  // scale 
     2694      "fmul       v2.4s, v2.4s, %3.s[0]          \n"  // scale 
     2695      "st1        {v1.4s, v2.4s}, [%1], #32      \n"  // store 8 samples 
     2696      "b.gt       1b                             \n" 
     2697      : "+r"(src),   // %0 
     2698        "+r"(dst),   // %1 
     2699        "+r"(width)  // %2 
     2700      : "w"(scale)   // %3 
     2701      : "cc", "memory", "v1", "v2"); 
     2702} 
     2703 
     2704// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row. 
     2705void GaussCol_NEON(const uint16* src0, 
     2706                   const uint16* src1, 
     2707                   const uint16* src2, 
     2708                   const uint16* src3, 
     2709                   const uint16* src4, 
     2710                   uint32* dst, 
     2711                   int width) { 
     2712  asm volatile( 
     2713      "movi       v6.8h, #4                      \n"  // constant 4 
     2714      "movi       v7.8h, #6                      \n"  // constant 6 
     2715 
     2716      "1:                                        \n" 
     2717      "ld1        {v1.8h}, [%0], #16             \n"  // load 8 samples, 5 rows 
     2718      "ld1        {v2.8h}, [%4], #16             \n" 
     2719      "uaddl      v0.4s, v1.4h, v2.4h            \n"  // * 1 
     2720      "uaddl2     v1.4s, v1.8h, v2.8h            \n"  // * 1 
     2721      "ld1        {v2.8h}, [%1], #16             \n" 
     2722      "umlal      v0.4s, v2.4h, v6.4h            \n"  // * 4 
     2723      "umlal2     v1.4s, v2.8h, v6.8h            \n"  // * 4 
     2724      "ld1        {v2.8h}, [%2], #16             \n" 
     2725      "umlal      v0.4s, v2.4h, v7.4h            \n"  // * 6 
     2726      "umlal2     v1.4s, v2.8h, v7.8h            \n"  // * 6 
     2727      "ld1        {v2.8h}, [%3], #16             \n" 
     2728      "umlal      v0.4s, v2.4h, v6.4h            \n"  // * 4 
     2729      "umlal2     v1.4s, v2.8h, v6.8h            \n"  // * 4 
     2730      "subs       %w6, %w6, #8                   \n"  // 8 processed per loop 
     2731      "st1        {v0.4s,v1.4s}, [%5], #32       \n"  // store 8 samples 
     2732      "b.gt       1b                             \n" 
     2733      : "+r"(src0),  // %0 
     2734        "+r"(src1),  // %1 
     2735        "+r"(src2),  // %2 
     2736        "+r"(src3),  // %3 
     2737        "+r"(src4),  // %4 
     2738        "+r"(dst),   // %5 
     2739        "+r"(width)  // %6 
     2740      : 
     2741      : "cc", "memory", "v0", "v1", "v2", "v6", "v7"); 
     2742} 
     2743 
     2744// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row. 
     2745void GaussRow_NEON(const uint32* src, uint16* dst, int width) { 
     2746  const uint32* src1 = src + 1; 
     2747  const uint32* src2 = src + 2; 
     2748  const uint32* src3 = src + 3; 
     2749  asm volatile( 
     2750      "movi       v6.4s, #4                      \n"  // constant 4 
     2751      "movi       v7.4s, #6                      \n"  // constant 6 
     2752 
     2753      "1:                                        \n" 
     2754      "ld1        {v0.4s,v1.4s,v2.4s}, [%0], %6  \n"  // load 12 source samples 
     2755      "add        v0.4s, v0.4s, v1.4s            \n"  // * 1 
     2756      "add        v1.4s, v1.4s, v2.4s            \n"  // * 1 
     2757      "ld1        {v2.4s,v3.4s}, [%2], #32       \n" 
     2758      "mla        v0.4s, v2.4s, v7.4s            \n"  // * 6 
     2759      "mla        v1.4s, v3.4s, v7.4s            \n"  // * 6 
     2760      "ld1        {v2.4s,v3.4s}, [%1], #32       \n" 
     2761      "ld1        {v4.4s,v5.4s}, [%3], #32       \n" 
     2762      "add        v2.4s, v2.4s, v4.4s            \n"  // add rows for * 4 
     2763      "add        v3.4s, v3.4s, v5.4s            \n" 
     2764      "mla        v0.4s, v2.4s, v6.4s            \n"  // * 4 
     2765      "mla        v1.4s, v3.4s, v6.4s            \n"  // * 4 
     2766      "subs       %w5, %w5, #8                   \n"  // 8 processed per loop 
     2767      "uqrshrn    v0.4h, v0.4s, #8               \n"  // round and pack 
     2768      "uqrshrn2   v0.8h, v1.4s, #8               \n" 
     2769      "st1        {v0.8h}, [%4], #16             \n"  // store 8 samples 
     2770      "b.gt       1b                             \n" 
     2771      : "+r"(src),   // %0 
     2772        "+r"(src1),  // %1 
     2773        "+r"(src2),  // %2 
     2774        "+r"(src3),  // %3 
     2775        "+r"(dst),   // %4 
     2776        "+r"(width)  // %5 
     2777      : "r"(32LL)    // %6 
     2778      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7"); 
     2779} 
     2780 
    26152781#endif  // !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__) 
    26162782 
Note: See TracChangeset for help on using the changeset viewer.