static int InterlaceRunFormat()
{
IceTVoid *imagebuffer;
IceTImage image;
int result;
imagebuffer = malloc(icetImageBufferSize(SCREEN_WIDTH, SCREEN_HEIGHT));
image = icetImageAssignBuffer(imagebuffer, SCREEN_WIDTH, SCREEN_HEIGHT);
printf("\n********* Creating lower triangle image\n");
LowerTriangleImage(image);
result = TestInterlaceSplit(image);
if (result != TEST_PASSED) { return result; }
printf("\n********* Creating full image\n");
FullImage(image);
result = TestInterlaceSplit(image);
if (result != TEST_PASSED) { return result; }
free(imagebuffer);
return TEST_PASSED;
}
static int CompareSparseImages(const IceTSparseImage image0,
const IceTSparseImage image1)
{
IceTSizeType width;
IceTSizeType height;
IceTVoid *image_buffer[2];
IceTImage image[2];
IceTUInt *color_buffer[2];
IceTSizeType i;
if ( icetSparseImageGetCompressedBufferSize(image0)
!= icetSparseImageGetCompressedBufferSize(image1) ) {
printf("Buffer sizes do not match: %d vs %d!\n",
icetSparseImageGetCompressedBufferSize(image0),
icetSparseImageGetCompressedBufferSize(image1));
return TEST_FAILED;
}
width = icetSparseImageGetWidth(image1);
height = icetSparseImageGetHeight(image1);
image_buffer[0] = malloc(icetImageBufferSize(width, height));
image[0] = icetImageAssignBuffer(image_buffer[0], width, height);
icetDecompressImage(image0, image[0]);
color_buffer[0] = icetImageGetColorui(image[0]);
image_buffer[1] = malloc(icetImageBufferSize(width, height));
image[1] = icetImageAssignBuffer(image_buffer[1], width, height);
icetDecompressImage(image1, image[1]);
color_buffer[1] = icetImageGetColorui(image[1]);
for (i = 0; i < width*height; i++) {
if (color_buffer[0][i] != color_buffer[1][i]) {
printf("Buffer mismatch at uint %d\n", i);
printf("0x%x vs 0x%x\n", color_buffer[0][i], color_buffer[1][i]);
return TEST_FAILED;
}
}
return TEST_PASSED;
}
static int SparseImageCopyRun()
{
IceTVoid *imagebuffer;
IceTImage image;
icetSetColorFormat(ICET_IMAGE_COLOR_RGBA_UBYTE);
icetSetDepthFormat(ICET_IMAGE_DEPTH_NONE);
icetCompositeMode(ICET_COMPOSITE_MODE_BLEND);
imagebuffer = malloc(icetImageBufferSize(SCREEN_WIDTH, SCREEN_HEIGHT));
image = icetImageAssignBuffer(imagebuffer, SCREEN_WIDTH, SCREEN_HEIGHT);
printf("\n********* Creating lower triangle image\n");
LowerTriangleImage(image);
if (TestSparseImageCopyPixels(image) != TEST_PASSED) {
return TEST_FAILED;
}
if (TestSparseImageSplit(image) != TEST_PASSED) {
return TEST_FAILED;
}
printf("\n********* Creating upper triangle image\n");
UpperTriangleImage(image);
if (TestSparseImageCopyPixels(image) != TEST_PASSED) {
return TEST_FAILED;
}
if (TestSparseImageSplit(image) != TEST_PASSED) {
return TEST_FAILED;
}
free(imagebuffer);
return TEST_PASSED;
}
static int DoCompressionTest(IceTEnum color_format, IceTEnum depth_format,
IceTEnum composite_mode)
{
IceTInt viewport[4];
IceTSizeType pixels;
IceTImage image;
IceTVoid *imagebuffer;
IceTSizeType imagesize;
IceTSparseImage compressedimage;
IceTVoid *compressedbuffer;
IceTSparseImage interlacedimage;
IceTVoid *interlacedbuffer;
IceTSizeType compressedsize;
IceTSizeType color_pixel_size;
IceTSizeType depth_pixel_size;
IceTSizeType pixel_size;
IceTSizeType size;
int result;
result = TEST_PASSED;
printstat("Using color format of 0x%x\n", (int)color_format);
printstat("Using depth format of 0x%x\n", (int)depth_format);
printstat("Using composite mode of 0x%x\n", (int)composite_mode);
icetSetColorFormat(color_format);
icetSetDepthFormat(depth_format);
icetCompositeMode(composite_mode);
pixels = SCREEN_WIDTH*SCREEN_HEIGHT;
printstat("Allocating memory for %dx%d pixel image.\n",
(int)SCREEN_WIDTH, (int)SCREEN_HEIGHT);
imagesize = icetImageBufferSize(SCREEN_WIDTH, SCREEN_HEIGHT);
imagebuffer = malloc(imagesize);
image = icetImageAssignBuffer(imagebuffer, SCREEN_WIDTH, SCREEN_HEIGHT);
compressedsize = icetSparseImageBufferSize(SCREEN_WIDTH, SCREEN_HEIGHT);
compressedbuffer = malloc(compressedsize);
compressedimage = icetSparseImageAssignBuffer(compressedbuffer,
SCREEN_WIDTH,
SCREEN_HEIGHT);
interlacedbuffer = malloc(compressedsize);
interlacedimage = icetSparseImageAssignBuffer(interlacedbuffer,
SCREEN_WIDTH,
SCREEN_HEIGHT);
/* Get the number of bytes per pixel. This is used in checking the
size of compressed images. */
icetImageGetColorVoid(image, &color_pixel_size);
icetImageGetDepthVoid(image, &depth_pixel_size);
pixel_size = color_pixel_size + depth_pixel_size;
printstat("Pixel size: color=%d, depth=%d, total=%d\n",
(int)color_pixel_size, (int)depth_pixel_size, (int)pixel_size);
printstat("\nCreating worst possible image"
" (with respect to compression).\n");
InitPathologicalImage(image);
printstat("Compressing image.\n");
icetCompressImage(image, compressedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)(pixel_size*(pixels/2) + 2*sizeof(IceTUShort)*(pixels/2)),
(int)size);
if ( (size > compressedsize)
|| (size < pixel_size*(pixels/2)) ) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("Interlacing image.\n");
icetSparseImageInterlace(compressedimage,
97,
ICET_SI_STRATEGY_BUFFER_0,
interlacedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)(pixel_size*(pixels/2) + 2*sizeof(IceTUShort)*(pixels/2)),
(int)size);
if ( (size > compressedsize)
|| (size < pixel_size*(pixels/2)) ) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("\nCreating a different worst possible image.\n");
InitActiveImage(image);
printstat("Compressing image.\n");
icetCompressImage(image, compressedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)compressedsize, (int)size);
if ((size > compressedsize) || (size < pixel_size*pixels)) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("Interlacing image.\n");
icetSparseImageInterlace(compressedimage,
97,
ICET_SI_STRATEGY_BUFFER_0,
interlacedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)(pixel_size*(pixels/2) + 2*sizeof(IceTUShort)*(pixels/2)),
(int)size);
if ( (size > compressedsize)
|| (size < pixel_size*(pixels/2)) ) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("\nCompressing zero size image.\n");
icetImageSetDimensions(image, 0, 0);
icetCompressImage(image, compressedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)icetSparseImageBufferSize(0, 0), (int)size);
if (size > icetSparseImageBufferSize(0, 0)) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
/* This test can be a little volatile. The icetGetCompressedTileImage
* expects certain things to be set correctly by the icetDrawFrame
* function. Since we want to call icetGetCompressedTileImage directly,
* we try to set up these parameters by hand. It is possible for this
* test to incorrectly fail if the two functions are mutually changed and
* this scaffolding is not updated correctly. */
printstat("\nSetup for actual render.\n");
icetResetTiles();
icetAddTile(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
icetDrawCallback(drawCallback);
/* Do a perfunctory draw to set other state variables. */
icetDrawFrame(IdentityMatrix, IdentityMatrix, Black);
viewport[0] = viewport[1] = 0;
viewport[2] = (IceTInt)SCREEN_WIDTH; viewport[3] = (IceTInt)SCREEN_HEIGHT;
icetStateSetIntegerv(ICET_CONTAINED_VIEWPORT, 4, viewport);
printstat("Now render and get compressed image.\n");
icetGetCompressedTileImage(0, compressedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)compressedsize, (int)size);
if ((size > compressedsize) || (size < pixel_size*pixels)) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("Cleaning up.\n");
free(imagebuffer);
free(compressedbuffer);
free(interlacedbuffer);
return result;
}
void icetSingleImageCollect(const IceTSparseImage input_image,
IceTInt dest,
IceTSizeType piece_offset,
IceTImage result_image)
{
IceTSizeType *offsets;
IceTSizeType *sizes;
IceTInt rank;
IceTInt numproc;
IceTSizeType piece_size;
IceTEnum color_format;
IceTEnum depth_format;
IceTSizeType color_size = 1;
IceTSizeType depth_size = 1;
#define DUMMY_BUFFER_SIZE ((IceTSizeType)(16*sizeof(IceTInt)))
IceTByte dummy_buffer[DUMMY_BUFFER_SIZE];
rank = icetCommRank();
numproc = icetCommSize();
/* Collect partitions held by each process. */
piece_size = icetSparseImageGetNumPixels(input_image);
if (rank == dest) {
offsets = icetGetStateBuffer(ICET_IMAGE_COLLECT_OFFSET_BUF,
sizeof(IceTSizeType)*numproc);
sizes = icetGetStateBuffer(ICET_IMAGE_COLLECT_SIZE_BUF,
sizeof(IceTSizeType)*numproc);
} else {
offsets = NULL;
sizes = NULL;
}
/* Technically, these gathers are part of the collection process and should
therefore be timed. However, unless the compositing is very well load
balanced (and typically it is not), different processes will arrive here
at different times. These gathers act something like a barrier that
helps separate the time spent collecting final pixels from the time spent
in transferring and compositing fragments. */
icetCommGather(&piece_offset, 1, ICET_SIZE_TYPE, offsets, dest);
icetCommGather(&piece_size, 1, ICET_SIZE_TYPE, sizes, dest);
#ifdef DEBUG
if (rank == dest) {
IceTVoid *data;
IceTSizeType size;
if (icetImageGetColorFormat(result_image) != ICET_IMAGE_COLOR_NONE) {
data = icetImageGetColorVoid(result_image, &size);
memset(data, 0xCD, icetImageGetNumPixels(result_image)*size);
}
if (icetImageGetDepthFormat(result_image) != ICET_IMAGE_DEPTH_NONE) {
data = icetImageGetDepthVoid(result_image, &size);
memset(data, 0xCD, icetImageGetNumPixels(result_image)*size);
}
}
#endif
if (piece_size > 0) {
/* Decompress data into appropriate offset of result image. */
icetDecompressSubImageCorrectBackground(input_image,
piece_offset,
result_image);
} else if (rank != dest) {
/* If this function is called for multiple collections, it is likely
that the local process will not have data for all collections. To
prevent making the calling function allocate an image buffer when it
is neither sending or receiving data, just allocate a dummy buffer to
satisfy the following code. */
if (DUMMY_BUFFER_SIZE < icetImageBufferSize(0, 0)) {
icetRaiseError("Oops. My dummy buffer is not big enough.",
ICET_SANITY_CHECK_FAIL);
return;
}
result_image = icetImageAssignBuffer(dummy_buffer, 0, 0);
} else {
/* Collecting data at empty process. We still want to use the provided
result_image, but we have nothing of our own to put in it. Thus, do
nothing. */
}
/* Adjust image for output as some buffers, such as depth, might be
dropped. */
icetImageAdjustForOutput(result_image);
icetTimingCollectBegin();
color_format = icetImageGetColorFormat(result_image);
depth_format = icetImageGetDepthFormat(result_image);
if (color_format != ICET_IMAGE_COLOR_NONE) {
/* Use IceTByte for byte-based pointer arithmetic. */
IceTByte *color_buffer
= icetImageGetColorVoid(result_image, &color_size);
int proc;
if (rank == dest) {
/* Adjust sizes and offsets to sizes of pixel colors. */
for (proc = 0; proc < numproc; proc++) {
offsets[proc] *= color_size;
sizes[proc] *= color_size;
}
icetCommGatherv(ICET_IN_PLACE_COLLECT,
sizes[rank],
ICET_BYTE,
color_buffer,
sizes,
offsets,
dest);
} else {
icetCommGatherv(color_buffer + piece_offset * color_size,
piece_size * color_size,
ICET_BYTE,
NULL,
NULL,
NULL,
dest);
}
}
if (depth_format != ICET_IMAGE_DEPTH_NONE) {
/* Use IceTByte for byte-based pointer arithmetic. */
IceTByte *depth_buffer
= icetImageGetDepthVoid(result_image, &depth_size);
int proc;
if (rank == dest) {
/* Adjust sizes and offsets to sizes of pixel depths. Also
adjust for any adjustments made for color. */
if (color_size != depth_size) {
for (proc = 0; proc < numproc; proc++) {
offsets[proc] /= color_size;
offsets[proc] *= depth_size;
sizes[proc] /= color_size;
sizes[proc] *= depth_size;
}
}
icetCommGatherv(ICET_IN_PLACE_COLLECT,
sizes[rank],
ICET_BYTE,
depth_buffer,
sizes,
offsets,
dest);
} else {
icetCommGatherv(depth_buffer + piece_offset * depth_size,
piece_size * depth_size,
ICET_BYTE,
NULL,
NULL,
NULL,
dest);
}
}
icetTimingCollectEnd();
}
static int TestInterlaceSplit(const IceTImage image)
{
#define NUM_PARTITIONS 13
IceTVoid *original_sparse_buffer;
IceTSparseImage original_sparse;
IceTVoid *interlaced_sparse_buffer;
IceTSparseImage interlaced_sparse;
IceTVoid *sparse_partition_buffer[NUM_PARTITIONS];
IceTSparseImage sparse_partition[NUM_PARTITIONS];
IceTSizeType offsets[NUM_PARTITIONS];
IceTVoid *reconstruction_buffer;
IceTImage reconstruction;
IceTSizeType width;
IceTSizeType height;
IceTSizeType num_partition_pixels;
IceTInt partition;
width = icetImageGetWidth(image);
height = icetImageGetHeight(image);
num_partition_pixels
= icetSparseImageSplitPartitionNumPixels(width*height,
NUM_PARTITIONS,
NUM_PARTITIONS);
original_sparse_buffer = malloc(icetSparseImageBufferSize(width, height));
original_sparse = icetSparseImageAssignBuffer(original_sparse_buffer,
width,
height);
interlaced_sparse_buffer = malloc(icetSparseImageBufferSize(width, height));
interlaced_sparse = icetSparseImageAssignBuffer(interlaced_sparse_buffer,
width,
height);
for (partition = 0; partition < NUM_PARTITIONS; partition++) {
sparse_partition_buffer[partition]
= malloc(icetSparseImageBufferSize(num_partition_pixels, 1));
sparse_partition[partition]
= icetSparseImageAssignBuffer(sparse_partition_buffer[partition],
num_partition_pixels, 1);
}
reconstruction_buffer = malloc(icetImageBufferSize(width, height));
reconstruction = icetImageAssignBuffer(reconstruction_buffer,width,height);
icetCompressImage(image, original_sparse);
printf("Interlacing image for %d pieces\n", NUM_PARTITIONS);
icetSparseImageInterlace(original_sparse,
NUM_PARTITIONS,
ICET_SI_STRATEGY_BUFFER_0,
interlaced_sparse);
printf("Splitting image %d times\n", NUM_PARTITIONS);
icetSparseImageSplit(interlaced_sparse,
0,
NUM_PARTITIONS,
NUM_PARTITIONS,
sparse_partition,
offsets);
printf("Reconstructing image.\n");
for (partition = 0; partition < NUM_PARTITIONS; partition++) {
IceTSizeType real_offset = icetGetInterlaceOffset(partition,
NUM_PARTITIONS,
width*height);
icetDecompressSubImage(sparse_partition[partition],
real_offset,
reconstruction);
}
if (!CompareImageColors(image, reconstruction)) { return TEST_FAILED; }
if (!CompareImageDepths(image, reconstruction)) { return TEST_FAILED; }
free(original_sparse_buffer);
free(interlaced_sparse_buffer);
for (partition = 0; partition < NUM_PARTITIONS; partition++) {
free(sparse_partition_buffer[partition]);
}
free(reconstruction_buffer);
return TEST_PASSED;
}
