git.cworth.org Git - apitrace/blob - retrace/d3d8state_images.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2011-2012 VMware, Inc.
   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 "d3d8imports.hpp"
  33 #include "d3dstate.hpp"
  34
  35
  36 namespace d3dstate {
  37
  38
  39 static image::Image *
  40 getRenderTargetImage(IDirect3DDevice8 *pDevice,
  41                      IDirect3DSurface8 *pRenderTarget) {
  42     image::Image *image = NULL;
  43     D3DSURFACE_DESC Desc;
  44     IDirect3DSurface8 *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->CreateImageSurface(Desc.Width, Desc.Height, Desc.Format, &pStagingSurface);
  65     if (FAILED(hr)) {
  66         goto no_staging;
  67     }
  68
  69     hr = pDevice->CopyRects(pRenderTarget, NULL, 0, pStagingSurface, NULL);
  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(IDirect3DDevice8 *pDevice) {
 118     HRESULT hr;
 119
 120     IDirect3DSurface8 *pRenderTarget = NULL;
 121     hr = pDevice->GetRenderTarget(&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, IDirect3DDevice8 *pDevice)
 139 {
 140     HRESULT hr;
 141
 142     json.beginMember("framebuffer");
 143     json.beginObject();
 144
 145     IDirect3DSurface8 *pRenderTarget = NULL;
 146     hr = pDevice->GetRenderTarget(&pRenderTarget);
 147     if (SUCCEEDED(hr) && pRenderTarget) {
 148         image::Image *image;
 149         image = getRenderTargetImage(pDevice, pRenderTarget);
 150         if (image) {
 151             json.beginMember("RENDER_TARGET_0");
 152             json.writeImage(image, "UNKNOWN");
 153             json.endMember(); // RENDER_TARGET_*
 154         }
 155
 156         pRenderTarget->Release();
 157     }
 158
 159     json.endObject();
 160     json.endMember(); // framebuffer
 161 }
 162
 163
 164 } /* namespace d3dstate */