/* * Copyright 2011 The LibYuv Project Authors. All rights reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. #include "libyuv/row.h" #include <stdio.h>#ifdef __cplusplusnamespace libyuv {extern "C" {#endif // This module is for GCC Neon #if !defined (LIBYUV_DISABLE_NEON) && defined (__ARM_NEON__) && \defined (__aarch64__)// Read 8 Y, 4 U and 4 V from 422 #define READYUV422 \"vld1.8 {d0}, [%0]! \n" \"vld1.32 {d2[0]}, [%1]! \n" \"vld1.32 {d2[1]}, [%2]! \n" // Read 8 Y, 8 U and 8 V from 444 #define READYUV444 \"vld1.8 {d0}, [%0]! \n" \"vld1.8 {d2}, [%1]! \n" \"vld1.8 {d3}, [%2]! \n" \"vpaddl.u8 q1, q1 \n" \"vrshrn.u16 d2, q1, #1 \n" // Read 8 Y, and set 4 U and 4 V to 128 #define READYUV400 \"vld1.8 {d0}, [%0]! \n" \"vmov.u8 d2, #128 \n" // Read 8 Y and 4 UV from NV12 #define READNV12 \"vld1.8 {d0}, [%0]! \n" \"vld1.8 {d2}, [%1]! \n" \"vmov.u8 d3, d2 \n" /* split odd/even uv apart */ \ "vuzp.u8 d2, d3 \n" \"vtrn.u32 d2, d3 \n" // Read 8 Y and 4 VU from NV21 #define READNV21 \"vld1.8 {d0}, [%0]! \n" \"vld1.8 {d2}, [%1]! \n" \"vmov.u8 d3, d2 \n" /* split odd/even uv apart */ \ "vuzp.u8 d3, d2 \n" \"vtrn.u32 d2, d3 \n" // Read 8 YUY2 #define READYUY2 \"vld2.8 {d0, d2}, [%0]! \n" \"vmov.u8 d3, d2 \n" \"vuzp.u8 d2, d3 \n" \"vtrn.u32 d2, d3 \n" // Read 8 UYVY #define READUYVY \"vld2.8 {d2, d3}, [%0]! \n" \"vmov.u8 d0, d3 \n" \"vmov.u8 d3, d2 \n" \"vuzp.u8 d2, d3 \n" \"vtrn.u32 d2, d3 \n" #define YUVTORGB_SETUP \"vld1.8 {d24}, [%[kUVToRB]] \n" \"vld1.8 {d25}, [%[kUVToG]] \n" \"vld1.16 {d26[], d27[]}, [%[kUVBiasBGR]]! \n" \"vld1.16 {d8[], d9[]}, [%[kUVBiasBGR]]! \n" \"vld1.16 {d28[], d29[]}, [%[kUVBiasBGR]] \n" \"vld1.32 {d30[], d31[]}, [%[kYToRgb]] \n" #define YUVTORGB \"vmull.u8 q8, d2, d24 \n" /* u/v B/R component */ \ "vmull.u8 q9, d2, d25 \n" /* u/v G component */ \ "vmovl.u8 q0, d0 \n" /* Y */ \ "vmovl.s16 q10, d1 \n" \"vmovl.s16 q0, d0 \n" \"vmul.s32 q10, q10, q15 \n" \"vmul.s32 q0, q0, q15 \n" \"vqshrun.s32 d0, q0, #16 \n" \"vqshrun.s32 d1, q10, #16 \n" /* Y */ \ "vadd.s16 d18, d19 \n" \"vshll.u16 q1, d16, #16 \n" /* Replicate u * UB */ \ "vshll.u16 q10, d17, #16 \n" /* Replicate v * VR */ \ "vshll.u16 q3, d18, #16 \n" /* Replicate (v*VG + u*UG)*/ \ "vaddw.u16 q1, q1, d16 \n" \"vaddw.u16 q10, q10, d17 \n" \"vaddw.u16 q3, q3, d18 \n" \"vqadd.s16 q8, q0, q13 \n" /* B */ \ "vqadd.s16 q9, q0, q14 \n" /* R */ \ "vqadd.s16 q0, q0, q4 \n" /* G */ \ "vqadd.s16 q8, q8, q1 \n" /* B */ \ "vqadd.s16 q9, q9, q10 \n" /* R */ \ "vqsub.s16 q0, q0, q3 \n" /* G */ \ "vqshrun.s16 d20, q8, #6 \n" /* B */ \ "vqshrun.s16 d22, q9, #6 \n" /* R */ \ "vqshrun.s16 d21, q0, #6 \n" /* G */ void I444ToARGBRow_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,const struct YuvConstants* yuvconstants,int width) {asm volatile ("vmov.u8 d23, #255 \n" "1: \n" READYUV444 YUVTORGB"subs %4, %4, #8 \n" "vst4.8 {d20, d21, d22, d23}, [%3]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (dst_argb), // %3 "+r" (width) // %4 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );void I422ToARGBRow_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,const struct YuvConstants* yuvconstants,int width) {asm volatile ("vmov.u8 d23, #255 \n" "1: \n" READYUV422 YUVTORGB"subs %4, %4, #8 \n" "vst4.8 {d20, d21, d22, d23}, [%3]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (dst_argb), // %3 "+r" (width) // %4 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );void I422AlphaToARGBRow_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,const uint8_t* src_a,const struct YuvConstants* yuvconstants,int width) {asm volatile ("1: \n" READYUV422 YUVTORGB"subs %5, %5, #8 \n" "vld1.8 {d23}, [%3]! \n" "vst4.8 {d20, d21, d22, d23}, [%4]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (src_a), // %3 "+r" (dst_argb), // %4 "+r" (width) // %5 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );void I422ToRGBARow_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,const struct YuvConstants* yuvconstants,int width) {asm volatile ("1: \n" READYUV422 YUVTORGB"subs %4, %4, #8 \n" "vmov.u8 d19, #255 \n" // YUVTORGB modified d19 "vst4.8 {d19, d20, d21, d22}, [%3]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (dst_rgba), // %3 "+r" (width) // %4 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );void I422ToRGB24Row_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,const struct YuvConstants* yuvconstants,int width) {asm volatile ("1: \n" READYUV422 YUVTORGB"subs %4, %4, #8 \n" "vst3.8 {d20, d21, d22}, [%3]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (dst_rgb24), // %3 "+r" (width) // %4 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );#define ARGBTORGB565 \"vshll.u8 q0, d22, #8 \n" /* R */ \ "vshll.u8 q8, d21, #8 \n" /* G */ \ "vshll.u8 q9, d20, #8 \n" /* B */ \ "vsri.16 q0, q8, #5 \n" /* RG */ \ "vsri.16 q0, q9, #11 \n" /* RGB */ void I422ToRGB565Row_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,const struct YuvConstants* yuvconstants,int width) {asm volatile ("1: \n" READYUV422 YUVTORGB"subs %4, %4, #8 \n" ARGBTORGB565"vst1.8 {q0}, [%3]! \n" // store 8 pixels RGB565. "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (dst_rgb565), // %3 "+r" (width) // %4 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );#define ARGBTOARGB1555 \"vshll.u8 q0, d23, #8 \n" /* A */ \ "vshll.u8 q8, d22, #8 \n" /* R */ \ "vshll.u8 q9, d21, #8 \n" /* G */ \ "vshll.u8 q10, d20, #8 \n" /* B */ \ "vsri.16 q0, q8, #1 \n" /* AR */ \ "vsri.16 q0, q9, #6 \n" /* ARG */ \ "vsri.16 q0, q10, #11 \n" /* ARGB */ void I422ToARGB1555Row_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,const struct YuvConstants* yuvconstants,int width) {asm volatile ("1: \n" READYUV422 YUVTORGB"subs %4, %4, #8 \n" "vmov.u8 d23, #255 \n" ARGBTOARGB1555"vst1.8 {q0}, [%3]! \n" // store 8 pixels "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (dst_argb1555), // %3 "+r" (width) // %4 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );#define ARGBTOARGB4444 \"vshr.u8 d20, d20, #4 \n" /* B */ \ "vbic.32 d21, d21, d4 \n" /* G */ \ "vshr.u8 d22, d22, #4 \n" /* R */ \ "vbic.32 d23, d23, d4 \n" /* A */ \ "vorr d0, d20, d21 \n" /* BG */ \ "vorr d1, d22, d23 \n" /* RA */ \ "vzip.u8 d0, d1 \n" /* BGRA */ void I422ToARGB4444Row_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,const struct YuvConstants* yuvconstants,int width) {asm volatile ("vmov.u8 d4, #0x0f \n" // vbic bits to clear "1: \n" "subs %4, %4, #8 \n" "vmov.u8 d23, #255 \n" ARGBTOARGB4444"vst1.8 {q0}, [%3]! \n" // store 8 pixels "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (dst_argb4444), // %3 "+r" (width) // %4 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );void I400ToARGBRow_NEON(const uint8_t* src_y,const struct YuvConstants* yuvconstants,int width) {asm volatile ("vmov.u8 d23, #255 \n" "1: \n" READYUV400 YUVTORGB"subs %2, %2, #8 \n" "vst4.8 {d20, d21, d22, d23}, [%1]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );void J400ToARGBRow_NEON(const uint8_t* src_y, uint8_t* dst_argb, int width) {asm volatile ("vmov.u8 d23, #255 \n" "1: \n" "vld1.8 {d20}, [%0]! \n" "vmov d21, d20 \n" "vmov d22, d20 \n" "subs %2, %2, #8 \n" "vst4.8 {d20, d21, d22, d23}, [%1]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "cc" , "memory" , "d20" , "d21" , "d22" , "d23" );void NV12ToARGBRow_NEON(const uint8_t* src_y,const uint8_t* src_uv,const struct YuvConstants* yuvconstants,int width) {asm volatile (YUVTORGB_SETUP"vmov.u8 d23, #255 \n" "1: \n" READNV12 YUVTORGB"subs %3, %3, #8 \n" "vst4.8 {d20, d21, d22, d23}, [%2]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_uv), // %1 "+r" (dst_argb), // %2 "+r" (width) // %3 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" ,"q10" , "q11" , "q12" , "q13" , "q14" , "q15" );void NV21ToARGBRow_NEON(const uint8_t* src_y,const uint8_t* src_vu,const struct YuvConstants* yuvconstants,int width) {asm volatile (YUVTORGB_SETUP"vmov.u8 d23, #255 \n" "1: \n" READNV21 YUVTORGB"subs %3, %3, #8 \n" "vst4.8 {d20, d21, d22, d23}, [%2]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_vu), // %1 "+r" (dst_argb), // %2 "+r" (width) // %3 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" ,"q10" , "q11" , "q12" , "q13" , "q14" , "q15" );void NV12ToRGB24Row_NEON(const uint8_t* src_y,const uint8_t* src_uv,const struct YuvConstants* yuvconstants,int width) {asm volatile ("1: \n" "subs %3, %3, #8 \n" "vst3.8 {d20, d21, d22}, [%2]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_uv), // %1 "+r" (dst_rgb24), // %2 "+r" (width) // %3 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );void NV21ToRGB24Row_NEON(const uint8_t* src_y,const uint8_t* src_vu,const struct YuvConstants* yuvconstants,int width) {asm volatile ("1: \n" "subs %3, %3, #8 \n" "vst3.8 {d20, d21, d22}, [%2]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_vu), // %1 "+r" (dst_rgb24), // %2 "+r" (width) // %3 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );void NV12ToRGB565Row_NEON(const uint8_t* src_y,const uint8_t* src_uv,const struct YuvConstants* yuvconstants,int width) {asm volatile ("1: \n" READNV12 YUVTORGB"subs %3, %3, #8 \n" ARGBTORGB565"vst1.8 {q0}, [%2]! \n" // store 8 pixels RGB565. "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_uv), // %1 "+r" (dst_rgb565), // %2 "+r" (width) // %3 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" , "q10" , "q11" ,"q12" , "q13" , "q14" , "q15" );void YUY2ToARGBRow_NEON(const uint8_t* src_yuy2,const struct YuvConstants* yuvconstants,int width) {asm volatile (YUVTORGB_SETUP"vmov.u8 d23, #255 \n" "1: \n" READYUY2 YUVTORGB"subs %2, %2, #8 \n" "vst4.8 {d20, d21, d22, d23}, [%1]! \n" "bgt 1b \n" "+r" (src_yuy2), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" ,"q10" , "q11" , "q12" , "q13" , "q14" , "q15" );void UYVYToARGBRow_NEON(const uint8_t* src_uyvy,const struct YuvConstants* yuvconstants,int width) {asm volatile (YUVTORGB_SETUP"vmov.u8 d23, #255 \n" "1: \n" READUYVY YUVTORGB"subs %2, %2, #8 \n" "vst4.8 {d20, d21, d22, d23}, [%1]! \n" "bgt 1b \n" "+r" (src_uyvy), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "r" (&yuvconstants->kUVToRB),"r" (&yuvconstants->kUVToG),"r" (&yuvconstants->kUVBiasBGR),"r" (&yuvconstants->kYToRgb)"cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q8" , "q9" ,"q10" , "q11" , "q12" , "q13" , "q14" , "q15" );// Reads 16 pairs of UV and write even values to dst_u and odd to dst_v. void SplitUVRow_NEON(const uint8_t* src_uv,int width) {asm volatile ("1: \n" "vld2.8 {q0, q1}, [%0]! \n" // load 16 pairs of UV "subs %3, %3, #16 \n" // 16 processed per loop "vst1.8 {q0}, [%1]! \n" // store U "vst1.8 {q1}, [%2]! \n" // store V "bgt 1b \n" "+r" (src_uv), // %0 "+r" (dst_u), // %1 "+r" (dst_v), // %2 "+r" (width) // %3 // Output registers // Input registers "cc" , "memory" , "q0" , "q1" // Clobber List // Reads 16 U's and V's and writes out 16 pairs of UV. void MergeUVRow_NEON(const uint8_t* src_u,const uint8_t* src_v,int width) {asm volatile ("1: \n" "vld1.8 {q0}, [%0]! \n" // load U "vld1.8 {q1}, [%1]! \n" // load V "subs %3, %3, #16 \n" // 16 processed per loop "vst2.8 {q0, q1}, [%2]! \n" // store 16 pairs of UV "bgt 1b \n" "+r" (src_u), // %0 "+r" (src_v), // %1 "+r" (dst_uv), // %2 "+r" (width) // %3 // Output registers // Input registers "cc" , "memory" , "q0" , "q1" // Clobber List // Reads 16 packed RGB and write to planar dst_r, dst_g, dst_b. void SplitRGBRow_NEON(const uint8_t* src_rgb,int width) {asm volatile ("1: \n" "vld3.8 {d0, d2, d4}, [%0]! \n" // load 8 RGB "vld3.8 {d1, d3, d5}, [%0]! \n" // next 8 RGB "subs %4, %4, #16 \n" // 16 processed per loop "vst1.8 {q0}, [%1]! \n" // store R "vst1.8 {q1}, [%2]! \n" // store G "vst1.8 {q2}, [%3]! \n" // store B "bgt 1b \n" "+r" (src_rgb), // %0 "+r" (dst_r), // %1 "+r" (dst_g), // %2 "+r" (dst_b), // %3 "+r" (width) // %4 // Input registers "cc" , "memory" , "d0" , "d1" , "d2" // Clobber List // Reads 16 planar R's, G's and B's and writes out 16 packed RGB at a time void MergeRGBRow_NEON(const uint8_t* src_r,const uint8_t* src_g,const uint8_t* src_b,int width) {asm volatile ("1: \n" "vld1.8 {q0}, [%0]! \n" // load R "vld1.8 {q1}, [%1]! \n" // load G "vld1.8 {q2}, [%2]! \n" // load B "subs %4, %4, #16 \n" // 16 processed per loop "vst3.8 {d0, d2, d4}, [%3]! \n" // store 8 RGB "vst3.8 {d1, d3, d5}, [%3]! \n" // next 8 RGB "bgt 1b \n" "+r" (src_r), // %0 "+r" (src_g), // %1 "+r" (src_b), // %2 "+r" (dst_rgb), // %3 "+r" (width) // %4 // Input registers "cc" , "memory" , "q0" , "q1" , "q2" // Clobber List // Copy multiple of 32. vld4.8 allow unaligned and is fastest on a15. void CopyRow_NEON(const uint8_t* src, uint8_t* dst, int width) {asm volatile ("1: \n" "vld1.8 {d0, d1, d2, d3}, [%0]! \n" // load 32 "subs %2, %2, #32 \n" // 32 processed per loop "vst1.8 {d0, d1, d2, d3}, [%1]! \n" // store 32 "bgt 1b \n" "+r" (src), // %0 "+r" (dst), // %1 "+r" (width) // %2 // Output registers // Input registers "cc" , "memory" , "q0" , "q1" // Clobber List // SetRow writes 'width' bytes using an 8 bit value repeated. void SetRow_NEON(uint8_t* dst, uint8_t v8, int width) {asm volatile ("vdup.8 q0, %2 \n" // duplicate 16 bytes "1: \n" "subs %1, %1, #16 \n" // 16 bytes per loop "vst1.8 {q0}, [%0]! \n" // store "bgt 1b \n" "+r" (dst), // %0 "+r" (width) // %1 "r" (v8) // %2 "cc" , "memory" , "q0" );// ARGBSetRow writes 'width' pixels using an 32 bit value repeated. void ARGBSetRow_NEON(uint8_t* dst, uint32_t v32, int width) {asm volatile ("vdup.u32 q0, %2 \n" // duplicate 4 ints "1: \n" "subs %1, %1, #4 \n" // 4 pixels per loop "vst1.8 {q0}, [%0]! \n" // store "bgt 1b \n" "+r" (dst), // %0 "+r" (width) // %1 "r" (v32) // %2 "cc" , "memory" , "q0" );void MirrorRow_NEON(const uint8_t* src, uint8_t* dst, int width) {asm volatile (// Start at end of source row. "add %0, %0, %2 \n" "sub %0, %0, #32 \n" // 32 bytes per loop "1: \n" "vld1.8 {q1, q2}, [%0], %3 \n" // src -= 32 "subs %2, #32 \n" // 32 pixels per loop. "vrev64.8 q0, q2 \n" "vrev64.8 q1, q1 \n" "vswp d0, d1 \n" "vswp d2, d3 \n" "vst1.8 {q0, q1}, [%1]! \n" // dst += 32 "bgt 1b \n" "+r" (src), // %0 "+r" (dst), // %1 "+r" (width) // %2 "r" (-32) // %3 "cc" , "memory" , "q0" , "q1" , "q2" );void MirrorUVRow_NEON(const uint8_t* src_uv, uint8_t* dst_uv, int width) {asm volatile (// Start at end of source row. "mov r12, #-16 \n" "add %0, %0, %2, lsl #1 \n" "sub %0, #16 \n" "1: \n" "vld2.8 {d0, d1}, [%0], r12 \n" // src -= 16 "subs %2, #8 \n" // 8 pixels per loop. "vrev64.8 q0, q0 \n" "vst2.8 {d0, d1}, [%1]! \n" // dst += 16 "bgt 1b \n" "+r" (src_uv), // %0 "+r" (dst_uv), // %1 "+r" (width) // %2 "cc" , "memory" , "r12" , "q0" );void MirrorSplitUVRow_NEON(const uint8_t* src_uv,int width) {asm volatile (// Start at end of source row. "mov r12, #-16 \n" "add %0, %0, %3, lsl #1 \n" "sub %0, #16 \n" "1: \n" "vld2.8 {d0, d1}, [%0], r12 \n" // src -= 16 "subs %3, #8 \n" // 8 pixels per loop. "vrev64.8 q0, q0 \n" "vst1.8 {d0}, [%1]! \n" // dst += 8 "vst1.8 {d1}, [%2]! \n" "bgt 1b \n" "+r" (src_uv), // %0 "+r" (dst_u), // %1 "+r" (dst_v), // %2 "+r" (width) // %3 "cc" , "memory" , "r12" , "q0" );void ARGBMirrorRow_NEON(const uint8_t* src_argb, uint8_t* dst_argb, int width) {asm volatile ("add %0, %0, %2, lsl #2 \n" "sub %0, #32 \n" "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0], %3 \n" // src -= 32 "subs %2, #8 \n" // 8 pixels per loop. "vrev64.8 d0, d0 \n" "vrev64.8 d1, d1 \n" "vrev64.8 d2, d2 \n" "vrev64.8 d3, d3 \n" "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // dst += 32 "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "r" (-32) // %3 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" );void RGB24MirrorRow_NEON(const uint8_t* src_rgb24,int width) {asm volatile ("1: \n" "vld3.8 {d0, d1, d2}, [%0], %3 \n" // src -= 24 "subs %2, #8 \n" // 8 pixels per loop. "vrev64.8 d0, d0 \n" "vrev64.8 d1, d1 \n" "vrev64.8 d2, d2 \n" "vst3.8 {d0, d1, d2}, [%1]! \n" // dst += 24 "bgt 1b \n" "+r" (src_rgb24), // %0 "+r" (dst_rgb24), // %1 "+r" (width) // %2 "r" (-24) // %3 "cc" , "memory" , "d0" , "d1" , "d2" );void RGB24ToARGBRow_NEON(const uint8_t* src_rgb24,int width) {asm volatile ("vmov.u8 d4, #255 \n" // Alpha "1: \n" "vld3.8 {d1, d2, d3}, [%0]! \n" // load 8 pixels of RGB24. "subs %2, %2, #8 \n" // 8 processed per loop. "vst4.8 {d1, d2, d3, d4}, [%1]! \n" // store 8 pixels of ARGB. "bgt 1b \n" "+r" (src_rgb24), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "cc" , "memory" , "d1" , "d2" , "d3" , "d4" // Clobber List void RAWToARGBRow_NEON(const uint8_t* src_raw, uint8_t* dst_argb, int width) {asm volatile ("vmov.u8 d4, #255 \n" // Alpha "1: \n" "vld3.8 {d1, d2, d3}, [%0]! \n" // load 8 pixels of RAW. "subs %2, %2, #8 \n" // 8 processed per loop. "vswp.u8 d1, d3 \n" // swap R, B "vst4.8 {d1, d2, d3, d4}, [%1]! \n" // store 8 pixels of ARGB. "bgt 1b \n" "+r" (src_raw), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "cc" , "memory" , "d1" , "d2" , "d3" , "d4" // Clobber List void RAWToRGBARow_NEON(const uint8_t* src_raw, uint8_t* dst_rgba, int width) {asm volatile ("vmov.u8 d0, #255 \n" // Alpha "1: \n" "vld3.8 {d1, d2, d3}, [%0]! \n" // load 8 pixels of RAW. "subs %2, %2, #8 \n" // 8 processed per loop. "vswp.u8 d1, d3 \n" // swap R, B "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 pixels of RGBA. "bgt 1b \n" "+r" (src_raw), // %0 "+r" (dst_rgba), // %1 "+r" (width) // %2 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" // Clobber List void RAWToRGB24Row_NEON(const uint8_t* src_raw, uint8_t* dst_rgb24, int width) {asm volatile ("1: \n" "vld3.8 {d1, d2, d3}, [%0]! \n" // load 8 pixels of RAW. "subs %2, %2, #8 \n" // 8 processed per loop. "vswp.u8 d1, d3 \n" // swap R, B "vst3.8 {d1, d2, d3}, [%1]! \n" // store 8 pixels of // RGB24. "bgt 1b \n" "+r" (src_raw), // %0 "+r" (dst_rgb24), // %1 "+r" (width) // %2 "cc" , "memory" , "d1" , "d2" , "d3" // Clobber List #define RGB565TOARGB \"vshrn.u16 d6, q0, #5 \n" /* G xxGGGGGG */ \ "vuzp.u8 d0, d1 \n" /* d0 xxxBBBBB RRRRRxxx */ \ "vshl.u8 d6, d6, #2 \n" /* G GGGGGG00 upper 6 */ \ "vshr.u8 d1, d1, #3 \n" /* R 000RRRRR lower 5 */ \ "vshl.u8 q0, q0, #3 \n" /* B,R BBBBB000 upper 5 */ \ "vshr.u8 q2, q0, #5 \n" /* B,R 00000BBB lower 3 */ \ "vorr.u8 d0, d0, d4 \n" /* B */ \ "vshr.u8 d4, d6, #6 \n" /* G 000000GG lower 2 */ \ "vorr.u8 d2, d1, d5 \n" /* R */ \ "vorr.u8 d1, d4, d6 \n" /* G */ void RGB565ToARGBRow_NEON(const uint8_t* src_rgb565,int width) {asm volatile ("vmov.u8 d3, #255 \n" // Alpha "1: \n" "vld1.8 {q0}, [%0]! \n" // load 8 RGB565 pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 pixels of ARGB. "bgt 1b \n" "+r" (src_rgb565), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" // Clobber List #define ARGB1555TOARGB \"vshrn.u16 d7, q0, #8 \n" /* A Arrrrrxx */ \ "vshr.u8 d6, d7, #2 \n" /* R xxxRRRRR */ \ "vshrn.u16 d5, q0, #5 \n" /* G xxxGGGGG */ \ "vmovn.u16 d4, q0 \n" /* B xxxBBBBB */ \ "vshr.u8 d7, d7, #7 \n" /* A 0000000A */ \ "vneg.s8 d7, d7 \n" /* A AAAAAAAA upper 8 */ \ "vshl.u8 d6, d6, #3 \n" /* R RRRRR000 upper 5 */ \ "vshr.u8 q1, q3, #5 \n" /* R,A 00000RRR lower 3 */ \ "vshl.u8 q0, q2, #3 \n" /* B,G BBBBB000 upper 5 */ \ "vshr.u8 q2, q0, #5 \n" /* B,G 00000BBB lower 3 */ \ "vorr.u8 q1, q1, q3 \n" /* R,A */ \ "vorr.u8 q0, q0, q2 \n" /* B,G */ // RGB555TOARGB is same as ARGB1555TOARGB but ignores alpha. #define RGB555TOARGB \"vshrn.u16 d6, q0, #5 \n" /* G xxxGGGGG */ \ "vuzp.u8 d0, d1 \n" /* d0 xxxBBBBB xRRRRRxx */ \ "vshl.u8 d6, d6, #3 \n" /* G GGGGG000 upper 5 */ \ "vshr.u8 d1, d1, #2 \n" /* R 00xRRRRR lower 5 */ \ "vshl.u8 q0, q0, #3 \n" /* B,R BBBBB000 upper 5 */ \ "vshr.u8 q2, q0, #5 \n" /* B,R 00000BBB lower 3 */ \ "vorr.u8 d0, d0, d4 \n" /* B */ \ "vshr.u8 d4, d6, #5 \n" /* G 00000GGG lower 3 */ \ "vorr.u8 d2, d1, d5 \n" /* R */ \ "vorr.u8 d1, d4, d6 \n" /* G */ void ARGB1555ToARGBRow_NEON(const uint8_t* src_argb1555,int width) {asm volatile ("vmov.u8 d3, #255 \n" // Alpha "1: \n" "vld1.8 {q0}, [%0]! \n" // load 8 ARGB1555 pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 pixels of ARGB. "bgt 1b \n" "+r" (src_argb1555), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" // Clobber List #define ARGB4444TOARGB \"vuzp.u8 d0, d1 \n" /* d0 BG, d1 RA */ \ "vshl.u8 q2, q0, #4 \n" /* B,R BBBB0000 */ \ "vshr.u8 q1, q0, #4 \n" /* G,A 0000GGGG */ \ "vshr.u8 q0, q2, #4 \n" /* B,R 0000BBBB */ \ "vorr.u8 q0, q0, q2 \n" /* B,R BBBBBBBB */ \ "vshl.u8 q2, q1, #4 \n" /* G,A GGGG0000 */ \ "vorr.u8 q1, q1, q2 \n" /* G,A GGGGGGGG */ \ "vswp.u8 d1, d2 \n" /* B,R,G,A -> B,G,R,A */ void ARGB4444ToARGBRow_NEON(const uint8_t* src_argb4444,int width) {asm volatile ("vmov.u8 d3, #255 \n" // Alpha "1: \n" "vld1.8 {q0}, [%0]! \n" // load 8 ARGB4444 pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 pixels of ARGB. "bgt 1b \n" "+r" (src_argb4444), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" // Clobber List void ARGBToRGB24Row_NEON(const uint8_t* src_argb,int width) {asm volatile ("1: \n" "vld4.8 {d1, d2, d3, d4}, [%0]! \n" // load 8 pixels of ARGB. "subs %2, %2, #8 \n" // 8 processed per loop. "vst3.8 {d1, d2, d3}, [%1]! \n" // store 8 pixels of // RGB24. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_rgb24), // %1 "+r" (width) // %2 "cc" , "memory" , "d1" , "d2" , "d3" , "d4" // Clobber List void ARGBToRAWRow_NEON(const uint8_t* src_argb, uint8_t* dst_raw, int width) {asm volatile ("1: \n" "vld4.8 {d1, d2, d3, d4}, [%0]! \n" // load 8 pixels of ARGB. "subs %2, %2, #8 \n" // 8 processed per loop. "vswp.u8 d1, d3 \n" // swap R, B "vst3.8 {d1, d2, d3}, [%1]! \n" // store 8 pixels of RAW. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_raw), // %1 "+r" (width) // %2 "cc" , "memory" , "d1" , "d2" , "d3" , "d4" // Clobber List void YUY2ToYRow_NEON(const uint8_t* src_yuy2, uint8_t* dst_y, int width) {asm volatile ("1: \n" "vld2.8 {q0, q1}, [%0]! \n" // load 16 pixels of YUY2. "subs %2, %2, #16 \n" // 16 processed per loop. "vst1.8 {q0}, [%1]! \n" // store 16 pixels of Y. "bgt 1b \n" "+r" (src_yuy2), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" // Clobber List void UYVYToYRow_NEON(const uint8_t* src_uyvy, uint8_t* dst_y, int width) {asm volatile ("1: \n" "vld2.8 {q0, q1}, [%0]! \n" // load 16 pixels of UYVY. "subs %2, %2, #16 \n" // 16 processed per loop. "vst1.8 {q1}, [%1]! \n" // store 16 pixels of Y. "bgt 1b \n" "+r" (src_uyvy), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" // Clobber List void YUY2ToUV422Row_NEON(const uint8_t* src_yuy2,int width) {asm volatile ("1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 16 pixels of YUY2. "subs %3, %3, #16 \n" // 16 pixels = 8 UVs. "vst1.8 {d1}, [%1]! \n" // store 8 U. "vst1.8 {d3}, [%2]! \n" // store 8 V. "bgt 1b \n" "+r" (src_yuy2), // %0 "+r" (dst_u), // %1 "+r" (dst_v), // %2 "+r" (width) // %3 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" // Clobber List void UYVYToUV422Row_NEON(const uint8_t* src_uyvy,int width) {asm volatile ("1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 16 pixels of UYVY. "subs %3, %3, #16 \n" // 16 pixels = 8 UVs. "vst1.8 {d0}, [%1]! \n" // store 8 U. "vst1.8 {d2}, [%2]! \n" // store 8 V. "bgt 1b \n" "+r" (src_uyvy), // %0 "+r" (dst_u), // %1 "+r" (dst_v), // %2 "+r" (width) // %3 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" // Clobber List void YUY2ToUVRow_NEON(const uint8_t* src_yuy2,int stride_yuy2,int width) {asm volatile ("add %1, %0, %1 \n" // stride + src_yuy2 "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 16 pixels of YUY2. "subs %4, %4, #16 \n" // 16 pixels = 8 UVs. "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load next row YUY2. "vrhadd.u8 d1, d1, d5 \n" // average rows of U "vrhadd.u8 d3, d3, d7 \n" // average rows of V "vst1.8 {d1}, [%2]! \n" // store 8 U. "vst1.8 {d3}, [%3]! \n" // store 8 V. "bgt 1b \n" "+r" (src_yuy2), // %0 "+r" (stride_yuy2), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" , "d4" , "d5" , "d6" ,"d7" // Clobber List void UYVYToUVRow_NEON(const uint8_t* src_uyvy,int stride_uyvy,int width) {asm volatile ("add %1, %0, %1 \n" // stride + src_uyvy "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 16 pixels of UYVY. "subs %4, %4, #16 \n" // 16 pixels = 8 UVs. "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load next row UYVY. "vrhadd.u8 d0, d0, d4 \n" // average rows of U "vrhadd.u8 d2, d2, d6 \n" // average rows of V "vst1.8 {d0}, [%2]! \n" // store 8 U. "vst1.8 {d2}, [%3]! \n" // store 8 V. "bgt 1b \n" "+r" (src_uyvy), // %0 "+r" (stride_uyvy), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" , "d4" , "d5" , "d6" ,"d7" // Clobber List // For BGRAToARGB, ABGRToARGB, RGBAToARGB, and ARGBToRGBA. void ARGBShuffleRow_NEON(const uint8_t* src_argb,const uint8_t* shuffler,int width) {asm volatile ("vld1.8 {q2}, [%3] \n" // shuffler "1: \n" "vld1.8 {q0}, [%0]! \n" // load 4 pixels. "subs %2, %2, #4 \n" // 4 processed per loop "vtbl.8 d2, {d0, d1}, d4 \n" // look up 2 first pixels "vtbl.8 d3, {d0, d1}, d5 \n" // look up 2 next pixels "vst1.8 {q1}, [%1]! \n" // store 4. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "r" (shuffler) // %3 "cc" , "memory" , "q0" , "q1" , "q2" // Clobber List void I422ToYUY2Row_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,int width) {asm volatile ("1: \n" "vld2.8 {d0, d2}, [%0]! \n" // load 16 Ys "vld1.8 {d1}, [%1]! \n" // load 8 Us "vld1.8 {d3}, [%2]! \n" // load 8 Vs "subs %4, %4, #16 \n" // 16 pixels "vst4.8 {d0, d1, d2, d3}, [%3]! \n" // Store 8 YUY2/16 pixels. "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (dst_yuy2), // %3 "+r" (width) // %4 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" );void I422ToUYVYRow_NEON(const uint8_t* src_y,const uint8_t* src_u,const uint8_t* src_v,int width) {asm volatile ("1: \n" "vld2.8 {d1, d3}, [%0]! \n" // load 16 Ys "vld1.8 {d0}, [%1]! \n" // load 8 Us "vld1.8 {d2}, [%2]! \n" // load 8 Vs "subs %4, %4, #16 \n" // 16 pixels "vst4.8 {d0, d1, d2, d3}, [%3]! \n" // Store 8 UYVY/16 pixels. "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_u), // %1 "+r" (src_v), // %2 "+r" (dst_uyvy), // %3 "+r" (width) // %4 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" );void ARGBToRGB565Row_NEON(const uint8_t* src_argb,int width) {asm volatile ("1: \n" "vld4.8 {d20, d21, d22, d23}, [%0]! \n" // load 8 pixels of ARGB. "subs %2, %2, #8 \n" // 8 processed per loop. "vst1.8 {q0}, [%1]! \n" // store 8 pixels RGB565. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_rgb565), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q8" , "q9" , "q10" , "q11" );void ARGBToRGB565DitherRow_NEON(const uint8_t* src_argb,const uint32_t dither4,int width) {asm volatile ("vdup.32 d2, %2 \n" // dither4 "1: \n" "vld4.8 {d20, d21, d22, d23}, [%1]! \n" // load 8 pixels of ARGB. "subs %3, %3, #8 \n" // 8 processed per loop. "vqadd.u8 d20, d20, d2 \n" "vqadd.u8 d21, d21, d2 \n" "vqadd.u8 d22, d22, d2 \n" // add for dither "vst1.8 {q0}, [%0]! \n" // store 8 RGB565. "bgt 1b \n" "+r" (dst_rgb) // %0 "r" (src_argb), // %1 "r" (dither4), // %2 "r" (width) // %3 "cc" , "memory" , "q0" , "q1" , "q8" , "q9" , "q10" , "q11" );void ARGBToARGB1555Row_NEON(const uint8_t* src_argb,int width) {asm volatile ("1: \n" "vld4.8 {d20, d21, d22, d23}, [%0]! \n" // load 8 pixels of ARGB. "subs %2, %2, #8 \n" // 8 processed per loop. "vst1.8 {q0}, [%1]! \n" // store 8 ARGB1555. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_argb1555), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q8" , "q9" , "q10" , "q11" );void ARGBToARGB4444Row_NEON(const uint8_t* src_argb,int width) {asm volatile ("vmov.u8 d4, #0x0f \n" // bits to clear with // vbic. "1: \n" "vld4.8 {d20, d21, d22, d23}, [%0]! \n" // load 8 pixels of ARGB. "subs %2, %2, #8 \n" // 8 processed per loop. "vst1.8 {q0}, [%1]! \n" // store 8 ARGB4444. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_argb4444), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q8" , "q9" , "q10" , "q11" );void ARGBToYRow_NEON(const uint8_t* src_argb, uint8_t* dst_y, int width) {asm volatile ("vmov.u8 d24, #25 \n" // B * 0.1016 coefficient "vmov.u8 d25, #129 \n" // G * 0.5078 coefficient "vmov.u8 d26, #66 \n" // R * 0.2578 coefficient "vmov.u8 d27, #16 \n" // Add 16 constant "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q2, d0, d24 \n" // B "vmlal.u8 q2, d1, d25 \n" // G "vmlal.u8 q2, d2, d26 \n" // R "vqrshrn.u16 d0, q2, #8 \n" // 16 bit to 8 bit Y "vqadd.u8 d0, d27 \n" "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q12" , "q13" );void ARGBExtractAlphaRow_NEON(const uint8_t* src_argb,int width) {asm volatile ("1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ARGB pixels "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 ARGB pixels "subs %2, %2, #16 \n" // 16 processed per loop "vst1.8 {q3}, [%1]! \n" // store 16 A's. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_a), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" // Clobber List void ARGBToYJRow_NEON(const uint8_t* src_argb, uint8_t* dst_y, int width) {asm volatile ("vmov.u8 d24, #29 \n" // B * 0.1140 coefficient "vmov.u8 d25, #150 \n" // G * 0.5870 coefficient "vmov.u8 d26, #77 \n" // R * 0.2990 coefficient "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q2, d0, d24 \n" // B "vmlal.u8 q2, d1, d25 \n" // G "vmlal.u8 q2, d2, d26 \n" // R "vqrshrn.u16 d0, q2, #8 \n" // 16 bit to 8 bit Y "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q12" , "q13" );void RGBAToYJRow_NEON(const uint8_t* src_argb, uint8_t* dst_y, int width) {asm volatile ("vmov.u8 d24, #29 \n" // B * 0.1140 coefficient "vmov.u8 d25, #150 \n" // G * 0.5870 coefficient "vmov.u8 d26, #77 \n" // R * 0.2990 coefficient "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 RGBA pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q2, d1, d24 \n" // B "vmlal.u8 q2, d2, d25 \n" // G "vmlal.u8 q2, d3, d26 \n" // R "vqrshrn.u16 d0, q2, #8 \n" // 16 bit to 8 bit Y "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q12" , "q13" );// 8x1 pixels. void ARGBToUV444Row_NEON(const uint8_t* src_argb,int width) {asm volatile ("vmov.u8 d24, #112 \n" // UB / VR 0.875 // coefficient "vmov.u8 d25, #74 \n" // UG -0.5781 coefficient "vmov.u8 d26, #38 \n" // UR -0.2969 coefficient "vmov.u8 d27, #18 \n" // VB -0.1406 coefficient "vmov.u8 d28, #94 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels. "subs %3, %3, #8 \n" // 8 processed per loop. "vmull.u8 q2, d0, d24 \n" // B "vmlsl.u8 q2, d1, d25 \n" // G "vmlsl.u8 q2, d2, d26 \n" // R "vadd.u16 q2, q2, q15 \n" // +128 -> unsigned "vmull.u8 q3, d2, d24 \n" // R "vmlsl.u8 q3, d1, d28 \n" // G "vmlsl.u8 q3, d0, d27 \n" // B "vadd.u16 q3, q3, q15 \n" // +128 -> unsigned "vqshrn.u16 d0, q2, #8 \n" // 16 bit to 8 bit U "vqshrn.u16 d1, q3, #8 \n" // 16 bit to 8 bit V "vst1.8 {d0}, [%1]! \n" // store 8 pixels U. "vst1.8 {d1}, [%2]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_u), // %1 "+r" (dst_v), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q12" , "q13" , "q14" ,"q15" );// clang-format off // 16x2 pixels -> 8x1. width is number of argb pixels. e.g. 16. #define RGBTOUV(QB, QG, QR) \"vmul.s16 q8, " #QB ", q10 \n" /* B */ \ "vmls.s16 q8, " #QG ", q11 \n" /* G */ \ "vmls.s16 q8, " #QR ", q12 \n" /* R */ \ "vadd.u16 q8, q8, q15 \n" /* +128 -> unsigned */ \ "vmul.s16 q9, " #QR ", q10 \n" /* R */ \ "vmls.s16 q9, " #QG ", q14 \n" /* G */ \ "vmls.s16 q9, " #QB ", q13 \n" /* B */ \ "vadd.u16 q9, q9, q15 \n" /* +128 -> unsigned */ \ "vqshrn.u16 d0, q8, #8 \n" /* 16 bit to 8 bit U */ \ "vqshrn.u16 d1, q9, #8 \n" /* 16 bit to 8 bit V */ // clang-format on // TODO(fbarchard): Consider vhadd vertical, then vpaddl horizontal, avoid shr. void ARGBToUVRow_NEON(const uint8_t* src_argb,int src_stride_argb,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_argb "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ARGB pixels. "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 ARGB pixels. "vpaddl.u8 q0, q0 \n" // B 16 bytes -> 8 shorts. "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts. "vpaddl.u8 q2, q2 \n" // R 16 bytes -> 8 shorts. "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more ARGB pixels. "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 ARGB pixels. "vpadal.u8 q0, q4 \n" // B 16 bytes -> 8 shorts. "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts. "vpadal.u8 q2, q6 \n" // R 16 bytes -> 8 shorts. "vrshr.u16 q0, q0, #1 \n" // 2x average "vrshr.u16 q1, q1, #1 \n" "vrshr.u16 q2, q2, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (src_stride_argb), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" ,"q8" , "q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" // TODO(fbarchard): Subsample match C code. void ARGBToUVJRow_NEON(const uint8_t* src_argb,int src_stride_argb,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_argb "vmov.s16 q10, #127 / 2 \n" // UB / VR 0.500 coefficient "vmov.s16 q11, #84 / 2 \n" // UG -0.33126 coefficient "vmov.s16 q12, #43 / 2 \n" // UR -0.16874 coefficient "vmov.s16 q13, #20 / 2 \n" // VB -0.08131 coefficient "vmov.s16 q14, #107 / 2 \n" // VG -0.41869 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ARGB pixels. "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 ARGB pixels. "vpaddl.u8 q0, q0 \n" // B 16 bytes -> 8 shorts. "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts. "vpaddl.u8 q2, q2 \n" // R 16 bytes -> 8 shorts. "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more ARGB pixels. "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 ARGB pixels. "vpadal.u8 q0, q4 \n" // B 16 bytes -> 8 shorts. "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts. "vpadal.u8 q2, q6 \n" // R 16 bytes -> 8 shorts. "vrshr.u16 q0, q0, #1 \n" // 2x average "vrshr.u16 q1, q1, #1 \n" "vrshr.u16 q2, q2, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (src_stride_argb), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" ,"q8" , "q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" void BGRAToUVRow_NEON(const uint8_t* src_bgra,int src_stride_bgra,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_bgra "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 BGRA pixels. "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 BGRA pixels. "vpaddl.u8 q3, q3 \n" // B 16 bytes -> 8 shorts. "vpaddl.u8 q2, q2 \n" // G 16 bytes -> 8 shorts. "vpaddl.u8 q1, q1 \n" // R 16 bytes -> 8 shorts. "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more BGRA pixels. "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 BGRA pixels. "vpadal.u8 q3, q7 \n" // B 16 bytes -> 8 shorts. "vpadal.u8 q2, q6 \n" // G 16 bytes -> 8 shorts. "vpadal.u8 q1, q5 \n" // R 16 bytes -> 8 shorts. "vrshr.u16 q1, q1, #1 \n" // 2x average "vrshr.u16 q2, q2, #1 \n" "vrshr.u16 q3, q3, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_bgra), // %0 "+r" (src_stride_bgra), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" ,"q8" , "q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" void ABGRToUVRow_NEON(const uint8_t* src_abgr,int src_stride_abgr,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_abgr "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ABGR pixels. "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 ABGR pixels. "vpaddl.u8 q2, q2 \n" // B 16 bytes -> 8 shorts. "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts. "vpaddl.u8 q0, q0 \n" // R 16 bytes -> 8 shorts. "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more ABGR pixels. "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 ABGR pixels. "vpadal.u8 q2, q6 \n" // B 16 bytes -> 8 shorts. "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts. "vpadal.u8 q0, q4 \n" // R 16 bytes -> 8 shorts. "vrshr.u16 q0, q0, #1 \n" // 2x average "vrshr.u16 q1, q1, #1 \n" "vrshr.u16 q2, q2, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_abgr), // %0 "+r" (src_stride_abgr), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" ,"q8" , "q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" void RGBAToUVRow_NEON(const uint8_t* src_rgba,int src_stride_rgba,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_rgba "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 RGBA pixels. "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 RGBA pixels. "vpaddl.u8 q0, q1 \n" // B 16 bytes -> 8 shorts. "vpaddl.u8 q1, q2 \n" // G 16 bytes -> 8 shorts. "vpaddl.u8 q2, q3 \n" // R 16 bytes -> 8 shorts. "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more RGBA pixels. "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 RGBA pixels. "vpadal.u8 q0, q5 \n" // B 16 bytes -> 8 shorts. "vpadal.u8 q1, q6 \n" // G 16 bytes -> 8 shorts. "vpadal.u8 q2, q7 \n" // R 16 bytes -> 8 shorts. "vrshr.u16 q0, q0, #1 \n" // 2x average "vrshr.u16 q1, q1, #1 \n" "vrshr.u16 q2, q2, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_rgba), // %0 "+r" (src_stride_rgba), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" ,"q8" , "q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" void RGB24ToUVRow_NEON(const uint8_t* src_rgb24,int src_stride_rgb24,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_rgb24 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld3.8 {d0, d2, d4}, [%0]! \n" // load 8 RGB24 pixels. "vld3.8 {d1, d3, d5}, [%0]! \n" // load next 8 RGB24 pixels. "vpaddl.u8 q0, q0 \n" // B 16 bytes -> 8 shorts. "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts. "vpaddl.u8 q2, q2 \n" // R 16 bytes -> 8 shorts. "vld3.8 {d8, d10, d12}, [%1]! \n" // load 8 more RGB24 pixels. "vld3.8 {d9, d11, d13}, [%1]! \n" // load last 8 RGB24 pixels. "vpadal.u8 q0, q4 \n" // B 16 bytes -> 8 shorts. "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts. "vpadal.u8 q2, q6 \n" // R 16 bytes -> 8 shorts. "vrshr.u16 q0, q0, #1 \n" // 2x average "vrshr.u16 q1, q1, #1 \n" "vrshr.u16 q2, q2, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_rgb24), // %0 "+r" (src_stride_rgb24), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" ,"q8" , "q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" void RAWToUVRow_NEON(const uint8_t* src_raw,int src_stride_raw,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_raw "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld3.8 {d0, d2, d4}, [%0]! \n" // load 8 RAW pixels. "vld3.8 {d1, d3, d5}, [%0]! \n" // load next 8 RAW pixels. "vpaddl.u8 q2, q2 \n" // B 16 bytes -> 8 shorts. "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts. "vpaddl.u8 q0, q0 \n" // R 16 bytes -> 8 shorts. "vld3.8 {d8, d10, d12}, [%1]! \n" // load 8 more RAW pixels. "vld3.8 {d9, d11, d13}, [%1]! \n" // load last 8 RAW pixels. "vpadal.u8 q2, q6 \n" // B 16 bytes -> 8 shorts. "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts. "vpadal.u8 q0, q4 \n" // R 16 bytes -> 8 shorts. "vrshr.u16 q0, q0, #1 \n" // 2x average "vrshr.u16 q1, q1, #1 \n" "vrshr.u16 q2, q2, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_raw), // %0 "+r" (src_stride_raw), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" ,"q8" , "q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" // 16x2 pixels -> 8x1. width is number of argb pixels. e.g. 16. void RGB565ToUVRow_NEON(const uint8_t* src_rgb565,int src_stride_rgb565,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_argb "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 // coefficient "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld1.8 {q0}, [%0]! \n" // load 8 RGB565 pixels. "vpaddl.u8 d8, d0 \n" // B 8 bytes -> 4 shorts. "vpaddl.u8 d10, d1 \n" // G 8 bytes -> 4 shorts. "vpaddl.u8 d12, d2 \n" // R 8 bytes -> 4 shorts. "vld1.8 {q0}, [%0]! \n" // next 8 RGB565 pixels. "vpaddl.u8 d9, d0 \n" // B 8 bytes -> 4 shorts. "vpaddl.u8 d11, d1 \n" // G 8 bytes -> 4 shorts. "vpaddl.u8 d13, d2 \n" // R 8 bytes -> 4 shorts. "vld1.8 {q0}, [%1]! \n" // load 8 RGB565 pixels. "vpadal.u8 d8, d0 \n" // B 8 bytes -> 4 shorts. "vpadal.u8 d10, d1 \n" // G 8 bytes -> 4 shorts. "vpadal.u8 d12, d2 \n" // R 8 bytes -> 4 shorts. "vld1.8 {q0}, [%1]! \n" // next 8 RGB565 pixels. "vpadal.u8 d9, d0 \n" // B 8 bytes -> 4 shorts. "vpadal.u8 d11, d1 \n" // G 8 bytes -> 4 shorts. "vpadal.u8 d13, d2 \n" // R 8 bytes -> 4 shorts. "vrshr.u16 q4, q4, #1 \n" // 2x average "vrshr.u16 q5, q5, #1 \n" "vrshr.u16 q6, q6, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vmul.s16 q8, q4, q10 \n" // B "vmls.s16 q8, q5, q11 \n" // G "vmls.s16 q8, q6, q12 \n" // R "vadd.u16 q8, q8, q15 \n" // +128 -> unsigned "vmul.s16 q9, q6, q10 \n" // R "vmls.s16 q9, q5, q14 \n" // G "vmls.s16 q9, q4, q13 \n" // B "vadd.u16 q9, q9, q15 \n" // +128 -> unsigned "vqshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit U "vqshrn.u16 d1, q9, #8 \n" // 16 bit to 8 bit V "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_rgb565), // %0 "+r" (src_stride_rgb565), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" , "q8" ,"q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" );// 16x2 pixels -> 8x1. width is number of argb pixels. e.g. 16. void ARGB1555ToUVRow_NEON(const uint8_t* src_argb1555,int src_stride_argb1555,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_argb "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 // coefficient "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld1.8 {q0}, [%0]! \n" // load 8 ARGB1555 pixels. "vpaddl.u8 d8, d0 \n" // B 8 bytes -> 4 shorts. "vpaddl.u8 d10, d1 \n" // G 8 bytes -> 4 shorts. "vpaddl.u8 d12, d2 \n" // R 8 bytes -> 4 shorts. "vld1.8 {q0}, [%0]! \n" // next 8 ARGB1555 pixels. "vpaddl.u8 d9, d0 \n" // B 8 bytes -> 4 shorts. "vpaddl.u8 d11, d1 \n" // G 8 bytes -> 4 shorts. "vpaddl.u8 d13, d2 \n" // R 8 bytes -> 4 shorts. "vld1.8 {q0}, [%1]! \n" // load 8 ARGB1555 pixels. "vpadal.u8 d8, d0 \n" // B 8 bytes -> 4 shorts. "vpadal.u8 d10, d1 \n" // G 8 bytes -> 4 shorts. "vpadal.u8 d12, d2 \n" // R 8 bytes -> 4 shorts. "vld1.8 {q0}, [%1]! \n" // next 8 ARGB1555 pixels. "vpadal.u8 d9, d0 \n" // B 8 bytes -> 4 shorts. "vpadal.u8 d11, d1 \n" // G 8 bytes -> 4 shorts. "vpadal.u8 d13, d2 \n" // R 8 bytes -> 4 shorts. "vrshr.u16 q4, q4, #1 \n" // 2x average "vrshr.u16 q5, q5, #1 \n" "vrshr.u16 q6, q6, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vmul.s16 q8, q4, q10 \n" // B "vmls.s16 q8, q5, q11 \n" // G "vmls.s16 q8, q6, q12 \n" // R "vadd.u16 q8, q8, q15 \n" // +128 -> unsigned "vmul.s16 q9, q6, q10 \n" // R "vmls.s16 q9, q5, q14 \n" // G "vmls.s16 q9, q4, q13 \n" // B "vadd.u16 q9, q9, q15 \n" // +128 -> unsigned "vqshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit U "vqshrn.u16 d1, q9, #8 \n" // 16 bit to 8 bit V "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_argb1555), // %0 "+r" (src_stride_argb1555), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" , "q8" ,"q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" );// 16x2 pixels -> 8x1. width is number of argb pixels. e.g. 16. void ARGB4444ToUVRow_NEON(const uint8_t* src_argb4444,int src_stride_argb4444,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_argb "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 // coefficient "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient "vmov.u16 q15, #0x8080 \n" // 128.5 "1: \n" "vld1.8 {q0}, [%0]! \n" // load 8 ARGB4444 pixels. "vpaddl.u8 d8, d0 \n" // B 8 bytes -> 4 shorts. "vpaddl.u8 d10, d1 \n" // G 8 bytes -> 4 shorts. "vpaddl.u8 d12, d2 \n" // R 8 bytes -> 4 shorts. "vld1.8 {q0}, [%0]! \n" // next 8 ARGB4444 pixels. "vpaddl.u8 d9, d0 \n" // B 8 bytes -> 4 shorts. "vpaddl.u8 d11, d1 \n" // G 8 bytes -> 4 shorts. "vpaddl.u8 d13, d2 \n" // R 8 bytes -> 4 shorts. "vld1.8 {q0}, [%1]! \n" // load 8 ARGB4444 pixels. "vpadal.u8 d8, d0 \n" // B 8 bytes -> 4 shorts. "vpadal.u8 d10, d1 \n" // G 8 bytes -> 4 shorts. "vpadal.u8 d12, d2 \n" // R 8 bytes -> 4 shorts. "vld1.8 {q0}, [%1]! \n" // next 8 ARGB4444 pixels. "vpadal.u8 d9, d0 \n" // B 8 bytes -> 4 shorts. "vpadal.u8 d11, d1 \n" // G 8 bytes -> 4 shorts. "vpadal.u8 d13, d2 \n" // R 8 bytes -> 4 shorts. "vrshr.u16 q0, q4, #1 \n" // 2x average "vrshr.u16 q1, q5, #1 \n" "vrshr.u16 q2, q6, #1 \n" "subs %4, %4, #16 \n" // 16 processed per loop. "vst1.8 {d0}, [%2]! \n" // store 8 pixels U. "vst1.8 {d1}, [%3]! \n" // store 8 pixels V. "bgt 1b \n" "+r" (src_argb4444), // %0 "+r" (src_stride_argb4444), // %1 "+r" (dst_u), // %2 "+r" (dst_v), // %3 "+r" (width) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" , "q8" ,"q9" , "q10" , "q11" , "q12" , "q13" , "q14" , "q15" );void RGB565ToYRow_NEON(const uint8_t* src_rgb565, uint8_t* dst_y, int width) {asm volatile ("vmov.u8 d24, #25 \n" // B * 0.1016 coefficient "vmov.u8 d25, #129 \n" // G * 0.5078 coefficient "vmov.u8 d26, #66 \n" // R * 0.2578 coefficient "vmov.u8 d27, #16 \n" // Add 16 constant "1: \n" "vld1.8 {q0}, [%0]! \n" // load 8 RGB565 pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q2, d0, d24 \n" // B "vmlal.u8 q2, d1, d25 \n" // G "vmlal.u8 q2, d2, d26 \n" // R "vqrshrn.u16 d0, q2, #8 \n" // 16 bit to 8 bit Y "vqadd.u8 d0, d27 \n" "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_rgb565), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q12" , "q13" );void ARGB1555ToYRow_NEON(const uint8_t* src_argb1555,int width) {asm volatile ("vmov.u8 d24, #25 \n" // B * 0.1016 coefficient "vmov.u8 d25, #129 \n" // G * 0.5078 coefficient "vmov.u8 d26, #66 \n" // R * 0.2578 coefficient "vmov.u8 d27, #16 \n" // Add 16 constant "1: \n" "vld1.8 {q0}, [%0]! \n" // load 8 ARGB1555 pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q2, d0, d24 \n" // B "vmlal.u8 q2, d1, d25 \n" // G "vmlal.u8 q2, d2, d26 \n" // R "vqrshrn.u16 d0, q2, #8 \n" // 16 bit to 8 bit Y "vqadd.u8 d0, d27 \n" "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_argb1555), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q12" , "q13" );void ARGB4444ToYRow_NEON(const uint8_t* src_argb4444,int width) {asm volatile ("vmov.u8 d24, #25 \n" // B * 0.1016 coefficient "vmov.u8 d25, #129 \n" // G * 0.5078 coefficient "vmov.u8 d26, #66 \n" // R * 0.2578 coefficient "vmov.u8 d27, #16 \n" // Add 16 constant "1: \n" "vld1.8 {q0}, [%0]! \n" // load 8 ARGB4444 pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q2, d0, d24 \n" // B "vmlal.u8 q2, d1, d25 \n" // G "vmlal.u8 q2, d2, d26 \n" // R "vqrshrn.u16 d0, q2, #8 \n" // 16 bit to 8 bit Y "vqadd.u8 d0, d27 \n" "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_argb4444), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q12" , "q13" );void BGRAToYRow_NEON(const uint8_t* src_bgra, uint8_t* dst_y, int width) {asm volatile ("vmov.u8 d6, #25 \n" // B * 0.1016 coefficient "vmov.u8 d5, #129 \n" // G * 0.5078 coefficient "vmov.u8 d4, #66 \n" // R * 0.2578 coefficient "vmov.u8 d7, #16 \n" // Add 16 constant "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of BGRA. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q8, d1, d4 \n" // R "vmlal.u8 q8, d2, d5 \n" // G "vmlal.u8 q8, d3, d6 \n" // B "vqrshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit Y "vqadd.u8 d0, d7 \n" "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_bgra), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" , "d4" , "d5" , "d6" , "d7" , "q8" );void ABGRToYRow_NEON(const uint8_t* src_abgr, uint8_t* dst_y, int width) {asm volatile ("vmov.u8 d6, #25 \n" // B * 0.1016 coefficient "vmov.u8 d5, #129 \n" // G * 0.5078 coefficient "vmov.u8 d4, #66 \n" // R * 0.2578 coefficient "vmov.u8 d7, #16 \n" // Add 16 constant "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of ABGR. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q8, d0, d4 \n" // R "vmlal.u8 q8, d1, d5 \n" // G "vmlal.u8 q8, d2, d6 \n" // B "vqrshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit Y "vqadd.u8 d0, d7 \n" "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_abgr), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" , "d4" , "d5" , "d6" , "d7" , "q8" );void RGBAToYRow_NEON(const uint8_t* src_rgba, uint8_t* dst_y, int width) {asm volatile ("vmov.u8 d4, #25 \n" // B * 0.1016 coefficient "vmov.u8 d5, #129 \n" // G * 0.5078 coefficient "vmov.u8 d6, #66 \n" // R * 0.2578 coefficient "vmov.u8 d7, #16 \n" // Add 16 constant "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of RGBA. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q8, d1, d4 \n" // B "vmlal.u8 q8, d2, d5 \n" // G "vmlal.u8 q8, d3, d6 \n" // R "vqrshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit Y "vqadd.u8 d0, d7 \n" "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_rgba), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" , "d4" , "d5" , "d6" , "d7" , "q8" );void RGB24ToYRow_NEON(const uint8_t* src_rgb24, uint8_t* dst_y, int width) {asm volatile ("vmov.u8 d4, #25 \n" // B * 0.1016 coefficient "vmov.u8 d5, #129 \n" // G * 0.5078 coefficient "vmov.u8 d6, #66 \n" // R * 0.2578 coefficient "vmov.u8 d7, #16 \n" // Add 16 constant "1: \n" "vld3.8 {d0, d1, d2}, [%0]! \n" // load 8 pixels of RGB24. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q8, d0, d4 \n" // B "vmlal.u8 q8, d1, d5 \n" // G "vmlal.u8 q8, d2, d6 \n" // R "vqrshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit Y "vqadd.u8 d0, d7 \n" "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_rgb24), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" , "d4" , "d5" , "d6" , "d7" , "q8" );void RAWToYRow_NEON(const uint8_t* src_raw, uint8_t* dst_y, int width) {asm volatile ("vmov.u8 d6, #25 \n" // B * 0.1016 coefficient "vmov.u8 d5, #129 \n" // G * 0.5078 coefficient "vmov.u8 d4, #66 \n" // R * 0.2578 coefficient "vmov.u8 d7, #16 \n" // Add 16 constant "1: \n" "vld3.8 {d0, d1, d2}, [%0]! \n" // load 8 pixels of RAW. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q8, d0, d4 \n" // B "vmlal.u8 q8, d1, d5 \n" // G "vmlal.u8 q8, d2, d6 \n" // R "vqrshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit Y "vqadd.u8 d0, d7 \n" "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_raw), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" , "d4" , "d5" , "d6" , "d7" , "q8" );void RGB24ToYJRow_NEON(const uint8_t* src_rgb24, uint8_t* dst_yj, int width) {asm volatile ("vmov.u8 d4, #29 \n" // B * 0.1140 coefficient "vmov.u8 d5, #150 \n" // G * 0.5870 coefficient "vmov.u8 d6, #77 \n" // R * 0.2990 coefficient "1: \n" "vld3.8 {d0, d1, d2}, [%0]! \n" // load 8 pixels of RGB24. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q4, d0, d4 \n" // B "vmlal.u8 q4, d1, d5 \n" // G "vmlal.u8 q4, d2, d6 \n" // R "vqrshrn.u16 d0, q4, #8 \n" // 16 bit to 8 bit Y "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_rgb24), // %0 "+r" (dst_yj), // %1 "+r" (width) // %2 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" , "d4" , "d5" , "d6" , "q4" );void RAWToYJRow_NEON(const uint8_t* src_raw, uint8_t* dst_yj, int width) {asm volatile ("vmov.u8 d6, #29 \n" // B * 0.1140 coefficient "vmov.u8 d5, #150 \n" // G * 0.5870 coefficient "vmov.u8 d4, #77 \n" // R * 0.2990 coefficient "1: \n" "vld3.8 {d0, d1, d2}, [%0]! \n" // load 8 pixels of RAW. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q4, d0, d4 \n" // B "vmlal.u8 q4, d1, d5 \n" // G "vmlal.u8 q4, d2, d6 \n" // R "vqrshrn.u16 d0, q4, #8 \n" // 16 bit to 8 bit Y "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y. "bgt 1b \n" "+r" (src_raw), // %0 "+r" (dst_yj), // %1 "+r" (width) // %2 "cc" , "memory" , "d0" , "d1" , "d2" , "d3" , "d4" , "d5" , "d6" , "q4" );// Bilinear filter 16x2 -> 16x1 void InterpolateRow_NEON(uint8_t* dst_ptr,const uint8_t* src_ptr,int dst_width,int source_y_fraction) {int y1_fraction = source_y_fraction;asm volatile ("cmp %4, #0 \n" "beq 100f \n" "add %2, %1 \n" "cmp %4, #128 \n" "beq 50f \n" "vdup.8 d5, %4 \n" "rsb %4, #256 \n" "vdup.8 d4, %4 \n" // General purpose row blend. "1: \n" "vld1.8 {q0}, [%1]! \n" "vld1.8 {q1}, [%2]! \n" "subs %3, %3, #16 \n" "vmull.u8 q13, d0, d4 \n" "vmull.u8 q14, d1, d4 \n" "vmlal.u8 q13, d2, d5 \n" "vmlal.u8 q14, d3, d5 \n" "vrshrn.u16 d0, q13, #8 \n" "vrshrn.u16 d1, q14, #8 \n" "vst1.8 {q0}, [%0]! \n" "bgt 1b \n" "b 99f \n" // Blend 50 / 50. "50: \n" "vld1.8 {q0}, [%1]! \n" "vld1.8 {q1}, [%2]! \n" "subs %3, %3, #16 \n" "vrhadd.u8 q0, q1 \n" "vst1.8 {q0}, [%0]! \n" "bgt 50b \n" "b 99f \n" // Blend 100 / 0 - Copy row unchanged. "100: \n" "vld1.8 {q0}, [%1]! \n" "subs %3, %3, #16 \n" "vst1.8 {q0}, [%0]! \n" "bgt 100b \n" "99: \n" "+r" (dst_ptr), // %0 "+r" (src_ptr), // %1 "+r" (src_stride), // %2 "+r" (dst_width), // %3 "+r" (y1_fraction) // %4 "cc" , "memory" , "q0" , "q1" , "d4" , "d5" , "q13" , "q14" );// dr * (256 - sa) / 256 + sr = dr - dr * sa / 256 + sr void ARGBBlendRow_NEON(const uint8_t* src_argb0,const uint8_t* src_argb1,int width) {asm volatile ("subs %3, #8 \n" "blt 89f \n" // Blend 8 pixels. "8: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of ARGB0. "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load 8 pixels of ARGB1. "subs %3, %3, #8 \n" // 8 processed per loop. "vmull.u8 q10, d4, d3 \n" // db * a "vmull.u8 q11, d5, d3 \n" // dg * a "vmull.u8 q12, d6, d3 \n" // dr * a "vqrshrn.u16 d20, q10, #8 \n" // db >>= 8 "vqrshrn.u16 d21, q11, #8 \n" // dg >>= 8 "vqrshrn.u16 d22, q12, #8 \n" // dr >>= 8 "vqsub.u8 q2, q2, q10 \n" // dbg - dbg * a / 256 "vqsub.u8 d6, d6, d22 \n" // dr - dr * a / 256 "vqadd.u8 q0, q0, q2 \n" // + sbg "vqadd.u8 d2, d2, d6 \n" // + sr "vmov.u8 d3, #255 \n" // a = 255 "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 pixels of ARGB. "bge 8b \n" "89: \n" "adds %3, #8-1 \n" "blt 99f \n" // Blend 1 pixels. "1: \n" "vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [%0]! \n" // load 1 pixel ARGB0. "vld4.8 {d4[0],d5[0],d6[0],d7[0]}, [%1]! \n" // load 1 pixel ARGB1. "subs %3, %3, #1 \n" // 1 processed per loop. "vmull.u8 q10, d4, d3 \n" // db * a "vmull.u8 q11, d5, d3 \n" // dg * a "vmull.u8 q12, d6, d3 \n" // dr * a "vqrshrn.u16 d20, q10, #8 \n" // db >>= 8 "vqrshrn.u16 d21, q11, #8 \n" // dg >>= 8 "vqrshrn.u16 d22, q12, #8 \n" // dr >>= 8 "vqsub.u8 q2, q2, q10 \n" // dbg - dbg * a / 256 "vqsub.u8 d6, d6, d22 \n" // dr - dr * a / 256 "vqadd.u8 q0, q0, q2 \n" // + sbg "vqadd.u8 d2, d2, d6 \n" // + sr "vmov.u8 d3, #255 \n" // a = 255 "vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [%2]! \n" // store 1 pixel. "bge 1b \n" "99: \n" "+r" (src_argb0), // %0 "+r" (src_argb1), // %1 "+r" (dst_argb), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q10" , "q11" , "q12" );// Attenuate 8 pixels at a time. void ARGBAttenuateRow_NEON(const uint8_t* src_argb,int width) {asm volatile (// Attenuate 8 pixels. "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of ARGB. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q10, d0, d3 \n" // b * a "vmull.u8 q11, d1, d3 \n" // g * a "vmull.u8 q12, d2, d3 \n" // r * a "vqrshrn.u16 d0, q10, #8 \n" // b >>= 8 "vqrshrn.u16 d1, q11, #8 \n" // g >>= 8 "vqrshrn.u16 d2, q12, #8 \n" // r >>= 8 "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 pixels of ARGB. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q10" , "q11" , "q12" );// Quantize 8 ARGB pixels (32 bytes). // dst = (dst * scale >> 16) * interval_size + interval_offset; void ARGBQuantizeRow_NEON(uint8_t* dst_argb,int scale,int interval_size,int interval_offset,int width) {asm volatile ("vdup.u16 q8, %2 \n" "vshr.u16 q8, q8, #1 \n" // scale >>= 1 "vdup.u16 q9, %3 \n" // interval multiply. "vdup.u16 q10, %4 \n" // interval add // 8 pixel loop. "1: \n" "vld4.8 {d0, d2, d4, d6}, [%0] \n" // load 8 pixels of ARGB. "subs %1, %1, #8 \n" // 8 processed per loop. "vmovl.u8 q0, d0 \n" // b (0 .. 255) "vmovl.u8 q1, d2 \n" "vmovl.u8 q2, d4 \n" "vqdmulh.s16 q0, q0, q8 \n" // b * scale "vqdmulh.s16 q1, q1, q8 \n" // g "vqdmulh.s16 q2, q2, q8 \n" // r "vmul.u16 q0, q0, q9 \n" // b * interval_size "vmul.u16 q1, q1, q9 \n" // g "vmul.u16 q2, q2, q9 \n" // r "vadd.u16 q0, q0, q10 \n" // b + interval_offset "vadd.u16 q1, q1, q10 \n" // g "vadd.u16 q2, q2, q10 \n" // r "vqmovn.u16 d0, q0 \n" "vqmovn.u16 d2, q1 \n" "vqmovn.u16 d4, q2 \n" "vst4.8 {d0, d2, d4, d6}, [%0]! \n" // store 8 pixels of ARGB. "bgt 1b \n" "+r" (dst_argb), // %0 "+r" (width) // %1 "r" (scale), // %2 "r" (interval_size), // %3 "r" (interval_offset) // %4 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q8" , "q9" , "q10" );// Shade 8 pixels at a time by specified value. // NOTE vqrdmulh.s16 q10, q10, d0[0] must use a scaler register from 0 to 8. // Rounding in vqrdmulh does +1 to high if high bit of low s16 is set. void ARGBShadeRow_NEON(const uint8_t* src_argb,int width,asm volatile ("vdup.u32 q0, %3 \n" // duplicate scale value. "vzip.u8 d0, d1 \n" // d0 aarrggbb. "vshr.u16 q0, q0, #1 \n" // scale / 2. // 8 pixel loop. "1: \n" "vld4.8 {d20, d22, d24, d26}, [%0]! \n" // load 8 pixels of ARGB. "subs %2, %2, #8 \n" // 8 processed per loop. "vmovl.u8 q10, d20 \n" // b (0 .. 255) "vmovl.u8 q11, d22 \n" "vmovl.u8 q12, d24 \n" "vmovl.u8 q13, d26 \n" "vqrdmulh.s16 q10, q10, d0[0] \n" // b * scale * 2 "vqrdmulh.s16 q11, q11, d0[1] \n" // g "vqrdmulh.s16 q12, q12, d0[2] \n" // r "vqrdmulh.s16 q13, q13, d0[3] \n" // a "vqmovn.u16 d20, q10 \n" "vqmovn.u16 d22, q11 \n" "vqmovn.u16 d24, q12 \n" "vqmovn.u16 d26, q13 \n" "vst4.8 {d20, d22, d24, d26}, [%1]! \n" // store 8 pixels of ARGB. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "r" (value) // %3 "cc" , "memory" , "q0" , "q10" , "q11" , "q12" , "q13" );// Convert 8 ARGB pixels (64 bytes) to 8 Gray ARGB pixels // Similar to ARGBToYJ but stores ARGB. // C code is (29 * b + 150 * g + 77 * r + 128) >> 8; void ARGBGrayRow_NEON(const uint8_t* src_argb, uint8_t* dst_argb, int width) {asm volatile ("vmov.u8 d24, #29 \n" // B * 0.1140 coefficient "vmov.u8 d25, #150 \n" // G * 0.5870 coefficient "vmov.u8 d26, #77 \n" // R * 0.2990 coefficient "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vmull.u8 q2, d0, d24 \n" // B "vmlal.u8 q2, d1, d25 \n" // G "vmlal.u8 q2, d2, d26 \n" // R "vqrshrn.u16 d0, q2, #8 \n" // 16 bit to 8 bit B "vmov d1, d0 \n" // G "vmov d2, d0 \n" // R "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 ARGB pixels. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q12" , "q13" );// Convert 8 ARGB pixels (32 bytes) to 8 Sepia ARGB pixels. // b = (r * 35 + g * 68 + b * 17) >> 7 // g = (r * 45 + g * 88 + b * 22) >> 7 // r = (r * 50 + g * 98 + b * 24) >> 7 void ARGBSepiaRow_NEON(uint8_t* dst_argb, int width) {asm volatile ("vmov.u8 d20, #17 \n" // BB coefficient "vmov.u8 d21, #68 \n" // BG coefficient "vmov.u8 d22, #35 \n" // BR coefficient "vmov.u8 d24, #22 \n" // GB coefficient "vmov.u8 d25, #88 \n" // GG coefficient "vmov.u8 d26, #45 \n" // GR coefficient "vmov.u8 d28, #24 \n" // BB coefficient "vmov.u8 d29, #98 \n" // BG coefficient "vmov.u8 d30, #50 \n" // BR coefficient "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0] \n" // load 8 ARGB pixels. "subs %1, %1, #8 \n" // 8 processed per loop. "vmull.u8 q2, d0, d20 \n" // B to Sepia B "vmlal.u8 q2, d1, d21 \n" // G "vmlal.u8 q2, d2, d22 \n" // R "vmull.u8 q3, d0, d24 \n" // B to Sepia G "vmlal.u8 q3, d1, d25 \n" // G "vmlal.u8 q3, d2, d26 \n" // R "vmull.u8 q8, d0, d28 \n" // B to Sepia R "vmlal.u8 q8, d1, d29 \n" // G "vmlal.u8 q8, d2, d30 \n" // R "vqshrn.u16 d0, q2, #7 \n" // 16 bit to 8 bit B "vqshrn.u16 d1, q3, #7 \n" // 16 bit to 8 bit G "vqshrn.u16 d2, q8, #7 \n" // 16 bit to 8 bit R "vst4.8 {d0, d1, d2, d3}, [%0]! \n" // store 8 ARGB pixels. "bgt 1b \n" "+r" (dst_argb), // %0 "+r" (width) // %1 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q10" , "q11" , "q12" , "q13" ,"q14" , "q15" );// Tranform 8 ARGB pixels (32 bytes) with color matrix. // TODO(fbarchard): Was same as Sepia except matrix is provided. This function // needs to saturate. Consider doing a non-saturating version. void ARGBColorMatrixRow_NEON(const uint8_t* src_argb,const int8_t* matrix_argb,int width) {asm volatile ("vld1.8 {q2}, [%3] \n" // load 3 ARGB vectors. "vmovl.s8 q0, d4 \n" // B,G coefficients s16. "vmovl.s8 q1, d5 \n" // R,A coefficients s16. "1: \n" "vld4.8 {d16, d18, d20, d22}, [%0]! \n" // load 8 ARGB pixels. "subs %2, %2, #8 \n" // 8 processed per loop. "vmovl.u8 q8, d16 \n" // b (0 .. 255) 16 bit "vmovl.u8 q9, d18 \n" // g "vmovl.u8 q10, d20 \n" // r "vmovl.u8 q11, d22 \n" // a "vmul.s16 q12, q8, d0[0] \n" // B = B * Matrix B "vmul.s16 q13, q8, d1[0] \n" // G = B * Matrix G "vmul.s16 q14, q8, d2[0] \n" // R = B * Matrix R "vmul.s16 q15, q8, d3[0] \n" // A = B * Matrix A "vmul.s16 q4, q9, d0[1] \n" // B += G * Matrix B "vmul.s16 q5, q9, d1[1] \n" // G += G * Matrix G "vmul.s16 q6, q9, d2[1] \n" // R += G * Matrix R "vmul.s16 q7, q9, d3[1] \n" // A += G * Matrix A "vqadd.s16 q12, q12, q4 \n" // Accumulate B "vqadd.s16 q13, q13, q5 \n" // Accumulate G "vqadd.s16 q14, q14, q6 \n" // Accumulate R "vqadd.s16 q15, q15, q7 \n" // Accumulate A "vmul.s16 q4, q10, d0[2] \n" // B += R * Matrix B "vmul.s16 q5, q10, d1[2] \n" // G += R * Matrix G "vmul.s16 q6, q10, d2[2] \n" // R += R * Matrix R "vmul.s16 q7, q10, d3[2] \n" // A += R * Matrix A "vqadd.s16 q12, q12, q4 \n" // Accumulate B "vqadd.s16 q13, q13, q5 \n" // Accumulate G "vqadd.s16 q14, q14, q6 \n" // Accumulate R "vqadd.s16 q15, q15, q7 \n" // Accumulate A "vmul.s16 q4, q11, d0[3] \n" // B += A * Matrix B "vmul.s16 q5, q11, d1[3] \n" // G += A * Matrix G "vmul.s16 q6, q11, d2[3] \n" // R += A * Matrix R "vmul.s16 q7, q11, d3[3] \n" // A += A * Matrix A "vqadd.s16 q12, q12, q4 \n" // Accumulate B "vqadd.s16 q13, q13, q5 \n" // Accumulate G "vqadd.s16 q14, q14, q6 \n" // Accumulate R "vqadd.s16 q15, q15, q7 \n" // Accumulate A "vqshrun.s16 d16, q12, #6 \n" // 16 bit to 8 bit B "vqshrun.s16 d18, q13, #6 \n" // 16 bit to 8 bit G "vqshrun.s16 d20, q14, #6 \n" // 16 bit to 8 bit R "vqshrun.s16 d22, q15, #6 \n" // 16 bit to 8 bit A "vst4.8 {d16, d18, d20, d22}, [%1]! \n" // store 8 ARGB pixels. "bgt 1b \n" "+r" (src_argb), // %0 "+r" (dst_argb), // %1 "+r" (width) // %2 "r" (matrix_argb) // %3 "cc" , "memory" , "q0" , "q1" , "q2" , "q4" , "q5" , "q6" , "q7" , "q8" , "q9" ,"q10" , "q11" , "q12" , "q13" , "q14" , "q15" );// Multiply 2 rows of ARGB pixels together, 8 pixels at a time. void ARGBMultiplyRow_NEON(const uint8_t* src_argb0,const uint8_t* src_argb1,int width) {asm volatile (// 8 pixel loop. "1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ARGB pixels. "vld4.8 {d1, d3, d5, d7}, [%1]! \n" // load 8 more ARGB "subs %3, %3, #8 \n" // 8 processed per loop. "vmull.u8 q0, d0, d1 \n" // multiply B "vmull.u8 q1, d2, d3 \n" // multiply G "vmull.u8 q2, d4, d5 \n" // multiply R "vmull.u8 q3, d6, d7 \n" // multiply A "vrshrn.u16 d0, q0, #8 \n" // 16 bit to 8 bit B "vrshrn.u16 d1, q1, #8 \n" // 16 bit to 8 bit G "vrshrn.u16 d2, q2, #8 \n" // 16 bit to 8 bit R "vrshrn.u16 d3, q3, #8 \n" // 16 bit to 8 bit A "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels. "bgt 1b \n" "+r" (src_argb0), // %0 "+r" (src_argb1), // %1 "+r" (dst_argb), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" );// Add 2 rows of ARGB pixels together, 8 pixels at a time. void ARGBAddRow_NEON(const uint8_t* src_argb0,const uint8_t* src_argb1,int width) {asm volatile (// 8 pixel loop. "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels. "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load 8 more ARGB "subs %3, %3, #8 \n" // 8 processed per loop. "vqadd.u8 q0, q0, q2 \n" // add B, G "vqadd.u8 q1, q1, q3 \n" // add R, A "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels. "bgt 1b \n" "+r" (src_argb0), // %0 "+r" (src_argb1), // %1 "+r" (dst_argb), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" );// Subtract 2 rows of ARGB pixels, 8 pixels at a time. void ARGBSubtractRow_NEON(const uint8_t* src_argb0,const uint8_t* src_argb1,int width) {asm volatile (// 8 pixel loop. "1: \n" "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels. "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load 8 more ARGB "subs %3, %3, #8 \n" // 8 processed per loop. "vqsub.u8 q0, q0, q2 \n" // subtract B, G "vqsub.u8 q1, q1, q3 \n" // subtract R, A "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels. "bgt 1b \n" "+r" (src_argb0), // %0 "+r" (src_argb1), // %1 "+r" (dst_argb), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" );// Adds Sobel X and Sobel Y and stores Sobel into ARGB. // A = 255 // R = Sobel // G = Sobel // B = Sobel void SobelRow_NEON(const uint8_t* src_sobelx,const uint8_t* src_sobely,int width) {asm volatile ("vmov.u8 d3, #255 \n" // alpha // 8 pixel loop. "1: \n" "vld1.8 {d0}, [%0]! \n" // load 8 sobelx. "vld1.8 {d1}, [%1]! \n" // load 8 sobely. "subs %3, %3, #8 \n" // 8 processed per loop. "vqadd.u8 d0, d0, d1 \n" // add "vmov.u8 d1, d0 \n" "vmov.u8 d2, d0 \n" "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels. "bgt 1b \n" "+r" (src_sobelx), // %0 "+r" (src_sobely), // %1 "+r" (dst_argb), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" );// Adds Sobel X and Sobel Y and stores Sobel into plane. void SobelToPlaneRow_NEON(const uint8_t* src_sobelx,const uint8_t* src_sobely,int width) {asm volatile (// 16 pixel loop. "1: \n" "vld1.8 {q0}, [%0]! \n" // load 16 sobelx. "vld1.8 {q1}, [%1]! \n" // load 16 sobely. "subs %3, %3, #16 \n" // 16 processed per loop. "vqadd.u8 q0, q0, q1 \n" // add "vst1.8 {q0}, [%2]! \n" // store 16 pixels. "bgt 1b \n" "+r" (src_sobelx), // %0 "+r" (src_sobely), // %1 "+r" (dst_y), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" );// Mixes Sobel X, Sobel Y and Sobel into ARGB. // A = 255 // R = Sobel X // G = Sobel // B = Sobel Y void SobelXYRow_NEON(const uint8_t* src_sobelx,const uint8_t* src_sobely,int width) {asm volatile ("vmov.u8 d3, #255 \n" // alpha // 8 pixel loop. "1: \n" "vld1.8 {d2}, [%0]! \n" // load 8 sobelx. "vld1.8 {d0}, [%1]! \n" // load 8 sobely. "subs %3, %3, #8 \n" // 8 processed per loop. "vqadd.u8 d1, d0, d2 \n" // add "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels. "bgt 1b \n" "+r" (src_sobelx), // %0 "+r" (src_sobely), // %1 "+r" (dst_argb), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" );// SobelX as a matrix is // -1 0 1 // -2 0 2 // -1 0 1 void SobelXRow_NEON(const uint8_t* src_y0,const uint8_t* src_y1,const uint8_t* src_y2,int width) {asm volatile ("1: \n" "vld1.8 {d0}, [%0],%5 \n" // top "vld1.8 {d1}, [%0],%6 \n" "vsubl.u8 q0, d0, d1 \n" "vld1.8 {d2}, [%1],%5 \n" // center * 2 "vld1.8 {d3}, [%1],%6 \n" "vsubl.u8 q1, d2, d3 \n" "vadd.s16 q0, q0, q1 \n" "vadd.s16 q0, q0, q1 \n" "vld1.8 {d2}, [%2],%5 \n" // bottom "vld1.8 {d3}, [%2],%6 \n" "subs %4, %4, #8 \n" // 8 pixels "vsubl.u8 q1, d2, d3 \n" "vadd.s16 q0, q0, q1 \n" "vabs.s16 q0, q0 \n" "vqmovn.u16 d0, q0 \n" "vst1.8 {d0}, [%3]! \n" // store 8 sobelx "bgt 1b \n" "+r" (src_y0), // %0 "+r" (src_y1), // %1 "+r" (src_y2), // %2 "+r" (dst_sobelx), // %3 "+r" (width) // %4 "r" (2), // %5 "r" (6) // %6 "cc" , "memory" , "q0" , "q1" // Clobber List // SobelY as a matrix is // -1 -2 -1 // 0 0 0 // 1 2 1 void SobelYRow_NEON(const uint8_t* src_y0,const uint8_t* src_y1,int width) {asm volatile ("1: \n" "vld1.8 {d0}, [%0],%4 \n" // left "vld1.8 {d1}, [%1],%4 \n" "vsubl.u8 q0, d0, d1 \n" "vld1.8 {d2}, [%0],%4 \n" // center * 2 "vld1.8 {d3}, [%1],%4 \n" "vsubl.u8 q1, d2, d3 \n" "vadd.s16 q0, q0, q1 \n" "vadd.s16 q0, q0, q1 \n" "vld1.8 {d2}, [%0],%5 \n" // right "vld1.8 {d3}, [%1],%5 \n" "subs %3, %3, #8 \n" // 8 pixels "vsubl.u8 q1, d2, d3 \n" "vadd.s16 q0, q0, q1 \n" "vabs.s16 q0, q0 \n" "vqmovn.u16 d0, q0 \n" "vst1.8 {d0}, [%2]! \n" // store 8 sobely "bgt 1b \n" "+r" (src_y0), // %0 "+r" (src_y1), // %1 "+r" (dst_sobely), // %2 "+r" (width) // %3 "r" (1), // %4 "r" (6) // %5 "cc" , "memory" , "q0" , "q1" // Clobber List // %y passes a float as a scalar vector for vector * scalar multiply. // the regoster must be d0 to d15 and indexed with [0] or [1] to access // the float in the first or second float of the d-reg void HalfFloat1Row_NEON(const uint16_t* src,float /*unused*/, int width) {asm volatile ("1: \n" "vld1.8 {q1}, [%0]! \n" // load 8 shorts "subs %2, %2, #8 \n" // 8 pixels per loop "vmovl.u16 q2, d2 \n" // 8 int's "vmovl.u16 q3, d3 \n" "vcvt.f32.u32 q2, q2 \n" // 8 floats "vcvt.f32.u32 q3, q3 \n" "vmul.f32 q2, q2, %y3 \n" // adjust exponent "vmul.f32 q3, q3, %y3 \n" "vqshrn.u32 d2, q2, #13 \n" // isolate halffloat "vqshrn.u32 d3, q3, #13 \n" "vst1.8 {q1}, [%1]! \n" "bgt 1b \n" "+r" (src), // %0 "+r" (dst), // %1 "+r" (width) // %2 "w" (1.9259299444e-34f) // %3 "cc" , "memory" , "q1" , "q2" , "q3" );void HalfFloatRow_NEON(const uint16_t* src,float scale,int width) {asm volatile ("1: \n" "vld1.8 {q1}, [%0]! \n" // load 8 shorts "subs %2, %2, #8 \n" // 8 pixels per loop "vmovl.u16 q2, d2 \n" // 8 int's "vmovl.u16 q3, d3 \n" "vcvt.f32.u32 q2, q2 \n" // 8 floats "vcvt.f32.u32 q3, q3 \n" "vmul.f32 q2, q2, %y3 \n" // adjust exponent "vmul.f32 q3, q3, %y3 \n" "vqshrn.u32 d2, q2, #13 \n" // isolate halffloat "vqshrn.u32 d3, q3, #13 \n" "vst1.8 {q1}, [%1]! \n" "bgt 1b \n" "+r" (src), // %0 "+r" (dst), // %1 "+r" (width) // %2 "w" (scale * 1.9259299444e-34f) // %3 "cc" , "memory" , "q1" , "q2" , "q3" );void ByteToFloatRow_NEON(const uint8_t* src,float * dst,float scale,int width) {asm volatile ("1: \n" "vld1.8 {d2}, [%0]! \n" // load 8 bytes "subs %2, %2, #8 \n" // 8 pixels per loop "vmovl.u8 q1, d2 \n" // 8 shorts "vmovl.u16 q2, d2 \n" // 8 ints "vmovl.u16 q3, d3 \n" "vcvt.f32.u32 q2, q2 \n" // 8 floats "vcvt.f32.u32 q3, q3 \n" "vmul.f32 q2, q2, %y3 \n" // scale "vmul.f32 q3, q3, %y3 \n" "vst1.8 {q2, q3}, [%1]! \n" // store 8 floats "bgt 1b \n" "+r" (src), // %0 "+r" (dst), // %1 "+r" (width) // %2 "w" (scale) // %3 "cc" , "memory" , "q1" , "q2" , "q3" );// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row. void GaussCol_NEON(const uint16_t* src0,const uint16_t* src1,const uint16_t* src2,const uint16_t* src3,const uint16_t* src4,int width) {asm volatile ("vmov.u16 d6, #4 \n" // constant 4 "vmov.u16 d7, #6 \n" // constant 6 "1: \n" "vld1.16 {q1}, [%0]! \n" // load 8 samples, 5 rows "vld1.16 {q2}, [%4]! \n" "vaddl.u16 q0, d2, d4 \n" // * 1 "vaddl.u16 q1, d3, d5 \n" // * 1 "vld1.16 {q2}, [%1]! \n" "vmlal.u16 q0, d4, d6 \n" // * 4 "vmlal.u16 q1, d5, d6 \n" // * 4 "vld1.16 {q2}, [%2]! \n" "vmlal.u16 q0, d4, d7 \n" // * 6 "vmlal.u16 q1, d5, d7 \n" // * 6 "vld1.16 {q2}, [%3]! \n" "vmlal.u16 q0, d4, d6 \n" // * 4 "vmlal.u16 q1, d5, d6 \n" // * 4 "subs %6, %6, #8 \n" // 8 processed per loop "vst1.32 {q0, q1}, [%5]! \n" // store 8 samples "bgt 1b \n" "+r" (src0), // %0 "+r" (src1), // %1 "+r" (src2), // %2 "+r" (src3), // %3 "+r" (src4), // %4 "+r" (dst), // %5 "+r" (width) // %6 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" );// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row. void GaussRow_NEON(const uint32_t* src, uint16_t* dst, int width) {const uint32_t* src1 = src + 1;const uint32_t* src2 = src + 2;const uint32_t* src3 = src + 3;asm volatile ("vmov.u32 q10, #4 \n" // constant 4 "vmov.u32 q11, #6 \n" // constant 6 "1: \n" "vld1.32 {q0, q1}, [%0]! \n" // load 12 source samples "vld1.32 {q2}, [%0] \n" "vadd.u32 q0, q0, q1 \n" // * 1 "vadd.u32 q1, q1, q2 \n" // * 1 "vld1.32 {q2, q3}, [%2]! \n" "vmla.u32 q0, q2, q11 \n" // * 6 "vmla.u32 q1, q3, q11 \n" // * 6 "vld1.32 {q2, q3}, [%1]! \n" "vld1.32 {q8, q9}, [%3]! \n" "vadd.u32 q2, q2, q8 \n" // add rows for * 4 "vadd.u32 q3, q3, q9 \n" "vmla.u32 q0, q2, q10 \n" // * 4 "vmla.u32 q1, q3, q10 \n" // * 4 "subs %5, %5, #8 \n" // 8 processed per loop "vqshrn.u32 d0, q0, #8 \n" // round and pack "vqshrn.u32 d1, q1, #8 \n" "vst1.u16 {q0}, [%4]! \n" // store 8 samples "bgt 1b \n" "+r" (src), // %0 "+r" (src1), // %1 "+r" (src2), // %2 "+r" (src3), // %3 "+r" (dst), // %4 "+r" (width) // %5 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q8" , "q9" , "q10" , "q11" );// Convert biplanar NV21 to packed YUV24 void NV21ToYUV24Row_NEON(const uint8_t* src_y,const uint8_t* src_vu,int width) {asm volatile ("1: \n" "vld1.8 {q2}, [%0]! \n" // load 16 Y values "vld2.8 {d0, d2}, [%1]! \n" // load 8 VU values "vmov d1, d0 \n" "vzip.u8 d0, d1 \n" // VV "vmov d3, d2 \n" "vzip.u8 d2, d3 \n" // UU "subs %3, %3, #16 \n" // 16 pixels per loop "vst3.8 {d0, d2, d4}, [%2]! \n" // store 16 YUV pixels "vst3.8 {d1, d3, d5}, [%2]! \n" "bgt 1b \n" "+r" (src_y), // %0 "+r" (src_vu), // %1 "+r" (dst_yuv24), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" , "q2" );void AYUVToUVRow_NEON(const uint8_t* src_ayuv,int src_stride_ayuv,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_AYUV "1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 AYUV pixels. "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 AYUV // pixels. "vpaddl.u8 q0, q0 \n" // V 16 bytes -> 8 shorts. "vpaddl.u8 q1, q1 \n" // U 16 bytes -> 8 shorts. "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more AYUV // pixels. "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 AYUV // pixels. "vpadal.u8 q0, q4 \n" // B 16 bytes -> 8 shorts. "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts. "vqrshrun.s16 d1, q0, #2 \n" // 2x2 average "vqrshrun.s16 d0, q1, #2 \n" "subs %3, %3, #16 \n" // 16 processed per loop. "vst2.8 {d0, d1}, [%2]! \n" // store 8 pixels UV. "bgt 1b \n" "+r" (src_ayuv), // %0 "+r" (src_stride_ayuv), // %1 "+r" (dst_uv), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" );void AYUVToVURow_NEON(const uint8_t* src_ayuv,int src_stride_ayuv,int width) {asm volatile ("add %1, %0, %1 \n" // src_stride + src_AYUV "1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 AYUV pixels. "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 AYUV // pixels. "vpaddl.u8 q0, q0 \n" // V 16 bytes -> 8 shorts. "vpaddl.u8 q1, q1 \n" // U 16 bytes -> 8 shorts. "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more AYUV // pixels. "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 AYUV // pixels. "vpadal.u8 q0, q4 \n" // B 16 bytes -> 8 shorts. "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts. "vqrshrun.s16 d0, q0, #2 \n" // 2x2 average "vqrshrun.s16 d1, q1, #2 \n" "subs %3, %3, #16 \n" // 16 processed per loop. "vst2.8 {d0, d1}, [%2]! \n" // store 8 pixels VU. "bgt 1b \n" "+r" (src_ayuv), // %0 "+r" (src_stride_ayuv), // %1 "+r" (dst_vu), // %2 "+r" (width) // %3 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" , "q4" , "q5" , "q6" , "q7" );// Copy row of AYUV Y's into Y. // Similar to ARGBExtractAlphaRow_NEON void AYUVToYRow_NEON(const uint8_t* src_ayuv, uint8_t* dst_y, int width) {asm volatile ("1: \n" "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 AYUV pixels "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 AYUV pixels "subs %2, %2, #16 \n" // 16 processed per loop "vst1.8 {q2}, [%1]! \n" // store 16 Y's. "bgt 1b \n" "+r" (src_ayuv), // %0 "+r" (dst_y), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" );// Convert UV plane of NV12 to VU of NV21. void SwapUVRow_NEON(const uint8_t* src_uv, uint8_t* dst_vu, int width) {asm volatile ("1: \n" "vld2.8 {d0, d2}, [%0]! \n" // load 16 UV values "vld2.8 {d1, d3}, [%0]! \n" "vorr.u8 q2, q0, q0 \n" // move U after V "subs %2, %2, #16 \n" // 16 pixels per loop "vst2.8 {q1, q2}, [%1]! \n" // store 16 VU pixels "bgt 1b \n" "+r" (src_uv), // %0 "+r" (dst_vu), // %1 "+r" (width) // %2 "cc" , "memory" , "q0" , "q1" , "q2" );void HalfMergeUVRow_NEON(const uint8_t* src_u,int src_stride_u,const uint8_t* src_v,int src_stride_v,int width) {const uint8_t* src_u_1 = src_u + src_stride_u;const uint8_t* src_v_1 = src_v + src_stride_v;asm volatile ("1: \n" "vld1.8 {q0}, [%0]! \n" // load 16 U values "vld1.8 {q1}, [%2]! \n" // load 16 V values "vld1.8 {q2}, [%1]! \n" "vld1.8 {q3}, [%3]! \n" "vpaddl.u8 q0, q0 \n" // half size "vpaddl.u8 q1, q1 \n" "vpadal.u8 q0, q2 \n" "vpadal.u8 q1, q3 \n" "vqrshrn.u16 d0, q0, #2 \n" "vqrshrn.u16 d1, q1, #2 \n" "subs %5, %5, #16 \n" // 16 src pixels per loop "vst2.8 {d0, d1}, [%4]! \n" // store 8 UV pixels "bgt 1b \n" "+r" (src_u), // %0 "+r" (src_u_1), // %1 "+r" (src_v), // %2 "+r" (src_v_1), // %3 "+r" (dst_uv), // %4 "+r" (width) // %5 "cc" , "memory" , "q0" , "q1" , "q2" , "q3" );#endif // !defined(LIBYUV_DISABLE_NEON) && defined(__ARM_NEON__).. #ifdef __cplusplus// extern "C" // namespace libyuv #endif
Messung V0.5 in Prozent C=89 H=89 G=88
¤ Dauer der Verarbeitung: 0.95 Sekunden
(vorverarbeitet am 2026-04-26)
¤ *© Formatika GbR, Deutschland
