src/gallium/state_trackers/nine/buffer9.c

   1 /*
   2  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
   3  * Copyright 2015 Patrick Rudolph <siro@das-labor.org>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * 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 NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  23
  24 #include "buffer9.h"
  25 #include "device9.h"
  26 #include "nine_helpers.h"
  27 #include "nine_pipe.h"
  28
  29 #include "pipe/p_screen.h"
  30 #include "pipe/p_context.h"
  31 #include "pipe/p_state.h"
  32 #include "pipe/p_defines.h"
  33 #include "pipe/p_format.h"
  34 #include "util/u_box.h"
  35
  36 #define DBG_CHANNEL (DBG_INDEXBUFFER|DBG_VERTEXBUFFER)
  37
  38 HRESULT
  39 NineBuffer9_ctor( struct NineBuffer9 *This,
  40                         struct NineUnknownParams *pParams,
  41                         D3DRESOURCETYPE Type,
  42                         DWORD Usage,
  43                         UINT Size,
  44                         D3DPOOL Pool )
  45 {
  46     struct pipe_resource *info = &This->base.info;
  47     HRESULT hr;
  48
  49     DBG("This=%p Size=0x%x Usage=%x Pool=%u\n", This, Size, Usage, Pool);
  50
  51     user_assert(Pool != D3DPOOL_SCRATCH, D3DERR_INVALIDCALL);
  52
  53     This->maps = MALLOC(sizeof(struct pipe_transfer *));
  54     if (!This->maps)
  55         return E_OUTOFMEMORY;
  56     This->nmaps = 0;
  57     This->maxmaps = 1;
  58     This->size = Size;
  59
  60     This->pipe = pParams->device->pipe;
  61
  62     info->screen = pParams->device->screen;
  63     info->target = PIPE_BUFFER;
  64     info->format = PIPE_FORMAT_R8_UNORM;
  65     info->width0 = Size;
  66     info->flags = 0;
  67
  68     info->bind = PIPE_BIND_VERTEX_BUFFER | PIPE_BIND_TRANSFER_WRITE;
  69     if (!(Usage & D3DUSAGE_WRITEONLY))
  70         info->bind |= PIPE_BIND_TRANSFER_READ;
  71
  72     info->usage = PIPE_USAGE_DEFAULT;
  73     if (Usage & D3DUSAGE_DYNAMIC)
  74         info->usage = PIPE_USAGE_STREAM;
  75     else if (Pool == D3DPOOL_SYSTEMMEM)
  76         info->usage = PIPE_USAGE_STAGING;
  77
  78     /* if (pDesc->Usage & D3DUSAGE_DONOTCLIP) { } */
  79     /* if (pDesc->Usage & D3DUSAGE_NONSECURE) { } */
  80     /* if (pDesc->Usage & D3DUSAGE_NPATCHES) { } */
  81     /* if (pDesc->Usage & D3DUSAGE_POINTS) { } */
  82     /* if (pDesc->Usage & D3DUSAGE_RTPATCHES) { } */
  83     if (Usage & D3DUSAGE_SOFTWAREPROCESSING)
  84         DBG("Application asked for Software Vertex Processing, "
  85             "but this is unimplemented\n");
  86     /* if (pDesc->Usage & D3DUSAGE_TEXTAPI) { } */
  87
  88     info->height0 = 1;
  89     info->depth0 = 1;
  90     info->array_size = 1;
  91     info->last_level = 0;
  92     info->nr_samples = 0;
  93
  94     hr = NineResource9_ctor(&This->base, pParams, NULL, TRUE,
  95                             Type, Pool, Usage);
  96
  97     if (FAILED(hr))
  98         return hr;
  99
 100     if (Pool == D3DPOOL_MANAGED) {
 101         This->managed.data = align_malloc(
 102             nine_format_get_level_alloc_size(This->base.info.format,
 103                                              Size, 1, 0), 32);
 104         if (!This->managed.data)
 105             return E_OUTOFMEMORY;
 106         memset(This->managed.data, 0, Size);
 107         This->managed.dirty = TRUE;
 108         u_box_1d(0, Size, &This->managed.dirty_box);
 109         list_inithead(&This->managed.list);
 110         list_inithead(&This->managed.list2);
 111         list_add(&This->managed.list, &pParams->device->update_buffers);
 112         list_add(&This->managed.list2, &pParams->device->managed_buffers);
 113     }
 114
 115     return D3D_OK;
 116 }
 117
 118 void
 119 NineBuffer9_dtor( struct NineBuffer9 *This )
 120 {
 121     if (This->maps) {
 122         while (This->nmaps) {
 123             NineBuffer9_Unlock(This);
 124         }
 125         FREE(This->maps);
 126     }
 127
 128     if (This->base.pool == D3DPOOL_MANAGED) {
 129         if (This->managed.data)
 130             align_free(This->managed.data);
 131         if (This->managed.list.prev != NULL && This->managed.list.next != NULL)
 132             list_del(&This->managed.list);
 133         if (This->managed.list2.prev != NULL && This->managed.list2.next != NULL)
 134             list_del(&This->managed.list2);
 135     }
 136
 137     NineResource9_dtor(&This->base);
 138 }
 139
 140 struct pipe_resource *
 141 NineBuffer9_GetResource( struct NineBuffer9 *This )
 142 {
 143     return NineResource9_GetResource(&This->base);
 144 }
 145
 146 HRESULT NINE_WINAPI
 147 NineBuffer9_Lock( struct NineBuffer9 *This,
 148                         UINT OffsetToLock,
 149                         UINT SizeToLock,
 150                         void **ppbData,
 151                         DWORD Flags )
 152 {
 153     struct pipe_box box;
 154     void *data;
 155     unsigned usage = d3dlock_buffer_to_pipe_transfer_usage(Flags);
 156
 157     DBG("This=%p(pipe=%p) OffsetToLock=0x%x, SizeToLock=0x%x, Flags=0x%x\n",
 158         This, This->base.resource,
 159         OffsetToLock, SizeToLock, Flags);
 160
 161     user_assert(ppbData, E_POINTER);
 162     user_assert(!(Flags & ~(D3DLOCK_DISCARD |
 163                             D3DLOCK_DONOTWAIT |
 164                             D3DLOCK_NO_DIRTY_UPDATE |
 165                             D3DLOCK_NOSYSLOCK |
 166                             D3DLOCK_READONLY |
 167                             D3DLOCK_NOOVERWRITE)), D3DERR_INVALIDCALL);
 168
 169     if (SizeToLock == 0) {
 170         SizeToLock = This->size - OffsetToLock;
 171         user_warn(OffsetToLock != 0);
 172     }
 173
 174     u_box_1d(OffsetToLock, SizeToLock, &box);
 175
 176     if (This->base.pool == D3DPOOL_MANAGED) {
 177         /* READONLY doesn't dirty the buffer */
 178         if (!(Flags & D3DLOCK_READONLY)) {
 179             if (!This->managed.dirty) {
 180                 assert(LIST_IS_EMPTY(&This->managed.list));
 181                 This->managed.dirty = TRUE;
 182                 This->managed.dirty_box = box;
 183             } else {
 184                 u_box_union_2d(&This->managed.dirty_box, &This->managed.dirty_box, &box);
 185                 /* Do not upload while we are locking, we'll add it back later */
 186                 if (!LIST_IS_EMPTY(&This->managed.list))
 187                     list_delinit(&This->managed.list);
 188             }
 189         }
 190         *ppbData = (char *)This->managed.data + OffsetToLock;
 191         DBG("returning pointer %p\n", *ppbData);
 192         This->nmaps++;
 193         return D3D_OK;
 194     }
 195
 196     if (This->nmaps == This->maxmaps) {
 197         struct pipe_transfer **newmaps =
 198             REALLOC(This->maps, sizeof(struct pipe_transfer *)*This->maxmaps,
 199                     sizeof(struct pipe_transfer *)*(This->maxmaps << 1));
 200         if (newmaps == NULL)
 201             return E_OUTOFMEMORY;
 202
 203         This->maxmaps <<= 1;
 204         This->maps = newmaps;
 205     }
 206
 207     data = This->pipe->transfer_map(This->pipe, This->base.resource, 0,
 208                                     usage, &box, &This->maps[This->nmaps]);
 209
 210     if (!data) {
 211         DBG("pipe::transfer_map failed\n"
 212             " usage = %x\n"
 213             " box.x = %u\n"
 214             " box.width = %u\n",
 215             usage, box.x, box.width);
 216         /* not sure what to return, msdn suggests this */
 217         if (Flags & D3DLOCK_DONOTWAIT)
 218             return D3DERR_WASSTILLDRAWING;
 219         return D3DERR_INVALIDCALL;
 220     }
 221
 222     DBG("returning pointer %p\n", data);
 223     This->nmaps++;
 224     *ppbData = data;
 225
 226     return D3D_OK;
 227 }
 228
 229 HRESULT NINE_WINAPI
 230 NineBuffer9_Unlock( struct NineBuffer9 *This )
 231 {
 232     DBG("This=%p\n", This);
 233
 234     user_assert(This->nmaps > 0, D3DERR_INVALIDCALL);
 235     if (This->base.pool != D3DPOOL_MANAGED)
 236         This->pipe->transfer_unmap(This->pipe, This->maps[--(This->nmaps)]);
 237     else {
 238         This->nmaps--;
 239         /* TODO: Fix this to upload at the first draw call needing the data,
 240          * instead of at the next draw call */
 241         if (!This->nmaps && This->managed.dirty && LIST_IS_EMPTY(&This->managed.list))
 242             list_add(&This->managed.list, &This->base.base.device->update_buffers);
 243     }
 244     return D3D_OK;
 245 }
 246
 247 void
 248 NineBuffer9_SetDirty( struct NineBuffer9 *This )
 249 {
 250     assert(This->base.pool == D3DPOOL_MANAGED);
 251
 252     if (!This->managed.dirty) {
 253         assert(LIST_IS_EMPTY(&This->managed.list));
 254         list_add(&This->managed.list, &This->base.base.device->update_buffers);
 255         This->managed.dirty = TRUE;
 256     }
 257     u_box_1d(0, This->size, &This->managed.dirty_box);
 258 }