static int TrySparseImageCopyPixels(const IceTImage image, IceTSizeType start, IceTSizeType end) { IceTVoid *full_sparse_buffer; IceTSparseImage full_sparse; IceTVoid *compress_sub_buffer; IceTSparseImage compress_sub; IceTVoid *sparse_copy_buffer; IceTSparseImage sparse_copy; IceTSizeType width = icetImageGetWidth(image); IceTSizeType height = icetImageGetHeight(image); IceTSizeType sub_size = end - start; int result; printf("Trying sparse image copy from %d to %d\n", start, end); full_sparse_buffer = malloc(icetSparseImageBufferSize(width, height)); full_sparse = icetSparseImageAssignBuffer(full_sparse_buffer,width,height); compress_sub_buffer = malloc(icetSparseImageBufferSize(sub_size, 1)); compress_sub = icetSparseImageAssignBuffer(compress_sub_buffer, sub_size, 1); sparse_copy_buffer = malloc(icetSparseImageBufferSize(sub_size, 1)); sparse_copy = icetSparseImageAssignBuffer(sparse_copy_buffer, sub_size, 1); icetCompressSubImage(image, start, sub_size, compress_sub); icetCompressImage(image, full_sparse); icetSparseImageCopyPixels(full_sparse, start, sub_size, sparse_copy); result = CompareSparseImages(compress_sub, sparse_copy); free(full_sparse_buffer); free(compress_sub_buffer); free(sparse_copy_buffer); return result; }
static int TestSparseImageSplit(const IceTImage image) { #define NUM_PARTITIONS 7 IceTVoid *full_sparse_buffer; IceTSparseImage full_sparse; IceTVoid *sparse_partition_buffer[NUM_PARTITIONS]; IceTSparseImage sparse_partition[NUM_PARTITIONS]; IceTSizeType offsets[NUM_PARTITIONS]; IceTVoid *compare_sparse_buffer; IceTSparseImage compare_sparse; 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); full_sparse_buffer = malloc(icetSparseImageBufferSize(width, height)); full_sparse = icetSparseImageAssignBuffer(full_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); } compare_sparse_buffer = malloc(icetSparseImageBufferSize(num_partition_pixels, 1)); compare_sparse = icetSparseImageAssignBuffer(compare_sparse_buffer, num_partition_pixels, 1); icetCompressImage(image, full_sparse); printf("Spliting image %d times\n", NUM_PARTITIONS); icetSparseImageSplit(full_sparse, 0, NUM_PARTITIONS, NUM_PARTITIONS, sparse_partition, offsets); for (partition = 0; partition < NUM_PARTITIONS; partition++) { IceTInt result; icetCompressSubImage(image, offsets[partition], icetSparseImageGetNumPixels( sparse_partition[partition]), compare_sparse); printf(" Comparing partition %d\n", partition); result = CompareSparseImages(compare_sparse, sparse_partition[partition]); if (result != TEST_PASSED) return result; } printf("Spliting image %d times with first partition in place.\n", NUM_PARTITIONS); sparse_partition[0] = full_sparse; icetSparseImageSplit(full_sparse, 0, NUM_PARTITIONS, NUM_PARTITIONS, sparse_partition, offsets); for (partition = 0; partition < NUM_PARTITIONS; partition++) { IceTInt result; icetCompressSubImage(image, offsets[partition], icetSparseImageGetNumPixels( sparse_partition[partition]), compare_sparse); printf(" Comparing partition %d\n", partition); result = CompareSparseImages(compare_sparse, sparse_partition[partition]); if (result != TEST_PASSED) return result; } free(full_sparse_buffer); for (partition = 0; partition < NUM_PARTITIONS; partition++) { free(sparse_partition_buffer[partition]); } free(compare_sparse_buffer); return TEST_PASSED; #undef NUM_PARTITIONS }
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; }
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; }