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_neon.cc

    r5633 r5699  
    116116      YUVTORGB_SETUP 
    117117      "vmov.u8    d23, #255                      \n" 
    118       "1:                                          \n" READYUV444 YUVTORGB 
     118      "1:                                        \n" READYUV444 YUVTORGB 
    119119      "subs       %4, %4, #8                     \n" 
    120120      "vst4.8     {d20, d21, d22, d23}, [%3]!    \n" 
     
    142142      YUVTORGB_SETUP 
    143143      "vmov.u8    d23, #255                      \n" 
    144       "1:                                          \n" READYUV422 YUVTORGB 
     144      "1:                                        \n" READYUV422 YUVTORGB 
    145145      "subs       %4, %4, #8                     \n" 
    146146      "vst4.8     {d20, d21, d22, d23}, [%3]!    \n" 
     
    168168  asm volatile( 
    169169      YUVTORGB_SETUP 
    170       "1:                                          \n" READYUV422 YUVTORGB 
     170      "1:                                        \n" READYUV422 YUVTORGB 
    171171      "subs       %5, %5, #8                     \n" 
    172172      "vld1.8     {d23}, [%3]!                   \n" 
     
    195195  asm volatile( 
    196196      YUVTORGB_SETUP 
    197       "1:                                          \n" READYUV422 YUVTORGB 
     197      "1:                                        \n" READYUV422 YUVTORGB 
    198198      "subs       %4, %4, #8                     \n" 
    199199      "vmov.u8    d19, #255                      \n"  // d19 modified by 
     
    222222  asm volatile( 
    223223      YUVTORGB_SETUP 
    224       "1:                                          \n" READYUV422 YUVTORGB 
     224      "1:                                        \n" READYUV422 YUVTORGB 
    225225      "subs       %4, %4, #8                     \n" 
    226226      "vst3.8     {d20, d21, d22}, [%3]!         \n" 
     
    254254  asm volatile( 
    255255      YUVTORGB_SETUP 
    256       "1:                                          \n" READYUV422 YUVTORGB 
     256      "1:                                        \n" READYUV422 YUVTORGB 
    257257      "subs       %4, %4, #8                     \n" ARGBTORGB565 
    258258      "vst1.8     {q0}, [%3]!                    \n"  // store 8 pixels RGB565. 
     
    288288  asm volatile( 
    289289      YUVTORGB_SETUP 
    290       "1:                                          \n" READYUV422 YUVTORGB 
     290      "1:                                        \n" READYUV422 YUVTORGB 
    291291      "subs       %4, %4, #8                     \n" 
    292292      "vmov.u8    d23, #255                      \n" ARGBTOARGB1555 
     
    326326      "vmov.u8    d4, #0x0f                      \n"  // bits to clear with 
    327327                                                      // vbic. 
    328       "1:                                          \n" READYUV422 YUVTORGB 
     328      "1:                                        \n" READYUV422 YUVTORGB 
    329329      "subs       %4, %4, #8                     \n" 
    330330      "vmov.u8    d23, #255                      \n" ARGBTOARGB4444 
     
    349349      YUVTORGB_SETUP 
    350350      "vmov.u8    d23, #255                      \n" 
    351       "1:                                          \n" READYUV400 YUVTORGB 
     351      "1:                                        \n" READYUV400 YUVTORGB 
    352352      "subs       %2, %2, #8                     \n" 
    353353      "vst4.8     {d20, d21, d22, d23}, [%1]!    \n" 
     
    367367  asm volatile( 
    368368      "vmov.u8    d23, #255                      \n" 
    369       "1:                                          \n" 
     369      "1:                                        \n" 
    370370      "vld1.8     {d20}, [%0]!                   \n" 
    371371      "vmov       d21, d20                       \n" 
     
    386386                        const struct YuvConstants* yuvconstants, 
    387387                        int width) { 
    388   asm volatile( 
    389       YUVTORGB_SETUP 
    390       "vmov.u8    d23, #255                      \n" 
    391       "1:                                          \n" READNV12 YUVTORGB 
    392       "subs       %3, %3, #8                     \n" 
    393       "vst4.8     {d20, d21, d22, d23}, [%2]!    \n" 
    394       "bgt        1b                             \n" 
    395       : "+r"(src_y),     // %0 
    396         "+r"(src_uv),    // %1 
    397         "+r"(dst_argb),  // %2 
    398         "+r"(width)      // %3 
    399       : [kUVToRB] "r"(&yuvconstants->kUVToRB), 
    400         [kUVToG] "r"(&yuvconstants->kUVToG), 
    401         [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR), 
    402         [kYToRgb] "r"(&yuvconstants->kYToRgb) 
    403       : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", "q10", "q11", 
    404         "q12", "q13", "q14", "q15"); 
     388  asm volatile(YUVTORGB_SETUP 
     389               "vmov.u8    d23, #255                      \n" 
     390               "1:                                        \n" READNV12 YUVTORGB 
     391               "subs       %3, %3, #8                     \n" 
     392               "vst4.8     {d20, d21, d22, d23}, [%2]!    \n" 
     393               "bgt        1b                             \n" 
     394               : "+r"(src_y),     // %0 
     395                 "+r"(src_uv),    // %1 
     396                 "+r"(dst_argb),  // %2 
     397                 "+r"(width)      // %3 
     398               : [kUVToRB] "r"(&yuvconstants->kUVToRB), 
     399                 [kUVToG] "r"(&yuvconstants->kUVToG), 
     400                 [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR), 
     401                 [kYToRgb] "r"(&yuvconstants->kYToRgb) 
     402               : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", 
     403                 "q10", "q11", "q12", "q13", "q14", "q15"); 
    405404} 
    406405 
     
    410409                        const struct YuvConstants* yuvconstants, 
    411410                        int width) { 
    412   asm volatile( 
    413       YUVTORGB_SETUP 
    414       "vmov.u8    d23, #255                      \n" 
    415       "1:                                          \n" READNV21 YUVTORGB 
    416       "subs       %3, %3, #8                     \n" 
    417       "vst4.8     {d20, d21, d22, d23}, [%2]!    \n" 
    418       "bgt        1b                             \n" 
    419       : "+r"(src_y),     // %0 
    420         "+r"(src_vu),    // %1 
    421         "+r"(dst_argb),  // %2 
    422         "+r"(width)      // %3 
    423       : [kUVToRB] "r"(&yuvconstants->kUVToRB), 
    424         [kUVToG] "r"(&yuvconstants->kUVToG), 
    425         [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR), 
    426         [kYToRgb] "r"(&yuvconstants->kYToRgb) 
    427       : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", "q10", "q11", 
    428         "q12", "q13", "q14", "q15"); 
     411  asm volatile(YUVTORGB_SETUP 
     412               "vmov.u8    d23, #255                      \n" 
     413               "1:                                        \n" READNV21 YUVTORGB 
     414               "subs       %3, %3, #8                     \n" 
     415               "vst4.8     {d20, d21, d22, d23}, [%2]!    \n" 
     416               "bgt        1b                             \n" 
     417               : "+r"(src_y),     // %0 
     418                 "+r"(src_vu),    // %1 
     419                 "+r"(dst_argb),  // %2 
     420                 "+r"(width)      // %3 
     421               : [kUVToRB] "r"(&yuvconstants->kUVToRB), 
     422                 [kUVToG] "r"(&yuvconstants->kUVToG), 
     423                 [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR), 
     424                 [kYToRgb] "r"(&yuvconstants->kYToRgb) 
     425               : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", 
     426                 "q10", "q11", "q12", "q13", "q14", "q15"); 
    429427} 
    430428 
     
    436434  asm volatile( 
    437435      YUVTORGB_SETUP 
    438       "1:                                          \n" READNV12 YUVTORGB 
     436      "1:                                        \n" READNV12 YUVTORGB 
    439437      "subs       %3, %3, #8                     \n" ARGBTORGB565 
    440438      "vst1.8     {q0}, [%2]!                    \n"  // store 8 pixels RGB565. 
     
    456454                        const struct YuvConstants* yuvconstants, 
    457455                        int width) { 
    458   asm volatile( 
    459       YUVTORGB_SETUP 
    460       "vmov.u8    d23, #255                      \n" 
    461       "1:                                          \n" READYUY2 YUVTORGB 
    462       "subs       %2, %2, #8                     \n" 
    463       "vst4.8     {d20, d21, d22, d23}, [%1]!    \n" 
    464       "bgt        1b                             \n" 
    465       : "+r"(src_yuy2),  // %0 
    466         "+r"(dst_argb),  // %1 
    467         "+r"(width)      // %2 
    468       : [kUVToRB] "r"(&yuvconstants->kUVToRB), 
    469         [kUVToG] "r"(&yuvconstants->kUVToG), 
    470         [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR), 
    471         [kYToRgb] "r"(&yuvconstants->kYToRgb) 
    472       : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", "q10", "q11", 
    473         "q12", "q13", "q14", "q15"); 
     456  asm volatile(YUVTORGB_SETUP 
     457               "vmov.u8    d23, #255                      \n" 
     458               "1:                                        \n" READYUY2 YUVTORGB 
     459               "subs       %2, %2, #8                     \n" 
     460               "vst4.8     {d20, d21, d22, d23}, [%1]!    \n" 
     461               "bgt        1b                             \n" 
     462               : "+r"(src_yuy2),  // %0 
     463                 "+r"(dst_argb),  // %1 
     464                 "+r"(width)      // %2 
     465               : [kUVToRB] "r"(&yuvconstants->kUVToRB), 
     466                 [kUVToG] "r"(&yuvconstants->kUVToG), 
     467                 [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR), 
     468                 [kYToRgb] "r"(&yuvconstants->kYToRgb) 
     469               : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", 
     470                 "q10", "q11", "q12", "q13", "q14", "q15"); 
    474471} 
    475472 
     
    478475                        const struct YuvConstants* yuvconstants, 
    479476                        int width) { 
    480   asm volatile( 
    481       YUVTORGB_SETUP 
    482       "vmov.u8    d23, #255                      \n" 
    483       "1:                                          \n" READUYVY YUVTORGB 
    484       "subs       %2, %2, #8                     \n" 
    485       "vst4.8     {d20, d21, d22, d23}, [%1]!    \n" 
    486       "bgt        1b                             \n" 
    487       : "+r"(src_uyvy),  // %0 
    488         "+r"(dst_argb),  // %1 
    489         "+r"(width)      // %2 
    490       : [kUVToRB] "r"(&yuvconstants->kUVToRB), 
    491         [kUVToG] "r"(&yuvconstants->kUVToG), 
    492         [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR), 
    493         [kYToRgb] "r"(&yuvconstants->kYToRgb) 
    494       : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", "q10", "q11", 
    495         "q12", "q13", "q14", "q15"); 
     477  asm volatile(YUVTORGB_SETUP 
     478               "vmov.u8    d23, #255                      \n" 
     479               "1:                                        \n" READUYVY YUVTORGB 
     480               "subs       %2, %2, #8                     \n" 
     481               "vst4.8     {d20, d21, d22, d23}, [%1]!    \n" 
     482               "bgt        1b                             \n" 
     483               : "+r"(src_uyvy),  // %0 
     484                 "+r"(dst_argb),  // %1 
     485                 "+r"(width)      // %2 
     486               : [kUVToRB] "r"(&yuvconstants->kUVToRB), 
     487                 [kUVToG] "r"(&yuvconstants->kUVToG), 
     488                 [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR), 
     489                 [kYToRgb] "r"(&yuvconstants->kYToRgb) 
     490               : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", 
     491                 "q10", "q11", "q12", "q13", "q14", "q15"); 
    496492} 
    497493 
     
    502498                     int width) { 
    503499  asm volatile( 
    504       "1:                                          \n" 
     500      "1:                                        \n" 
    505501      "vld2.8     {q0, q1}, [%0]!                \n"  // load 16 pairs of UV 
    506502      "subs       %3, %3, #16                    \n"  // 16 processed per loop 
     
    523519                     int width) { 
    524520  asm volatile( 
    525       "1:                                          \n" 
     521      "1:                                        \n" 
    526522      "vld1.8     {q0}, [%0]!                    \n"  // load U 
    527523      "vld1.8     {q1}, [%1]!                    \n"  // load V 
    528524      "subs       %3, %3, #16                    \n"  // 16 processed per loop 
    529       "vst2.u8    {q0, q1}, [%2]!                \n"  // store 16 pairs of UV 
     525      "vst2.8     {q0, q1}, [%2]!                \n"  // store 16 pairs of UV 
    530526      "bgt        1b                             \n" 
    531527      : "+r"(src_u),                // %0 
     
    538534} 
    539535 
     536// Reads 16 packed RGB and write to planar dst_r, dst_g, dst_b. 
     537void SplitRGBRow_NEON(const uint8* src_rgb, 
     538                      uint8* dst_r, 
     539                      uint8* dst_g, 
     540                      uint8* dst_b, 
     541                      int width) { 
     542  asm volatile( 
     543      "1:                                        \n" 
     544      "vld3.8     {d0, d2, d4}, [%0]!            \n"  // load 8 RGB 
     545      "vld3.8     {d1, d3, d5}, [%0]!            \n"  // next 8 RGB 
     546      "subs       %4, %4, #16                    \n"  // 16 processed per loop 
     547      "vst1.8     {q0}, [%1]!                    \n"  // store R 
     548      "vst1.8     {q1}, [%2]!                    \n"  // store G 
     549      "vst1.8     {q2}, [%3]!                    \n"  // store B 
     550      "bgt        1b                             \n" 
     551      : "+r"(src_rgb),                    // %0 
     552        "+r"(dst_r),                      // %1 
     553        "+r"(dst_g),                      // %2 
     554        "+r"(dst_b),                      // %3 
     555        "+r"(width)                       // %4 
     556      :                                   // Input registers 
     557      : "cc", "memory", "d0", "d1", "d2"  // Clobber List 
     558      ); 
     559} 
     560 
     561// Reads 16 planar R's, G's and B's and writes out 16 packed RGB at a time 
     562void MergeRGBRow_NEON(const uint8* src_r, 
     563                      const uint8* src_g, 
     564                      const uint8* src_b, 
     565                      uint8* dst_rgb, 
     566                      int width) { 
     567  asm volatile( 
     568      "1:                                        \n" 
     569      "vld1.8     {q0}, [%0]!                    \n"  // load R 
     570      "vld1.8     {q1}, [%1]!                    \n"  // load G 
     571      "vld1.8     {q2}, [%2]!                    \n"  // load B 
     572      "subs       %4, %4, #16                    \n"  // 16 processed per loop 
     573      "vst3.8     {d0, d2, d4}, [%3]!            \n"  // store 8 RGB 
     574      "vst3.8     {d1, d3, d5}, [%3]!            \n"  // next 8 RGB 
     575      "bgt        1b                             \n" 
     576      : "+r"(src_r),                      // %0 
     577        "+r"(src_g),                      // %1 
     578        "+r"(src_b),                      // %2 
     579        "+r"(dst_rgb),                    // %3 
     580        "+r"(width)                       // %4 
     581      :                                   // Input registers 
     582      : "cc", "memory", "q0", "q1", "q2"  // Clobber List 
     583      ); 
     584} 
     585 
    540586// Copy multiple of 32.  vld4.8  allow unaligned and is fastest on a15. 
    541587void CopyRow_NEON(const uint8* src, uint8* dst, int count) { 
    542588  asm volatile( 
    543       "1:                                          \n" 
     589      "1:                                        \n" 
    544590      "vld1.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 32 
    545591      "subs       %2, %2, #32                    \n"  // 32 processed per loop 
     
    558604  asm volatile( 
    559605      "vdup.8    q0, %2                          \n"  // duplicate 16 bytes 
    560       "1:                                          \n" 
     606      "1:                                        \n" 
    561607      "subs      %1, %1, #16                     \n"  // 16 bytes per loop 
    562608      "vst1.8    {q0}, [%0]!                     \n"  // store 
     
    572618  asm volatile( 
    573619      "vdup.u32  q0, %2                          \n"  // duplicate 4 ints 
    574       "1:                                          \n" 
     620      "1:                                        \n" 
    575621      "subs      %1, %1, #4                      \n"  // 4 pixels per loop 
    576622      "vst1.8    {q0}, [%0]!                     \n"  // store 
     
    589635      "sub        %0, #16                        \n" 
    590636 
    591       "1:                                          \n" 
     637      "1:                                        \n" 
    592638      "vld1.8     {q0}, [%0], r3                 \n"  // src -= 16 
    593639      "subs       %2, #16                        \n"  // 16 pixels per loop. 
     
    613659      "sub        %0, #16                        \n" 
    614660 
    615       "1:                                          \n" 
     661      "1:                                        \n" 
    616662      "vld2.8     {d0, d1}, [%0], r12            \n"  // src -= 16 
    617663      "subs       %3, #8                         \n"  // 8 pixels per loop. 
     
    635681      "sub        %0, #16                        \n" 
    636682 
    637       "1:                                          \n" 
     683      "1:                                        \n" 
    638684      "vld1.8     {q0}, [%0], r3                 \n"  // src -= 16 
    639685      "subs       %2, #4                         \n"  // 4 pixels per loop. 
     
    652698  asm volatile( 
    653699      "vmov.u8    d4, #255                       \n"  // Alpha 
    654       "1:                                          \n" 
     700      "1:                                        \n" 
    655701      "vld3.8     {d1, d2, d3}, [%0]!            \n"  // load 8 pixels of RGB24. 
    656702      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    668714  asm volatile( 
    669715      "vmov.u8    d4, #255                       \n"  // Alpha 
    670       "1:                                          \n" 
     716      "1:                                        \n" 
    671717      "vld3.8     {d1, d2, d3}, [%0]!            \n"  // load 8 pixels of RAW. 
    672718      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    684730void RAWToRGB24Row_NEON(const uint8* src_raw, uint8* dst_rgb24, int width) { 
    685731  asm volatile( 
    686       "1:                                          \n" 
     732      "1:                                        \n" 
    687733      "vld3.8     {d1, d2, d3}, [%0]!            \n"  // load 8 pixels of RAW. 
    688734      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    714760  asm volatile( 
    715761      "vmov.u8    d3, #255                       \n"  // Alpha 
    716       "1:                                          \n" 
     762      "1:                                        \n" 
    717763      "vld1.8     {q0}, [%0]!                    \n"  // load 8 RGB565 pixels. 
    718764      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    760806  asm volatile( 
    761807      "vmov.u8    d3, #255                       \n"  // Alpha 
    762       "1:                                          \n" 
     808      "1:                                        \n" 
    763809      "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB1555 pixels. 
    764810      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    789835  asm volatile( 
    790836      "vmov.u8    d3, #255                       \n"  // Alpha 
    791       "1:                                          \n" 
     837      "1:                                        \n" 
    792838      "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB4444 pixels. 
    793839      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    805851void ARGBToRGB24Row_NEON(const uint8* src_argb, uint8* dst_rgb24, int width) { 
    806852  asm volatile( 
    807       "1:                                          \n" 
     853      "1:                                        \n" 
    808854      "vld4.8     {d1, d2, d3, d4}, [%0]!        \n"  // load 8 pixels of ARGB. 
    809855      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    821867void ARGBToRAWRow_NEON(const uint8* src_argb, uint8* dst_raw, int width) { 
    822868  asm volatile( 
    823       "1:                                          \n" 
     869      "1:                                        \n" 
    824870      "vld4.8     {d1, d2, d3, d4}, [%0]!        \n"  // load 8 pixels of ARGB. 
    825871      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    837883void YUY2ToYRow_NEON(const uint8* src_yuy2, uint8* dst_y, int width) { 
    838884  asm volatile( 
    839       "1:                                          \n" 
     885      "1:                                        \n" 
    840886      "vld2.8     {q0, q1}, [%0]!                \n"  // load 16 pixels of YUY2. 
    841887      "subs       %2, %2, #16                    \n"  // 16 processed per loop. 
     
    852898void UYVYToYRow_NEON(const uint8* src_uyvy, uint8* dst_y, int width) { 
    853899  asm volatile( 
    854       "1:                                          \n" 
     900      "1:                                        \n" 
    855901      "vld2.8     {q0, q1}, [%0]!                \n"  // load 16 pixels of UYVY. 
    856902      "subs       %2, %2, #16                    \n"  // 16 processed per loop. 
     
    870916                         int width) { 
    871917  asm volatile( 
    872       "1:                                          \n" 
     918      "1:                                        \n" 
    873919      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 16 pixels of YUY2. 
    874920      "subs       %3, %3, #16                    \n"  // 16 pixels = 8 UVs. 
     
    890936                         int width) { 
    891937  asm volatile( 
    892       "1:                                          \n" 
     938      "1:                                        \n" 
    893939      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 16 pixels of UYVY. 
    894940      "subs       %3, %3, #16                    \n"  // 16 pixels = 8 UVs. 
     
    912958  asm volatile( 
    913959      "add        %1, %0, %1                     \n"  // stride + src_yuy2 
    914       "1:                                          \n" 
     960      "1:                                        \n" 
    915961      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 16 pixels of YUY2. 
    916962      "subs       %4, %4, #16                    \n"  // 16 pixels = 8 UVs. 
     
    939985  asm volatile( 
    940986      "add        %1, %0, %1                     \n"  // stride + src_uyvy 
    941       "1:                                          \n" 
     987      "1:                                        \n" 
    942988      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 16 pixels of UYVY. 
    943989      "subs       %4, %4, #16                    \n"  // 16 pixels = 8 UVs. 
     
    9661012  asm volatile( 
    9671013      "vld1.8     {q2}, [%3]                     \n"  // shuffler 
    968       "1:                                          \n" 
     1014      "1:                                        \n" 
    9691015      "vld1.8     {q0}, [%0]!                    \n"  // load 4 pixels. 
    9701016      "subs       %2, %2, #4                     \n"  // 4 processed per loop 
     
    9871033                        int width) { 
    9881034  asm volatile( 
    989       "1:                                          \n" 
     1035      "1:                                        \n" 
    9901036      "vld2.8     {d0, d2}, [%0]!                \n"  // load 16 Ys 
    9911037      "vld1.8     {d1}, [%1]!                    \n"  // load 8 Us 
     
    10091055                        int width) { 
    10101056  asm volatile( 
    1011       "1:                                          \n" 
     1057      "1:                                        \n" 
    10121058      "vld2.8     {d1, d3}, [%0]!                \n"  // load 16 Ys 
    10131059      "vld1.8     {d0}, [%1]!                    \n"  // load 8 Us 
     
    10271073void ARGBToRGB565Row_NEON(const uint8* src_argb, uint8* dst_rgb565, int width) { 
    10281074  asm volatile( 
    1029       "1:                                          \n" 
     1075      "1:                                        \n" 
    10301076      "vld4.8     {d20, d21, d22, d23}, [%0]!    \n"  // load 8 pixels of ARGB. 
    10311077      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    10461092  asm volatile( 
    10471093      "vdup.32    d2, %2                         \n"  // dither4 
    1048       "1:                                          \n" 
     1094      "1:                                        \n" 
    10491095      "vld4.8     {d20, d21, d22, d23}, [%1]!    \n"  // load 8 pixels of ARGB. 
    10501096      "subs       %3, %3, #8                     \n"  // 8 processed per loop. 
    10511097      "vqadd.u8   d20, d20, d2                   \n" 
    10521098      "vqadd.u8   d21, d21, d2                   \n" 
    1053       "vqadd.u8   d22, d22, d2                   \n" ARGBTORGB565 
    1054       "vst1.8     {q0}, [%0]!                    \n"  // store 8 pixels RGB565. 
     1099      "vqadd.u8   d22, d22, d2                   \n"  // add for dither 
     1100      ARGBTORGB565 
     1101      "vst1.8     {q0}, [%0]!                    \n"  // store 8 RGB565. 
    10551102      "bgt        1b                             \n" 
    10561103      : "+r"(dst_rgb)   // %0 
     
    10651112                            int width) { 
    10661113  asm volatile( 
    1067       "1:                                          \n" 
     1114      "1:                                        \n" 
    10681115      "vld4.8     {d20, d21, d22, d23}, [%0]!    \n"  // load 8 pixels of ARGB. 
    10691116      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
    10701117      ARGBTOARGB1555 
    1071       "vst1.8     {q0}, [%1]!                    \n"  // store 8 pixels 
    1072                                                       // ARGB1555. 
     1118      "vst1.8     {q0}, [%1]!                    \n"  // store 8 ARGB1555. 
    10731119      "bgt        1b                             \n" 
    10741120      : "+r"(src_argb),      // %0 
     
    10851131      "vmov.u8    d4, #0x0f                      \n"  // bits to clear with 
    10861132                                                      // vbic. 
    1087       "1:                                          \n" 
     1133      "1:                                        \n" 
    10881134      "vld4.8     {d20, d21, d22, d23}, [%0]!    \n"  // load 8 pixels of ARGB. 
    10891135      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
    10901136      ARGBTOARGB4444 
    1091       "vst1.8     {q0}, [%1]!                    \n"  // store 8 pixels 
    1092                                                       // ARGB4444. 
     1137      "vst1.8     {q0}, [%1]!                    \n"  // store 8 ARGB4444. 
    10931138      "bgt        1b                             \n" 
    10941139      : "+r"(src_argb),      // %0 
     
    11051150      "vmov.u8    d26, #33                       \n"  // R * 0.2578 coefficient 
    11061151      "vmov.u8    d27, #16                       \n"  // Add 16 constant 
    1107       "1:                                          \n" 
     1152      "1:                                        \n" 
    11081153      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels. 
    11091154      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    11241169void ARGBExtractAlphaRow_NEON(const uint8* src_argb, uint8* dst_a, int width) { 
    11251170  asm volatile( 
    1126       "1:                                          \n" 
     1171      "1:                                        \n" 
    11271172      "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ARGB pixels 
    11281173      "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 ARGB pixels 
     
    11431188      "vmov.u8    d25, #75                       \n"  // G * 0.58700 coefficient 
    11441189      "vmov.u8    d26, #38                       \n"  // R * 0.29900 coefficient 
    1145       "1:                                          \n" 
     1190      "1:                                        \n" 
    11461191      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels. 
    11471192      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    11721217      "vmov.u8    d28, #94                       \n"  // VG -0.7344 coefficient 
    11731218      "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1174       "1:                                          \n" 
     1219      "1:                                        \n" 
    11751220      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels. 
    11761221      "subs       %3, %3, #8                     \n"  // 8 processed per loop. 
     
    12001245} 
    12011246 
     1247// clang-format off 
    12021248// 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16. 
    12031249#define RGBTOUV(QB, QG, QR)                                                 \ 
    1204   "vmul.s16   q8, " #QB                                                     \ 
    1205   ", q10               \n" /* B                    */                       \ 
    1206   "vmls.s16   q8, " #QG                                                     \ 
    1207   ", q11               \n" /* G                    */                       \ 
    1208   "vmls.s16   q8, " #QR                                                     \ 
    1209   ", q12               \n"                       /* R                    */ \ 
     1250  "vmul.s16   q8, " #QB ", q10               \n" /* B                    */ \ 
     1251  "vmls.s16   q8, " #QG ", q11               \n" /* G                    */ \ 
     1252  "vmls.s16   q8, " #QR ", q12               \n" /* R                    */ \ 
    12101253  "vadd.u16   q8, q8, q15                    \n" /* +128 -> unsigned     */ \ 
    1211   "vmul.s16   q9, " #QR                                                     \ 
    1212   ", q10               \n" /* R                    */                       \ 
    1213   "vmls.s16   q9, " #QG                                                     \ 
    1214   ", q14               \n" /* G                    */                       \ 
    1215   "vmls.s16   q9, " #QB                                                     \ 
    1216   ", q13               \n"                       /* B                    */ \ 
     1254  "vmul.s16   q9, " #QR ", q10               \n" /* R                    */ \ 
     1255  "vmls.s16   q9, " #QG ", q14               \n" /* G                    */ \ 
     1256  "vmls.s16   q9, " #QB ", q13               \n" /* B                    */ \ 
    12171257  "vadd.u16   q9, q9, q15                    \n" /* +128 -> unsigned     */ \ 
    12181258  "vqshrn.u16  d0, q8, #8                    \n" /* 16 bit to 8 bit U    */ \ 
    12191259  "vqshrn.u16  d1, q9, #8                    \n" /* 16 bit to 8 bit V    */ 
     1260// clang-format on 
    12201261 
    12211262// TODO(fbarchard): Consider vhadd vertical, then vpaddl horizontal, avoid shr. 
     
    12331274    "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient 
    12341275    "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1235   "1:                                          \n" 
     1276    "1:                                        \n" 
    12361277    "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ARGB pixels. 
    12371278    "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 ARGB pixels. 
     
    12791320    "vmov.s16   q14, #107 / 2                  \n"  // VG -0.41869 coefficient 
    12801321    "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1281   "1:                                          \n" 
     1322    "1:                                        \n" 
    12821323    "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ARGB pixels. 
    12831324    "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 ARGB pixels. 
     
    13241365    "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient 
    13251366    "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1326   "1:                                          \n" 
     1367    "1:                                        \n" 
    13271368    "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 BGRA pixels. 
    13281369    "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 BGRA pixels. 
     
    13691410    "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient 
    13701411    "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1371   "1:                                          \n" 
     1412    "1:                                        \n" 
    13721413    "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ABGR pixels. 
    13731414    "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 ABGR pixels. 
     
    14141455    "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient 
    14151456    "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1416   "1:                                          \n" 
     1457    "1:                                        \n" 
    14171458    "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 RGBA pixels. 
    14181459    "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 RGBA pixels. 
     
    14591500    "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient 
    14601501    "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1461   "1:                                          \n" 
     1502    "1:                                        \n" 
    14621503    "vld3.8     {d0, d2, d4}, [%0]!            \n"  // load 8 RGB24 pixels. 
    14631504    "vld3.8     {d1, d3, d5}, [%0]!            \n"  // load next 8 RGB24 pixels. 
     
    15041545    "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient 
    15051546    "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1506   "1:                                          \n" 
     1547    "1:                                        \n" 
    15071548    "vld3.8     {d0, d2, d4}, [%0]!            \n"  // load 8 RAW pixels. 
    15081549    "vld3.8     {d1, d3, d5}, [%0]!            \n"  // load next 8 RAW pixels. 
     
    15511592      "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient 
    15521593      "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1553       "1:                                          \n" 
     1594      "1:                                        \n" 
    15541595      "vld1.8     {q0}, [%0]!                    \n"  // load 8 RGB565 pixels. 
    15551596      RGB565TOARGB 
     
    16171658      "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient 
    16181659      "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1619       "1:                                          \n" 
     1660      "1:                                        \n" 
    16201661      "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB1555 pixels. 
    16211662      RGB555TOARGB 
     
    16831724      "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient 
    16841725      "vmov.u16   q15, #0x8080                   \n"  // 128.5 
    1685       "1:                                          \n" 
     1726      "1:                                        \n" 
    16861727      "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB4444 pixels. 
    16871728      ARGB4444TOARGB 
     
    17401781      "vmov.u8    d26, #33                       \n"  // R * 0.2578 coefficient 
    17411782      "vmov.u8    d27, #16                       \n"  // Add 16 constant 
    1742       "1:                                          \n" 
     1783      "1:                                        \n" 
    17431784      "vld1.8     {q0}, [%0]!                    \n"  // load 8 RGB565 pixels. 
    17441785      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    17641805      "vmov.u8    d26, #33                       \n"  // R * 0.2578 coefficient 
    17651806      "vmov.u8    d27, #16                       \n"  // Add 16 constant 
    1766       "1:                                          \n" 
     1807      "1:                                        \n" 
    17671808      "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB1555 pixels. 
    17681809      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    17881829      "vmov.u8    d26, #33                       \n"  // R * 0.2578 coefficient 
    17891830      "vmov.u8    d27, #16                       \n"  // Add 16 constant 
    1790       "1:                                          \n" 
     1831      "1:                                        \n" 
    17911832      "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB4444 pixels. 
    17921833      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    18121853      "vmov.u8    d6, #13                        \n"  // B * 0.1016 coefficient 
    18131854      "vmov.u8    d7, #16                        \n"  // Add 16 constant 
    1814       "1:                                          \n" 
     1855      "1:                                        \n" 
    18151856      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of BGRA. 
    18161857      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    18351876      "vmov.u8    d6, #13                        \n"  // B * 0.1016 coefficient 
    18361877      "vmov.u8    d7, #16                        \n"  // Add 16 constant 
    1837       "1:                                          \n" 
     1878      "1:                                        \n" 
    18381879      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of ABGR. 
    18391880      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    18581899      "vmov.u8    d6, #33                        \n"  // R * 0.2578 coefficient 
    18591900      "vmov.u8    d7, #16                        \n"  // Add 16 constant 
    1860       "1:                                          \n" 
     1901      "1:                                        \n" 
    18611902      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of RGBA. 
    18621903      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    18811922      "vmov.u8    d6, #33                        \n"  // R * 0.2578 coefficient 
    18821923      "vmov.u8    d7, #16                        \n"  // Add 16 constant 
    1883       "1:                                          \n" 
     1924      "1:                                        \n" 
    18841925      "vld3.8     {d0, d1, d2}, [%0]!            \n"  // load 8 pixels of RGB24. 
    18851926      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    19041945      "vmov.u8    d6, #13                        \n"  // B * 0.1016 coefficient 
    19051946      "vmov.u8    d7, #16                        \n"  // Add 16 constant 
    1906       "1:                                          \n" 
     1947      "1:                                        \n" 
    19071948      "vld3.8     {d0, d1, d2}, [%0]!            \n"  // load 8 pixels of RAW. 
    19081949      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    19391980      "vdup.8     d4, %4                         \n" 
    19401981      // General purpose row blend. 
    1941       "1:                                          \n" 
     1982      "1:                                        \n" 
    19421983      "vld1.8     {q0}, [%1]!                    \n" 
    19431984      "vld1.8     {q1}, [%2]!                    \n" 
     
    19541995 
    19551996      // Blend 50 / 50. 
    1956       "50:                                         \n" 
     1997      "50:                                       \n" 
    19571998      "vld1.8     {q0}, [%1]!                    \n" 
    19581999      "vld1.8     {q1}, [%2]!                    \n" 
     
    19642005 
    19652006      // Blend 100 / 0 - Copy row unchanged. 
    1966       "100:                                        \n" 
     2007      "100:                                      \n" 
    19672008      "vld1.8     {q0}, [%1]!                    \n" 
    19682009      "subs       %3, %3, #16                    \n" 
     
    19702011      "bgt        100b                           \n" 
    19712012 
    1972       "99:                                         \n" 
     2013      "99:                                       \n" 
    19732014      : "+r"(dst_ptr),     // %0 
    19742015        "+r"(src_ptr),     // %1 
     
    19892030      "blt        89f                            \n" 
    19902031      // Blend 8 pixels. 
    1991       "8:                                          \n" 
     2032      "8:                                        \n" 
    19922033      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of ARGB0. 
    19932034      "vld4.8     {d4, d5, d6, d7}, [%1]!        \n"  // load 8 pixels of ARGB1. 
     
    20072048      "bge        8b                             \n" 
    20082049 
    2009       "89:                                         \n" 
     2050      "89:                                       \n" 
    20102051      "adds       %3, #8-1                       \n" 
    20112052      "blt        99f                            \n" 
    20122053 
    20132054      // Blend 1 pixels. 
    2014       "1:                                          \n" 
     2055      "1:                                        \n" 
    20152056      "vld4.8     {d0[0],d1[0],d2[0],d3[0]}, [%0]! \n"  // load 1 pixel ARGB0. 
    20162057      "vld4.8     {d4[0],d5[0],d6[0],d7[0]}, [%1]! \n"  // load 1 pixel ARGB1. 
     
    20442085  asm volatile( 
    20452086      // Attenuate 8 pixels. 
    2046       "1:                                          \n" 
     2087      "1:                                        \n" 
    20472088      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of ARGB. 
    20482089      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    20762117 
    20772118      // 8 pixel loop. 
    2078       "1:                                          \n" 
     2119      "1:                                        \n" 
    20792120      "vld4.8     {d0, d2, d4, d6}, [%0]         \n"  // load 8 pixels of ARGB. 
    20802121      "subs       %1, %1, #8                     \n"  // 8 processed per loop. 
     
    21172158 
    21182159      // 8 pixel loop. 
    2119       "1:                                          \n" 
     2160      "1:                                        \n" 
    21202161      "vld4.8     {d20, d22, d24, d26}, [%0]!    \n"  // load 8 pixels of ARGB. 
    21212162      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    21492190      "vmov.u8    d25, #75                       \n"  // G * 0.58700 coefficient 
    21502191      "vmov.u8    d26, #38                       \n"  // R * 0.29900 coefficient 
    2151       "1:                                          \n" 
     2192      "1:                                        \n" 
    21522193      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels. 
    21532194      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    21822223      "vmov.u8    d29, #98                       \n"  // BG coefficient 
    21832224      "vmov.u8    d30, #50                       \n"  // BR coefficient 
    2184       "1:                                          \n" 
     2225      "1:                                        \n" 
    21852226      "vld4.8     {d0, d1, d2, d3}, [%0]         \n"  // load 8 ARGB pixels. 
    21862227      "subs       %1, %1, #8                     \n"  // 8 processed per loop. 
     
    22182259      "vmovl.s8   q1, d5                         \n"  // R,A coefficients s16. 
    22192260 
    2220       "1:                                          \n" 
     2261      "1:                                        \n" 
    22212262      "vld4.8     {d16, d18, d20, d22}, [%0]!    \n"  // load 8 ARGB pixels. 
    22222263      "subs       %2, %2, #8                     \n"  // 8 processed per loop. 
     
    22742315  asm volatile( 
    22752316      // 8 pixel loop. 
    2276       "1:                                          \n" 
     2317      "1:                                        \n" 
    22772318      "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ARGB pixels. 
    22782319      "vld4.8     {d1, d3, d5, d7}, [%1]!        \n"  // load 8 more ARGB 
    2279                                                       // pixels. 
    22802320      "subs       %3, %3, #8                     \n"  // 8 processed per loop. 
    22812321      "vmull.u8   q0, d0, d1                     \n"  // multiply B 
     
    22892329      "vst4.8     {d0, d1, d2, d3}, [%2]!        \n"  // store 8 ARGB pixels. 
    22902330      "bgt        1b                             \n" 
    2291  
    22922331      : "+r"(src_argb0),  // %0 
    22932332        "+r"(src_argb1),  // %1 
     
    23052344  asm volatile( 
    23062345      // 8 pixel loop. 
    2307       "1:                                          \n" 
     2346      "1:                                        \n" 
    23082347      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels. 
    23092348      "vld4.8     {d4, d5, d6, d7}, [%1]!        \n"  // load 8 more ARGB 
    2310                                                       // pixels. 
    23112349      "subs       %3, %3, #8                     \n"  // 8 processed per loop. 
    23122350      "vqadd.u8   q0, q0, q2                     \n"  // add B, G 
     
    23142352      "vst4.8     {d0, d1, d2, d3}, [%2]!        \n"  // store 8 ARGB pixels. 
    23152353      "bgt        1b                             \n" 
    2316  
    23172354      : "+r"(src_argb0),  // %0 
    23182355        "+r"(src_argb1),  // %1 
     
    23302367  asm volatile( 
    23312368      // 8 pixel loop. 
    2332       "1:                                          \n" 
     2369      "1:                                        \n" 
    23332370      "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels. 
    23342371      "vld4.8     {d4, d5, d6, d7}, [%1]!        \n"  // load 8 more ARGB 
    2335                                                       // pixels. 
    23362372      "subs       %3, %3, #8                     \n"  // 8 processed per loop. 
    23372373      "vqsub.u8   q0, q0, q2                     \n"  // subtract B, G 
     
    23392375      "vst4.8     {d0, d1, d2, d3}, [%2]!        \n"  // store 8 ARGB pixels. 
    23402376      "bgt        1b                             \n" 
    2341  
    23422377      : "+r"(src_argb0),  // %0 
    23432378        "+r"(src_argb1),  // %1 
     
    23602395      "vmov.u8    d3, #255                       \n"  // alpha 
    23612396      // 8 pixel loop. 
    2362       "1:                                          \n" 
     2397      "1:                                        \n" 
    23632398      "vld1.8     {d0}, [%0]!                    \n"  // load 8 sobelx. 
    23642399      "vld1.8     {d1}, [%1]!                    \n"  // load 8 sobely. 
     
    23842419  asm volatile( 
    23852420      // 16 pixel loop. 
    2386       "1:                                          \n" 
     2421      "1:                                        \n" 
    23872422      "vld1.8     {q0}, [%0]!                    \n"  // load 16 sobelx. 
    23882423      "vld1.8     {q1}, [%1]!                    \n"  // load 16 sobely. 
     
    24112446      "vmov.u8    d3, #255                       \n"  // alpha 
    24122447      // 8 pixel loop. 
    2413       "1:                                          \n" 
     2448      "1:                                        \n" 
    24142449      "vld1.8     {d2}, [%0]!                    \n"  // load 8 sobelx. 
    24152450      "vld1.8     {d0}, [%1]!                    \n"  // load 8 sobely. 
     
    24362471                    int width) { 
    24372472  asm volatile( 
    2438       "1:                                          \n" 
     2473      "1:                                        \n" 
    24392474      "vld1.8     {d0}, [%0],%5                  \n"  // top 
    24402475      "vld1.8     {d1}, [%0],%6                  \n" 
     
    24742509                    int width) { 
    24752510  asm volatile( 
    2476       "1:                                          \n" 
     2511      "1:                                        \n" 
    24772512      "vld1.8     {d0}, [%0],%4                  \n"  // left 
    24782513      "vld1.8     {d1}, [%1],%4                  \n" 
     
    25062541      "vdup.32    q0, %3                         \n" 
    25072542 
    2508       "1:                                          \n" 
     2543      "1:                                        \n" 
    25092544      "vld1.8     {q1}, [%0]!                    \n"  // load 8 shorts 
    25102545      "subs       %2, %2, #8                     \n"  // 8 pixels per loop 
     
    25312566      "vdup.32    q0, %3                         \n" 
    25322567 
    2533       "1:                                          \n" 
     2568      "1:                                        \n" 
    25342569      "vld1.8     {q1}, [%0]!                    \n"  // load 8 shorts 
    25352570      "subs       %2, %2, #8                     \n"  // 8 pixels per loop 
Note: See TracChangeset for help on using the changeset viewer.