src/gallium/state_trackers/nine/volume9.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 "device9.h"
  24 #include "volume9.h"
  25 #include "basetexture9.h" /* for marking dirty */
  26 #include "volumetexture9.h"
  27 #include "nine_helpers.h"
  28 #include "nine_pipe.h"
  29 #include "nine_dump.h"
  30
  31 #include "util/u_format.h"
  32 #include "util/u_surface.h"
  33
  34 #define DBG_CHANNEL DBG_VOLUME
  35
  36
  37 static HRESULT
  38 NineVolume9_AllocateData( struct NineVolume9 *This )
  39 {
  40     unsigned size = This->layer_stride * This->desc.Depth;
  41
  42     DBG("(%p(This=%p),level=%u) Allocating 0x%x bytes of system memory.\n",
  43         This->base.container, This, This->level, size);
  44
  45     This->data = (uint8_t *)align_calloc(size, 32);
  46     if (!This->data)
  47         return E_OUTOFMEMORY;
  48     return D3D_OK;
  49 }
  50
  51 static HRESULT
  52 NineVolume9_ctor( struct NineVolume9 *This,
  53                   struct NineUnknownParams *pParams,
  54                   struct NineUnknown *pContainer,
  55                   struct pipe_resource *pResource,
  56                   unsigned Level,
  57                   D3DVOLUME_DESC *pDesc )
  58 {
  59     HRESULT hr;
  60
  61     assert(pContainer); /* stand-alone volumes can't be created */
  62
  63     DBG("This=%p pContainer=%p pDevice=%p pResource=%p Level=%u pDesc=%p\n",
  64         This, pContainer, pParams->device, pResource, Level, pDesc);
  65
  66     /* Mark this as a special surface held by another internal resource. */
  67     pParams->container = pContainer;
  68
  69     user_assert(!(pDesc->Usage & D3DUSAGE_DYNAMIC) ||
  70                 (pDesc->Pool != D3DPOOL_MANAGED), D3DERR_INVALIDCALL);
  71
  72     assert(pResource || pDesc->Pool != D3DPOOL_DEFAULT);
  73
  74     hr = NineUnknown_ctor(&This->base, pParams);
  75     if (FAILED(hr))
  76         return hr;
  77
  78     pipe_resource_reference(&This->resource, pResource);
  79
  80     This->transfer = NULL;
  81     This->lock_count = 0;
  82
  83     This->level = Level;
  84     This->level_actual = Level;
  85     This->desc = *pDesc;
  86
  87     This->info.screen = pParams->device->screen;
  88     This->info.target = PIPE_TEXTURE_3D;
  89     This->info.width0 = pDesc->Width;
  90     This->info.height0 = pDesc->Height;
  91     This->info.depth0 = pDesc->Depth;
  92     This->info.last_level = 0;
  93     This->info.array_size = 1;
  94     This->info.nr_samples = 0;
  95     This->info.nr_storage_samples = 0;
  96     This->info.usage = PIPE_USAGE_DEFAULT;
  97     This->info.bind = PIPE_BIND_SAMPLER_VIEW;
  98     This->info.flags = 0;
  99     This->info.format = d3d9_to_pipe_format_checked(This->info.screen,
 100                                                     pDesc->Format,
 101                                                     This->info.target,
 102                                                     This->info.nr_samples,
 103                                                     This->info.bind, FALSE,
 104                                                     pDesc->Pool == D3DPOOL_SCRATCH);
 105
 106     if (This->info.format == PIPE_FORMAT_NONE)
 107         return D3DERR_DRIVERINTERNALERROR;
 108
 109     This->stride = util_format_get_stride(This->info.format, pDesc->Width);
 110     This->stride = align(This->stride, 4);
 111     This->layer_stride = util_format_get_2d_size(This->info.format,
 112                                                  This->stride, pDesc->Height);
 113
 114     /* Get true format */
 115     This->format_conversion = d3d9_to_pipe_format_checked(This->info.screen,
 116                                                          pDesc->Format,
 117                                                          This->info.target,
 118                                                          This->info.nr_samples,
 119                                                          This->info.bind, FALSE,
 120                                                          TRUE);
 121     if (This->info.format != This->format_conversion) {
 122         This->stride_conversion = nine_format_get_stride(This->format_conversion,
 123                                                          pDesc->Width);
 124         This->layer_stride_conversion = util_format_get_2d_size(This->format_conversion,
 125                                                                 This->stride_conversion,
 126                                                                 pDesc->Height);
 127         This->data_conversion = align_calloc(This->layer_stride_conversion *
 128                                              This->desc.Depth, 32);
 129         if (!This->data_conversion)
 130             return E_OUTOFMEMORY;
 131     }
 132
 133     if (!This->resource) {
 134         hr = NineVolume9_AllocateData(This);
 135         if (FAILED(hr))
 136             return hr;
 137     }
 138     return D3D_OK;
 139 }
 140
 141 static void
 142 NineVolume9_dtor( struct NineVolume9 *This )
 143 {
 144     DBG("This=%p\n", This);
 145
 146     if (This->transfer) {
 147         struct pipe_context *pipe = nine_context_get_pipe_multithread(This->base.device);
 148         pipe->transfer_unmap(pipe, This->transfer);
 149         This->transfer = NULL;
 150     }
 151
 152     /* Note: Following condition cannot happen currently, since we
 153      * refcount the volume in the functions increasing
 154      * pending_uploads_counter. */
 155     if (p_atomic_read(&This->pending_uploads_counter))
 156         nine_csmt_process(This->base.device);
 157
 158     if (This->data)
 159         align_free(This->data);
 160     if (This->data_conversion)
 161         align_free(This->data_conversion);
 162
 163     pipe_resource_reference(&This->resource, NULL);
 164
 165     NineUnknown_dtor(&This->base);
 166 }
 167
 168 HRESULT NINE_WINAPI
 169 NineVolume9_GetContainer( struct NineVolume9 *This,
 170                           REFIID riid,
 171                           void **ppContainer )
 172 {
 173     char guid_str[64];
 174
 175     DBG("This=%p riid=%p id=%s ppContainer=%p\n",
 176         This, riid, riid ? GUID_sprintf(guid_str, riid) : "", ppContainer);
 177
 178     (void)guid_str;
 179
 180     if (!NineUnknown(This)->container)
 181         return E_NOINTERFACE;
 182     return NineUnknown_QueryInterface(NineUnknown(This)->container, riid, ppContainer);
 183 }
 184
 185 static inline void
 186 NineVolume9_MarkContainerDirty( struct NineVolume9 *This )
 187 {
 188     struct NineBaseTexture9 *tex;
 189 #ifdef DEBUG
 190     /* This is always contained by a NineVolumeTexture9. */
 191     GUID id = IID_IDirect3DVolumeTexture9;
 192     REFIID ref = &id;
 193     assert(NineUnknown_QueryInterface(This->base.container, ref, (void **)&tex)
 194            == S_OK);
 195     assert(NineUnknown_Release(NineUnknown(tex)) != 0);
 196 #endif
 197
 198     tex = NineBaseTexture9(This->base.container);
 199     assert(tex);
 200     if (This->desc.Pool == D3DPOOL_MANAGED)
 201         tex->managed.dirty = TRUE;
 202
 203     BASETEX_REGISTER_UPDATE(tex);
 204 }
 205
 206 HRESULT NINE_WINAPI
 207 NineVolume9_GetDesc( struct NineVolume9 *This,
 208                      D3DVOLUME_DESC *pDesc )
 209 {
 210     user_assert(pDesc != NULL, E_POINTER);
 211     *pDesc = This->desc;
 212     return D3D_OK;
 213 }
 214
 215 inline void
 216 NineVolume9_AddDirtyRegion( struct NineVolume9 *This,
 217                             const struct pipe_box *box )
 218 {
 219     D3DBOX dirty_region;
 220     struct NineVolumeTexture9 *tex = NineVolumeTexture9(This->base.container);
 221
 222     if (!box) {
 223         NineVolumeTexture9_AddDirtyBox(tex, NULL);
 224     } else {
 225         dirty_region.Left = box->x << This->level_actual;
 226         dirty_region.Top = box->y << This->level_actual;
 227         dirty_region.Front = box->z << This->level_actual;
 228         dirty_region.Right = dirty_region.Left + (box->width << This->level_actual);
 229         dirty_region.Bottom = dirty_region.Top + (box->height << This->level_actual);
 230         dirty_region.Back = dirty_region.Front + (box->depth << This->level_actual);
 231         NineVolumeTexture9_AddDirtyBox(tex, &dirty_region);
 232     }
 233 }
 234
 235 static inline uint8_t *
 236 NineVolume9_GetSystemMemPointer(struct NineVolume9 *This, int x, int y, int z)
 237 {
 238     unsigned x_offset = util_format_get_stride(This->info.format, x);
 239
 240     y = util_format_get_nblocksy(This->info.format, y);
 241
 242     assert(This->data);
 243     return This->data + (z * This->layer_stride + y * This->stride + x_offset);
 244 }
 245
 246 HRESULT NINE_WINAPI
 247 NineVolume9_LockBox( struct NineVolume9 *This,
 248                      D3DLOCKED_BOX *pLockedVolume,
 249                      const D3DBOX *pBox,
 250                      DWORD Flags )
 251 {
 252     struct pipe_context *pipe;
 253     struct pipe_resource *resource = This->resource;
 254     struct pipe_box box;
 255     unsigned usage;
 256
 257     DBG("This=%p(%p) pLockedVolume=%p pBox=%p[%u..%u,%u..%u,%u..%u] Flags=%s\n",
 258         This, This->base.container, pLockedVolume, pBox,
 259         pBox ? pBox->Left : 0, pBox ? pBox->Right : 0,
 260         pBox ? pBox->Top : 0, pBox ? pBox->Bottom : 0,
 261         pBox ? pBox->Front : 0, pBox ? pBox->Back : 0,
 262         nine_D3DLOCK_to_str(Flags));
 263
 264     /* check if it's already locked */
 265     user_assert(This->lock_count == 0, D3DERR_INVALIDCALL);
 266
 267     /* set pBits to NULL after lock_count check */
 268     user_assert(pLockedVolume, E_POINTER);
 269     pLockedVolume->pBits = NULL;
 270
 271     user_assert(This->desc.Pool != D3DPOOL_DEFAULT ||
 272                 (This->desc.Usage & D3DUSAGE_DYNAMIC), D3DERR_INVALIDCALL);
 273
 274     user_assert(!((Flags & D3DLOCK_DISCARD) && (Flags & D3DLOCK_READONLY)),
 275                 D3DERR_INVALIDCALL);
 276
 277     if (pBox && compressed_format (This->desc.Format)) { /* For volume all pools are checked */
 278         const unsigned w = util_format_get_blockwidth(This->info.format);
 279         const unsigned h = util_format_get_blockheight(This->info.format);
 280         user_assert((pBox->Left == 0 && pBox->Right == This->desc.Width &&
 281                      pBox->Top == 0 && pBox->Bottom == This->desc.Height) ||
 282                     (!(pBox->Left % w) && !(pBox->Right % w) &&
 283                      !(pBox->Top % h) && !(pBox->Bottom % h)),
 284                     D3DERR_INVALIDCALL);
 285     }
 286
 287     if (Flags & D3DLOCK_DISCARD) {
 288         usage = PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE;
 289     } else {
 290         usage = (Flags & D3DLOCK_READONLY) ?
 291             PIPE_TRANSFER_READ : PIPE_TRANSFER_READ_WRITE;
 292     }
 293     if (Flags & D3DLOCK_DONOTWAIT)
 294         usage |= PIPE_TRANSFER_DONTBLOCK;
 295
 296     if (pBox) {
 297         user_assert(pBox->Right > pBox->Left, D3DERR_INVALIDCALL);
 298         user_assert(pBox->Bottom > pBox->Top, D3DERR_INVALIDCALL);
 299         user_assert(pBox->Back > pBox->Front, D3DERR_INVALIDCALL);
 300         user_assert(pBox->Right <= This->desc.Width, D3DERR_INVALIDCALL);
 301         user_assert(pBox->Bottom <= This->desc.Height, D3DERR_INVALIDCALL);
 302         user_assert(pBox->Back <= This->desc.Depth, D3DERR_INVALIDCALL);
 303
 304         d3dbox_to_pipe_box(&box, pBox);
 305         if (u_box_clip_2d(&box, &box, This->desc.Width, This->desc.Height) < 0) {
 306             DBG("Locked volume intersection empty.\n");
 307             return D3DERR_INVALIDCALL;
 308         }
 309     } else {
 310         u_box_3d(0, 0, 0, This->desc.Width, This->desc.Height, This->desc.Depth,
 311                  &box);
 312     }
 313
 314     if (p_atomic_read(&This->pending_uploads_counter))
 315         nine_csmt_process(This->base.device);
 316
 317     if (This->data_conversion) {
 318         /* For now we only have uncompressed formats here */
 319         pLockedVolume->RowPitch = This->stride_conversion;
 320         pLockedVolume->SlicePitch = This->layer_stride_conversion;
 321         pLockedVolume->pBits = This->data_conversion + box.z * This->layer_stride_conversion +
 322                                box.y * This->stride_conversion +
 323                                util_format_get_stride(This->format_conversion, box.x);
 324     } else if (This->data) {
 325         pLockedVolume->RowPitch = This->stride;
 326         pLockedVolume->SlicePitch = This->layer_stride;
 327         pLockedVolume->pBits =
 328             NineVolume9_GetSystemMemPointer(This, box.x, box.y, box.z);
 329     } else {
 330         bool no_refs = !p_atomic_read(&This->base.bind) &&
 331             !p_atomic_read(&This->base.container->bind);
 332         if (no_refs)
 333             pipe = nine_context_get_pipe_acquire(This->base.device);
 334         else
 335             pipe = NineDevice9_GetPipe(This->base.device);
 336         pLockedVolume->pBits =
 337             pipe->transfer_map(pipe, resource, This->level, usage,
 338                                &box, &This->transfer);
 339         if (no_refs)
 340             nine_context_get_pipe_release(This->base.device);
 341         if (!This->transfer) {
 342             if (Flags & D3DLOCK_DONOTWAIT)
 343                 return D3DERR_WASSTILLDRAWING;
 344             return D3DERR_DRIVERINTERNALERROR;
 345         }
 346         pLockedVolume->RowPitch = This->transfer->stride;
 347         pLockedVolume->SlicePitch = This->transfer->layer_stride;
 348     }
 349
 350     if (!(Flags & (D3DLOCK_NO_DIRTY_UPDATE | D3DLOCK_READONLY))) {
 351         NineVolume9_MarkContainerDirty(This);
 352         NineVolume9_AddDirtyRegion(This, &box);
 353     }
 354
 355     ++This->lock_count;
 356     return D3D_OK;
 357 }
 358
 359 HRESULT NINE_WINAPI
 360 NineVolume9_UnlockBox( struct NineVolume9 *This )
 361 {
 362     struct pipe_context *pipe;
 363
 364     DBG("This=%p lock_count=%u\n", This, This->lock_count);
 365     user_assert(This->lock_count, D3DERR_INVALIDCALL);
 366     if (This->transfer) {
 367         pipe = nine_context_get_pipe_acquire(This->base.device);
 368         pipe->transfer_unmap(pipe, This->transfer);
 369         This->transfer = NULL;
 370         nine_context_get_pipe_release(This->base.device);
 371     }
 372     --This->lock_count;
 373
 374     if (This->data_conversion) {
 375         struct pipe_transfer *transfer;
 376         uint8_t *dst = This->data;
 377         struct pipe_box box;
 378
 379         u_box_3d(0, 0, 0, This->desc.Width, This->desc.Height, This->desc.Depth,
 380                  &box);
 381
 382         pipe = NineDevice9_GetPipe(This->base.device);
 383         if (!dst) {
 384             dst = pipe->transfer_map(pipe,
 385                                      This->resource,
 386                                      This->level,
 387                                      PIPE_TRANSFER_WRITE |
 388                                      PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
 389                                      &box, &transfer);
 390             if (!dst)
 391                 return D3D_OK;
 392         }
 393
 394         (void) util_format_translate_3d(This->info.format,
 395                                         dst, This->data ? This->stride : transfer->stride,
 396                                         This->data ? This->layer_stride : transfer->layer_stride,
 397                                         0, 0, 0,
 398                                         This->format_conversion,
 399                                         This->data_conversion,
 400                                         This->stride_conversion,
 401                                         This->layer_stride_conversion,
 402                                         0, 0, 0,
 403                                         This->desc.Width, This->desc.Height,
 404                                         This->desc.Depth);
 405
 406         if (!This->data)
 407             pipe_transfer_unmap(pipe, transfer);
 408     }
 409
 410     return D3D_OK;
 411 }
 412
 413 /* When this function is called, we have already checked
 414  * The copy regions fit the volumes */
 415 void
 416 NineVolume9_CopyMemToDefault( struct NineVolume9 *This,
 417                               struct NineVolume9 *From,
 418                               unsigned dstx, unsigned dsty, unsigned dstz,
 419                               struct pipe_box *pSrcBox )
 420 {
 421     struct pipe_resource *r_dst = This->resource;
 422     struct pipe_box src_box;
 423     struct pipe_box dst_box;
 424
 425     DBG("This=%p From=%p dstx=%u dsty=%u dstz=%u pSrcBox=%p\n",
 426         This, From, dstx, dsty, dstz, pSrcBox);
 427
 428     assert(This->desc.Pool == D3DPOOL_DEFAULT &&
 429            From->desc.Pool == D3DPOOL_SYSTEMMEM);
 430
 431     dst_box.x = dstx;
 432     dst_box.y = dsty;
 433     dst_box.z = dstz;
 434
 435     if (pSrcBox) {
 436         src_box = *pSrcBox;
 437     } else {
 438         src_box.x = 0;
 439         src_box.y = 0;
 440         src_box.z = 0;
 441         src_box.width = From->desc.Width;
 442         src_box.height = From->desc.Height;
 443         src_box.depth = From->desc.Depth;
 444     }
 445
 446     dst_box.width = src_box.width;
 447     dst_box.height = src_box.height;
 448     dst_box.depth = src_box.depth;
 449
 450     nine_context_box_upload(This->base.device,
 451                             &From->pending_uploads_counter,
 452                             (struct NineUnknown *)From,
 453                             r_dst,
 454                             This->level,
 455                             &dst_box,
 456                             From->info.format,
 457                             From->data, From->stride,
 458                             From->layer_stride,
 459                             &src_box);
 460
 461     if (This->data_conversion)
 462         (void) util_format_translate_3d(This->format_conversion,
 463                                         This->data_conversion,
 464                                         This->stride_conversion,
 465                                         This->layer_stride_conversion,
 466                                         dstx, dsty, dstz,
 467                                         From->info.format,
 468                                         From->data, From->stride,
 469                                         From->layer_stride,
 470                                         src_box.x, src_box.y,
 471                                         src_box.z,
 472                                         src_box.width,
 473                                         src_box.height,
 474                                         src_box.depth);
 475
 476     NineVolume9_MarkContainerDirty(This);
 477
 478     return;
 479 }
 480
 481 HRESULT
 482 NineVolume9_UploadSelf( struct NineVolume9 *This,
 483                         const struct pipe_box *damaged )
 484 {
 485     struct pipe_resource *res = This->resource;
 486     struct pipe_box box;
 487
 488     DBG("This=%p damaged=%p data=%p res=%p\n", This, damaged,
 489         This->data, res);
 490
 491     assert(This->desc.Pool == D3DPOOL_MANAGED);
 492     assert(res);
 493
 494     if (damaged) {
 495         box = *damaged;
 496     } else {
 497         box.x = 0;
 498         box.y = 0;
 499         box.z = 0;
 500         box.width = This->desc.Width;
 501         box.height = This->desc.Height;
 502         box.depth = This->desc.Depth;
 503     }
 504
 505     nine_context_box_upload(This->base.device,
 506                             &This->pending_uploads_counter,
 507                             (struct NineUnknown *)This,
 508                             res,
 509                             This->level,
 510                             &box,
 511                             res->format,
 512                             This->data, This->stride,
 513                             This->layer_stride,
 514                             &box);
 515
 516     return D3D_OK;
 517 }
 518
 519
 520 IDirect3DVolume9Vtbl NineVolume9_vtable = {
 521     (void *)NineUnknown_QueryInterface,
 522     (void *)NineUnknown_AddRef,
 523     (void *)NineUnknown_Release,
 524     (void *)NineUnknown_GetDevice, /* actually part of Volume9 iface */
 525     (void *)NineUnknown_SetPrivateData,
 526     (void *)NineUnknown_GetPrivateData,
 527     (void *)NineUnknown_FreePrivateData,
 528     (void *)NineVolume9_GetContainer,
 529     (void *)NineVolume9_GetDesc,
 530     (void *)NineVolume9_LockBox,
 531     (void *)NineVolume9_UnlockBox
 532 };
 533
 534 static const GUID *NineVolume9_IIDs[] = {
 535     &IID_IDirect3DVolume9,
 536     &IID_IUnknown,
 537     NULL
 538 };
 539
 540 HRESULT
 541 NineVolume9_new( struct NineDevice9 *pDevice,
 542                  struct NineUnknown *pContainer,
 543                  struct pipe_resource *pResource,
 544                  unsigned Level,
 545                  D3DVOLUME_DESC *pDesc,
 546                  struct NineVolume9 **ppOut )
 547 {
 548     NINE_DEVICE_CHILD_NEW(Volume9, ppOut, pDevice, /* args */
 549                           pContainer, pResource, Level, pDesc);
 550 }