src/gallium/frontends/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/format/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_internal = 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_internal ||
 122         /* DYNAMIC Textures requires same stride as ram buffers.
 123          * Do not use workaround by default as it eats more virtual space */
 124         (pParams->device->workarounds.dynamic_texture_workaround &&
 125          pDesc->Pool == D3DPOOL_DEFAULT && pDesc->Usage & D3DUSAGE_DYNAMIC)) {
 126         This->stride_internal = nine_format_get_stride(This->format_internal,
 127                                                          pDesc->Width);
 128         This->layer_stride_internal = util_format_get_2d_size(This->format_internal,
 129                                                                 This->stride_internal,
 130                                                                 pDesc->Height);
 131         This->data_internal = align_calloc(This->layer_stride_internal *
 132                                              This->desc.Depth, 32);
 133         if (!This->data_internal)
 134             return E_OUTOFMEMORY;
 135     }
 136
 137     if (!This->resource) {
 138         hr = NineVolume9_AllocateData(This);
 139         if (FAILED(hr))
 140             return hr;
 141     }
 142     return D3D_OK;
 143 }
 144
 145 static void
 146 NineVolume9_dtor( struct NineVolume9 *This )
 147 {
 148     DBG("This=%p\n", This);
 149
 150     if (This->transfer) {
 151         struct pipe_context *pipe = nine_context_get_pipe_multithread(This->base.device);
 152         pipe->transfer_unmap(pipe, This->transfer);
 153         This->transfer = NULL;
 154     }
 155
 156     /* Note: Following condition cannot happen currently, since we
 157      * refcount the volume in the functions increasing
 158      * pending_uploads_counter. */
 159     if (p_atomic_read(&This->pending_uploads_counter))
 160         nine_csmt_process(This->base.device);
 161
 162     if (This->data)
 163         align_free(This->data);
 164     if (This->data_internal)
 165         align_free(This->data_internal);
 166
 167     pipe_resource_reference(&This->resource, NULL);
 168
 169     NineUnknown_dtor(&This->base);
 170 }
 171
 172 HRESULT NINE_WINAPI
 173 NineVolume9_GetContainer( struct NineVolume9 *This,
 174                           REFIID riid,
 175                           void **ppContainer )
 176 {
 177     char guid_str[64];
 178
 179     DBG("This=%p riid=%p id=%s ppContainer=%p\n",
 180         This, riid, riid ? GUID_sprintf(guid_str, riid) : "", ppContainer);
 181
 182     (void)guid_str;
 183
 184     if (!NineUnknown(This)->container)
 185         return E_NOINTERFACE;
 186     return NineUnknown_QueryInterface(NineUnknown(This)->container, riid, ppContainer);
 187 }
 188
 189 static inline void
 190 NineVolume9_MarkContainerDirty( struct NineVolume9 *This )
 191 {
 192     struct NineBaseTexture9 *tex;
 193 #if defined(DEBUG) || !defined(NDEBUG)
 194     /* This is always contained by a NineVolumeTexture9. */
 195     GUID id = IID_IDirect3DVolumeTexture9;
 196     REFIID ref = &id;
 197     assert(NineUnknown_QueryInterface(This->base.container, ref, (void **)&tex)
 198            == S_OK);
 199     assert(NineUnknown_Release(NineUnknown(tex)) != 0);
 200 #endif
 201
 202     tex = NineBaseTexture9(This->base.container);
 203     assert(tex);
 204     if (This->desc.Pool == D3DPOOL_MANAGED)
 205         tex->managed.dirty = TRUE;
 206
 207     BASETEX_REGISTER_UPDATE(tex);
 208 }
 209
 210 HRESULT NINE_WINAPI
 211 NineVolume9_GetDesc( struct NineVolume9 *This,
 212                      D3DVOLUME_DESC *pDesc )
 213 {
 214     user_assert(pDesc != NULL, E_POINTER);
 215     *pDesc = This->desc;
 216     return D3D_OK;
 217 }
 218
 219 inline void
 220 NineVolume9_AddDirtyRegion( struct NineVolume9 *This,
 221                             const struct pipe_box *box )
 222 {
 223     D3DBOX dirty_region;
 224     struct NineVolumeTexture9 *tex = NineVolumeTexture9(This->base.container);
 225
 226     if (!box) {
 227         NineVolumeTexture9_AddDirtyBox(tex, NULL);
 228     } else {
 229         dirty_region.Left = box->x << This->level_actual;
 230         dirty_region.Top = box->y << This->level_actual;
 231         dirty_region.Front = box->z << This->level_actual;
 232         dirty_region.Right = dirty_region.Left + (box->width << This->level_actual);
 233         dirty_region.Bottom = dirty_region.Top + (box->height << This->level_actual);
 234         dirty_region.Back = dirty_region.Front + (box->depth << This->level_actual);
 235         NineVolumeTexture9_AddDirtyBox(tex, &dirty_region);
 236     }
 237 }
 238
 239 static inline unsigned
 240 NineVolume9_GetSystemMemOffset(enum pipe_format format, unsigned stride,
 241                                unsigned layer_stride,
 242                                int x, int y, int z)
 243 {
 244     unsigned x_offset = util_format_get_stride(format, x);
 245
 246     y = util_format_get_nblocksy(format, y);
 247
 248     return z * layer_stride + y * stride + x_offset;
 249 }
 250
 251 HRESULT NINE_WINAPI
 252 NineVolume9_LockBox( struct NineVolume9 *This,
 253                      D3DLOCKED_BOX *pLockedVolume,
 254                      const D3DBOX *pBox,
 255                      DWORD Flags )
 256 {
 257     struct pipe_context *pipe;
 258     struct pipe_resource *resource = This->resource;
 259     struct pipe_box box;
 260     unsigned usage;
 261
 262     DBG("This=%p(%p) pLockedVolume=%p pBox=%p[%u..%u,%u..%u,%u..%u] Flags=%s\n",
 263         This, This->base.container, pLockedVolume, pBox,
 264         pBox ? pBox->Left : 0, pBox ? pBox->Right : 0,
 265         pBox ? pBox->Top : 0, pBox ? pBox->Bottom : 0,
 266         pBox ? pBox->Front : 0, pBox ? pBox->Back : 0,
 267         nine_D3DLOCK_to_str(Flags));
 268
 269     /* check if it's already locked */
 270     user_assert(This->lock_count == 0, D3DERR_INVALIDCALL);
 271
 272     /* set pBits to NULL after lock_count check */
 273     user_assert(pLockedVolume, E_POINTER);
 274     pLockedVolume->pBits = NULL;
 275
 276     user_assert(This->desc.Pool != D3DPOOL_DEFAULT ||
 277                 (This->desc.Usage & D3DUSAGE_DYNAMIC), D3DERR_INVALIDCALL);
 278
 279     user_assert(!((Flags & D3DLOCK_DISCARD) && (Flags & D3DLOCK_READONLY)),
 280                 D3DERR_INVALIDCALL);
 281
 282     if (pBox && compressed_format (This->desc.Format)) { /* For volume all pools are checked */
 283         const unsigned w = util_format_get_blockwidth(This->info.format);
 284         const unsigned h = util_format_get_blockheight(This->info.format);
 285         user_assert((pBox->Left == 0 && pBox->Right == This->desc.Width &&
 286                      pBox->Top == 0 && pBox->Bottom == This->desc.Height) ||
 287                     (!(pBox->Left % w) && !(pBox->Right % w) &&
 288                      !(pBox->Top % h) && !(pBox->Bottom % h)),
 289                     D3DERR_INVALIDCALL);
 290     }
 291
 292     if (Flags & D3DLOCK_DISCARD) {
 293         usage = PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE;
 294     } else {
 295         usage = (Flags & D3DLOCK_READONLY) ?
 296             PIPE_TRANSFER_READ : PIPE_TRANSFER_READ_WRITE;
 297     }
 298     if (Flags & D3DLOCK_DONOTWAIT)
 299         usage |= PIPE_TRANSFER_DONTBLOCK;
 300
 301     if (pBox) {
 302         user_assert(pBox->Right > pBox->Left, D3DERR_INVALIDCALL);
 303         user_assert(pBox->Bottom > pBox->Top, D3DERR_INVALIDCALL);
 304         user_assert(pBox->Back > pBox->Front, D3DERR_INVALIDCALL);
 305         user_assert(pBox->Right <= This->desc.Width, D3DERR_INVALIDCALL);
 306         user_assert(pBox->Bottom <= This->desc.Height, D3DERR_INVALIDCALL);
 307         user_assert(pBox->Back <= This->desc.Depth, D3DERR_INVALIDCALL);
 308
 309         d3dbox_to_pipe_box(&box, pBox);
 310         if (u_box_clip_2d(&box, &box, This->desc.Width, This->desc.Height) < 0) {
 311             DBG("Locked volume intersection empty.\n");
 312             return D3DERR_INVALIDCALL;
 313         }
 314     } else {
 315         u_box_3d(0, 0, 0, This->desc.Width, This->desc.Height, This->desc.Depth,
 316                  &box);
 317     }
 318
 319     if (p_atomic_read(&This->pending_uploads_counter))
 320         nine_csmt_process(This->base.device);
 321
 322     if (This->data_internal || This->data) {
 323         enum pipe_format format = This->info.format;
 324         unsigned stride = This->stride;
 325         unsigned layer_stride = This->layer_stride;
 326         uint8_t *data = This->data;
 327         if (This->data_internal) {
 328             format = This->format_internal;
 329             stride = This->stride_internal;
 330             layer_stride = This->layer_stride_internal;
 331             data = This->data_internal;
 332         }
 333         pLockedVolume->RowPitch = stride;
 334         pLockedVolume->SlicePitch = layer_stride;
 335         pLockedVolume->pBits = data +
 336             NineVolume9_GetSystemMemOffset(format, stride,
 337                                            layer_stride,
 338                                            box.x, box.y, box.z);
 339     } else {
 340         bool no_refs = !p_atomic_read(&This->base.bind) &&
 341             !p_atomic_read(&This->base.container->bind);
 342         if (no_refs)
 343             pipe = nine_context_get_pipe_acquire(This->base.device);
 344         else
 345             pipe = NineDevice9_GetPipe(This->base.device);
 346         pLockedVolume->pBits =
 347             pipe->transfer_map(pipe, resource, This->level, usage,
 348                                &box, &This->transfer);
 349         if (no_refs)
 350             nine_context_get_pipe_release(This->base.device);
 351         if (!This->transfer) {
 352             if (Flags & D3DLOCK_DONOTWAIT)
 353                 return D3DERR_WASSTILLDRAWING;
 354             return D3DERR_DRIVERINTERNALERROR;
 355         }
 356         pLockedVolume->RowPitch = This->transfer->stride;
 357         pLockedVolume->SlicePitch = This->transfer->layer_stride;
 358     }
 359
 360     if (!(Flags & (D3DLOCK_NO_DIRTY_UPDATE | D3DLOCK_READONLY))) {
 361         NineVolume9_MarkContainerDirty(This);
 362         NineVolume9_AddDirtyRegion(This, &box);
 363     }
 364
 365     ++This->lock_count;
 366     return D3D_OK;
 367 }
 368
 369 HRESULT NINE_WINAPI
 370 NineVolume9_UnlockBox( struct NineVolume9 *This )
 371 {
 372     struct pipe_context *pipe;
 373
 374     DBG("This=%p lock_count=%u\n", This, This->lock_count);
 375     user_assert(This->lock_count, D3DERR_INVALIDCALL);
 376     if (This->transfer) {
 377         pipe = nine_context_get_pipe_acquire(This->base.device);
 378         pipe->transfer_unmap(pipe, This->transfer);
 379         This->transfer = NULL;
 380         nine_context_get_pipe_release(This->base.device);
 381     }
 382     --This->lock_count;
 383
 384     if (This->data_internal) {
 385         struct pipe_box box;
 386
 387         u_box_3d(0, 0, 0, This->desc.Width, This->desc.Height, This->desc.Depth,
 388                  &box);
 389
 390
 391         if (This->data) {
 392             (void) util_format_translate_3d(This->info.format,
 393                                             This->data, This->stride,
 394                                             This->layer_stride,
 395                                             0, 0, 0,
 396                                             This->format_internal,
 397                                             This->data_internal,
 398                                             This->stride_internal,
 399                                             This->layer_stride_internal,
 400                                             0, 0, 0,
 401                                             This->desc.Width, This->desc.Height,
 402                                             This->desc.Depth);
 403         } else {
 404             nine_context_box_upload(This->base.device,
 405                                     &This->pending_uploads_counter,
 406                                     (struct NineUnknown *)This,
 407                                     This->resource,
 408                                     This->level,
 409                                     &box,
 410                                     This->format_internal,
 411                                     This->data_internal,
 412                                     This->stride_internal,
 413                                     This->layer_stride_internal,
 414                                     &box);
 415         }
 416     }
 417
 418     return D3D_OK;
 419 }
 420
 421 /* When this function is called, we have already checked
 422  * The copy regions fit the volumes */
 423 void
 424 NineVolume9_CopyMemToDefault( struct NineVolume9 *This,
 425                               struct NineVolume9 *From,
 426                               unsigned dstx, unsigned dsty, unsigned dstz,
 427                               struct pipe_box *pSrcBox )
 428 {
 429     struct pipe_resource *r_dst = This->resource;
 430     struct pipe_box src_box;
 431     struct pipe_box dst_box;
 432
 433     DBG("This=%p From=%p dstx=%u dsty=%u dstz=%u pSrcBox=%p\n",
 434         This, From, dstx, dsty, dstz, pSrcBox);
 435
 436     assert(This->desc.Pool == D3DPOOL_DEFAULT &&
 437            From->desc.Pool == D3DPOOL_SYSTEMMEM);
 438
 439     dst_box.x = dstx;
 440     dst_box.y = dsty;
 441     dst_box.z = dstz;
 442
 443     if (pSrcBox) {
 444         src_box = *pSrcBox;
 445     } else {
 446         src_box.x = 0;
 447         src_box.y = 0;
 448         src_box.z = 0;
 449         src_box.width = From->desc.Width;
 450         src_box.height = From->desc.Height;
 451         src_box.depth = From->desc.Depth;
 452     }
 453
 454     dst_box.width = src_box.width;
 455     dst_box.height = src_box.height;
 456     dst_box.depth = src_box.depth;
 457
 458     nine_context_box_upload(This->base.device,
 459                             &From->pending_uploads_counter,
 460                             (struct NineUnknown *)From,
 461                             r_dst,
 462                             This->level,
 463                             &dst_box,
 464                             From->info.format,
 465                             From->data, From->stride,
 466                             From->layer_stride,
 467                             &src_box);
 468
 469     if (This->data_internal)
 470         (void) util_format_translate_3d(This->format_internal,
 471                                         This->data_internal,
 472                                         This->stride_internal,
 473                                         This->layer_stride_internal,
 474                                         dstx, dsty, dstz,
 475                                         From->info.format,
 476                                         From->data, From->stride,
 477                                         From->layer_stride,
 478                                         src_box.x, src_box.y,
 479                                         src_box.z,
 480                                         src_box.width,
 481                                         src_box.height,
 482                                         src_box.depth);
 483
 484     NineVolume9_MarkContainerDirty(This);
 485
 486     return;
 487 }
 488
 489 HRESULT
 490 NineVolume9_UploadSelf( struct NineVolume9 *This,
 491                         const struct pipe_box *damaged )
 492 {
 493     struct pipe_resource *res = This->resource;
 494     struct pipe_box box;
 495
 496     DBG("This=%p damaged=%p data=%p res=%p\n", This, damaged,
 497         This->data, res);
 498
 499     assert(This->desc.Pool == D3DPOOL_MANAGED);
 500     assert(res);
 501
 502     if (damaged) {
 503         box = *damaged;
 504     } else {
 505         box.x = 0;
 506         box.y = 0;
 507         box.z = 0;
 508         box.width = This->desc.Width;
 509         box.height = This->desc.Height;
 510         box.depth = This->desc.Depth;
 511     }
 512
 513     nine_context_box_upload(This->base.device,
 514                             &This->pending_uploads_counter,
 515                             (struct NineUnknown *)This,
 516                             res,
 517                             This->level,
 518                             &box,
 519                             res->format,
 520                             This->data, This->stride,
 521                             This->layer_stride,
 522                             &box);
 523
 524     return D3D_OK;
 525 }
 526
 527
 528 IDirect3DVolume9Vtbl NineVolume9_vtable = {
 529     (void *)NineUnknown_QueryInterface,
 530     (void *)NineUnknown_AddRef,
 531     (void *)NineUnknown_Release,
 532     (void *)NineUnknown_GetDevice, /* actually part of Volume9 iface */
 533     (void *)NineUnknown_SetPrivateData,
 534     (void *)NineUnknown_GetPrivateData,
 535     (void *)NineUnknown_FreePrivateData,
 536     (void *)NineVolume9_GetContainer,
 537     (void *)NineVolume9_GetDesc,
 538     (void *)NineVolume9_LockBox,
 539     (void *)NineVolume9_UnlockBox
 540 };
 541
 542 static const GUID *NineVolume9_IIDs[] = {
 543     &IID_IDirect3DVolume9,
 544     &IID_IUnknown,
 545     NULL
 546 };
 547
 548 HRESULT
 549 NineVolume9_new( struct NineDevice9 *pDevice,
 550                  struct NineUnknown *pContainer,
 551                  struct pipe_resource *pResource,
 552                  unsigned Level,
 553                  D3DVOLUME_DESC *pDesc,
 554                  struct NineVolume9 **ppOut )
 555 {
 556     NINE_DEVICE_CHILD_NEW(Volume9, ppOut, pDevice, /* args */
 557                           pContainer, pResource, Level, pDesc);
 558 }