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