The Tor Browser / file comparison
comparison: gfx/ycbcr/yuv_row_win.cpp
gfx/ycbcr/yuv_row_win.cpp
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:71a024d2d8aa |
|---|---|
| 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "yuv_row.h" | |
| 6 #include "mozilla/SSE.h" | |
| 7 | |
| 8 #define kCoefficientsRgbU kCoefficientsRgbY + 2048 | |
| 9 #define kCoefficientsRgbV kCoefficientsRgbY + 4096 | |
| 10 | |
| 11 extern "C" { | |
| 12 | |
| 13 #if defined(MOZILLA_MAY_SUPPORT_SSE) && defined(_M_IX86) | |
| 14 __declspec(naked) | |
| 15 void FastConvertYUVToRGB32Row_SSE(const uint8* y_buf, | |
| 16 const uint8* u_buf, | |
| 17 const uint8* v_buf, | |
| 18 uint8* rgb_buf, | |
| 19 int width) { | |
| 20 __asm { | |
| 21 pushad | |
| 22 mov edx, [esp + 32 + 4] // Y | |
| 23 mov edi, [esp + 32 + 8] // U | |
| 24 mov esi, [esp + 32 + 12] // V | |
| 25 mov ebp, [esp + 32 + 16] // rgb | |
| 26 mov ecx, [esp + 32 + 20] // width | |
| 27 jmp convertend | |
| 28 | |
| 29 convertloop : | |
| 30 movzx eax, byte ptr [edi] | |
| 31 add edi, 1 | |
| 32 movzx ebx, byte ptr [esi] | |
| 33 add esi, 1 | |
| 34 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 35 movzx eax, byte ptr [edx] | |
| 36 paddsw mm0, [kCoefficientsRgbV + 8 * ebx] | |
| 37 movzx ebx, byte ptr [edx + 1] | |
| 38 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 39 add edx, 2 | |
| 40 movq mm2, [kCoefficientsRgbY + 8 * ebx] | |
| 41 paddsw mm1, mm0 | |
| 42 paddsw mm2, mm0 | |
| 43 psraw mm1, 6 | |
| 44 psraw mm2, 6 | |
| 45 packuswb mm1, mm2 | |
| 46 movntq [ebp], mm1 | |
| 47 add ebp, 8 | |
| 48 convertend : | |
| 49 sub ecx, 2 | |
| 50 jns convertloop | |
| 51 | |
| 52 and ecx, 1 // odd number of pixels? | |
| 53 jz convertdone | |
| 54 | |
| 55 movzx eax, byte ptr [edi] | |
| 56 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 57 movzx eax, byte ptr [esi] | |
| 58 paddsw mm0, [kCoefficientsRgbV + 8 * eax] | |
| 59 movzx eax, byte ptr [edx] | |
| 60 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 61 paddsw mm1, mm0 | |
| 62 psraw mm1, 6 | |
| 63 packuswb mm1, mm1 | |
| 64 movd [ebp], mm1 | |
| 65 convertdone : | |
| 66 | |
| 67 popad | |
| 68 ret | |
| 69 } | |
| 70 } | |
| 71 | |
| 72 __declspec(naked) | |
| 73 void ConvertYUVToRGB32Row_SSE(const uint8* y_buf, | |
| 74 const uint8* u_buf, | |
| 75 const uint8* v_buf, | |
| 76 uint8* rgb_buf, | |
| 77 int width, | |
| 78 int step) { | |
| 79 __asm { | |
| 80 pushad | |
| 81 mov edx, [esp + 32 + 4] // Y | |
| 82 mov edi, [esp + 32 + 8] // U | |
| 83 mov esi, [esp + 32 + 12] // V | |
| 84 mov ebp, [esp + 32 + 16] // rgb | |
| 85 mov ecx, [esp + 32 + 20] // width | |
| 86 mov ebx, [esp + 32 + 24] // step | |
| 87 jmp wend | |
| 88 | |
| 89 wloop : | |
| 90 movzx eax, byte ptr [edi] | |
| 91 add edi, ebx | |
| 92 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 93 movzx eax, byte ptr [esi] | |
| 94 add esi, ebx | |
| 95 paddsw mm0, [kCoefficientsRgbV + 8 * eax] | |
| 96 movzx eax, byte ptr [edx] | |
| 97 add edx, ebx | |
| 98 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 99 movzx eax, byte ptr [edx] | |
| 100 add edx, ebx | |
| 101 movq mm2, [kCoefficientsRgbY + 8 * eax] | |
| 102 paddsw mm1, mm0 | |
| 103 paddsw mm2, mm0 | |
| 104 psraw mm1, 6 | |
| 105 psraw mm2, 6 | |
| 106 packuswb mm1, mm2 | |
| 107 movntq [ebp], mm1 | |
| 108 add ebp, 8 | |
| 109 wend : | |
| 110 sub ecx, 2 | |
| 111 jns wloop | |
| 112 | |
| 113 and ecx, 1 // odd number of pixels? | |
| 114 jz wdone | |
| 115 | |
| 116 movzx eax, byte ptr [edi] | |
| 117 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 118 movzx eax, byte ptr [esi] | |
| 119 paddsw mm0, [kCoefficientsRgbV + 8 * eax] | |
| 120 movzx eax, byte ptr [edx] | |
| 121 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 122 paddsw mm1, mm0 | |
| 123 psraw mm1, 6 | |
| 124 packuswb mm1, mm1 | |
| 125 movd [ebp], mm1 | |
| 126 wdone : | |
| 127 | |
| 128 popad | |
| 129 ret | |
| 130 } | |
| 131 } | |
| 132 | |
| 133 __declspec(naked) | |
| 134 void RotateConvertYUVToRGB32Row_SSE(const uint8* y_buf, | |
| 135 const uint8* u_buf, | |
| 136 const uint8* v_buf, | |
| 137 uint8* rgb_buf, | |
| 138 int width, | |
| 139 int ystep, | |
| 140 int uvstep) { | |
| 141 __asm { | |
| 142 pushad | |
| 143 mov edx, [esp + 32 + 4] // Y | |
| 144 mov edi, [esp + 32 + 8] // U | |
| 145 mov esi, [esp + 32 + 12] // V | |
| 146 mov ebp, [esp + 32 + 16] // rgb | |
| 147 mov ecx, [esp + 32 + 20] // width | |
| 148 jmp wend | |
| 149 | |
| 150 wloop : | |
| 151 movzx eax, byte ptr [edi] | |
| 152 mov ebx, [esp + 32 + 28] // uvstep | |
| 153 add edi, ebx | |
| 154 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 155 movzx eax, byte ptr [esi] | |
| 156 add esi, ebx | |
| 157 paddsw mm0, [kCoefficientsRgbV + 8 * eax] | |
| 158 movzx eax, byte ptr [edx] | |
| 159 mov ebx, [esp + 32 + 24] // ystep | |
| 160 add edx, ebx | |
| 161 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 162 movzx eax, byte ptr [edx] | |
| 163 add edx, ebx | |
| 164 movq mm2, [kCoefficientsRgbY + 8 * eax] | |
| 165 paddsw mm1, mm0 | |
| 166 paddsw mm2, mm0 | |
| 167 psraw mm1, 6 | |
| 168 psraw mm2, 6 | |
| 169 packuswb mm1, mm2 | |
| 170 movntq [ebp], mm1 | |
| 171 add ebp, 8 | |
| 172 wend : | |
| 173 sub ecx, 2 | |
| 174 jns wloop | |
| 175 | |
| 176 and ecx, 1 // odd number of pixels? | |
| 177 jz wdone | |
| 178 | |
| 179 movzx eax, byte ptr [edi] | |
| 180 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 181 movzx eax, byte ptr [esi] | |
| 182 paddsw mm0, [kCoefficientsRgbV + 8 * eax] | |
| 183 movzx eax, byte ptr [edx] | |
| 184 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 185 paddsw mm1, mm0 | |
| 186 psraw mm1, 6 | |
| 187 packuswb mm1, mm1 | |
| 188 movd [ebp], mm1 | |
| 189 wdone : | |
| 190 | |
| 191 popad | |
| 192 ret | |
| 193 } | |
| 194 } | |
| 195 | |
| 196 __declspec(naked) | |
| 197 void DoubleYUVToRGB32Row_SSE(const uint8* y_buf, | |
| 198 const uint8* u_buf, | |
| 199 const uint8* v_buf, | |
| 200 uint8* rgb_buf, | |
| 201 int width) { | |
| 202 __asm { | |
| 203 pushad | |
| 204 mov edx, [esp + 32 + 4] // Y | |
| 205 mov edi, [esp + 32 + 8] // U | |
| 206 mov esi, [esp + 32 + 12] // V | |
| 207 mov ebp, [esp + 32 + 16] // rgb | |
| 208 mov ecx, [esp + 32 + 20] // width | |
| 209 jmp wend | |
| 210 | |
| 211 wloop : | |
| 212 movzx eax, byte ptr [edi] | |
| 213 add edi, 1 | |
| 214 movzx ebx, byte ptr [esi] | |
| 215 add esi, 1 | |
| 216 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 217 movzx eax, byte ptr [edx] | |
| 218 paddsw mm0, [kCoefficientsRgbV + 8 * ebx] | |
| 219 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 220 paddsw mm1, mm0 | |
| 221 psraw mm1, 6 | |
| 222 packuswb mm1, mm1 | |
| 223 punpckldq mm1, mm1 | |
| 224 movntq [ebp], mm1 | |
| 225 | |
| 226 movzx ebx, byte ptr [edx + 1] | |
| 227 add edx, 2 | |
| 228 paddsw mm0, [kCoefficientsRgbY + 8 * ebx] | |
| 229 psraw mm0, 6 | |
| 230 packuswb mm0, mm0 | |
| 231 punpckldq mm0, mm0 | |
| 232 movntq [ebp+8], mm0 | |
| 233 add ebp, 16 | |
| 234 wend : | |
| 235 sub ecx, 4 | |
| 236 jns wloop | |
| 237 | |
| 238 add ecx, 4 | |
| 239 jz wdone | |
| 240 | |
| 241 movzx eax, byte ptr [edi] | |
| 242 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 243 movzx eax, byte ptr [esi] | |
| 244 paddsw mm0, [kCoefficientsRgbV + 8 * eax] | |
| 245 movzx eax, byte ptr [edx] | |
| 246 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 247 paddsw mm1, mm0 | |
| 248 psraw mm1, 6 | |
| 249 packuswb mm1, mm1 | |
| 250 jmp wend1 | |
| 251 | |
| 252 wloop1 : | |
| 253 movd [ebp], mm1 | |
| 254 add ebp, 4 | |
| 255 wend1 : | |
| 256 sub ecx, 1 | |
| 257 jns wloop1 | |
| 258 wdone : | |
| 259 popad | |
| 260 ret | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 // This version does general purpose scaling by any amount, up or down. | |
| 265 // The only thing it cannot do is rotation by 90 or 270. | |
| 266 // For performance the chroma is under-sampled, reducing cost of a 3x | |
| 267 // 1080p scale from 8.4 ms to 5.4 ms. | |
| 268 __declspec(naked) | |
| 269 void ScaleYUVToRGB32Row_SSE(const uint8* y_buf, | |
| 270 const uint8* u_buf, | |
| 271 const uint8* v_buf, | |
| 272 uint8* rgb_buf, | |
| 273 int width, | |
| 274 int source_dx) { | |
| 275 __asm { | |
| 276 pushad | |
| 277 mov edx, [esp + 32 + 4] // Y | |
| 278 mov edi, [esp + 32 + 8] // U | |
| 279 mov esi, [esp + 32 + 12] // V | |
| 280 mov ebp, [esp + 32 + 16] // rgb | |
| 281 mov ecx, [esp + 32 + 20] // width | |
| 282 xor ebx, ebx // x | |
| 283 jmp scaleend | |
| 284 | |
| 285 scaleloop : | |
| 286 mov eax, ebx | |
| 287 sar eax, 17 | |
| 288 movzx eax, byte ptr [edi + eax] | |
| 289 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 290 mov eax, ebx | |
| 291 sar eax, 17 | |
| 292 movzx eax, byte ptr [esi + eax] | |
| 293 paddsw mm0, [kCoefficientsRgbV + 8 * eax] | |
| 294 mov eax, ebx | |
| 295 add ebx, [esp + 32 + 24] // x += source_dx | |
| 296 sar eax, 16 | |
| 297 movzx eax, byte ptr [edx + eax] | |
| 298 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 299 mov eax, ebx | |
| 300 add ebx, [esp + 32 + 24] // x += source_dx | |
| 301 sar eax, 16 | |
| 302 movzx eax, byte ptr [edx + eax] | |
| 303 movq mm2, [kCoefficientsRgbY + 8 * eax] | |
| 304 paddsw mm1, mm0 | |
| 305 paddsw mm2, mm0 | |
| 306 psraw mm1, 6 | |
| 307 psraw mm2, 6 | |
| 308 packuswb mm1, mm2 | |
| 309 movntq [ebp], mm1 | |
| 310 add ebp, 8 | |
| 311 scaleend : | |
| 312 sub ecx, 2 | |
| 313 jns scaleloop | |
| 314 | |
| 315 and ecx, 1 // odd number of pixels? | |
| 316 jz scaledone | |
| 317 | |
| 318 mov eax, ebx | |
| 319 sar eax, 17 | |
| 320 movzx eax, byte ptr [edi + eax] | |
| 321 movq mm0, [kCoefficientsRgbU + 8 * eax] | |
| 322 mov eax, ebx | |
| 323 sar eax, 17 | |
| 324 movzx eax, byte ptr [esi + eax] | |
| 325 paddsw mm0, [kCoefficientsRgbV + 8 * eax] | |
| 326 mov eax, ebx | |
| 327 sar eax, 16 | |
| 328 movzx eax, byte ptr [edx + eax] | |
| 329 movq mm1, [kCoefficientsRgbY + 8 * eax] | |
| 330 paddsw mm1, mm0 | |
| 331 psraw mm1, 6 | |
| 332 packuswb mm1, mm1 | |
| 333 movd [ebp], mm1 | |
| 334 | |
| 335 scaledone : | |
| 336 popad | |
| 337 ret | |
| 338 } | |
| 339 } | |
| 340 | |
| 341 __declspec(naked) | |
| 342 void LinearScaleYUVToRGB32Row_SSE(const uint8* y_buf, | |
| 343 const uint8* u_buf, | |
| 344 const uint8* v_buf, | |
| 345 uint8* rgb_buf, | |
| 346 int width, | |
| 347 int source_dx) { | |
| 348 __asm { | |
| 349 pushad | |
| 350 mov edx, [esp + 32 + 4] // Y | |
| 351 mov edi, [esp + 32 + 8] // U | |
| 352 // [esp + 32 + 12] // V | |
| 353 mov ebp, [esp + 32 + 16] // rgb | |
| 354 mov ecx, [esp + 32 + 20] // width | |
| 355 imul ecx, [esp + 32 + 24] // source_dx | |
| 356 mov [esp + 32 + 20], ecx // source_width = width * source_dx | |
| 357 mov ecx, [esp + 32 + 24] // source_dx | |
| 358 xor ebx, ebx // x = 0 | |
| 359 cmp ecx, 0x20000 | |
| 360 jl lscaleend | |
| 361 mov ebx, 0x8000 // x = 0.5 for 1/2 or less | |
| 362 jmp lscaleend | |
| 363 lscaleloop: | |
| 364 mov eax, ebx | |
| 365 sar eax, 0x11 | |
| 366 | |
| 367 movzx ecx, byte ptr [edi + eax] | |
| 368 movzx esi, byte ptr [edi + eax + 1] | |
| 369 mov eax, ebx | |
| 370 and eax, 0x1fffe | |
| 371 imul esi, eax | |
| 372 xor eax, 0x1fffe | |
| 373 imul ecx, eax | |
| 374 add ecx, esi | |
| 375 shr ecx, 17 | |
| 376 movq mm0, [kCoefficientsRgbU + 8 * ecx] | |
| 377 | |
| 378 mov esi, [esp + 32 + 12] | |
| 379 mov eax, ebx | |
| 380 sar eax, 0x11 | |
| 381 | |
| 382 movzx ecx, byte ptr [esi + eax] | |
| 383 movzx esi, byte ptr [esi + eax + 1] | |
| 384 mov eax, ebx | |
| 385 and eax, 0x1fffe | |
| 386 imul esi, eax | |
| 387 xor eax, 0x1fffe | |
| 388 imul ecx, eax | |
| 389 add ecx, esi | |
| 390 shr ecx, 17 | |
| 391 paddsw mm0, [kCoefficientsRgbV + 8 * ecx] | |
| 392 | |
| 393 mov eax, ebx | |
| 394 sar eax, 0x10 | |
| 395 movzx ecx, byte ptr [edx + eax] | |
| 396 movzx esi, byte ptr [1 + edx + eax] | |
| 397 mov eax, ebx | |
| 398 add ebx, [esp + 32 + 24] | |
| 399 and eax, 0xffff | |
| 400 imul esi, eax | |
| 401 xor eax, 0xffff | |
| 402 imul ecx, eax | |
| 403 add ecx, esi | |
| 404 shr ecx, 16 | |
| 405 movq mm1, [kCoefficientsRgbY + 8 * ecx] | |
| 406 | |
| 407 cmp ebx, [esp + 32 + 20] | |
| 408 jge lscalelastpixel | |
| 409 | |
| 410 mov eax, ebx | |
| 411 sar eax, 0x10 | |
| 412 movzx ecx, byte ptr [edx + eax] | |
| 413 movzx esi, byte ptr [edx + eax + 1] | |
| 414 mov eax, ebx | |
| 415 add ebx, [esp + 32 + 24] | |
| 416 and eax, 0xffff | |
| 417 imul esi, eax | |
| 418 xor eax, 0xffff | |
| 419 imul ecx, eax | |
| 420 add ecx, esi | |
| 421 shr ecx, 16 | |
| 422 movq mm2, [kCoefficientsRgbY + 8 * ecx] | |
| 423 | |
| 424 paddsw mm1, mm0 | |
| 425 paddsw mm2, mm0 | |
| 426 psraw mm1, 0x6 | |
| 427 psraw mm2, 0x6 | |
| 428 packuswb mm1, mm2 | |
| 429 movntq [ebp], mm1 | |
| 430 add ebp, 0x8 | |
| 431 | |
| 432 lscaleend: | |
| 433 cmp ebx, [esp + 32 + 20] | |
| 434 jl lscaleloop | |
| 435 popad | |
| 436 ret | |
| 437 | |
| 438 lscalelastpixel: | |
| 439 paddsw mm1, mm0 | |
| 440 psraw mm1, 6 | |
| 441 packuswb mm1, mm1 | |
| 442 movd [ebp], mm1 | |
| 443 popad | |
| 444 ret | |
| 445 }; | |
| 446 } | |
| 447 #endif // if defined(MOZILLA_MAY_SUPPORT_SSE) && defined(_M_IX86) | |
| 448 | |
| 449 void FastConvertYUVToRGB32Row(const uint8* y_buf, | |
| 450 const uint8* u_buf, | |
| 451 const uint8* v_buf, | |
| 452 uint8* rgb_buf, | |
| 453 int width) { | |
| 454 #if defined(MOZILLA_MAY_SUPPORT_SSE) && defined(_M_IX86) | |
| 455 if (mozilla::supports_sse()) { | |
| 456 FastConvertYUVToRGB32Row_SSE(y_buf, u_buf, v_buf, rgb_buf, width); | |
| 457 return; | |
| 458 } | |
| 459 #endif | |
| 460 | |
| 461 FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width, 1); | |
| 462 } | |
| 463 | |
| 464 void ScaleYUVToRGB32Row(const uint8* y_buf, | |
| 465 const uint8* u_buf, | |
| 466 const uint8* v_buf, | |
| 467 uint8* rgb_buf, | |
| 468 int width, | |
| 469 int source_dx) { | |
| 470 | |
| 471 #if defined(MOZILLA_MAY_SUPPORT_SSE) && defined(_M_IX86) | |
| 472 if (mozilla::supports_sse()) { | |
| 473 ScaleYUVToRGB32Row_SSE(y_buf, u_buf, v_buf, rgb_buf, width, source_dx); | |
| 474 return; | |
| 475 } | |
| 476 #endif | |
| 477 | |
| 478 ScaleYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width, source_dx); | |
| 479 } | |
| 480 | |
| 481 void LinearScaleYUVToRGB32Row(const uint8* y_buf, | |
| 482 const uint8* u_buf, | |
| 483 const uint8* v_buf, | |
| 484 uint8* rgb_buf, | |
| 485 int width, | |
| 486 int source_dx) { | |
| 487 #if defined(MOZILLA_MAY_SUPPORT_SSE) && defined(_M_IX86) | |
| 488 if (mozilla::supports_sse()) { | |
| 489 LinearScaleYUVToRGB32Row_SSE(y_buf, u_buf, v_buf, rgb_buf, width, | |
| 490 source_dx); | |
| 491 return; | |
| 492 } | |
| 493 #endif | |
| 494 | |
| 495 LinearScaleYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width, source_dx); | |
| 496 } | |
| 497 | |
| 498 } // extern "C" |
