OLD | NEW |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 |
OLD | NEW |