Mercurial > sdl-ios-xcode

comparison src/video/win32/SDL_d3drender.c @ 2973:ab0c00f1b070

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Improved Direct3D YUV texture support
author Sam Lantinga <slouken@libsdl.org>
date Sat, 03 Jan 2009 05:42:18 +0000
parents 0a4b70368372
children 502adab079a4
comparison
equal deleted inserted replaced
2972:0a4b70368372 2973:ab0c00f1b070
22 #include "SDL_config.h" 22 #include "SDL_config.h"
23 23
24 #if SDL_VIDEO_RENDER_D3D 24 #if SDL_VIDEO_RENDER_D3D
25 25
26 #include "SDL_win32video.h" 26 #include "SDL_win32video.h"
27 #include "../SDL_yuv_sw_c.h"
27 28
28 /* Direct3D renderer implementation */ 29 /* Direct3D renderer implementation */
29 30
30 #if 1 /* This takes more memory but you won't lose your texture data */ 31 #if 1 /* This takes more memory but you won't lose your texture data */
31 #define D3DPOOL_SDL D3DPOOL_MANAGED 32 #define D3DPOOL_SDL D3DPOOL_MANAGED
36 #endif 37 #endif
37 38
38 static SDL_Renderer *D3D_CreateRenderer(SDL_Window * window, Uint32 flags); 39 static SDL_Renderer *D3D_CreateRenderer(SDL_Window * window, Uint32 flags);
39 static int D3D_DisplayModeChanged(SDL_Renderer * renderer); 40 static int D3D_DisplayModeChanged(SDL_Renderer * renderer);
40 static int D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture); 41 static int D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
42 static int D3D_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture, void **pixels, int *pitch);
41 static int D3D_SetTexturePalette(SDL_Renderer * renderer, 43 static int D3D_SetTexturePalette(SDL_Renderer * renderer,
42 SDL_Texture * texture, 44 SDL_Texture * texture,
43 const SDL_Color * colors, int firstcolor, 45 const SDL_Color * colors, int firstcolor,
44 int ncolors); 46 int ncolors);
45 static int D3D_GetTexturePalette(SDL_Renderer * renderer, 47 static int D3D_GetTexturePalette(SDL_Renderer * renderer,
94 0} 96 0}
95 }; 97 };
96 98
97 typedef struct 99 typedef struct
98 { 100 {
101 IDirect3D9 *d3d;
99 IDirect3DDevice9 *device; 102 IDirect3DDevice9 *device;
100 D3DPRESENT_PARAMETERS pparams; 103 D3DPRESENT_PARAMETERS pparams;
101 SDL_bool beginScene; 104 SDL_bool beginScene;
102 } D3D_RenderData; 105 } D3D_RenderData;
103 106
104 typedef struct 107 typedef struct
105 { 108 {
109 SDL_SW_YUVTexture *yuv;
110 Uint32 format;
106 IDirect3DTexture9 *texture; 111 IDirect3DTexture9 *texture;
107 } D3D_TextureData; 112 } D3D_TextureData;
108 113
109 typedef struct 114 typedef struct
110 { 115 {
224 default: 229 default:
225 return D3DFMT_UNKNOWN; 230 return D3DFMT_UNKNOWN;
226 } 231 }
227 } 232 }
228 233
234 static SDL_bool
235 D3D_IsTextureFormatAvailable(IDirect3D9 *d3d, Uint32 display_format, Uint32 texture_format)
236 {
237 HRESULT result;
238
239 result = IDirect3D9_CheckDeviceFormat(d3d,
240 D3DADAPTER_DEFAULT, /* FIXME */
241 D3DDEVTYPE_HAL,
242 PixelFormatToD3DFMT(display_format),
243 0,
244 D3DRTYPE_TEXTURE,
245 PixelFormatToD3DFMT(texture_format));
246 return FAILED(result) ? SDL_FALSE : SDL_TRUE;
247 }
248
249 static void
250 UpdateYUVTextureData(SDL_Texture * texture)
251 {
252 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
253 SDL_Rect rect;
254 RECT d3drect;
255 D3DLOCKED_RECT locked;
256 HRESULT result;
257
258 d3drect.left = 0;
259 d3drect.right = texture->w;
260 d3drect.top = 0;
261 d3drect.bottom = texture->h;
262
263 result = IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect, 0);
264 if (FAILED(result)) {
265 return;
266 }
267
268 rect.x = 0;
269 rect.y = 0;
270 rect.w = texture->w;
271 rect.h = texture->h;
272 SDL_SW_CopyYUVToRGB(data->yuv, &rect, data->format, texture->w,
273 texture->h, locked.pBits, locked.Pitch);
274
275 IDirect3DTexture9_UnlockRect(data->texture, 0);
276 }
277
229 void 278 void
230 D3D_AddRenderDriver(_THIS) 279 D3D_AddRenderDriver(_THIS)
231 { 280 {
232 SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; 281 SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
233 SDL_RendererInfo *info = &D3D_RenderDriver.info; 282 SDL_RendererInfo *info = &D3D_RenderDriver.info;
244 SDL_PIXELFORMAT_ARGB1555, 293 SDL_PIXELFORMAT_ARGB1555,
245 SDL_PIXELFORMAT_RGB565, 294 SDL_PIXELFORMAT_RGB565,
246 SDL_PIXELFORMAT_RGB888, 295 SDL_PIXELFORMAT_RGB888,
247 SDL_PIXELFORMAT_ARGB8888, 296 SDL_PIXELFORMAT_ARGB8888,
248 SDL_PIXELFORMAT_ARGB2101010, 297 SDL_PIXELFORMAT_ARGB2101010,
249 SDL_PIXELFORMAT_YUY2,
250 SDL_PIXELFORMAT_UYVY,
251 }; 298 };
252 HRESULT result;
253 299
254 for (i = 0; i < SDL_arraysize(formats); ++i) { 300 for (i = 0; i < SDL_arraysize(formats); ++i) {
255 result = IDirect3D9_CheckDeviceFormat(data->d3d, 301 if (D3D_IsTextureFormatAvailable(data->d3d, mode->format, formats[i])) {
256 D3DADAPTER_DEFAULT, /* FIXME */
257 D3DDEVTYPE_HAL,
258 PixelFormatToD3DFMT(mode->format),
259 0,
260 D3DRTYPE_TEXTURE,
261 PixelFormatToD3DFMT(formats[i]));
262 if (!FAILED(result)) {
263 info->texture_formats[info->num_texture_formats++] = formats[i]; 302 info->texture_formats[info->num_texture_formats++] = formats[i];
264 } 303 }
265 } 304 }
305 info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_YV12;
306 info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_IYUV;
307 info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_YUY2;
308 info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_UYVY;
309 info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_YVYU;
266 310
267 SDL_AddRenderDriver(0, &D3D_RenderDriver); 311 SDL_AddRenderDriver(0, &D3D_RenderDriver);
268 } 312 }
269 } 313 }
270 314
291 if (!data) { 335 if (!data) {
292 D3D_DestroyRenderer(renderer); 336 D3D_DestroyRenderer(renderer);
293 SDL_OutOfMemory(); 337 SDL_OutOfMemory();
294 return NULL; 338 return NULL;
295 } 339 }
340 data->d3d = videodata->d3d;
296 341
297 renderer->DisplayModeChanged = D3D_DisplayModeChanged; 342 renderer->DisplayModeChanged = D3D_DisplayModeChanged;
298 renderer->CreateTexture = D3D_CreateTexture; 343 renderer->CreateTexture = D3D_CreateTexture;
344 renderer->QueryTexturePixels = D3D_QueryTexturePixels;
299 renderer->SetTexturePalette = D3D_SetTexturePalette; 345 renderer->SetTexturePalette = D3D_SetTexturePalette;
300 renderer->GetTexturePalette = D3D_GetTexturePalette; 346 renderer->GetTexturePalette = D3D_GetTexturePalette;
301 renderer->SetTextureColorMod = D3D_SetTextureColorMod; 347 renderer->SetTextureColorMod = D3D_SetTextureColorMod;
302 renderer->SetTextureAlphaMod = D3D_SetTextureAlphaMod; 348 renderer->SetTextureAlphaMod = D3D_SetTextureAlphaMod;
303 renderer->SetTextureBlendMode = D3D_SetTextureBlendMode; 349 renderer->SetTextureBlendMode = D3D_SetTextureBlendMode;
487 D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) 533 D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
488 { 534 {
489 D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata; 535 D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;
490 SDL_Window *window = SDL_GetWindowFromID(renderer->window); 536 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
491 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); 537 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
538 Uint32 display_format = display->current_mode.format;
492 D3D_TextureData *data; 539 D3D_TextureData *data;
493 HRESULT result; 540 HRESULT result;
494 541
495 data = (D3D_TextureData *) SDL_calloc(1, sizeof(*data)); 542 data = (D3D_TextureData *) SDL_calloc(1, sizeof(*data));
496 if (!data) { 543 if (!data) {
498 return -1; 545 return -1;
499 } 546 }
500 547
501 texture->driverdata = data; 548 texture->driverdata = data;
502 549
550 if (SDL_ISPIXELFORMAT_FOURCC(texture->format) &&
551 (texture->format != SDL_PIXELFORMAT_YUY2 ||
552 !D3D_IsTextureFormatAvailable(renderdata->d3d, display_format, texture->format)) &&
553 (texture->format != SDL_PIXELFORMAT_YVYU ||
554 !D3D_IsTextureFormatAvailable(renderdata->d3d, display_format, texture->format))) {
555 data->yuv =
556 SDL_SW_CreateYUVTexture(texture->format, texture->w, texture->h);
557 if (!data->yuv) {
558 return -1;
559 }
560 data->format = display->current_mode.format;
561 } else {
562 data->format = texture->format;
563 }
564
503 result = 565 result =
504 IDirect3DDevice9_CreateTexture(renderdata->device, texture->w, 566 IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,
505 texture->h, 1, 0, 567 texture->h, 1, 0,
506 PixelFormatToD3DFMT(texture->format), 568 PixelFormatToD3DFMT(data->format),
507 D3DPOOL_SDL, &data->texture, NULL); 569 D3DPOOL_SDL, &data->texture, NULL);
508 if (FAILED(result)) { 570 if (FAILED(result)) {
509 D3D_SetError("CreateTexture()", result); 571 D3D_SetError("CreateTexture()", result);
510 return -1; 572 return -1;
511 } 573 }
512 574
513 return 0; 575 return 0;
576 }
577
578 static int
579 D3D_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
580 void **pixels, int *pitch)
581 {
582 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
583
584 if (data->yuv) {
585 return SDL_SW_QueryYUVTexturePixels(data->yuv, pixels, pitch);
586 } else {
587 /* D3D textures don't have their pixels hanging out */
588 return -1;
589 }
514 } 590 }
515 591
516 static int 592 static int
517 D3D_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, 593 D3D_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
518 const SDL_Color * colors, int firstcolor, int ncolors) 594 const SDL_Color * colors, int firstcolor, int ncolors)
576 return -1; 652 return -1;
577 } 653 }
578 return 0; 654 return 0;
579 } 655 }
580 656
581 #ifdef SDL_MEMORY_POOL_DEFAULT
582 static int 657 static int
583 D3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, 658 D3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
584 const SDL_Rect * rect, const void *pixels, int pitch) 659 const SDL_Rect * rect, const void *pixels, int pitch)
585 { 660 {
586 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata; 661 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
587 D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata; 662 D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;
588 IDirect3DTexture9 *temp; 663
589 RECT d3drect; 664 if (data->yuv) {
590 D3DLOCKED_RECT locked; 665 if (SDL_SW_UpdateYUVTexture(data->yuv, rect, pixels, pitch) < 0) {
591 const Uint8 *src; 666 return -1;
592 Uint8 *dst; 667 }
593 int row, length; 668 UpdateYUVTextureData(texture);
594 HRESULT result; 669 return 0;
595 670 } else {
596 result = 671 #ifdef SDL_MEMORY_POOL_DEFAULT
597 IDirect3DDevice9_CreateTexture(renderdata->device, texture->w, 672 IDirect3DTexture9 *temp;
598 texture->h, 1, 0, 673 RECT d3drect;
599 PixelFormatToD3DFMT(texture->format), 674 D3DLOCKED_RECT locked;
600 D3DPOOL_SYSTEMMEM, &temp, NULL); 675 const Uint8 *src;
601 if (FAILED(result)) { 676 Uint8 *dst;
602 D3D_SetError("CreateTexture()", result); 677 int row, length;
603 return -1; 678 HRESULT result;
604 } 679
605 680 result =
606 d3drect.left = rect->x; 681 IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,
607 d3drect.right = rect->x + rect->w; 682 texture->h, 1, 0,
608 d3drect.top = rect->y; 683 PixelFormatToD3DFMT(texture->format),
609 d3drect.bottom = rect->y + rect->h; 684 D3DPOOL_SYSTEMMEM, &temp, NULL);
610 685 if (FAILED(result)) {
611 result = IDirect3DTexture9_LockRect(temp, 0, &locked, &d3drect, 0); 686 D3D_SetError("CreateTexture()", result);
612 if (FAILED(result)) { 687 return -1;
688 }
689
690 d3drect.left = rect->x;
691 d3drect.right = rect->x + rect->w;
692 d3drect.top = rect->y;
693 d3drect.bottom = rect->y + rect->h;
694
695 result = IDirect3DTexture9_LockRect(temp, 0, &locked, &d3drect, 0);
696 if (FAILED(result)) {
697 IDirect3DTexture9_Release(temp);
698 D3D_SetError("LockRect()", result);
699 return -1;
700 }
701
702 src = pixels;
703 dst = locked.pBits;
704 length = rect->w * SDL_BYTESPERPIXEL(texture->format);
705 for (row = 0; row < rect->h; ++row) {
706 SDL_memcpy(dst, src, length);
707 src += pitch;
708 dst += locked.Pitch;
709 }
710 IDirect3DTexture9_UnlockRect(temp, 0);
711
712 result =
713 IDirect3DDevice9_UpdateTexture(renderdata->device,
714 (IDirect3DBaseTexture9 *) temp,
715 (IDirect3DBaseTexture9 *)
716 data->texture);
613 IDirect3DTexture9_Release(temp); 717 IDirect3DTexture9_Release(temp);
614 D3D_SetError("LockRect()", result); 718 if (FAILED(result)) {
615 return -1; 719 D3D_SetError("UpdateTexture()", result);
616 } 720 return -1;
617 721 }
618 src = pixels;
619 dst = locked.pBits;
620 length = rect->w * SDL_BYTESPERPIXEL(texture->format);
621 for (row = 0; row < rect->h; ++row) {
622 SDL_memcpy(dst, src, length);
623 src += pitch;
624 dst += locked.Pitch;
625 }
626 IDirect3DTexture9_UnlockRect(temp, 0);
627
628 result =
629 IDirect3DDevice9_UpdateTexture(renderdata->device,
630 (IDirect3DBaseTexture9 *) temp,
631 (IDirect3DBaseTexture9 *)
632 data->texture);
633 IDirect3DTexture9_Release(temp);
634 if (FAILED(result)) {
635 D3D_SetError("UpdateTexture()", result);
636 return -1;
637 }
638 return 0;
639 }
640 #else 722 #else
641 static int 723 RECT d3drect;
642 D3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, 724 D3DLOCKED_RECT locked;
643 const SDL_Rect * rect, const void *pixels, int pitch) 725 const Uint8 *src;
644 { 726 Uint8 *dst;
645 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata; 727 int row, length;
646 D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata; 728 HRESULT result;
647 RECT d3drect; 729
648 D3DLOCKED_RECT locked; 730 d3drect.left = rect->x;
649 const Uint8 *src; 731 d3drect.right = rect->x + rect->w;
650 Uint8 *dst; 732 d3drect.top = rect->y;
651 int row, length; 733 d3drect.bottom = rect->y + rect->h;
652 HRESULT result; 734
653 735 result =
654 d3drect.left = rect->x; 736 IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect, 0);
655 d3drect.right = rect->x + rect->w; 737 if (FAILED(result)) {
656 d3drect.top = rect->y; 738 D3D_SetError("LockRect()", result);
657 d3drect.bottom = rect->y + rect->h; 739 return -1;
658 740 }
659 result = 741
660 IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect, 0); 742 src = pixels;
661 if (FAILED(result)) { 743 dst = locked.pBits;
662 D3D_SetError("LockRect()", result); 744 length = rect->w * SDL_BYTESPERPIXEL(texture->format);
663 return -1; 745 for (row = 0; row < rect->h; ++row) {
664 } 746 SDL_memcpy(dst, src, length);
665 747 src += pitch;
666 src = pixels; 748 dst += locked.Pitch;
667 dst = locked.pBits; 749 }
668 length = rect->w * SDL_BYTESPERPIXEL(texture->format); 750 IDirect3DTexture9_UnlockRect(data->texture, 0);
669 for (row = 0; row < rect->h; ++row) {
670 SDL_memcpy(dst, src, length);
671 src += pitch;
672 dst += locked.Pitch;
673 }
674 IDirect3DTexture9_UnlockRect(data->texture, 0);
675 return 0;
676 }
677 #endif // SDL_MEMORY_POOL_DEFAULT 751 #endif // SDL_MEMORY_POOL_DEFAULT
752
753 return 0;
754 }
755 }
678 756
679 static int 757 static int
680 D3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, 758 D3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
681 const SDL_Rect * rect, int markDirty, void **pixels, 759 const SDL_Rect * rect, int markDirty, void **pixels,
682 int *pitch) 760 int *pitch)
683 { 761 {
684 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata; 762 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
685 RECT d3drect; 763
686 D3DLOCKED_RECT locked; 764 if (data->yuv) {
687 HRESULT result; 765 return SDL_SW_LockYUVTexture(data->yuv, rect, markDirty, pixels,
688 766 pitch);
689 d3drect.left = rect->x; 767 } else {
690 d3drect.right = rect->x + rect->w; 768 RECT d3drect;
691 d3drect.top = rect->y; 769 D3DLOCKED_RECT locked;
692 d3drect.bottom = rect->y + rect->h; 770 HRESULT result;
693 771
694 result = 772 d3drect.left = rect->x;
695 IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect, 773 d3drect.right = rect->x + rect->w;
696 markDirty ? 0 : D3DLOCK_NO_DIRTY_UPDATE); 774 d3drect.top = rect->y;
697 if (FAILED(result)) { 775 d3drect.bottom = rect->y + rect->h;
698 D3D_SetError("LockRect()", result); 776
699 return -1; 777 result =
700 } 778 IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect,
701 *pixels = locked.pBits; 779 markDirty ? 0 : D3DLOCK_NO_DIRTY_UPDATE);
702 *pitch = locked.Pitch; 780 if (FAILED(result)) {
703 return 0; 781 D3D_SetError("LockRect()", result);
782 return -1;
783 }
784 *pixels = locked.pBits;
785 *pitch = locked.Pitch;
786 return 0;
787 }
704 } 788 }
705 789
706 static void 790 static void
707 D3D_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture) 791 D3D_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
708 { 792 {
709 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata; 793 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
710 794
711 IDirect3DTexture9_UnlockRect(data->texture, 0); 795 if (data->yuv) {
796 SDL_SW_UnlockYUVTexture(data->yuv);
797 UpdateYUVTextureData(texture);
798 } else {
799 IDirect3DTexture9_UnlockRect(data->texture, 0);
800 }
712 } 801 }
713 802
714 static void 803 static void
715 D3D_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects, 804 D3D_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects,
716 const SDL_Rect * rects) 805 const SDL_Rect * rects)
1064 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata; 1153 D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
1065 1154
1066 if (!data) { 1155 if (!data) {
1067 return; 1156 return;
1068 } 1157 }
1158 if (data->yuv) {
1159 SDL_SW_DestroyYUVTexture(data->yuv);
1160 }
1069 if (data->texture) { 1161 if (data->texture) {
1070 IDirect3DTexture9_Release(data->texture); 1162 IDirect3DTexture9_Release(data->texture);
1071 } 1163 }
1072 SDL_free(data); 1164 SDL_free(data);
1073 texture->driverdata = NULL; 1165 texture->driverdata = NULL;