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
NineSurface9_CopySurface( struct NineSurface9 *This,
struct NineSurface9 *From,
const POINT *pDestPoint,
const RECT *pSourceRect )
{
struct pipe_context *pipe = This->pipe;
struct pipe_resource *r_dst = This->base.resource;
struct pipe_resource *r_src = From->base.resource;
struct pipe_transfer *transfer;
struct pipe_box src_box;
struct pipe_box dst_box;
uint8_t *p_dst;
const uint8_t *p_src;
DBG("This=%p From=%p pDestPoint=%p pSourceRect=%p\n",
This, From, pDestPoint, pSourceRect);
assert(This->base.pool != D3DPOOL_MANAGED &&
From->base.pool != D3DPOOL_MANAGED);
user_assert(This->desc.Format == From->desc.Format, D3DERR_INVALIDCALL);
dst_box.x = pDestPoint ? pDestPoint->x : 0;
dst_box.y = pDestPoint ? pDestPoint->y : 0;
user_assert(dst_box.x >= 0 &&
dst_box.y >= 0, D3DERR_INVALIDCALL);
dst_box.z = This->layer;
src_box.z = From->layer;
dst_box.depth = 1;
src_box.depth = 1;
if (pSourceRect) {
/* make sure it doesn't range outside the source surface */
user_assert(pSourceRect->left >= 0 &&
pSourceRect->right <= From->desc.Width &&
pSourceRect->top >= 0 &&
pSourceRect->bottom <= From->desc.Height,
D3DERR_INVALIDCALL);
if (rect_to_pipe_box_xy_only_clamp(&src_box, pSourceRect))
return D3D_OK;
} else {
src_box.x = 0;
src_box.y = 0;
src_box.width = From->desc.Width;
src_box.height = From->desc.Height;
}
/* limits */
dst_box.width = This->desc.Width - dst_box.x;
dst_box.height = This->desc.Height - dst_box.y;
user_assert(src_box.width <= dst_box.width &&
src_box.height <= dst_box.height, D3DERR_INVALIDCALL);
dst_box.width = src_box.width;
dst_box.height = src_box.height;
/* check source block align for compressed textures */
if (util_format_is_compressed(From->base.info.format) &&
((src_box.width != From->desc.Width) ||
(src_box.height != From->desc.Height))) {
const unsigned w = util_format_get_blockwidth(From->base.info.format);
const unsigned h = util_format_get_blockheight(From->base.info.format);
user_assert(!(src_box.width % w) &&
!(src_box.height % h),
D3DERR_INVALIDCALL);
}
/* check destination block align for compressed textures */
if (util_format_is_compressed(This->base.info.format) &&
((dst_box.width != This->desc.Width) ||
(dst_box.height != This->desc.Height) ||
dst_box.x != 0 ||
dst_box.y != 0)) {
const unsigned w = util_format_get_blockwidth(This->base.info.format);
const unsigned h = util_format_get_blockheight(This->base.info.format);
user_assert(!(dst_box.x % w) && !(dst_box.width % w) &&
!(dst_box.y % h) && !(dst_box.height % h),
D3DERR_INVALIDCALL);
}
if (r_dst && r_src) {
pipe->resource_copy_region(pipe,
r_dst, This->level,
dst_box.x, dst_box.y, dst_box.z,
r_src, From->level,
&src_box);
} else
if (r_dst) {
p_src = NineSurface9_GetSystemMemPointer(From, src_box.x, src_box.y);
pipe->transfer_inline_write(pipe, r_dst, This->level,
0, /* WRITE|DISCARD are implicit */
&dst_box, p_src, From->stride, 0);
} else
if (r_src) {
p_dst = NineSurface9_GetSystemMemPointer(This, 0, 0);
p_src = pipe->transfer_map(pipe, r_src, From->level,
PIPE_TRANSFER_READ,
&src_box, &transfer);
if (!p_src)
return D3DERR_DRIVERINTERNALERROR;
util_copy_rect(p_dst, This->base.info.format,
This->stride, dst_box.x, dst_box.y,
dst_box.width, dst_box.height,
p_src,
transfer->stride, src_box.x, src_box.y);
pipe->transfer_unmap(pipe, transfer);
} else {
p_dst = NineSurface9_GetSystemMemPointer(This, 0, 0);
p_src = NineSurface9_GetSystemMemPointer(From, 0, 0);
util_copy_rect(p_dst, This->base.info.format,
This->stride, dst_box.x, dst_box.y,
dst_box.width, dst_box.height,
p_src,
From->stride, src_box.x, src_box.y);
}
if (This->base.pool == D3DPOOL_DEFAULT)
NineSurface9_MarkContainerDirty(This);
if (!r_dst && This->base.resource)
NineSurface9_AddDirtyRect(This, &dst_box);
return D3D_OK;
}
/* When this function is called, we have already checked
* The copy regions fit the surfaces */
void
NineSurface9_CopyMemToDefault( struct NineSurface9 *This,
struct NineSurface9 *From,
const POINT *pDestPoint,
const RECT *pSourceRect )
{
struct pipe_context *pipe = This->pipe;
struct pipe_transfer *transfer = NULL;
struct pipe_resource *r_dst = This->base.resource;
struct pipe_box dst_box;
uint8_t *map = NULL;
int src_x, src_y, dst_x, dst_y, copy_width, copy_height;
assert(This->base.pool == D3DPOOL_DEFAULT &&
From->base.pool == D3DPOOL_SYSTEMMEM);
if (pDestPoint) {
dst_x = pDestPoint->x;
dst_y = pDestPoint->y;
} else {
dst_x = 0;
dst_y = 0;
}
if (pSourceRect) {
src_x = pSourceRect->left;
src_y = pSourceRect->top;
copy_width = pSourceRect->right - pSourceRect->left;
copy_height = pSourceRect->bottom - pSourceRect->top;
} else {
src_x = 0;
src_y = 0;
copy_width = From->desc.Width;
copy_height = From->desc.Height;
}
u_box_2d_zslice(dst_x, dst_y, This->layer,
copy_width, copy_height, &dst_box);
map = pipe->transfer_map(pipe,
r_dst,
This->level,
PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
&dst_box, &transfer);
if (!map)
return;
/* Note: if formats are the sames, it will revert
* to normal memcpy */
(void) util_format_translate(r_dst->format,
map, transfer->stride,
0, 0,
From->base.info.format,
From->data, From->stride,
src_x, src_y,
copy_width, copy_height);
pipe_transfer_unmap(pipe, transfer);
if (This->data_conversion)
(void) util_format_translate(This->format_conversion,
This->data_conversion,
This->stride_conversion,
dst_x, dst_y,
From->base.info.format,
From->data, From->stride,
src_x, src_y,
copy_width, copy_height);
NineSurface9_MarkContainerDirty(This);
}
