text: //========================================================================================================================================================================================================200
  //======================================================================================================================================================150
  //====================================================================================================100
  //==================================================50
  
  //========================================================================================================================================================================================================200
  //	DEFINE / INCLUDE
  //========================================================================================================================================================================================================200
  
  //======================================================================================================================================================150
  //	LIBRARIES
  //======================================================================================================================================================150
  
  #include <stdlib.h>								// (in directory known to compiler)
  #include <math.h>								// (in directory known to compiler)
  #include <string.h>								// (in directory known to compiler)
  #include <CL/cl.h>
  
  //======================================================================================================================================================150
  //	MAIN FUNCTION HEADER
  //======================================================================================================================================================150
  
  #include "./main.h"								// (in the main program folder)	needed to recognized input parameters
  
  //======================================================================================================================================================150
  //	UTILITIES
  //======================================================================================================================================================150
  
  #include "./util/avi/avilib.h"					// (in directory)							needed by avi functions
  #include "./util/avi/avimod.h"					// (in directory)							needed by avi functions
  #include "./util/file/file.h"
  
  //======================================================================================================================================================150
  //	KERNEL
  //======================================================================================================================================================150
  
  #include "./kernel/kernel_gpu_opencl_wrapper.h"
  
  //======================================================================================================================================================150
  //	END
  //======================================================================================================================================================150
  
  //========================================================================================================================================================================================================200
  //	MAIN FUNCTION
  //========================================================================================================================================================================================================200
  
  int platform_id_inuse = 0; // platform id in use (default: 0)
  int device_id_inuse = 0; //device id in use (default : 0)
  
  int
  main(	int argc, 
  		char* argv []){
  
      printf("WG size of kernel = %d \n", NUMBER_THREADS);
  
  	//======================================================================================================================================================150
  	//	STRUCTURES, GLOBAL STRUCTURE VARIABLES
  	//======================================================================================================================================================150
  
  	params_common common;
  	common.common_mem = sizeof(params_common);
  
  	//======================================================================================================================================================150
  	// 	CHECK INPUT ARGUMENTS
  	//======================================================================================================================================================150
  
  	char* video_file_name = NULL;
  	char* input_file_name = NULL;
      common.frames_processed = -1;
  
      for (int i =0; i < argc; ++i) {
          switch (argv[i][1]) {
          case 'f':	// -f video file
              if (++i < argc) {
                  video_file_name = argv[i];
              } else {
                  printf("Could not read argument after option %s\n", argv[i-1]);
                  return 1;
              }
              break;
          case 'i':	 // -i input file
              if (++i < argc) {
                  input_file_name = argv[i];
              } else {
                  printf("Could not read argument after option %s\n", argv[i-1]);
                  return 1;
              }
              break;
          case 'h':
  		    printf("%s <-f video_file> <-i input_file> <-n num_frames> [-p platform_id] [-n device_id]\n", argv[0]);
              return 0;
          case 'n':   // -n number of frames
              if (++i < argc) {
      		    common.frames_processed = atoi(argv[i]);
              } else {
                  printf("Could not read argument after option %s\n", argv[i-1]);
                  return 1;
              }
              break;
          case 'p':   // -p platform id
              if (++i < argc) {
                  platform_id_inuse = atoi(argv[i]);
              } else {
                  printf("Could not read argument after option %s\n", argv[i-1]);
                  return 1;
              }
              break;
          case 'd':   // -d device id
              if (++i < argc) {
                  device_id_inuse = atoi(argv[i]);
              } else {
                  printf("Could not read argument after option %s\n", argv[i-1]);
                  return 1;
              }
              break;
          }
      }
  
      if (input_file_name == NULL || video_file_name == NULL) {
          printf("Input or video file name is missing\n");
          return 0;
      }
  
  	//======================================================================================================================================================150
  	//	VARIABLES
  	//======================================================================================================================================================150
  
  	// other
  	int i;
  	avi_t* frames;
  
  	//======================================================================================================================================================150
  	// 	FRAME INFO
  	//======================================================================================================================================================150
  
  	// open movie file
  	frames = (avi_t*)AVI_open_input_file(video_file_name, 1);														// added casting
  	if (frames == NULL)  {
  		   AVI_print_error((char *) "Error with AVI_open_input_file");
  		   return -1;
  	}
  
  	// dimensions
  	common.no_frames = AVI_video_frames(frames);
  	common.frame_rows = AVI_video_height(frames);
  	common.frame_cols = AVI_video_width(frames);
  	common.frame_elem = common.frame_rows * common.frame_cols;
  	common.frame_mem = sizeof(fp) * common.frame_elem;
  
      if (common.frames_processed<0 || common.frames_processed>common.no_frames){
          printf("ERROR: %d is an incorrect number of frames specified, select in the range of 0-%d\n", common.frames_processed, common.no_frames);
          return 0;
      }
  
  	//======================================================================================================================================================150
  	//	INPUTS
  	//======================================================================================================================================================150
  
  	//====================================================================================================100
  	//	READ PARAMETERS FROM FILE
  	//====================================================================================================100
  
  	read_parameters(	input_file_name,
  						&common.tSize,
  						&common.sSize,
  						&common.maxMove,
  						&common.alpha);
  
  	//====================================================================================================100
  	//	READ SIZE OF INPUTS FROM FILE
  	//====================================================================================================100
  
  	read_header(	input_file_name,
  					&common.endoPoints,
  					&common.epiPoints);
  
  	common.allPoints = common.endoPoints + common.epiPoints;
  
  	//====================================================================================================100
  	//	READ DATA FROM FILE
  	//====================================================================================================100
  
  	//==================================================50
  	//	ENDO POINTS MEMORY ALLOCATION
  	//==================================================50
  
  	common.endo_mem = sizeof(int) * common.endoPoints;
  
  	int* endoRow;
  	endoRow = (int*)malloc(common.endo_mem);
  	int* endoCol;
  	endoCol = (int*)malloc(common.endo_mem);
  	int* tEndoRowLoc;
  	tEndoRowLoc = (int*)malloc(common.endo_mem * common.no_frames);
  	int* tEndoColLoc;
  	tEndoColLoc = (int*)malloc(common.endo_mem * common.no_frames);
  
  	//==================================================50
  	//	EPI POINTS MEMORY ALLOCATION
  	//==================================================50
  
  	common.epi_mem = sizeof(int) * common.epiPoints;
  
  	int* epiRow;
  	epiRow = (int *)malloc(common.epi_mem);
  	int* epiCol;
  	epiCol = (int *)malloc(common.epi_mem);
  	int* tEpiRowLoc;
  	tEpiRowLoc = (int *)malloc(common.epi_mem * common.no_frames);
  	int* tEpiColLoc;
  	tEpiColLoc = (int *)malloc(common.epi_mem * common.no_frames);
  
  	//==================================================50
  	//	READ DATA FROM FILE
  	//==================================================50
  
  	read_data(	input_file_name,
  				common.endoPoints,
  				endoRow,
  				endoCol,
  				common.epiPoints,
  				epiRow,
  				epiCol);
  
  	//==================================================50
  	//	End
  	//==================================================50
  
  	//====================================================================================================100
  	//	End
  	//====================================================================================================100
  
  	//======================================================================================================================================================150
  	//	KERNELL WRAPPER CALL
  	//======================================================================================================================================================150
  
  	kernel_gpu_opencl_wrapper(	common,
  								endoRow,
  								endoCol,
  								tEndoRowLoc,
  								tEndoColLoc,
  								epiRow,
  								epiCol,
  								tEpiRowLoc,
  								tEpiColLoc,
  								frames);
  
  	//==================================================50
  	//	DUMP DATA TO FILE
  	//==================================================50
  #ifdef OUTPUT
  	write_data(	"result.txt",
  			common.no_frames,
  			common.frames_processed,		
  				common.endoPoints,
  				tEndoRowLoc,
  				tEndoColLoc,
  				common.epiPoints,
  				tEpiRowLoc,
  				tEpiColLoc);
  
  #endif
  	//==================================================50
  	//	End
  	//==================================================50
  
  
  	//======================================================================================================================================================150
  	//	DEALLOCATION
  	//======================================================================================================================================================150
  
  	//====================================================================================================100
  	// endo points
  	//====================================================================================================100
  
  	free(endoRow);
  	free(endoCol);
  	free(tEndoRowLoc);
  	free(tEndoColLoc);
  
  	//====================================================================================================100
  	// epi points
  	//====================================================================================================100
  
  	free(epiRow);
  	free(epiCol);
  	free(tEpiRowLoc);
  	free(tEpiColLoc);
  
  	//====================================================================================================100
  	//	End
  	//====================================================================================================100
  
  //========================================================================================================================================================================================================200
  //	End
  //========================================================================================================================================================================================================200
  
  }
  