boolean
util_format_translate_3d(enum pipe_format dst_format,
void *dst, unsigned dst_stride,
unsigned dst_slice_stride,
unsigned dst_x, unsigned dst_y,
unsigned dst_z,
enum pipe_format src_format,
const void *src, unsigned src_stride,
unsigned src_slice_stride,
unsigned src_x, unsigned src_y,
unsigned src_z, unsigned width,
unsigned height, unsigned depth)
{
uint8_t *dst_layer;
const uint8_t *src_layer;
unsigned z;
dst_layer = dst;
src_layer = src;
dst_layer += dst_z * dst_slice_stride;
src_layer += src_z * src_slice_stride;
for (z = 0; z < depth; ++z) {
if (!util_format_translate(dst_format, dst_layer, dst_stride,
dst_x, dst_y,
src_format, src_layer, src_stride,
src_x, src_y,
width, height))
return FALSE;
dst_layer += dst_slice_stride;
src_layer += src_slice_stride;
}
return TRUE;
}
/**
* Dump an image to .ppm file.
* \param format PIPE_FORMAT_x
* \param cpp bytes per pixel
* \param width width in pixels
* \param height height in pixels
* \param stride row stride in bytes
*/
void
debug_dump_image(const char *prefix,
enum pipe_format format, unsigned cpp,
unsigned width, unsigned height,
unsigned stride,
const void *data)
{
/* write a ppm file */
char filename[256];
unsigned char *rgb8;
FILE *f;
util_snprintf(filename, sizeof(filename), "%s.ppm", prefix);
rgb8 = MALLOC(height * width * 3);
if (!rgb8) {
return;
}
util_format_translate(
PIPE_FORMAT_R8G8B8_UNORM,
rgb8, width * 3,
0, 0,
format,
data, stride,
0, 0, width, height);
/* Must be opened in binary mode or DOS line ending causes data
* to be read with one byte offset.
*/
f = fopen(filename, "wb");
if (f) {
fprintf(f, "P6\n");
fprintf(f, "# ppm-file created by gallium\n");
fprintf(f, "%i %i\n", width, height);
fprintf(f, "255\n");
fwrite(rgb8, 1, height * width * 3, f);
fclose(f);
}
else {
fprintf(stderr, "Can't open %s for writing\n", filename);
}
FREE(rgb8);
}
HRESULT NINE_WINAPI
NineSurface9_UnlockRect( struct NineSurface9 *This )
{
DBG("This=%p lock_count=%u\n", This, This->lock_count);
user_assert(This->lock_count, D3DERR_INVALIDCALL);
if (This->transfer) {
This->pipe->transfer_unmap(This->pipe, This->transfer);
This->transfer = NULL;
}
--This->lock_count;
if (This->data_conversion) {
struct pipe_transfer *transfer;
uint8_t *dst = This->data;
struct pipe_box box;
u_box_origin_2d(This->desc.Width, This->desc.Height, &box);
if (!dst) {
dst = This->pipe->transfer_map(This->pipe,
This->base.resource,
This->level,
PIPE_TRANSFER_WRITE |
PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
&box, &transfer);
if (!dst)
return D3D_OK;
}
(void) util_format_translate(This->base.info.format,
dst, This->data ? This->stride : transfer->stride,
0, 0,
This->format_conversion,
This->data_conversion,
This->stride_conversion,
0, 0,
This->desc.Width, This->desc.Height);
if (!This->data)
pipe_transfer_unmap(This->pipe, transfer);
}
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);
}
