HRESULT WINAPI
NineSurface9_LockRect( struct NineSurface9 *This,
D3DLOCKED_RECT *pLockedRect,
const RECT *pRect,
DWORD Flags )
{
struct pipe_resource *resource = This->base.resource;
struct pipe_box box;
unsigned usage;
DBG("This=%p pLockedRect=%p pRect=%p[%u..%u,%u..%u] Flags=%s\n", This,
pLockedRect, pRect,
pRect ? pRect->left : 0, pRect ? pRect->right : 0,
pRect ? pRect->top : 0, pRect ? pRect->bottom : 0,
nine_D3DLOCK_to_str(Flags));
NineSurface9_Dump(This);
#ifdef NINE_STRICT
user_assert(This->base.pool != D3DPOOL_DEFAULT ||
(resource && (resource->flags & NINE_RESOURCE_FLAG_LOCKABLE)),
D3DERR_INVALIDCALL);
#endif
user_assert(!(Flags & ~(D3DLOCK_DISCARD |
D3DLOCK_DONOTWAIT |
D3DLOCK_NO_DIRTY_UPDATE |
D3DLOCK_NOOVERWRITE |
D3DLOCK_NOSYSLOCK | /* ignored */
D3DLOCK_READONLY)), D3DERR_INVALIDCALL);
user_assert(!((Flags & D3DLOCK_DISCARD) && (Flags & D3DLOCK_READONLY)),
D3DERR_INVALIDCALL);
/* check if it's already locked */
user_assert(This->lock_count == 0, D3DERR_INVALIDCALL);
user_assert(pLockedRect, E_POINTER);
user_assert(This->desc.MultiSampleType == D3DMULTISAMPLE_NONE,
D3DERR_INVALIDCALL);
if (pRect && This->base.pool == D3DPOOL_DEFAULT &&
util_format_is_compressed(This->base.info.format)) {
const unsigned w = util_format_get_blockwidth(This->base.info.format);
const unsigned h = util_format_get_blockheight(This->base.info.format);
user_assert(!(pRect->left % w) && !(pRect->right % w) &&
!(pRect->top % h) && !(pRect->bottom % h),
D3DERR_INVALIDCALL);
}
if (Flags & D3DLOCK_DISCARD) {
usage = PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE;
} else {
usage = (Flags & D3DLOCK_READONLY) ?
PIPE_TRANSFER_READ : PIPE_TRANSFER_READ_WRITE;
}
if (Flags & D3DLOCK_DONOTWAIT)
usage |= PIPE_TRANSFER_DONTBLOCK;
if (pRect) {
rect_to_pipe_box(&box, pRect);
if (u_box_clip_2d(&box, &box, This->desc.Width,
This->desc.Height) < 0) {
DBG("pRect clipped by Width=%u Height=%u\n",
This->desc.Width, This->desc.Height);
return D3DERR_INVALIDCALL;
}
} else {
u_box_origin_2d(This->desc.Width, This->desc.Height, &box);
}
user_warn(This->desc.Format == D3DFMT_NULL);
if (This->data) {
DBG("returning system memory\n");
/* ATI1 and ATI2 need special handling, because of d3d9 bug.
* We must advertise to the application as if it is uncompressed
* and bpp 8, and the app has a workaround to work with the fact
* that it is actually compressed. */
if (is_ATI1_ATI2(This->base.info.format)) {
pLockedRect->Pitch = This->desc.Height;
pLockedRect->pBits = This->data + box.y * This->desc.Height + box.x;
} else {
pLockedRect->Pitch = This->stride;
pLockedRect->pBits = NineSurface9_GetSystemMemPointer(This,
box.x,
box.y);
}
} else {
DBG("mapping pipe_resource %p (level=%u usage=%x)\n",
resource, This->level, usage);
pLockedRect->pBits = This->pipe->transfer_map(This->pipe, resource,
This->level, usage, &box,
&This->transfer);
if (!This->transfer) {
DBG("transfer_map failed\n");
if (Flags & D3DLOCK_DONOTWAIT)
return D3DERR_WASSTILLDRAWING;
return D3DERR_INVALIDCALL;
}
pLockedRect->Pitch = This->transfer->stride;
}
if (!(Flags & (D3DLOCK_NO_DIRTY_UPDATE | D3DLOCK_READONLY))) {
NineSurface9_MarkContainerDirty(This);
NineSurface9_AddDirtyRect(This, &box);
}
++This->lock_count;
return D3D_OK;
}
HRESULT NINE_WINAPI
NineBuffer9_Lock( struct NineBuffer9 *This,
UINT OffsetToLock,
UINT SizeToLock,
void **ppbData,
DWORD Flags )
{
struct pipe_box box;
void *data;
unsigned usage = d3dlock_buffer_to_pipe_transfer_usage(Flags);
DBG("This=%p(pipe=%p) OffsetToLock=0x%x, SizeToLock=0x%x, Flags=0x%x\n",
This, This->base.resource,
OffsetToLock, SizeToLock, Flags);
user_assert(ppbData, E_POINTER);
user_assert(!(Flags & ~(D3DLOCK_DISCARD |
D3DLOCK_DONOTWAIT |
D3DLOCK_NO_DIRTY_UPDATE |
D3DLOCK_NOSYSLOCK |
D3DLOCK_READONLY |
D3DLOCK_NOOVERWRITE)), D3DERR_INVALIDCALL);
if (SizeToLock == 0) {
SizeToLock = This->size - OffsetToLock;
user_warn(OffsetToLock != 0);
}
u_box_1d(OffsetToLock, SizeToLock, &box);
if (This->base.pool == D3DPOOL_MANAGED) {
if (!This->managed.dirty) {
assert(LIST_IS_EMPTY(&This->managed.list));
list_add(&This->managed.list, &This->base.base.device->update_buffers);
This->managed.dirty = TRUE;
This->managed.dirty_box = box;
} else {
u_box_union_2d(&This->managed.dirty_box, &This->managed.dirty_box, &box);
}
*ppbData = (char *)This->managed.data + OffsetToLock;
DBG("returning pointer %p\n", *ppbData);
This->nmaps++;
return D3D_OK;
}
if (This->nmaps == This->maxmaps) {
struct pipe_transfer **newmaps =
REALLOC(This->maps, sizeof(struct pipe_transfer *)*This->maxmaps,
sizeof(struct pipe_transfer *)*(This->maxmaps << 1));
if (newmaps == NULL)
return E_OUTOFMEMORY;
This->maxmaps <<= 1;
This->maps = newmaps;
}
data = This->pipe->transfer_map(This->pipe, This->base.resource, 0,
usage, &box, &This->maps[This->nmaps]);
if (!data) {
DBG("pipe::transfer_map failed\n"
" usage = %x\n"
" box.x = %u\n"
" box.width = %u\n",
usage, box.x, box.width);
/* not sure what to return, msdn suggests this */
if (Flags & D3DLOCK_DONOTWAIT)
return D3DERR_WASSTILLDRAWING;
return D3DERR_INVALIDCALL;
}
DBG("returning pointer %p\n", data);
This->nmaps++;
*ppbData = data;
return D3D_OK;
}
