git.cworth.org Git - apitrace/blob - 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 #include <stdio.h>
  30
  31 #include "image.hpp"
  32 #include "json.hpp"
  33 #include "d3d9imports.hpp"
  34 #include "d3dstate.hpp"
  35
  36
  37 namespace d3dstate {
  38
  39
  40 static image::Image *
  41 getSurfaceImage(IDirect3DDevice9 *pDevice,
  42                 IDirect3DSurface9 *pSurface) {
  43     image::Image *image = NULL;
  44     D3DSURFACE_DESC Desc;
  45     D3DLOCKED_RECT LockedRect;
  46     const unsigned char *src;
  47     unsigned char *dst;
  48     HRESULT hr;
  49
  50     if (!pSurface) {
  51         return NULL;
  52     }
  53
  54     hr = pSurface->GetDesc(&Desc);
  55     assert(SUCCEEDED(hr));
  56
  57     unsigned numChannels;
  58     image::ChannelType channelType;
  59     switch (Desc.Format) {
  60     case D3DFMT_X8R8G8B8:
  61     case D3DFMT_A8R8G8B8:
  62     case D3DFMT_R5G6B5:
  63         numChannels = 3;
  64         channelType = image::TYPE_UNORM8;
  65         break;
  66     case D3DFMT_D16:
  67     case D3DFMT_D16_LOCKABLE:
  68     case D3DFMT_D32F_LOCKABLE:
  69         numChannels = 1;
  70         channelType = image::TYPE_FLOAT;
  71         break;
  72     default:
  73         std::cerr << "warning: unsupported D3DFORMAT " << Desc.Format << "\n";
  74         goto no_lock;
  75     }
  76
  77     hr = pSurface->LockRect(&LockedRect, NULL, D3DLOCK_READONLY);
  78     if (FAILED(hr)) {
  79         goto no_lock;
  80     }
  81
  82     image = new image::Image(Desc.Width, Desc.Height, numChannels, true, channelType);
  83     if (!image) {
  84         goto no_image;
  85     }
  86
  87     dst = image->start();
  88     src = (const unsigned char *)LockedRect.pBits;
  89     for (unsigned y = 0; y < Desc.Height; ++y) {
  90         switch (Desc.Format) {
  91         case D3DFMT_R5G6B5:
  92             for (unsigned x = 0; x < Desc.Width; ++x) {
  93                 uint32_t pixel = ((const uint16_t *)src)[x];
  94                 dst[3*x + 0] = (( pixel        & 0x1f) * (2*0xff) + 0x1f) / (2*0x1f);
  95                 dst[3*x + 1] = (((pixel >>  5) & 0x3f) * (2*0xff) + 0x3f) / (2*0x3f);
  96                 dst[3*x + 2] = (( pixel >> 11        ) * (2*0xff) + 0x1f) / (2*0x1f);
  97             }
  98             break;
  99         case D3DFMT_X8R8G8B8:
 100         case D3DFMT_A8R8G8B8:
 101             for (unsigned x = 0; x < Desc.Width; ++x) {
 102                 dst[3*x + 0] = src[4*x + 2];
 103                 dst[3*x + 1] = src[4*x + 1];
 104                 dst[3*x + 2] = src[4*x + 0];
 105             }
 106             break;
 107         case D3DFMT_D16:
 108         case D3DFMT_D16_LOCKABLE:
 109             for (unsigned x = 0; x < Desc.Width; ++x) {
 110                 ((float *)dst)[x] = ((const uint16_t *)src)[x] * (1.0f / 0xffff);
 111             }
 112             break;
 113         case D3DFMT_D32F_LOCKABLE:
 114             memcpy(dst, src, Desc.Width * sizeof(float));
 115             break;
 116         default:
 117             assert(0);
 118             break;
 119         }
 120
 121         src += LockedRect.Pitch;
 122         dst += image->stride();
 123     }
 124
 125 no_image:
 126     pSurface->UnlockRect();
 127 no_lock:
 128     return image;
 129 }
 130
 131
 132 static image::Image *
 133 getRenderTargetImage(IDirect3DDevice9 *pDevice,
 134                      IDirect3DSurface9 *pRenderTarget) {
 135     image::Image *image = NULL;
 136     D3DSURFACE_DESC Desc;
 137     IDirect3DSurface9 *pStagingSurface = NULL;
 138     HRESULT hr;
 139
 140     if (!pRenderTarget) {
 141         return NULL;
 142     }
 143
 144     hr = pRenderTarget->GetDesc(&Desc);
 145     assert(SUCCEEDED(hr));
 146
 147     hr = pDevice->CreateOffscreenPlainSurface(Desc.Width, Desc.Height, Desc.Format, D3DPOOL_SYSTEMMEM, &pStagingSurface, NULL);
 148     if (FAILED(hr)) {
 149         goto no_staging;
 150     }
 151
 152     hr = pDevice->GetRenderTargetData(pRenderTarget, pStagingSurface);
 153     if (FAILED(hr)) {
 154         goto no_rendertargetdata;
 155     }
 156
 157     image = getSurfaceImage(pDevice, pStagingSurface);
 158
 159 no_rendertargetdata:
 160     pStagingSurface->Release();
 161 no_staging:
 162     return image;
 163 }
 164
 165
 166 image::Image *
 167 getRenderTargetImage(IDirect3DDevice9 *pDevice) {
 168     HRESULT hr;
 169
 170     IDirect3DSurface9 *pRenderTarget = NULL;
 171     hr = pDevice->GetRenderTarget(0, &pRenderTarget);
 172     if (FAILED(hr)) {
 173         return NULL;
 174     }
 175     assert(pRenderTarget);
 176
 177     image::Image *image = NULL;
 178     if (pRenderTarget) {
 179         image = getRenderTargetImage(pDevice, pRenderTarget);
 180         pRenderTarget->Release();
 181     }
 182
 183     return image;
 184 }
 185
 186
 187 void
 188 dumpFramebuffer(JSONWriter &json, IDirect3DDevice9 *pDevice)
 189 {
 190     HRESULT hr;
 191
 192     json.beginMember("framebuffer");
 193     json.beginObject();
 194
 195     D3DCAPS9 Caps;
 196     pDevice->GetDeviceCaps(&Caps);
 197
 198     for (UINT i = 0; i < Caps.NumSimultaneousRTs; ++i) {
 199         IDirect3DSurface9 *pRenderTarget = NULL;
 200         hr = pDevice->GetRenderTarget(i, &pRenderTarget);
 201         if (FAILED(hr)) {
 202             continue;
 203         }
 204
 205         if (!pRenderTarget) {
 206             continue;
 207         }
 208
 209         image::Image *image;
 210         image = getRenderTargetImage(pDevice, pRenderTarget);
 211         if (image) {
 212             char label[64];
 213             _snprintf(label, sizeof label, "RENDER_TARGET_%u", i);
 214             json.beginMember(label);
 215             json.writeImage(image, "UNKNOWN");
 216             json.endMember(); // RENDER_TARGET_*
 217         }
 218
 219         pRenderTarget->Release();
 220     }
 221
 222     IDirect3DSurface9 *pDepthStencil = NULL;
 223     hr = pDevice->GetDepthStencilSurface(&pDepthStencil);
 224     if (SUCCEEDED(hr) && pDepthStencil) {
 225         image::Image *image;
 226         image = getSurfaceImage(pDevice, pDepthStencil);
 227         if (image) {
 228             json.beginMember("DEPTH_STENCIL");
 229             json.writeImage(image, "UNKNOWN");
 230             json.endMember(); // RENDER_TARGET_*
 231         }
 232     }
 233
 234
 235     json.endObject();
 236     json.endMember(); // framebuffer
 237 }
 238
 239
 240 } /* namespace d3dstate */