int stitcher::read_images()
{
//Read in first image and make of copy of it in the image highlight
if( read_image_file( p_image, p_file_name ) )
{
cout << "Error reading image 1" << endl;
return -1;
}
else
{
p_image.copyTo( p_image_highlight );
}
//Read in second image and make of copy of it in the image highlight
if( read_image_file( p_prime_image, p_prime_file_name ) )
{
cout << "Error reading image 2" << endl;
return -1;
}
else
{
p_prime_image.copyTo( p_prime_image_highlight );
}
return 0;
}
static COMMAND_FUNC( do_read_image_file ) /** open file for reading */
{
char prompt[256];
const char *s;
Image_File *ifp;
Filetype *ftp;
ftp = current_filetype();
sprintf(prompt,"input %s file",FT_NAME(ftp));
s = NAMEOF(prompt);
if( s == NULL || *s == 0 ){
WARN("Null filename!?");
return;
}
ifp = img_file_of(QSP_ARG s);
if( ifp != NO_IMAGE_FILE ){
sprintf(ERROR_STRING,"do_read_image_file: file %s is already open",ifp->if_name);
WARN(ERROR_STRING);
return;
}
if( read_image_file(QSP_ARG s) == NO_IMAGE_FILE )
WARN("error reading image file");
}
image_t *
get_next_frame (bool_t store_wfa, int enlarge_factor,
int smoothing, const char *reference_frame,
format_e format, video_t *video, dectimer_t *timer,
wfa_t *orig_wfa, bitfile_t *input)
/*
* Get next frame of the WFA 'video' from stream 'input'.
* 'orig_wfa' is the constant part of the WFA used by all frames.
* Depending on values of 'enlarge_factor' and 'smoothing' enlarge and
* smooth image, respectively.
* If 'store_wfa' is TRUE, then store WFA structure of reference frames
* (used by analysis tool xwfa).
* If 'reference_frame' is not NULL, then load image 'reference_frame'
* from disk.
* 'format' gives the color format to be used (either 4:2:0 or 4:4:4).
* If 'timer' is not NULL, then accumulate running time statistics.
*
* Return value:
* pointer to decoded frame
*
* Side effects:
* 'video' and 'timer' struct are modified.
*/
{
image_t *frame = NULL; /* current frame */
image_t *sframe = NULL; /* current smoothed frame */
bool_t current_frame_is_future_frame = NO;
if (video->future_display == video->display)
{
/*
* Future frame is already computed since it has been used
* as reference frame. So just return the stored frame.
*/
if (video->frame) /* discard current frame */
free_image (video->frame);
video->frame = video->future;
video->future = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = video->sfuture;
video->sfuture = NULL;
if (store_wfa)
copy_wfa (video->wfa, video->wfa_future);
video->display++;
if (!store_wfa)
video->wfa = NULL;
}
else
{
do /* compute next frame(s) */
{
unsigned frame_number; /* current frame number */
clock_t ptimer;
unsigned int stop_timer [3];
wfa_t *tmp_wfa = NULL;
if (!store_wfa)
video->wfa = orig_wfa;
else
{
tmp_wfa = alloc_wfa (NO);
copy_wfa (tmp_wfa, video->wfa);
copy_wfa (video->wfa, orig_wfa);
}
/*
* First step: read WFA from disk
*/
prg_timer (&ptimer, START);
frame_number = read_next_wfa (video->wfa, input);
stop_timer [0] = prg_timer (&ptimer, STOP);
if (timer)
{
timer->input [video->wfa->frame_type] += stop_timer [0];
timer->frames [video->wfa->frame_type]++;
}
/*
* Read reference frame from disk if required
* (i.e., 1st frame is of type B or P)
*/
if (video->display == 0 && video->wfa->frame_type != I_FRAME)
{
if (!reference_frame)
error ("First frame is %c-frame but no "
"reference frame is given.",
video->wfa->frame_type == B_FRAME ? 'B' : 'P');
video->frame = read_image_file (reference_frame);
video->sframe = NULL;
}
/*
* Depending on current frame type update past and future frames
*/
if (video->wfa->frame_type == I_FRAME)
{
if (video->past) /* discard past frame */
free_image (video->past);
video->past = NULL;
if (video->future) /* discard future frame */
free_image (video->future);
video->future = NULL;
if (video->sfuture) /* discard (smoothed) future frame */
free_image (video->sfuture);
video->sfuture = NULL;
if (video->frame) /* discard current frame */
free_image (video->frame);
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
}
else if (video->wfa->frame_type == P_FRAME)
{
if (video->past) /* discard past frame */
free_image (video->past);
video->past = video->frame; /* past <- current frame */
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
if (store_wfa)
copy_wfa (video->wfa_past, tmp_wfa);
if (video->future) /* discard future frame */
free_image (video->future);
video->future = NULL;
if (video->sfuture) /* discard (smoothed) future frame */
free_image (video->sfuture);
video->sfuture = NULL;
}
else /* B_FRAME */
{
if (current_frame_is_future_frame)
{
if (video->future) /* discard future frame */
free_image (video->future);
video->future = frame; /* future <- current frame */
if (video->sfuture) /* discard (smoothed) future frame */
free_image (video->sfuture);
video->sfuture = sframe; /* future <- current (smoothed) */
if (store_wfa)
copy_wfa (video->wfa_future, tmp_wfa);
if (video->frame) /* discard current frame */
free_image (video->frame);
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
frame = NULL;
sframe = NULL;
}
else
{
if (video->wfa->wfainfo->B_as_past_ref == YES)
{
if (video->past) /* discard past frame */
free_image (video->past);
video->past = video->frame; /* past <- current frame */
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
if (store_wfa)
copy_wfa (video->wfa_past, tmp_wfa);
}
else
{
if (video->frame) /* discard current */
free_image (video->frame);
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
}
}
}
if (tmp_wfa)
free_wfa (tmp_wfa);
current_frame_is_future_frame = NO;
/*
* Second step: decode image
* Optionally enlarge image if specified by option 'enlarge_factor'.
*/
{
unsigned orig_width, orig_height;
stop_timer [0] = stop_timer [1] = stop_timer [2] = 0;
enlarge_image (enlarge_factor, format,
(video->wfa->wfainfo->color
&& format == FORMAT_4_2_0)
? video->wfa->tree [video->wfa->tree [video->wfa->root_state][0]][0] : -1, video->wfa);
if (enlarge_factor > 0)
{
orig_width = video->wfa->wfainfo->width << enlarge_factor;
orig_height = video->wfa->wfainfo->height << enlarge_factor;
}
else
{
orig_width = video->wfa->wfainfo->width >> - enlarge_factor;
orig_height = video->wfa->wfainfo->height >> - enlarge_factor;
if (orig_width & 1)
orig_width++;
if (orig_height & 1)
orig_height++;
}
frame = decode_image (orig_width, orig_height, format,
timer != NULL ? stop_timer : NULL,
video->wfa);
if (timer)
{
timer->preprocessing [video->wfa->frame_type] += stop_timer [0];
timer->decoder [video->wfa->frame_type] += stop_timer [1];
timer->cleanup [video->wfa->frame_type] += stop_timer [2];
}
}
/*
* Third step: restore motion compensation
*/
if (video->wfa->frame_type != I_FRAME)
{
prg_timer (&ptimer, START);
restore_mc (enlarge_factor, frame, video->past, video->future,
video->wfa);
stop_timer [0] = prg_timer (&ptimer, STOP);
if (timer)
timer->motion [video->wfa->frame_type] += stop_timer [0];
}
/*
* Fourth step: smooth image along partitioning borders
*/
prg_timer (&ptimer, START);
if (smoothing < 0) /* smoothing not changed by user */
smoothing = video->wfa->wfainfo->smoothing;
if (smoothing > 0 && smoothing <= 100)
{
sframe = clone_image (frame);
smooth_image (smoothing, video->wfa, sframe);
}
else
sframe = NULL;
stop_timer [0] = prg_timer (&ptimer, STOP);
if (timer)
timer->smooth [video->wfa->frame_type] += stop_timer [0];
if (frame_number == video->display)
{
video->display++;
video->frame = frame;
video->sframe = sframe;
frame = NULL;
sframe = NULL;
}
else if (frame_number > video->display)
{
video->future_display = frame_number;
current_frame_is_future_frame = YES;
}
if (!store_wfa)
remove_states (video->wfa->basis_states, video->wfa);
} while (!video->frame);
if (!store_wfa)
video->wfa = NULL;
}
return video->sframe ? video->sframe : video->frame;
}
void
firmware(int argc, char *argv[])
{
int fd = -1, slot = 0;
int a_flag, s_flag, f_flag;
int activate_action, reboot_required;
char ch, *p, *image = NULL;
char *controller = NULL, prompt[64];
void *buf = NULL;
int32_t size = 0;
struct nvme_controller_data cdata;
a_flag = s_flag = f_flag = false;
while ((ch = getopt(argc, argv, "af:s:")) != -1) {
switch (ch) {
case 'a':
a_flag = true;
break;
case 's':
slot = strtol(optarg, &p, 0);
if (p != NULL && *p != '\0') {
fprintf(stderr,
"\"%s\" not valid slot.\n",
optarg);
firmware_usage();
} else if (slot == 0) {
fprintf(stderr,
"0 is not a valid slot number. "
"Slot numbers start at 1.\n");
firmware_usage();
} else if (slot > 7) {
fprintf(stderr,
"Slot number %s specified which is "
"greater than max allowed slot number of "
"7.\n", optarg);
firmware_usage();
}
s_flag = true;
break;
case 'f':
image = optarg;
f_flag = true;
break;
}
}
/* Check that a controller (and not a namespace) was specified. */
if (optind >= argc || strstr(argv[optind], NVME_NS_PREFIX) != NULL)
firmware_usage();
if (!f_flag && !a_flag) {
fprintf(stderr,
"Neither a replace ([-f path_to_firmware]) nor "
"activate ([-a]) firmware image action\n"
"was specified.\n");
firmware_usage();
}
if (!f_flag && a_flag && slot == 0) {
fprintf(stderr,
"Slot number to activate not specified.\n");
firmware_usage();
}
controller = argv[optind];
open_dev(controller, &fd, 1, 1);
read_controller_data(fd, &cdata);
if (cdata.oacs.firmware == 0)
errx(1,
"controller does not support firmware activate/download");
if (f_flag && slot == 1 && cdata.frmw.slot1_ro)
errx(1, "slot %d is marked as read only", slot);
if (slot > cdata.frmw.num_slots)
errx(1,
"slot %d specified but controller only supports %d slots",
slot, cdata.frmw.num_slots);
if (a_flag && !f_flag && !slot_has_valid_firmware(fd, slot))
errx(1,
"slot %d does not contain valid firmware,\n"
"try 'nvmecontrol logpage -p 3 %s' to get a list "
"of available images\n",
slot, controller);
if (f_flag)
read_image_file(image, &buf, &size);
if (f_flag && a_flag)
printf("You are about to download and activate "
"firmware image (%s) to controller %s.\n"
"This may damage your controller and/or "
"overwrite an existing firmware image.\n",
image, controller);
else if (a_flag)
printf("You are about to activate a new firmware "
"image on controller %s.\n"
"This may damage your controller.\n",
controller);
else if (f_flag)
printf("You are about to download firmware image "
"(%s) to controller %s.\n"
"This may damage your controller and/or "
"overwrite an existing firmware image.\n",
image, controller);
printf("Are you sure you want to continue? (yes/no) ");
while (1) {
fgets(prompt, sizeof(prompt), stdin);
if (strncasecmp(prompt, "yes", 3) == 0)
break;
if (strncasecmp(prompt, "no", 2) == 0)
exit(1);
printf("Please answer \"yes\" or \"no\". ");
}
if (f_flag) {
update_firmware(fd, buf, size);
if (a_flag)
activate_action = NVME_AA_REPLACE_ACTIVATE;
else
activate_action = NVME_AA_REPLACE_NO_ACTIVATE;
} else {
activate_action = NVME_AA_ACTIVATE;
}
reboot_required = activate_firmware(fd, slot, activate_action);
if (a_flag) {
if (reboot_required) {
printf("New firmware image activated but requires "
"conventional reset (i.e. reboot) to "
"complete activation.\n");
} else {
printf("New firmware image activated and will take "
"effect after next controller reset.\n"
"Controller reset can be initiated via "
"'nvmecontrol reset %s'\n",
controller);
}
}
close(fd);
exit(0);
}
int main(int argc, char **argv)
{
u16 (*bayer)[WAMI_DEBAYER_IMG_NUM_COLS] = NULL;
rgb_pixel (*debayer)[WAMI_DEBAYER_IMG_NUM_COLS-2*PAD] = NULL;
char *input_directory = NULL;
#ifdef ENABLE_CORRECTNESS_CHECKING
rgb_pixel (*gold_debayer)[WAMI_DEBAYER_IMG_NUM_COLS-2*PAD] = NULL;
#endif
const size_t num_bayer_pixels = WAMI_DEBAYER_IMG_NUM_ROWS *
WAMI_DEBAYER_IMG_NUM_COLS;
const size_t num_debayer_pixels = (WAMI_DEBAYER_IMG_NUM_ROWS-2*PAD) *
(WAMI_DEBAYER_IMG_NUM_COLS-2*PAD);
if (argc != 2)
{
fprintf(stderr, "%s <directory-containing-input-files>\n", argv[0]);
exit(EXIT_FAILURE);
}
input_directory = argv[1];
bayer = XMALLOC(sizeof(u16) * num_bayer_pixels);
debayer = XMALLOC(sizeof(rgb_pixel) * num_debayer_pixels);
#ifdef ENABLE_CORRECTNESS_CHECKING
gold_debayer = XMALLOC(sizeof(rgb_pixel) * num_debayer_pixels);
#endif
read_image_file(
(char *) bayer,
input_filename,
input_directory,
sizeof(u16) * num_bayer_pixels);
memset(debayer, 0, sizeof(u16) * num_debayer_pixels);
printf("WAMI kernel 1 parameters:\n\n");
printf("Input image width = %u pixels\n", WAMI_DEBAYER_IMG_NUM_COLS);
printf("Input image height = %u pixels\n", WAMI_DEBAYER_IMG_NUM_ROWS);
printf("Output image width = %u pixels\n", WAMI_DEBAYER_IMG_NUM_COLS-2*PAD);
printf("Output image height = %u pixels\n", WAMI_DEBAYER_IMG_NUM_ROWS-2*PAD);
printf("\nStarting WAMI kernel 1 (debayer).\n");
tic();
accept_roi_begin();
wami_debayer(
debayer,
bayer);
accept_roi_end();
PRINT_STAT_DOUBLE("CPU time using func toc - ", toc());
#ifdef ENABLE_CORRECTNESS_CHECKING
read_image_file(
(char *) gold_debayer,
golden_output_filename,
input_directory,
sizeof(rgb_pixel) * num_debayer_pixels);
/*
* An exact match is expected for the debayer kernel, so we check
* each pixel individually and report either the first failure or
* a success message.
*/
{
/*
// original error metric
int r, c, success = 1;
for (r = 0; success && r < WAMI_DEBAYER_IMG_NUM_ROWS - 2*PAD; ++r)
{
for (c = 0; c < WAMI_DEBAYER_IMG_NUM_ROWS - 2*PAD; ++c)
{
if (ENDORSE(debayer[r][c].r != gold_debayer[r][c].r))
{
printf("Validation error: red pixel mismatch at row=%d, col=%d : "
"test value = %u, golden value = %u\n\n", r, c,
debayer[r][c].r, gold_debayer[r][c].r);
success = 0;
break;
}
if (ENDORSE(debayer[r][c].g != gold_debayer[r][c].g))
{
printf("Validation error: green pixel mismatch at row=%d, col=%d : "
"test value = %u, golden value = %u\n\n", r, c,
debayer[r][c].g, gold_debayer[r][c].g);
success = 0;
break;
}
if (ENDORSE(debayer[r][c].b != gold_debayer[r][c].b))
{
printf("Validation error: blue pixel mismatch at row=%d, col=%d : "
"test value = %u, golden value = %u\n\n", r, c,
debayer[r][c].b, gold_debayer[r][c].b);
success = 0;
break;
}
}
}
if (success)
{
printf("\nValidation checks passed -- the test output matches the golden output.\n\n");
}
*/
// new error metric
int r, c;
double err;
for (r = 0; r < WAMI_DEBAYER_IMG_NUM_ROWS - 2*PAD; ++r)
{
for (c = 0; c < WAMI_DEBAYER_IMG_NUM_ROWS - 2*PAD; ++c)
{
double pixel_error = 0.0;
pixel_error += ENDORSE(((double) abs(debayer[r][c].r - gold_debayer[r][c].r)) / ((double) 65535));
pixel_error += ENDORSE(((double) abs(debayer[r][c].g - gold_debayer[r][c].g)) / ((double) 65535));
pixel_error += ENDORSE(((double) abs(debayer[r][c].b - gold_debayer[r][c].b)) / ((double) 65535));
err += (pixel_error / ((double) 3))
/ ((double) ((WAMI_DEBAYER_IMG_NUM_ROWS - 2*PAD) * (WAMI_DEBAYER_IMG_NUM_ROWS - 2*PAD)));
}
}
FILE *fp = fopen("err.txt", "wb");
assert(fp != NULL);
fprintf(fp, "%.2f\n", err);
fclose(fp);
}
#endif
#ifdef WRITE_OUTPUT_TO_DISK
printf("Writing output to %s/%s.\n", output_directory, output_filename);
{
const u16 output_channels = 3;
write_image_file(
(char *) debayer,
output_filename,
output_directory,
WAMI_DEBAYER_IMG_NUM_COLS - 2*PAD,
WAMI_DEBAYER_IMG_NUM_ROWS - 2*PAD,
output_channels);
}
#endif
FREE_AND_NULL(bayer);
FREE_AND_NULL(debayer);
#ifdef ENABLE_CORRECTNESS_CHECKING
FREE_AND_NULL(gold_debayer);
#endif
return 0;
}
