src/gallium/frontends/nine/resource9.c

   1 /*
   2  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  22
  23 #include "resource9.h"
  24 #include "device9.h"
  25 #include "nine_helpers.h"
  26 #include "nine_defines.h"
  27
  28 #include "util/u_inlines.h"
  29 #include "util/u_resource.h"
  30
  31 #include "pipe/p_screen.h"
  32
  33 #define DBG_CHANNEL DBG_RESOURCE
  34
  35 HRESULT
  36 NineResource9_ctor( struct NineResource9 *This,
  37                     struct NineUnknownParams *pParams,
  38                     struct pipe_resource *initResource,
  39                     BOOL Allocate,
  40                     D3DRESOURCETYPE Type,
  41                     D3DPOOL Pool,
  42                     DWORD Usage)
  43 {
  44     struct pipe_screen *screen;
  45     HRESULT hr;
  46
  47     DBG("This=%p pParams=%p initResource=%p Allocate=%d "
  48         "Type=%d Pool=%d Usage=%d\n",
  49         This, pParams, initResource, (int) Allocate,
  50         Type, Pool, Usage);
  51
  52     hr = NineUnknown_ctor(&This->base, pParams);
  53     if (FAILED(hr))
  54         return hr;
  55
  56     This->info.screen = screen = This->base.device->screen;
  57     if (initResource)
  58         pipe_resource_reference(&This->resource, initResource);
  59
  60     if (Allocate) {
  61         assert(!initResource);
  62
  63         /* On Windows it is possible allocation fails when
  64          * IDirect3DDevice9::GetAvailableTextureMem() still reports
  65          * enough free space.
  66          *
  67          * Some games allocate surfaces
  68          * in a loop until they receive D3DERR_OUTOFVIDEOMEMORY to measure
  69          * the available texture memory size.
  70          *
  71          * We are not using the drivers VRAM statistics because:
  72          *  * This would add overhead to each resource allocation.
  73          *  * Freeing memory is lazy and takes some time, but applications
  74          *    expects the memory counter to change immediately after allocating
  75          *    or freeing memory.
  76          *
  77          * Vertexbuffers and indexbuffers are not accounted !
  78          */
  79         if (This->info.target != PIPE_BUFFER) {
  80             This->size = util_resource_size(&This->info);
  81
  82             p_atomic_add(&This->base.device->available_texture_mem, -This->size);
  83             if (This->base.device->available_texture_mem <=
  84                     This->base.device->available_texture_limit) {
  85                 return D3DERR_OUTOFVIDEOMEMORY;
  86             }
  87         }
  88
  89         DBG("(%p) Creating pipe_resource.\n", This);
  90         This->resource = screen->resource_create(screen, &This->info);
  91         if (!This->resource)
  92             return D3DERR_OUTOFVIDEOMEMORY;
  93     }
  94
  95     This->type = Type;
  96     This->pool = Pool;
  97     This->usage = Usage;
  98     This->priority = 0;
  99
 100     return D3D_OK;
 101 }
 102
 103 void
 104 NineResource9_dtor( struct NineResource9 *This )
 105 {
 106     DBG("This=%p\n", This);
 107
 108     /* NOTE: We do have to use refcounting, the driver might
 109      * still hold a reference. */
 110     pipe_resource_reference(&This->resource, NULL);
 111
 112     /* NOTE: size is 0, unless something has actually been allocated */
 113     if (This->base.device)
 114         p_atomic_add(&This->base.device->available_texture_mem, This->size);
 115
 116     NineUnknown_dtor(&This->base);
 117 }
 118
 119 struct pipe_resource *
 120 NineResource9_GetResource( struct NineResource9 *This )
 121 {
 122     return This->resource;
 123 }
 124
 125 D3DPOOL
 126 NineResource9_GetPool( struct NineResource9 *This )
 127 {
 128     return This->pool;
 129 }
 130
 131 DWORD NINE_WINAPI
 132 NineResource9_SetPriority( struct NineResource9 *This,
 133                            DWORD PriorityNew )
 134 {
 135     DWORD prev;
 136     DBG("This=%p, PriorityNew=%d\n", This, PriorityNew);
 137
 138     if (This->pool != D3DPOOL_MANAGED || This->type == D3DRTYPE_SURFACE)
 139         return 0;
 140
 141     prev = This->priority;
 142     This->priority = PriorityNew;
 143     return prev;
 144 }
 145
 146 DWORD NINE_WINAPI
 147 NineResource9_GetPriority( struct NineResource9 *This )
 148 {
 149     if (This->pool != D3DPOOL_MANAGED || This->type == D3DRTYPE_SURFACE)
 150         return 0;
 151
 152     return This->priority;
 153 }
 154
 155 /* NOTE: Don't forget to adjust locked vtable if you change this ! */
 156 void NINE_WINAPI
 157 NineResource9_PreLoad( struct NineResource9 *This )
 158 {
 159     if (This->pool != D3DPOOL_MANAGED)
 160         return;
 161     /* We don't treat managed vertex or index buffers different from
 162      * default ones (are managed vertex buffers even allowed ?), and
 163      * the PreLoad for textures is overridden by superclass.
 164      */
 165 }
 166
 167 D3DRESOURCETYPE NINE_WINAPI
 168 NineResource9_GetType( struct NineResource9 *This )
 169 {
 170     return This->type;
 171 }