rodinia-benchmark/opencl/heartwall/util/avi/avimod.c

// #ifdef __cplusplus
// extern "C" {
// #endif

//===============================================================================================================================================================================================================
//	DEFINE / INCLUDE
//===============================================================================================================================================================================================================
#include "avimod.h"

//===============================================================================================================================================================================================================
//	FUNCTIONS
//===============================================================================================================================================================================================================

// Flips the specified image and crops it to the specified dimensions
// If scaled == true, all values are scaled to the range [0.0, 1.0
fp* chop_flip_image(	char *image, 
								int height, 
								int width, 
								int cropped,
								int scaled,
								int converted) {

	// fixed dimensions for cropping or not cropping, square vertices starting from initial point in top left corner going down and right
	int top;
	int bottom;
	int left;
	int right;
	if(cropped==1){
		top = 0;
		bottom = 0;
		left = 0;
		right = 0;
	}
	else{
		top = 0;
		bottom = height - 1;
		left = 0;
		right = width - 1;
	}

	// dimensions of new cropped image
	int height_new = bottom - top + 1;
	int width_new = right - left + 1;

	// counters
	int i, j;

	// allocate memory for cropped/flipped frame
	fp* result = (fp *) malloc(height_new * width_new * sizeof(fp));

	// crop/flip and scale frame
	fp temp;
	if (scaled) {
		fp scale = 1.0 / 255.0;
		for(i = 0; i <height_new; i++){				// rows
			for(j = 0; j <width_new; j++){			// colums
				temp = (fp) image[((height - 1 - (i + top)) * width) + (j + left)] * scale;
				if(temp<0){
					result[i*width_new+j] = temp + 256;
				}
				else{
					result[i*width_new+j] = temp;
				}
			}
		}
	} else {
		for(i = 0; i <height_new; i++){				// rows
			for(j = 0; j <width_new; j++){			// colums
				temp = (fp) image[((height - 1 - (i + top)) * width) + (j + left)] ;
				if(temp<0){
					result[i*width_new+j] = temp + 256;
				}
				else{
					result[i*width_new+j] = temp;
				}
			}
		}
	}

// convert storage method (from row-major to column-major)
	fp* result_converted = (fp *) malloc(height_new * width_new * sizeof(fp));
	if(converted==1){
		for(i = 0; i <width_new; i++){				// rows
			for(j = 0; j <height_new; j++){			// colums
				result_converted[i*height_new+j] = result[j*width_new+i];
			}
		}
	}
	else{
		result_converted = result;
	}
	free(result);

	// return
	return result_converted;
}

// Returns the specified frame from the specified video file
// If cropped == true, the frame is cropped to pre-determined dimensions
//  (hardcoded to the boundaries of the blood vessel in the test video)
// If scaled == true, all values are scaled to the range [0.0, 1.0]
fp* get_frame(	avi_t* cell_file, 
						int frame_num, 
						int cropped, 
						int scaled,
						int converted) {

	// variable
	int dummy;
	int width = AVI_video_width(cell_file);
	int height = AVI_video_height(cell_file);
	int status;

	// There are 600 frames in this file (i.e. frame_num = 600 causes an error)
	AVI_set_video_position(cell_file, frame_num);

	//Read in the frame from the AVI
	char* image_buf = (char*) malloc(width * height * sizeof(char));
	status = AVI_read_frame(cell_file, image_buf, &dummy);
	if(status == -1) {
		AVI_print_error((char*) "Error with AVI_read_frame");
		exit(-1);
	}

	// The image is read in upside-down, so we need to flip it
	fp* image_chopped;
	image_chopped = chop_flip_image(	image_buf, 
														height, 
														width, 
														cropped,
														scaled,
														converted);

	// free image buffer
	free(image_buf);

	// return
	return image_chopped;

} 

// #ifdef __cplusplus
// }
// #endif