]> git.cworth.org Git - apitrace/blob - retrace/d3d9state_images.cpp
Check for ARB_sampler_objects before dumping its state.
[apitrace] / retrace / d3d9state_images.cpp
1 /**************************************************************************
2  *
3  * Copyright 2011 Jose Fonseca
4  * All Rights Reserved.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  *
24  **************************************************************************/
25
26
27 #include <assert.h>
28 #include <stdint.h>
29
30 #include "image.hpp"
31 #include "json.hpp"
32 #include "d3d9imports.hpp"
33 #include "d3dstate.hpp"
34
35
36 namespace d3dstate {
37
38
39 static image::Image *
40 getRenderTargetImage(IDirect3DDevice9 *pDevice,
41                      IDirect3DSurface9 *pRenderTarget) {
42     image::Image *image = NULL;
43     D3DSURFACE_DESC Desc;
44     IDirect3DSurface9 *pStagingSurface = NULL;
45     D3DLOCKED_RECT LockedRect;
46     const unsigned char *src;
47     unsigned char *dst;
48     HRESULT hr;
49
50     if (!pRenderTarget) {
51         return NULL;
52     }
53
54     hr = pRenderTarget->GetDesc(&Desc);
55     assert(SUCCEEDED(hr));
56
57     if (Desc.Format != D3DFMT_X8R8G8B8 &&
58         Desc.Format != D3DFMT_A8R8G8B8 &&
59         Desc.Format != D3DFMT_R5G6B5) {
60         std::cerr << "warning: unsupported D3DFORMAT " << Desc.Format << "\n";
61         goto no_staging;
62     }
63
64     hr = pDevice->CreateOffscreenPlainSurface(Desc.Width, Desc.Height, Desc.Format, D3DPOOL_SYSTEMMEM, &pStagingSurface, NULL);
65     if (FAILED(hr)) {
66         goto no_staging;
67     }
68
69     hr = pDevice->GetRenderTargetData(pRenderTarget, pStagingSurface);
70     if (FAILED(hr)) {
71         goto no_rendertargetdata;
72     }
73
74     hr = pStagingSurface->LockRect(&LockedRect, NULL, D3DLOCK_READONLY);
75     if (FAILED(hr)) {
76         goto no_rendertargetdata;
77     }
78
79     image = new image::Image(Desc.Width, Desc.Height, 3, true);
80     if (!image) {
81         goto no_image;
82     }
83
84     dst = image->start();
85     src = (const unsigned char *)LockedRect.pBits;
86     for (unsigned y = 0; y < Desc.Height; ++y) {
87         if (Desc.Format == D3DFMT_R5G6B5) {
88             for (unsigned x = 0; x < Desc.Width; ++x) {
89                 uint32_t pixel = ((const uint16_t *)src)[x];
90                 dst[3*x + 0] = (( pixel        & 0x1f) * (2*0xff) + 0x1f) / (2*0x1f);
91                 dst[3*x + 1] = (((pixel >>  5) & 0x3f) * (2*0xff) + 0x3f) / (2*0x3f);
92                 dst[3*x + 2] = (( pixel >> 11        ) * (2*0xff) + 0x1f) / (2*0x1f);
93                 dst[3*x + 3] = 0xff;
94             }
95         } else {
96             for (unsigned x = 0; x < Desc.Width; ++x) {
97                 dst[3*x + 0] = src[4*x + 2];
98                 dst[3*x + 1] = src[4*x + 1];
99                 dst[3*x + 2] = src[4*x + 0];
100             }
101         }
102
103         src += LockedRect.Pitch;
104         dst += image->stride();
105     }
106
107 no_image:
108     pStagingSurface->UnlockRect();
109 no_rendertargetdata:
110     pStagingSurface->Release();
111 no_staging:
112     return image;
113 }
114
115
116 image::Image *
117 getRenderTargetImage(IDirect3DDevice9 *pDevice) {
118     HRESULT hr;
119
120     IDirect3DSurface9 *pRenderTarget = NULL;
121     hr = pDevice->GetRenderTarget(0, &pRenderTarget);
122     if (FAILED(hr)) {
123         return NULL;
124     }
125     assert(pRenderTarget);
126
127     image::Image *image = NULL;
128     if (pRenderTarget) {
129         image = getRenderTargetImage(pDevice, pRenderTarget);
130         pRenderTarget->Release();
131     }
132
133     return image;
134 }
135
136
137 void
138 dumpFramebuffer(JSONWriter &json, IDirect3DDevice9 *pDevice)
139 {
140     HRESULT hr;
141
142     json.beginMember("framebuffer");
143     json.beginObject();
144
145     D3DCAPS9 Caps;
146     pDevice->GetDeviceCaps(&Caps);
147
148     for (UINT i = 0; i < Caps.NumSimultaneousRTs; ++i) {
149         IDirect3DSurface9 *pRenderTarget = NULL;
150         hr = pDevice->GetRenderTarget(i, &pRenderTarget);
151         if (FAILED(hr)) {
152             continue;
153         }
154
155         if (!pRenderTarget) {
156             continue;
157         }
158
159         image::Image *image;
160         image = getRenderTargetImage(pDevice, pRenderTarget);
161         if (image) {
162             char label[64];
163             _snprintf(label, sizeof label, "RENDER_TARGET_%u", i);
164             json.beginMember(label);
165             json.writeImage(image, "UNKNOWN");
166             json.endMember(); // RENDER_TARGET_*
167         }
168
169         pRenderTarget->Release();
170     }
171
172     json.endObject();
173     json.endMember(); // framebuffer
174 }
175
176
177 } /* namespace d3dstate */