static void do_send_receive(struct node_info *my_info, int tile_held, GLint max_pixels, GLint num_tiles, GLint * tile_viewports, GLboolean *all_contained_tmasks, IceTImage imageBuffer, IceTSparseImage inImage, IceTSparseImage outImage) { GLint outImageSize = 0; /* To remove warning */ (void)tile_viewports; if (my_info->tile_sending != -1) { icetRaiseDebug2("Sending tile %d to node %d.", my_info->tile_sending, my_info->send_dest); if (tile_held == my_info->tile_sending) { outImageSize = icetCompressImage(imageBuffer, outImage); tile_held = -1; } else { outImageSize = icetGetCompressedTileImage(my_info->tile_sending, outImage); } } if (my_info->tile_receiving != -1) { icetRaiseDebug2("Receiving tile %d from node %d.", my_info->tile_receiving, my_info->recv_src); if ( (tile_held != my_info->tile_receiving) && all_contained_tmasks[my_info->rank*num_tiles +my_info->tile_receiving]) { icetGetTileImage(my_info->tile_receiving, imageBuffer); tile_held = my_info->tile_receiving; } if (my_info->tile_sending != -1) { icetAddSentBytes(outImageSize); ICET_COMM_SENDRECV(outImage, outImageSize, ICET_BYTE, my_info->send_dest, VTREE_IMAGE_DATA, inImage, icetSparseImageSize(max_pixels), ICET_BYTE, my_info->recv_src, VTREE_IMAGE_DATA); } else { ICET_COMM_RECV(inImage, icetSparseImageSize(max_pixels), ICET_BYTE, my_info->recv_src, VTREE_IMAGE_DATA); } if (tile_held == my_info->tile_receiving) { icetCompressedComposite(imageBuffer, inImage, 1); } else { icetDecompressImage(inImage, imageBuffer); } } else if (my_info->tile_sending != -1) { icetAddSentBytes(outImageSize); ICET_COMM_SEND(outImage, outImageSize, ICET_BYTE, my_info->send_dest, VTREE_IMAGE_DATA); } }
static IceTVoid *rtsi_generateDataFunc(IceTInt id, IceTInt dest, IceTSizeType *size) { IceTInt rank; const IceTInt *tile_list = icetUnsafeStateGetInteger(ICET_CONTAINED_TILES_LIST); IceTVoid *outBuffer; icetGetIntegerv(ICET_RANK, &rank); if (dest == rank) { /* Special case: sending to myself. Just get directly to color and depth buffers. */ icetGetCompressedTileImage(tile_list[id], rtsi_workingImage); *size = 0; return NULL; } icetGetCompressedTileImage(tile_list[id], rtsi_outSparseImage); icetSparseImagePackageForSend(rtsi_outSparseImage, &outBuffer, size); return outBuffer; }
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; }