int snapshot_write_next(struct snapshot_handle *handle, size_t count)
{
static struct chain_allocator ca;
int error = 0;
/* Check if we have already loaded the entire image */
if (handle->prev && handle->cur > nr_meta_pages + nr_copy_pages)
return 0;
if (!buffer) {
/* This makes the buffer be freed by swsusp_free() */
buffer = alloc_image_page(GFP_ATOMIC, PG_ANY);
if (!buffer)
return -ENOMEM;
}
if (!handle->offset)
handle->buffer = buffer;
handle->sync_read = 1;
if (handle->prev < handle->cur) {
if (handle->prev == 0) {
error = load_header(buffer);
if (error)
return error;
error = memory_bm_create(©_bm, GFP_ATOMIC, PG_ANY);
if (error)
return error;
} else if (handle->prev <= nr_meta_pages) {
unpack_orig_pfns(buffer, ©_bm);
if (handle->prev == nr_meta_pages) {
error = prepare_image(&orig_bm, ©_bm);
if (error)
return error;
chain_init(&ca, GFP_ATOMIC, PG_SAFE);
memory_bm_position_reset(&orig_bm);
restore_pblist = NULL;
handle->buffer = get_buffer(&orig_bm, &ca);
handle->sync_read = 0;
if (!handle->buffer)
return -ENOMEM;
}
} else {
handle->buffer = get_buffer(&orig_bm, &ca);
handle->sync_read = 0;
}
handle->prev = handle->cur;
}
handle->buf_offset = handle->cur_offset;
if (handle->cur_offset + count >= PAGE_SIZE) {
count = PAGE_SIZE - handle->cur_offset;
handle->cur_offset = 0;
handle->cur++;
} else {
handle->cur_offset += count;
}
handle->offset += count;
return count;
}
static void
update_preview_cb (GtkFileChooser *file_chooser,
gpointer data)
{
GtkWidget *preview;
gchar *filename, *file_contents = NULL;
GdkPixbuf *pixbuf = NULL;
gboolean have_preview;
gsize length = 0;
preview = GTK_WIDGET (data);
filename = gtk_file_chooser_get_preview_filename (file_chooser);
have_preview = filename && prepare_image (filename, &file_contents, &length, &pixbuf, FALSE);
if (have_preview) {
g_free (file_contents);
have_preview = pixbuf != NULL;
}
g_free (filename);
gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf);
if (pixbuf)
g_object_unref (pixbuf);
gtk_file_chooser_set_preview_widget_active (file_chooser, have_preview);
}
static GdkPixbuf *
choose_new_face (void)
{
GdkPixbuf *res = NULL;
GtkWidget *filesel, *preview;
GtkFileFilter *filter;
filesel = gtk_file_chooser_dialog_new (
_("Select a Face Picture"),
NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (filesel), GTK_RESPONSE_OK);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Image files"));
gtk_file_filter_add_mime_type (filter, "image/*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (filesel), filter);
preview = gtk_image_new ();
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (filesel), preview);
g_signal_connect (filesel, "update-preview", G_CALLBACK (update_preview_cb), preview);
if (GTK_RESPONSE_OK == gtk_dialog_run (GTK_DIALOG (filesel))) {
gchar *image_filename, *file_contents = NULL;
gsize length = 0;
image_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filesel));
gtk_widget_destroy (filesel);
if (prepare_image (image_filename, &file_contents, &length, &res, TRUE)) {
set_face_raw (file_contents, length);
}
g_free (file_contents);
g_free (image_filename);
} else {
gtk_widget_destroy (filesel);
}
return res;
}
void MatCache::rgb_from_yuv()
{
auto it_y = images.find("gray_8u");
auto it_u = images.find("yuv422_u_8u");
auto it_v = images.find("yuv422_v_8u");
if (it_y == images.end() || it_y->second.ready == false
|| it_y == images.end() || it_y->second.ready == false
|| it_y == images.end() || it_y->second.ready == false)
return;
CachedMat& rgb = prepare_image("rgb_8u");
imgproc::rgb_from_yuv(it_y->second.mat, it_u->second.mat, it_v->second.mat, rgb.mat);
rgb.ready = true;
// cv::Mat bgr;
// cv::cvtColor(rgb.mat, bgr, CV_RGB2BGR);
// cv::imshow("test-ffmpeg", bgr);
// cv::waitKey();
}
int main(int ac, char **av)
{
t_fdf e;
fdf_ini(&e);
if (ac < 2 || !my_parse(&e, ac, av))
return (0);
e.wia = FT_MAX(e.maa - e.mia, 1);
if (!(e.mlx = mlx_init()))
return (fdf_quit(&e));
if (!(e.win = mlx_new_window(e.mlx, e.wid, e.hig, "FdF")))
return (fdf_quit(&e));
if (!(e.img = mlx_new_image(e.mlx, e.wid, e.hig)))
return (fdf_quit(&e));
e.buf = mlx_get_data_addr(e.img, &e.bit, &e.lin, &e.end);
e.bit /= 8;
prepare_image(&e);
mlx_key_hook(e.win, &my_key_func, &e);
mlx_expose_hook(e.win, &my_expose_func, &e);
mlx_loop(e.mlx);
return (0);
}
int main(int argc, char **argv)
{
int ret;
const char *arch = qtest_get_arch();
const char *genisocheck[] = { "genisoimage", "-version", NULL };
g_test_init(&argc, &argv, NULL);
if (exec_genisoimg(genisocheck)) {
/* genisoimage not available - so can't run tests */
return g_test_run();
}
ret = prepare_image(arch, isoimage);
if (ret) {
return ret;
}
if (g_str_equal(arch, "i386") || g_str_equal(arch, "x86_64")) {
add_x86_tests();
} else if (g_str_equal(arch, "s390x")) {
add_s390x_tests();
} else if (g_str_equal(arch, "ppc64")) {
const char *ppcmachines[] = {
"pseries", "mac99", "g3beige", "40p", "prep", NULL
};
add_cdrom_param_tests(ppcmachines);
} else if (g_str_equal(arch, "sparc")) {
const char *sparcmachines[] = {
"LX", "SPARCClassic", "SPARCbook", "SS-10", "SS-20", "SS-4",
"SS-5", "SS-600MP", "Voyager", "leon3_generic", NULL
};
add_cdrom_param_tests(sparcmachines);
} else if (g_str_equal(arch, "sparc64")) {
const char *sparc64machines[] = {
"niagara", "sun4u", "sun4v", NULL
};
add_cdrom_param_tests(sparc64machines);
} else if (!strncmp(arch, "mips64", 6)) {
const char *mips64machines[] = {
"magnum", "malta", "mips", "pica61", NULL
};
add_cdrom_param_tests(mips64machines);
} else if (g_str_equal(arch, "arm") || g_str_equal(arch, "aarch64")) {
const char *armmachines[] = {
"realview-eb", "realview-eb-mpcore", "realview-pb-a8",
"realview-pbx-a9", "versatileab", "versatilepb", "vexpress-a15",
"vexpress-a9", "virt", NULL
};
add_cdrom_param_tests(armmachines);
} else {
const char *nonemachine[] = { "none", NULL };
add_cdrom_param_tests(nonemachine);
}
ret = g_test_run();
unlink(isoimage);
return ret;
}
static image_reconstruct_ERROR_CODE
do_reconstruction(const image_filter_IMG* original,
const image_reconstruct_PARAMETERS* params,
image_filter_IMG* result)
{
image_reconstruct_ERROR_CODE ret = IMAGE_RECONSTRUCT_OK;
image_filter_FILTER row_filter = {0};
image_filter_FILTER col_filter = {0};
image_filter_IMG approx_row = {0};
image_filter_IMG approx_col = {0};
image_filter_IMG approx_diag = {0};
image_filter_IMG tmp = {0};
double row_mask[] = PREWITT_ROW_MASK;
double col_mask[] = PREWITT_COL_MASK;
image_filter_create_filter_by_mask(3,
row_mask,
&row_filter);
image_filter_create_filter_by_mask(3,
col_mask,
&col_filter);
image_filter_create_image(original->width,
original->height,
&approx_row);
image_filter_create_image(original->width,
original->height,
&tmp);
image_filter_create_image(original->width,
original->height,
&approx_col);
image_filter_create_image(original->width,
original->height,
&approx_diag);
if ((ret = prepare_image(original, params, &tmp))
!= IMAGE_AMPLIFIER_OK)
{}
else if ((ret = apply_filter(&tmp,
&row_filter,
&approx_row)) != IMAGE_RECONSTRUCT_OK)
{}
else if ((ret = apply_filter(&tmp,
&col_filter,
&approx_col)) != IMAGE_RECONSTRUCT_OK)
{}
if (ret == IMAGE_RECONSTRUCT_OK)
{
haar_transformation_DATA_SOURCE data;
calculate_sum(&approx_col,
&approx_row,
NULL,
&approx_diag);
data.width = original->width;
data.height = original->height;
data.original_image = result->content;
data.avg_image = tmp.content;
data.vertical_edges = approx_col.content;
data.horizontal_edges = approx_row.content;
data.diagonal_edges = approx_diag.content;
/* DUMPER_TRACE_IMAGE(data.avg_image, data.width, data.height);
DUMPER_TRACE_IMAGE(data.vertical_edges, data.width, data.height);
DUMPER_TRACE_IMAGE(data.horizontal_edges, data.width, data.height);
DUMPER_TRACE_IMAGE(data.diagonal_edges, data.width, data.height);
DUMPER_TRACE_IMAGE(tmp.content, data.width, data.height); */
data.width *= 2;
data.height *= 2;
haar_transformation_inverse_transformation(data);
/* DUMPER_TRACE_IMAGE(data.original_image, data.width, data.height); */
}
image_filter_destroy_image(&approx_diag);
image_filter_destroy_image(&tmp);
image_filter_destroy_image(&approx_col);
image_filter_destroy_image(&approx_row);
image_filter_destroy_filter(&row_filter);
image_filter_destroy_filter(&col_filter);
return ret;
}
