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 getRenderTargetImage(IDirect3DDevice9 *pDevice,
  42                      IDirect3DSurface9 *pRenderTarget) {
  43     image::Image *image = NULL;
  44     D3DSURFACE_DESC Desc;
  45     IDirect3DSurface9 *pStagingSurface = NULL;
  46     D3DLOCKED_RECT LockedRect;
  47     const unsigned char *src;
  48     unsigned char *dst;
  49     HRESULT hr;
  50
  51     if (!pRenderTarget) {
  52         return NULL;
  53     }
  54
  55     hr = pRenderTarget->GetDesc(&Desc);
  56     assert(SUCCEEDED(hr));
  57
  58     if (Desc.Format != D3DFMT_X8R8G8B8 &&
  59         Desc.Format != D3DFMT_A8R8G8B8 &&
  60         Desc.Format != D3DFMT_R5G6B5) {
  61         std::cerr << "warning: unsupported D3DFORMAT " << Desc.Format << "\n";
  62         goto no_staging;
  63     }
  64
  65     hr = pDevice->CreateOffscreenPlainSurface(Desc.Width, Desc.Height, Desc.Format, D3DPOOL_SYSTEMMEM, &pStagingSurface, NULL);
  66     if (FAILED(hr)) {
  67         goto no_staging;
  68     }
  69
  70     hr = pDevice->GetRenderTargetData(pRenderTarget, pStagingSurface);
  71     if (FAILED(hr)) {
  72         goto no_rendertargetdata;
  73     }
  74
  75     hr = pStagingSurface->LockRect(&LockedRect, NULL, D3DLOCK_READONLY);
  76     if (FAILED(hr)) {
  77         goto no_rendertargetdata;
  78     }
  79
  80     image = new image::Image(Desc.Width, Desc.Height, 3, true);
  81     if (!image) {
  82         goto no_image;
  83     }
  84
  85     dst = image->start();
  86     src = (const unsigned char *)LockedRect.pBits;
  87     for (unsigned y = 0; y < Desc.Height; ++y) {
  88         if (Desc.Format == D3DFMT_R5G6B5) {
  89             for (unsigned x = 0; x < Desc.Width; ++x) {
  90                 uint32_t pixel = ((const uint16_t *)src)[x];
  91                 dst[3*x + 0] = (( pixel        & 0x1f) * (2*0xff) + 0x1f) / (2*0x1f);
  92                 dst[3*x + 1] = (((pixel >>  5) & 0x3f) * (2*0xff) + 0x3f) / (2*0x3f);
  93                 dst[3*x + 2] = (( pixel >> 11        ) * (2*0xff) + 0x1f) / (2*0x1f);
  94                 dst[3*x + 3] = 0xff;
  95             }
  96         } else {
  97             for (unsigned x = 0; x < Desc.Width; ++x) {
  98                 dst[3*x + 0] = src[4*x + 2];
  99                 dst[3*x + 1] = src[4*x + 1];
 100                 dst[3*x + 2] = src[4*x + 0];
 101             }
 102         }
 103
 104         src += LockedRect.Pitch;
 105         dst += image->stride();
 106     }
 107
 108 no_image:
 109     pStagingSurface->UnlockRect();
 110 no_rendertargetdata:
 111     pStagingSurface->Release();
 112 no_staging:
 113     return image;
 114 }
 115
 116
 117 image::Image *
 118 getRenderTargetImage(IDirect3DDevice9 *pDevice) {
 119     HRESULT hr;
 120
 121     IDirect3DSurface9 *pRenderTarget = NULL;
 122     hr = pDevice->GetRenderTarget(0, &pRenderTarget);
 123     if (FAILED(hr)) {
 124         return NULL;
 125     }
 126     assert(pRenderTarget);
 127
 128     image::Image *image = NULL;
 129     if (pRenderTarget) {
 130         image = getRenderTargetImage(pDevice, pRenderTarget);
 131         pRenderTarget->Release();
 132     }
 133
 134     return image;
 135 }
 136
 137
 138 void
 139 dumpFramebuffer(JSONWriter &json, IDirect3DDevice9 *pDevice)
 140 {
 141     HRESULT hr;
 142
 143     json.beginMember("framebuffer");
 144     json.beginObject();
 145
 146     D3DCAPS9 Caps;
 147     pDevice->GetDeviceCaps(&Caps);
 148
 149     for (UINT i = 0; i < Caps.NumSimultaneousRTs; ++i) {
 150         IDirect3DSurface9 *pRenderTarget = NULL;
 151         hr = pDevice->GetRenderTarget(i, &pRenderTarget);
 152         if (FAILED(hr)) {
 153             continue;
 154         }
 155
 156         if (!pRenderTarget) {
 157             continue;
 158         }
 159
 160         image::Image *image;
 161         image = getRenderTargetImage(pDevice, pRenderTarget);
 162         if (image) {
 163             char label[64];
 164             _snprintf(label, sizeof label, "RENDER_TARGET_%u", i);
 165             json.beginMember(label);
 166             json.writeImage(image, "UNKNOWN");
 167             json.endMember(); // RENDER_TARGET_*
 168         }
 169
 170         pRenderTarget->Release();
 171     }
 172
 173     json.endObject();
 174     json.endMember(); // framebuffer
 175 }
 176
 177
 178 } /* namespace d3dstate */