Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(886)

Side by Side Diff: source/row_neon.cc

Issue 1363503002: yuvconstants for all YUV to RGB conversion functions. (Closed) Base URL: https://chromium.googlesource.com/libyuv/libyuv@master
Patch Set: mips dspr2 add constants parameter Created 5 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « source/row_mips.cc ('k') | source/row_neon64.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright 2011 The LibYuv Project Authors. All rights reserved. 2 * Copyright 2011 The LibYuv Project Authors. All rights reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source 5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after
86 86
87 // Read 8 UYVY 87 // Read 8 UYVY
88 #define READUYVY \ 88 #define READUYVY \
89 MEMACCESS(0) \ 89 MEMACCESS(0) \
90 "vld2.8 {d2, d3}, [%0]! \n" \ 90 "vld2.8 {d2, d3}, [%0]! \n" \
91 "vmov.u8 d0, d3 \n" \ 91 "vmov.u8 d0, d3 \n" \
92 "vmov.u8 d3, d2 \n" \ 92 "vmov.u8 d3, d2 \n" \
93 "vuzp.u8 d2, d3 \n" \ 93 "vuzp.u8 d2, d3 \n" \
94 "vtrn.u32 d2, d3 \n" 94 "vtrn.u32 d2, d3 \n"
95 95
96 #define YUV422TORGB_SETUP_REG \ 96 #define YUVTORGB_SETUP \
97 MEMACCESS([kUVToRB]) \ 97 MEMACCESS([kUVToRB]) \
98 "vld1.8 {d24}, [%[kUVToRB]] \n" \ 98 "vld1.8 {d24}, [%[kUVToRB]] \n" \
99 MEMACCESS([kUVToG]) \ 99 MEMACCESS([kUVToG]) \
100 "vld1.8 {d25}, [%[kUVToG]] \n" \ 100 "vld1.8 {d25}, [%[kUVToG]] \n" \
101 MEMACCESS([kUVBiasBGR]) \ 101 MEMACCESS([kUVBiasBGR]) \
102 "vld1.16 {d26[], d27[]}, [%[kUVBiasBGR]]! \n" \ 102 "vld1.16 {d26[], d27[]}, [%[kUVBiasBGR]]! \n" \
103 MEMACCESS([kUVBiasBGR]) \ 103 MEMACCESS([kUVBiasBGR]) \
104 "vld1.16 {d8[], d9[]}, [%[kUVBiasBGR]]! \n" \ 104 "vld1.16 {d8[], d9[]}, [%[kUVBiasBGR]]! \n" \
105 MEMACCESS([kUVBiasBGR]) \ 105 MEMACCESS([kUVBiasBGR]) \
106 "vld1.16 {d28[], d29[]}, [%[kUVBiasBGR]] \n" \ 106 "vld1.16 {d28[], d29[]}, [%[kUVBiasBGR]] \n" \
107 MEMACCESS([kYToRgb]) \ 107 MEMACCESS([kYToRgb]) \
108 "vld1.32 {d30[], d31[]}, [%[kYToRgb]] \n" 108 "vld1.32 {d30[], d31[]}, [%[kYToRgb]] \n"
109 109
110 #define YUV422TORGB \ 110 #define YUVTORGB \
111 "vmull.u8 q8, d2, d24 \n" /* u/v B/R component */\ 111 "vmull.u8 q8, d2, d24 \n" /* u/v B/R component */\
112 "vmull.u8 q9, d2, d25 \n" /* u/v G component */\ 112 "vmull.u8 q9, d2, d25 \n" /* u/v G component */\
113 "vmovl.u8 q0, d0 \n" /* Y */\ 113 "vmovl.u8 q0, d0 \n" /* Y */\
114 "vmovl.s16 q10, d1 \n" \ 114 "vmovl.s16 q10, d1 \n" \
115 "vmovl.s16 q0, d0 \n" \ 115 "vmovl.s16 q0, d0 \n" \
116 "vmul.s32 q10, q10, q15 \n" \ 116 "vmul.s32 q10, q10, q15 \n" \
117 "vmul.s32 q0, q0, q15 \n" \ 117 "vmul.s32 q0, q0, q15 \n" \
118 "vqshrun.s32 d0, q0, #16 \n" \ 118 "vqshrun.s32 d0, q0, #16 \n" \
119 "vqshrun.s32 d1, q10, #16 \n" /* Y */\ 119 "vqshrun.s32 d1, q10, #16 \n" /* Y */\
120 "vadd.s16 d18, d19 \n" \ 120 "vadd.s16 d18, d19 \n" \
(...skipping 10 matching lines...) Expand all
131 "vqadd.s16 q9, q9, q10 \n" /* R */ \ 131 "vqadd.s16 q9, q9, q10 \n" /* R */ \
132 "vqsub.s16 q0, q0, q3 \n" /* G */ \ 132 "vqsub.s16 q0, q0, q3 \n" /* G */ \
133 "vqshrun.s16 d20, q8, #6 \n" /* B */ \ 133 "vqshrun.s16 d20, q8, #6 \n" /* B */ \
134 "vqshrun.s16 d22, q9, #6 \n" /* R */ \ 134 "vqshrun.s16 d22, q9, #6 \n" /* R */ \
135 "vqshrun.s16 d21, q0, #6 \n" /* G */ 135 "vqshrun.s16 d21, q0, #6 \n" /* G */
136 136
137 void I444ToARGBRow_NEON(const uint8* src_y, 137 void I444ToARGBRow_NEON(const uint8* src_y,
138 const uint8* src_u, 138 const uint8* src_u,
139 const uint8* src_v, 139 const uint8* src_v,
140 uint8* dst_argb, 140 uint8* dst_argb,
141 struct YuvConstants* yuvconstants,
141 int width) { 142 int width) {
142 asm volatile ( 143 asm volatile (
143 YUV422TORGB_SETUP_REG 144 YUVTORGB_SETUP
144 "1: \n" 145 "1: \n"
145 READYUV444 146 READYUV444
146 YUV422TORGB 147 YUVTORGB
147 "subs %4, %4, #8 \n" 148 "subs %4, %4, #8 \n"
148 "vmov.u8 d23, #255 \n" 149 "vmov.u8 d23, #255 \n"
149 MEMACCESS(3) 150 MEMACCESS(3)
150 "vst4.8 {d20, d21, d22, d23}, [%3]! \n" 151 "vst4.8 {d20, d21, d22, d23}, [%3]! \n"
151 "bgt 1b \n" 152 "bgt 1b \n"
152 : "+r"(src_y), // %0 153 : "+r"(src_y), // %0
153 "+r"(src_u), // %1 154 "+r"(src_u), // %1
154 "+r"(src_v), // %2 155 "+r"(src_v), // %2
155 "+r"(dst_argb), // %3 156 "+r"(dst_argb), // %3
156 "+r"(width) // %4 157 "+r"(width) // %4
157 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %5 158 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
158 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %6 159 [kUVToG]"r"(&yuvconstants->kUVToG),
159 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 160 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
160 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 161 [kYToRgb]"r"(&yuvconstants->kYToRgb)
161 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 162 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
162 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 163 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
163 ); 164 );
164 } 165 }
165 166
166 void I422ToARGBMatrixRow_NEON(const uint8* src_y, 167 void I422ToARGBRow_NEON(const uint8* src_y,
167 const uint8* src_u, 168 const uint8* src_u,
168 const uint8* src_v, 169 const uint8* src_v,
169 uint8* dst_argb, 170 uint8* dst_argb,
170 struct YuvConstantsNEON* YuvConstants, 171 struct YuvConstants* yuvconstants,
171 int width) { 172 int width) {
172 asm volatile ( 173 asm volatile (
173 YUV422TORGB_SETUP_REG 174 YUVTORGB_SETUP
174 "1: \n" 175 "1: \n"
175 READYUV422 176 READYUV422
176 YUV422TORGB 177 YUVTORGB
177 "subs %4, %4, #8 \n" 178 "subs %4, %4, #8 \n"
178 "vmov.u8 d23, #255 \n" 179 "vmov.u8 d23, #255 \n"
179 MEMACCESS(3) 180 MEMACCESS(3)
180 "vst4.8 {d20, d21, d22, d23}, [%3]! \n" 181 "vst4.8 {d20, d21, d22, d23}, [%3]! \n"
181 "bgt 1b \n" 182 "bgt 1b \n"
182 : "+r"(src_y), // %0 183 : "+r"(src_y), // %0
183 "+r"(src_u), // %1 184 "+r"(src_u), // %1
184 "+r"(src_v), // %2 185 "+r"(src_v), // %2
185 "+r"(dst_argb), // %3 186 "+r"(dst_argb), // %3
186 "+r"(width) // %4 187 "+r"(width) // %4
187 : [kUVToRB]"r"(&YuvConstants->kUVToRB), // %5 188 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
188 [kUVToG]"r"(&YuvConstants->kUVToG), // %6 189 [kUVToG]"r"(&yuvconstants->kUVToG),
189 [kUVBiasBGR]"r"(&YuvConstants->kUVBiasBGR), 190 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
190 [kYToRgb]"r"(&YuvConstants->kYToRgb) 191 [kYToRgb]"r"(&yuvconstants->kYToRgb)
191 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 192 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
192 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 193 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
193 ); 194 );
194 } 195 }
195 196
196 void I411ToARGBRow_NEON(const uint8* src_y, 197 void I411ToARGBRow_NEON(const uint8* src_y,
197 const uint8* src_u, 198 const uint8* src_u,
198 const uint8* src_v, 199 const uint8* src_v,
199 uint8* dst_argb, 200 uint8* dst_argb,
201 struct YuvConstants* yuvconstants,
200 int width) { 202 int width) {
201 asm volatile ( 203 asm volatile (
202 YUV422TORGB_SETUP_REG 204 YUVTORGB_SETUP
203 "1: \n" 205 "1: \n"
204 READYUV411 206 READYUV411
205 YUV422TORGB 207 YUVTORGB
206 "subs %4, %4, #8 \n" 208 "subs %4, %4, #8 \n"
207 "vmov.u8 d23, #255 \n" 209 "vmov.u8 d23, #255 \n"
208 MEMACCESS(3) 210 MEMACCESS(3)
209 "vst4.8 {d20, d21, d22, d23}, [%3]! \n" 211 "vst4.8 {d20, d21, d22, d23}, [%3]! \n"
210 "bgt 1b \n" 212 "bgt 1b \n"
211 : "+r"(src_y), // %0 213 : "+r"(src_y), // %0
212 "+r"(src_u), // %1 214 "+r"(src_u), // %1
213 "+r"(src_v), // %2 215 "+r"(src_v), // %2
214 "+r"(dst_argb), // %3 216 "+r"(dst_argb), // %3
215 "+r"(width) // %4 217 "+r"(width) // %4
216 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %5 218 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
217 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %6 219 [kUVToG]"r"(&yuvconstants->kUVToG),
218 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 220 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
219 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 221 [kYToRgb]"r"(&yuvconstants->kYToRgb)
220 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 222 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
221 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 223 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
222 ); 224 );
223 } 225 }
224 226
225 void I422ToBGRARow_NEON(const uint8* src_y, 227 void I422ToBGRARow_NEON(const uint8* src_y,
226 const uint8* src_u, 228 const uint8* src_u,
227 const uint8* src_v, 229 const uint8* src_v,
228 uint8* dst_bgra, 230 uint8* dst_bgra,
231 struct YuvConstants* yuvconstants,
229 int width) { 232 int width) {
230 asm volatile ( 233 asm volatile (
231 YUV422TORGB_SETUP_REG 234 YUVTORGB_SETUP
232 "1: \n" 235 "1: \n"
233 READYUV422 236 READYUV422
234 YUV422TORGB 237 YUVTORGB
235 "subs %4, %4, #8 \n" 238 "subs %4, %4, #8 \n"
236 "vswp.u8 d20, d22 \n" 239 "vswp.u8 d20, d22 \n"
237 "vmov.u8 d19, #255 \n" 240 "vmov.u8 d19, #255 \n"
238 MEMACCESS(3) 241 MEMACCESS(3)
239 "vst4.8 {d19, d20, d21, d22}, [%3]! \n" 242 "vst4.8 {d19, d20, d21, d22}, [%3]! \n"
240 "bgt 1b \n" 243 "bgt 1b \n"
241 : "+r"(src_y), // %0 244 : "+r"(src_y), // %0
242 "+r"(src_u), // %1 245 "+r"(src_u), // %1
243 "+r"(src_v), // %2 246 "+r"(src_v), // %2
244 "+r"(dst_bgra), // %3 247 "+r"(dst_bgra), // %3
245 "+r"(width) // %4 248 "+r"(width) // %4
246 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %5 249 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
247 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %6 250 [kUVToG]"r"(&yuvconstants->kUVToG),
248 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 251 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
249 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 252 [kYToRgb]"r"(&yuvconstants->kYToRgb)
250 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 253 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
251 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 254 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
252 ); 255 );
253 } 256 }
254 257
255 void I422ToABGRMatrixRow_NEON(const uint8* src_y, 258 void I422ToABGRRow_NEON(const uint8* src_y,
256 const uint8* src_u, 259 const uint8* src_u,
257 const uint8* src_v, 260 const uint8* src_v,
258 uint8* dst_abgr, 261 uint8* dst_abgr,
259 struct YuvConstantsNEON* YuvConstants, 262 struct YuvConstants* yuvconstants,
260 int width) { 263 int width) {
261 asm volatile ( 264 asm volatile (
262 YUV422TORGB_SETUP_REG 265 YUVTORGB_SETUP
263 "1: \n" 266 "1: \n"
264 READYUV422 267 READYUV422
265 YUV422TORGB 268 YUVTORGB
266 "subs %4, %4, #8 \n" 269 "subs %4, %4, #8 \n"
267 "vswp.u8 d20, d22 \n" 270 "vswp.u8 d20, d22 \n"
268 "vmov.u8 d23, #255 \n" 271 "vmov.u8 d23, #255 \n"
269 MEMACCESS(3) 272 MEMACCESS(3)
270 "vst4.8 {d20, d21, d22, d23}, [%3]! \n" 273 "vst4.8 {d20, d21, d22, d23}, [%3]! \n"
271 "bgt 1b \n" 274 "bgt 1b \n"
272 : "+r"(src_y), // %0 275 : "+r"(src_y), // %0
273 "+r"(src_u), // %1 276 "+r"(src_u), // %1
274 "+r"(src_v), // %2 277 "+r"(src_v), // %2
275 "+r"(dst_abgr), // %3 278 "+r"(dst_abgr), // %3
276 "+r"(width) // %4 279 "+r"(width) // %4
277 : [kUVToRB]"r"(&YuvConstants->kUVToRB), // %5 280 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
278 [kUVToG]"r"(&YuvConstants->kUVToG), // %6 281 [kUVToG]"r"(&yuvconstants->kUVToG),
279 [kUVBiasBGR]"r"(&YuvConstants->kUVBiasBGR), 282 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
280 [kYToRgb]"r"(&YuvConstants->kYToRgb) 283 [kYToRgb]"r"(&yuvconstants->kYToRgb)
281 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 284 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
282 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 285 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
283 ); 286 );
284 } 287 }
285 288
286 void I422ToRGBARow_NEON(const uint8* src_y, 289 void I422ToRGBARow_NEON(const uint8* src_y,
287 const uint8* src_u, 290 const uint8* src_u,
288 const uint8* src_v, 291 const uint8* src_v,
289 uint8* dst_rgba, 292 uint8* dst_rgba,
293 struct YuvConstants* yuvconstants,
290 int width) { 294 int width) {
291 asm volatile ( 295 asm volatile (
292 YUV422TORGB_SETUP_REG 296 YUVTORGB_SETUP
293 "1: \n" 297 "1: \n"
294 READYUV422 298 READYUV422
295 YUV422TORGB 299 YUVTORGB
296 "subs %4, %4, #8 \n" 300 "subs %4, %4, #8 \n"
297 "vmov.u8 d19, #255 \n" 301 "vmov.u8 d19, #255 \n"
298 MEMACCESS(3) 302 MEMACCESS(3)
299 "vst4.8 {d19, d20, d21, d22}, [%3]! \n" 303 "vst4.8 {d19, d20, d21, d22}, [%3]! \n"
300 "bgt 1b \n" 304 "bgt 1b \n"
301 : "+r"(src_y), // %0 305 : "+r"(src_y), // %0
302 "+r"(src_u), // %1 306 "+r"(src_u), // %1
303 "+r"(src_v), // %2 307 "+r"(src_v), // %2
304 "+r"(dst_rgba), // %3 308 "+r"(dst_rgba), // %3
305 "+r"(width) // %4 309 "+r"(width) // %4
306 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %5 310 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
307 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %6 311 [kUVToG]"r"(&yuvconstants->kUVToG),
308 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 312 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
309 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 313 [kYToRgb]"r"(&yuvconstants->kYToRgb)
310 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 314 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
311 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 315 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
312 ); 316 );
313 } 317 }
314 318
315 void I422ToRGB24Row_NEON(const uint8* src_y, 319 void I422ToRGB24Row_NEON(const uint8* src_y,
316 const uint8* src_u, 320 const uint8* src_u,
317 const uint8* src_v, 321 const uint8* src_v,
318 uint8* dst_rgb24, 322 uint8* dst_rgb24,
323 struct YuvConstants* yuvconstants,
319 int width) { 324 int width) {
320 asm volatile ( 325 asm volatile (
321 YUV422TORGB_SETUP_REG 326 YUVTORGB_SETUP
322 "1: \n" 327 "1: \n"
323 READYUV422 328 READYUV422
324 YUV422TORGB 329 YUVTORGB
325 "subs %4, %4, #8 \n" 330 "subs %4, %4, #8 \n"
326 MEMACCESS(3) 331 MEMACCESS(3)
327 "vst3.8 {d20, d21, d22}, [%3]! \n" 332 "vst3.8 {d20, d21, d22}, [%3]! \n"
328 "bgt 1b \n" 333 "bgt 1b \n"
329 : "+r"(src_y), // %0 334 : "+r"(src_y), // %0
330 "+r"(src_u), // %1 335 "+r"(src_u), // %1
331 "+r"(src_v), // %2 336 "+r"(src_v), // %2
332 "+r"(dst_rgb24), // %3 337 "+r"(dst_rgb24), // %3
333 "+r"(width) // %4 338 "+r"(width) // %4
334 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %5 339 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
335 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %6 340 [kUVToG]"r"(&yuvconstants->kUVToG),
336 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 341 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
337 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 342 [kYToRgb]"r"(&yuvconstants->kYToRgb)
338 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 343 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
339 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 344 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
340 ); 345 );
341 } 346 }
342 347
343 void I422ToRAWRow_NEON(const uint8* src_y, 348 void I422ToRAWRow_NEON(const uint8* src_y,
344 const uint8* src_u, 349 const uint8* src_u,
345 const uint8* src_v, 350 const uint8* src_v,
346 uint8* dst_raw, 351 uint8* dst_raw,
352 struct YuvConstants* yuvconstants,
347 int width) { 353 int width) {
348 asm volatile ( 354 asm volatile (
349 YUV422TORGB_SETUP_REG 355 YUVTORGB_SETUP
350 "1: \n" 356 "1: \n"
351 READYUV422 357 READYUV422
352 YUV422TORGB 358 YUVTORGB
353 "subs %4, %4, #8 \n" 359 "subs %4, %4, #8 \n"
354 "vswp.u8 d20, d22 \n" 360 "vswp.u8 d20, d22 \n"
355 MEMACCESS(3) 361 MEMACCESS(3)
356 "vst3.8 {d20, d21, d22}, [%3]! \n" 362 "vst3.8 {d20, d21, d22}, [%3]! \n"
357 "bgt 1b \n" 363 "bgt 1b \n"
358 : "+r"(src_y), // %0 364 : "+r"(src_y), // %0
359 "+r"(src_u), // %1 365 "+r"(src_u), // %1
360 "+r"(src_v), // %2 366 "+r"(src_v), // %2
361 "+r"(dst_raw), // %3 367 "+r"(dst_raw), // %3
362 "+r"(width) // %4 368 "+r"(width) // %4
363 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %5 369 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
364 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %6 370 [kUVToG]"r"(&yuvconstants->kUVToG),
365 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 371 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
366 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 372 [kYToRgb]"r"(&yuvconstants->kYToRgb)
367 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 373 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
368 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 374 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
369 ); 375 );
370 } 376 }
371 377
372 #define ARGBTORGB565 \ 378 #define ARGBTORGB565 \
373 "vshr.u8 d20, d20, #3 \n" /* B */ \ 379 "vshr.u8 d20, d20, #3 \n" /* B */ \
374 "vshr.u8 d21, d21, #2 \n" /* G */ \ 380 "vshr.u8 d21, d21, #2 \n" /* G */ \
375 "vshr.u8 d22, d22, #3 \n" /* R */ \ 381 "vshr.u8 d22, d22, #3 \n" /* R */ \
376 "vmovl.u8 q8, d20 \n" /* B */ \ 382 "vmovl.u8 q8, d20 \n" /* B */ \
377 "vmovl.u8 q9, d21 \n" /* G */ \ 383 "vmovl.u8 q9, d21 \n" /* G */ \
378 "vmovl.u8 q10, d22 \n" /* R */ \ 384 "vmovl.u8 q10, d22 \n" /* R */ \
379 "vshl.u16 q9, q9, #5 \n" /* G */ \ 385 "vshl.u16 q9, q9, #5 \n" /* G */ \
380 "vshl.u16 q10, q10, #11 \n" /* R */ \ 386 "vshl.u16 q10, q10, #11 \n" /* R */ \
381 "vorr q0, q8, q9 \n" /* BG */ \ 387 "vorr q0, q8, q9 \n" /* BG */ \
382 "vorr q0, q0, q10 \n" /* BGR */ 388 "vorr q0, q0, q10 \n" /* BGR */
383 389
384 void I422ToRGB565Row_NEON(const uint8* src_y, 390 void I422ToRGB565Row_NEON(const uint8* src_y,
385 const uint8* src_u, 391 const uint8* src_u,
386 const uint8* src_v, 392 const uint8* src_v,
387 uint8* dst_rgb565, 393 uint8* dst_rgb565,
394 struct YuvConstants* yuvconstants,
388 int width) { 395 int width) {
389 asm volatile ( 396 asm volatile (
390 YUV422TORGB_SETUP_REG 397 YUVTORGB_SETUP
391 "1: \n" 398 "1: \n"
392 READYUV422 399 READYUV422
393 YUV422TORGB 400 YUVTORGB
394 "subs %4, %4, #8 \n" 401 "subs %4, %4, #8 \n"
395 ARGBTORGB565 402 ARGBTORGB565
396 MEMACCESS(3) 403 MEMACCESS(3)
397 "vst1.8 {q0}, [%3]! \n" // store 8 pixels RGB565. 404 "vst1.8 {q0}, [%3]! \n" // store 8 pixels RGB565.
398 "bgt 1b \n" 405 "bgt 1b \n"
399 : "+r"(src_y), // %0 406 : "+r"(src_y), // %0
400 "+r"(src_u), // %1 407 "+r"(src_u), // %1
401 "+r"(src_v), // %2 408 "+r"(src_v), // %2
402 "+r"(dst_rgb565), // %3 409 "+r"(dst_rgb565), // %3
403 "+r"(width) // %4 410 "+r"(width) // %4
404 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %5 411 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
405 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %6 412 [kUVToG]"r"(&yuvconstants->kUVToG),
406 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 413 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
407 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 414 [kYToRgb]"r"(&yuvconstants->kYToRgb)
408 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 415 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
409 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 416 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
410 ); 417 );
411 } 418 }
412 419
413 #define ARGBTOARGB1555 \ 420 #define ARGBTOARGB1555 \
414 "vshr.u8 q10, q10, #3 \n" /* B */ \ 421 "vshr.u8 q10, q10, #3 \n" /* B */ \
415 "vshr.u8 d22, d22, #3 \n" /* R */ \ 422 "vshr.u8 d22, d22, #3 \n" /* R */ \
416 "vshr.u8 d23, d23, #7 \n" /* A */ \ 423 "vshr.u8 d23, d23, #7 \n" /* A */ \
417 "vmovl.u8 q8, d20 \n" /* B */ \ 424 "vmovl.u8 q8, d20 \n" /* B */ \
418 "vmovl.u8 q9, d21 \n" /* G */ \ 425 "vmovl.u8 q9, d21 \n" /* G */ \
419 "vmovl.u8 q10, d22 \n" /* R */ \ 426 "vmovl.u8 q10, d22 \n" /* R */ \
420 "vmovl.u8 q11, d23 \n" /* A */ \ 427 "vmovl.u8 q11, d23 \n" /* A */ \
421 "vshl.u16 q9, q9, #5 \n" /* G */ \ 428 "vshl.u16 q9, q9, #5 \n" /* G */ \
422 "vshl.u16 q10, q10, #10 \n" /* R */ \ 429 "vshl.u16 q10, q10, #10 \n" /* R */ \
423 "vshl.u16 q11, q11, #15 \n" /* A */ \ 430 "vshl.u16 q11, q11, #15 \n" /* A */ \
424 "vorr q0, q8, q9 \n" /* BG */ \ 431 "vorr q0, q8, q9 \n" /* BG */ \
425 "vorr q1, q10, q11 \n" /* RA */ \ 432 "vorr q1, q10, q11 \n" /* RA */ \
426 "vorr q0, q0, q1 \n" /* BGRA */ 433 "vorr q0, q0, q1 \n" /* BGRA */
427 434
428 void I422ToARGB1555Row_NEON(const uint8* src_y, 435 void I422ToARGB1555Row_NEON(const uint8* src_y,
429 const uint8* src_u, 436 const uint8* src_u,
430 const uint8* src_v, 437 const uint8* src_v,
431 uint8* dst_argb1555, 438 uint8* dst_argb1555,
439 struct YuvConstants* yuvconstants,
432 int width) { 440 int width) {
433 asm volatile ( 441 asm volatile (
434 YUV422TORGB_SETUP_REG 442 YUVTORGB_SETUP
435 "1: \n" 443 "1: \n"
436 READYUV422 444 READYUV422
437 YUV422TORGB 445 YUVTORGB
438 "subs %4, %4, #8 \n" 446 "subs %4, %4, #8 \n"
439 "vmov.u8 d23, #255 \n" 447 "vmov.u8 d23, #255 \n"
440 ARGBTOARGB1555 448 ARGBTOARGB1555
441 MEMACCESS(3) 449 MEMACCESS(3)
442 "vst1.8 {q0}, [%3]! \n" // store 8 pixels ARGB1555. 450 "vst1.8 {q0}, [%3]! \n" // store 8 pixels ARGB1555.
443 "bgt 1b \n" 451 "bgt 1b \n"
444 : "+r"(src_y), // %0 452 : "+r"(src_y), // %0
445 "+r"(src_u), // %1 453 "+r"(src_u), // %1
446 "+r"(src_v), // %2 454 "+r"(src_v), // %2
447 "+r"(dst_argb1555), // %3 455 "+r"(dst_argb1555), // %3
448 "+r"(width) // %4 456 "+r"(width) // %4
449 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %5 457 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
450 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %6 458 [kUVToG]"r"(&yuvconstants->kUVToG),
451 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 459 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
452 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 460 [kYToRgb]"r"(&yuvconstants->kYToRgb)
453 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 461 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
454 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 462 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
455 ); 463 );
456 } 464 }
457 465
458 #define ARGBTOARGB4444 \ 466 #define ARGBTOARGB4444 \
459 "vshr.u8 d20, d20, #4 \n" /* B */ \ 467 "vshr.u8 d20, d20, #4 \n" /* B */ \
460 "vbic.32 d21, d21, d4 \n" /* G */ \ 468 "vbic.32 d21, d21, d4 \n" /* G */ \
461 "vshr.u8 d22, d22, #4 \n" /* R */ \ 469 "vshr.u8 d22, d22, #4 \n" /* R */ \
462 "vbic.32 d23, d23, d4 \n" /* A */ \ 470 "vbic.32 d23, d23, d4 \n" /* A */ \
463 "vorr d0, d20, d21 \n" /* BG */ \ 471 "vorr d0, d20, d21 \n" /* BG */ \
464 "vorr d1, d22, d23 \n" /* RA */ \ 472 "vorr d1, d22, d23 \n" /* RA */ \
465 "vzip.u8 d0, d1 \n" /* BGRA */ 473 "vzip.u8 d0, d1 \n" /* BGRA */
466 474
467 void I422ToARGB4444Row_NEON(const uint8* src_y, 475 void I422ToARGB4444Row_NEON(const uint8* src_y,
468 const uint8* src_u, 476 const uint8* src_u,
469 const uint8* src_v, 477 const uint8* src_v,
470 uint8* dst_argb4444, 478 uint8* dst_argb4444,
479 struct YuvConstants* yuvconstants,
471 int width) { 480 int width) {
472 asm volatile ( 481 asm volatile (
473 YUV422TORGB_SETUP_REG 482 YUVTORGB_SETUP
474 "vmov.u8 d4, #0x0f \n" // bits to clear with vbic. 483 "vmov.u8 d4, #0x0f \n" // bits to clear with vbic.
475 "1: \n" 484 "1: \n"
476 READYUV422 485 READYUV422
477 YUV422TORGB 486 YUVTORGB
478 "subs %4, %4, #8 \n" 487 "subs %4, %4, #8 \n"
479 "vmov.u8 d23, #255 \n" 488 "vmov.u8 d23, #255 \n"
480 ARGBTOARGB4444 489 ARGBTOARGB4444
481 MEMACCESS(3) 490 MEMACCESS(3)
482 "vst1.8 {q0}, [%3]! \n" // store 8 pixels ARGB4444. 491 "vst1.8 {q0}, [%3]! \n" // store 8 pixels ARGB4444.
483 "bgt 1b \n" 492 "bgt 1b \n"
484 : "+r"(src_y), // %0 493 : "+r"(src_y), // %0
485 "+r"(src_u), // %1 494 "+r"(src_u), // %1
486 "+r"(src_v), // %2 495 "+r"(src_v), // %2
487 "+r"(dst_argb4444), // %3 496 "+r"(dst_argb4444), // %3
488 "+r"(width) // %4 497 "+r"(width) // %4
489 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %5 498 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
490 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %6 499 [kUVToG]"r"(&yuvconstants->kUVToG),
491 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 500 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
492 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 501 [kYToRgb]"r"(&yuvconstants->kYToRgb)
493 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 502 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
494 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 503 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
495 ); 504 );
496 } 505 }
497 506
498 void I400ToARGBRow_NEON(const uint8* src_y, 507 void I400ToARGBRow_NEON(const uint8* src_y,
499 uint8* dst_argb, 508 uint8* dst_argb,
500 int width) { 509 int width) {
501 asm volatile ( 510 asm volatile (
502 YUV422TORGB_SETUP_REG 511 YUVTORGB_SETUP
503 "1: \n" 512 "1: \n"
504 READYUV400 513 READYUV400
505 YUV422TORGB 514 YUVTORGB
506 "subs %2, %2, #8 \n" 515 "subs %2, %2, #8 \n"
507 "vmov.u8 d23, #255 \n" 516 "vmov.u8 d23, #255 \n"
508 MEMACCESS(1) 517 MEMACCESS(1)
509 "vst4.8 {d20, d21, d22, d23}, [%1]! \n" 518 "vst4.8 {d20, d21, d22, d23}, [%1]! \n"
510 "bgt 1b \n" 519 "bgt 1b \n"
511 : "+r"(src_y), // %0 520 : "+r"(src_y), // %0
512 "+r"(dst_argb), // %1 521 "+r"(dst_argb), // %1
513 "+r"(width) // %2 522 "+r"(width) // %2
514 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %3 523 : [kUVToRB]"r"(&kYuvConstants.kUVToRB),
515 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %4 524 [kUVToG]"r"(&kYuvConstants.kUVToG),
516 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 525 [kUVBiasBGR]"r"(&kYuvConstants.kUVBiasBGR),
517 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 526 [kYToRgb]"r"(&kYuvConstants.kYToRgb)
518 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 527 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
519 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 528 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
520 ); 529 );
521 } 530 }
522 531
523 void J400ToARGBRow_NEON(const uint8* src_y, 532 void J400ToARGBRow_NEON(const uint8* src_y,
524 uint8* dst_argb, 533 uint8* dst_argb,
525 int width) { 534 int width) {
526 asm volatile ( 535 asm volatile (
527 "vmov.u8 d23, #255 \n" 536 "vmov.u8 d23, #255 \n"
(...skipping 10 matching lines...) Expand all
538 "+r"(dst_argb), // %1 547 "+r"(dst_argb), // %1
539 "+r"(width) // %2 548 "+r"(width) // %2
540 : 549 :
541 : "cc", "memory", "d20", "d21", "d22", "d23" 550 : "cc", "memory", "d20", "d21", "d22", "d23"
542 ); 551 );
543 } 552 }
544 553
545 void NV12ToARGBRow_NEON(const uint8* src_y, 554 void NV12ToARGBRow_NEON(const uint8* src_y,
546 const uint8* src_uv, 555 const uint8* src_uv,
547 uint8* dst_argb, 556 uint8* dst_argb,
557 struct YuvConstants* yuvconstants,
548 int width) { 558 int width) {
549 asm volatile ( 559 asm volatile (
550 YUV422TORGB_SETUP_REG 560 YUVTORGB_SETUP
551 "1: \n" 561 "1: \n"
552 READNV12 562 READNV12
553 YUV422TORGB 563 YUVTORGB
554 "subs %3, %3, #8 \n" 564 "subs %3, %3, #8 \n"
555 "vmov.u8 d23, #255 \n" 565 "vmov.u8 d23, #255 \n"
556 MEMACCESS(2) 566 MEMACCESS(2)
557 "vst4.8 {d20, d21, d22, d23}, [%2]! \n" 567 "vst4.8 {d20, d21, d22, d23}, [%2]! \n"
558 "bgt 1b \n" 568 "bgt 1b \n"
559 : "+r"(src_y), // %0 569 : "+r"(src_y), // %0
560 "+r"(src_uv), // %1 570 "+r"(src_uv), // %1
561 "+r"(dst_argb), // %2 571 "+r"(dst_argb), // %2
562 "+r"(width) // %3 572 "+r"(width) // %3
563 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %4 573 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
564 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %5 574 [kUVToG]"r"(&yuvconstants->kUVToG),
565 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 575 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
566 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 576 [kYToRgb]"r"(&yuvconstants->kYToRgb)
567 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 577 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
568 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 578 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
569 ); 579 );
570 }
571
572 void NV21ToARGBRow_NEON(const uint8* src_y,
573 const uint8* src_uv,
574 uint8* dst_argb,
575 int width) {
576 asm volatile (
577 YUV422TORGB_SETUP_REG
578 "1: \n"
579 READNV21
580 YUV422TORGB
581 "subs %3, %3, #8 \n"
582 "vmov.u8 d23, #255 \n"
583 MEMACCESS(2)
584 "vst4.8 {d20, d21, d22, d23}, [%2]! \n"
585 "bgt 1b \n"
586 : "+r"(src_y), // %0
587 "+r"(src_uv), // %1
588 "+r"(dst_argb), // %2
589 "+r"(width) // %3
590 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %4
591 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %5
592 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR),
593 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb)
594 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
595 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
596 );
597 } 580 }
598 581
599 void NV12ToRGB565Row_NEON(const uint8* src_y, 582 void NV12ToRGB565Row_NEON(const uint8* src_y,
600 const uint8* src_uv, 583 const uint8* src_uv,
601 uint8* dst_rgb565, 584 uint8* dst_rgb565,
585 struct YuvConstants* yuvconstants,
602 int width) { 586 int width) {
603 asm volatile ( 587 asm volatile (
604 YUV422TORGB_SETUP_REG 588 YUVTORGB_SETUP
605 "1: \n" 589 "1: \n"
606 READNV12 590 READNV12
607 YUV422TORGB 591 YUVTORGB
608 "subs %3, %3, #8 \n" 592 "subs %3, %3, #8 \n"
609 ARGBTORGB565 593 ARGBTORGB565
610 MEMACCESS(2) 594 MEMACCESS(2)
611 "vst1.8 {q0}, [%2]! \n" // store 8 pixels RGB565.
612 "bgt 1b \n"
613 : "+r"(src_y), // %0
614 "+r"(src_uv), // %1
615 "+r"(dst_rgb565), // %2
616 "+r"(width) // %3
617 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %4
618 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %5
619 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR),
620 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb)
621 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
622 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
623 );
624 }
625
626 void NV21ToRGB565Row_NEON(const uint8* src_y,
627 const uint8* src_uv,
628 uint8* dst_rgb565,
629 int width) {
630 asm volatile (
631 YUV422TORGB_SETUP_REG
632 "1: \n"
633 READNV21
634 YUV422TORGB
635 "subs %3, %3, #8 \n"
636 ARGBTORGB565
637 MEMACCESS(2)
638 "vst1.8 {q0}, [%2]! \n" // store 8 pixels RGB565. 595 "vst1.8 {q0}, [%2]! \n" // store 8 pixels RGB565.
639 "bgt 1b \n" 596 "bgt 1b \n"
640 : "+r"(src_y), // %0 597 : "+r"(src_y), // %0
641 "+r"(src_uv), // %1 598 "+r"(src_uv), // %1
642 "+r"(dst_rgb565), // %2 599 "+r"(dst_rgb565), // %2
643 "+r"(width) // %3 600 "+r"(width) // %3
644 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %4 601 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
645 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %5 602 [kUVToG]"r"(&yuvconstants->kUVToG),
646 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 603 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
647 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 604 [kYToRgb]"r"(&yuvconstants->kYToRgb)
648 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 605 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
649 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 606 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
650 ); 607 );
651 } 608 }
652 609
653 void YUY2ToARGBRow_NEON(const uint8* src_yuy2, 610 void YUY2ToARGBRow_NEON(const uint8* src_yuy2,
654 uint8* dst_argb, 611 uint8* dst_argb,
612 struct YuvConstants* yuvconstants,
655 int width) { 613 int width) {
656 asm volatile ( 614 asm volatile (
657 YUV422TORGB_SETUP_REG 615 YUVTORGB_SETUP
658 "1: \n" 616 "1: \n"
659 READYUY2 617 READYUY2
660 YUV422TORGB 618 YUVTORGB
661 "subs %2, %2, #8 \n" 619 "subs %2, %2, #8 \n"
662 "vmov.u8 d23, #255 \n" 620 "vmov.u8 d23, #255 \n"
663 MEMACCESS(1) 621 MEMACCESS(1)
664 "vst4.8 {d20, d21, d22, d23}, [%1]! \n" 622 "vst4.8 {d20, d21, d22, d23}, [%1]! \n"
665 "bgt 1b \n" 623 "bgt 1b \n"
666 : "+r"(src_yuy2), // %0 624 : "+r"(src_yuy2), // %0
667 "+r"(dst_argb), // %1 625 "+r"(dst_argb), // %1
668 "+r"(width) // %2 626 "+r"(width) // %2
669 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %3 627 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
670 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %4 628 [kUVToG]"r"(&yuvconstants->kUVToG),
671 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 629 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
672 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 630 [kYToRgb]"r"(&yuvconstants->kYToRgb)
673 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 631 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
674 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 632 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
675 ); 633 );
676 } 634 }
677 635
678 void UYVYToARGBRow_NEON(const uint8* src_uyvy, 636 void UYVYToARGBRow_NEON(const uint8* src_uyvy,
679 uint8* dst_argb, 637 uint8* dst_argb,
638 struct YuvConstants* yuvconstants,
680 int width) { 639 int width) {
681 asm volatile ( 640 asm volatile (
682 YUV422TORGB_SETUP_REG 641 YUVTORGB_SETUP
683 "1: \n" 642 "1: \n"
684 READUYVY 643 READUYVY
685 YUV422TORGB 644 YUVTORGB
686 "subs %2, %2, #8 \n" 645 "subs %2, %2, #8 \n"
687 "vmov.u8 d23, #255 \n" 646 "vmov.u8 d23, #255 \n"
688 MEMACCESS(1) 647 MEMACCESS(1)
689 "vst4.8 {d20, d21, d22, d23}, [%1]! \n" 648 "vst4.8 {d20, d21, d22, d23}, [%1]! \n"
690 "bgt 1b \n" 649 "bgt 1b \n"
691 : "+r"(src_uyvy), // %0 650 : "+r"(src_uyvy), // %0
692 "+r"(dst_argb), // %1 651 "+r"(dst_argb), // %1
693 "+r"(width) // %2 652 "+r"(width) // %2
694 : [kUVToRB]"r"(&kYuvConstantsNEON.kUVToRB), // %3 653 : [kUVToRB]"r"(&yuvconstants->kUVToRB),
695 [kUVToG]"r"(&kYuvConstantsNEON.kUVToG), // %4 654 [kUVToG]"r"(&yuvconstants->kUVToG),
696 [kUVBiasBGR]"r"(&kYuvConstantsNEON.kUVBiasBGR), 655 [kUVBiasBGR]"r"(&yuvconstants->kUVBiasBGR),
697 [kYToRgb]"r"(&kYuvConstantsNEON.kYToRgb) 656 [kYToRgb]"r"(&yuvconstants->kYToRgb)
698 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", 657 : "cc", "memory", "q0", "q1", "q2", "q3", "q4",
699 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 658 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
700 ); 659 );
701 } 660 }
702 661
703 // Reads 16 pairs of UV and write even values to dst_u and odd to dst_v. 662 // Reads 16 pairs of UV and write even values to dst_u and odd to dst_v.
704 void SplitUVRow_NEON(const uint8* src_uv, uint8* dst_u, uint8* dst_v, 663 void SplitUVRow_NEON(const uint8* src_uv, uint8* dst_u, uint8* dst_v,
705 int width) { 664 int width) {
706 asm volatile ( 665 asm volatile (
707 "1: \n" 666 "1: \n"
(...skipping 2256 matching lines...) Expand 10 before | Expand all | Expand 10 after
2964 "r"(6) // %5 2923 "r"(6) // %5
2965 : "cc", "memory", "q0", "q1" // Clobber List 2924 : "cc", "memory", "q0", "q1" // Clobber List
2966 ); 2925 );
2967 } 2926 }
2968 #endif // defined(__ARM_NEON__) && !defined(__aarch64__) 2927 #endif // defined(__ARM_NEON__) && !defined(__aarch64__)
2969 2928
2970 #ifdef __cplusplus 2929 #ifdef __cplusplus
2971 } // extern "C" 2930 } // extern "C"
2972 } // namespace libyuv 2931 } // namespace libyuv
2973 #endif 2932 #endif
OLDNEW
« no previous file with comments | « source/row_mips.cc ('k') | source/row_neon64.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698