static int
EvasImageSetData( vout_display_t *vd )
{
vout_display_sys_t *sys = vd->sys;
struct buffer *p_buffer = sys->p_new_buffer;
if( sys->u.evas.b_yuv )
{
void *p_data = evas_object_image_data_get( sys->p_evas, 1 );
const uint8_t **pp_rows = (const uint8_t **) p_data;
if( !p_data )
return -1;
for( unsigned int i = 0; i < sys->i_nb_planes; ++i )
{
plane_t *p_plane = &sys->p_planes[sys->i_planes_order[i]];
for( int j = 0; j < p_plane->i_visible_lines; ++j )
*(pp_rows++) = &p_buffer->p[i][j * p_plane->i_pitch];
}
evas_object_image_data_set( sys->p_evas, p_data );
}
else
evas_object_image_data_set( sys->p_evas, p_buffer->p[0] );
return 0;
}
EAPI Eina_Bool
emotion_object_file_set(Evas_Object *obj, const char *file)
{
Smart_Data *sd;
E_SMART_OBJ_GET_RETURN(sd, obj, E_OBJ_NAME, EINA_FALSE);
DBG("file=%s", file);
if (!eina_stringshare_replace(&sd->file, file))
return EINA_TRUE;
if (!sd->engine_instance)
{
WRN("No engine choosen. Call emotion_object_init()?");
return EINA_FALSE;
}
sd->video.w = 0;
sd->video.h = 0;
if ((file) && (file[0] != 0))
{
eina_stringshare_replace(&sd->file, file);
emotion_engine_instance_file_close(sd->engine_instance);
evas_object_image_data_set(sd->obj, NULL);
evas_object_image_size_set(sd->obj, 1, 1);
_emotion_image_data_zero(sd->obj);
sd->open = 0;
if (!emotion_engine_instance_file_open(sd->engine_instance, sd->file))
{
WRN("Couldn't open file=%s", sd->file);
return EINA_FALSE;
}
DBG("successfully opened file=%s", sd->file);
sd->pos = 0.0;
if (sd->play) emotion_engine_instance_play(sd->engine_instance, 0.0);
}
else
{
emotion_engine_instance_file_close(sd->engine_instance);
evas_object_image_data_set(sd->obj, NULL);
evas_object_image_size_set(sd->obj, 1, 1);
_emotion_image_data_zero(sd->obj);
eina_stringshare_replace(&sd->file, NULL);
}
if (sd->anim) ecore_animator_del(sd->anim);
sd->anim = NULL;
#ifdef HAVE_EIO
/* Only cancel the load_xattr or we will loose ref to time_seek stringshare */
if (sd->load_xattr) eio_file_cancel(sd->load_xattr);
sd->load_xattr = NULL;
if (sd->save_xattr) eio_file_cancel(sd->save_xattr);
sd->save_xattr = NULL;
#endif
return EINA_TRUE;
}
static int
EvasResetMainloopCb( vout_display_t *vd )
{
vout_display_sys_t *sys = vd->sys;
if( sys->b_evas_changed )
return -1;
if( sys->p_anim )
{
ecore_animator_del( sys->p_anim );
sys->p_anim = NULL;
}
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_IMAGE_RESIZE,
EvasResizeCb, vd );
FmtUpdate( vd );
evas_object_image_data_set( sys->p_evas, NULL );
evas_object_image_size_set( sys->p_evas, sys->i_width, sys->i_height );
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_IMAGE_RESIZE,
EvasResizeCb, vd );
return 0;
}
void _eyelight_viewer_slideshow_slides_load(Eyelight_Viewer* pres)
{
int i;
Evas_Object *o_image;
char buf[EYELIGHT_BUFLEN];
int nb_slides = pres->slideshow_nb_slides;
int first_slide = pres->slideshow_current - (nb_slides/2);
if(!pres->slideshow_image_thumbnails)
pres->slideshow_image_thumbnails = calloc(nb_slides,sizeof(Evas_Object*));
for(i=0;i<nb_slides; i++)
{
if(first_slide+i<0 || i+first_slide>=pres->size)
{
snprintf(buf,EYELIGHT_BUFLEN,"slideshow,slide,hide,%d",i+1);
edje_object_signal_emit(pres->slideshow_background,
buf,"eyelight");
}
else
{
snprintf(buf,EYELIGHT_BUFLEN,"slideshow,slide,show,%d",i+1);
edje_object_signal_emit(pres->slideshow_background,
buf,"eyelight");
if(!pres->slideshow_image_thumbnails[i])
{
const Eyelight_Thumb* thumb = eyelight_viewer_thumbnails_get(pres,first_slide+i);
o_image = evas_object_image_add(pres->evas);
pres->slideshow_image_thumbnails[i] = o_image;
if (thumb->thumb)
{
evas_object_image_size_set(o_image, thumb->w, thumb->h);
evas_object_image_data_set(o_image,thumb->thumb);
evas_object_image_filled_set(o_image,1);
}
else
{
char key[256];
int w;
int h;
snprintf(key, sizeof (key), "eyelight/thumb/%i", thumb->pos);
evas_object_image_file_set(o_image, pres->dump_in, key);
evas_object_image_size_get(o_image, &w, &h);
evas_object_image_fill_set(o_image, 0, 0, w, h);
}
evas_object_show(o_image);
snprintf(buf,EYELIGHT_BUFLEN,"object.swallow_%d",i+1);
edje_object_part_swallow(pres->slideshow_background,buf,o_image);
}
}
}
eyelight_viewer_thumbnails_clean(pres,first_slide,first_slide+nb_slides);
}
/**
* @internal
*
* This function takes actual shot and saves it in PNG
* @param data Tsuite_Data pointer initiated by user
* @param obj Window pointer
* @param obj name file name. Will use name_+serial if NULL
*
* @ingroup Tsuite
*/
void
tsuite_shot_do(char *name, Evas *e)
{
if (!e)
return;
Ecore_Evas *ee, *ee_orig;
Evas_Object *o;
unsigned int *pixels;
int w, h,dir_name_len = 0;
char *filename;
if (_hook_setting->dest_dir)
dir_name_len = strlen(_hook_setting->dest_dir) + 1; /* includes space of a '/' */
if (name)
{
filename = malloc(strlen(name) + strlen(IMAGE_FILENAME_EXT) +
dir_name_len + 4);
if (_hook_setting->dest_dir)
sprintf(filename, "%s/", _hook_setting->dest_dir);
sprintf(filename + dir_name_len, "%s%s", name, IMAGE_FILENAME_EXT);
}
else
{
filename = malloc(strlen(_hook_setting->test_name) + strlen(IMAGE_FILENAME_EXT) +
dir_name_len + 8); /* also space for serial */
ts.serial++;
if (_hook_setting->dest_dir)
sprintf(filename, "%s/", _hook_setting->dest_dir);
sprintf(filename + dir_name_len, "%s_%d%s", _hook_setting->test_name,
ts.serial, IMAGE_FILENAME_EXT);
}
ee_orig = ecore_evas_ecore_evas_get(e);
ecore_evas_manual_render(ee_orig);
pixels = (void *)ecore_evas_buffer_pixels_get(ee_orig);
if (!pixels) return;
ecore_evas_geometry_get(ee_orig, NULL, NULL, &w, &h);
if ((w < 1) || (h < 1)) return;
ee = ecore_evas_buffer_new(1, 1);
o = evas_object_image_add(ecore_evas_get(ee));
evas_object_image_alpha_set(o, ecore_evas_alpha_get(ee_orig));
evas_object_image_size_set(o, w, h);
evas_object_image_data_set(o, pixels);
if (!evas_object_image_save(o, filename, NULL, NULL))
{
printf("Cannot save widget to <%s>\n", filename);
}
ecore_evas_free(ee);
free(filename);
}
void ewk_paint_context_free(Ewk_Paint_Context* context)
{
EINA_SAFETY_ON_NULL_RETURN(context);
if (context->image && context->pixels) {
// Decrease refcount inside image object.
evas_object_image_data_set(context->image, context->pixels);
}
delete context;
}
static void
_ecore_evas_resize(Ecore_Evas *ee, int w, int h)
{
Evas_Engine_Info_Buffer *einfo;
Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
int stride = 0;
if (w < 1) w = 1;
if (h < 1) h = 1;
ee->req.w = w;
ee->req.h = h;
if ((w == ee->w) && (h == ee->h)) return;
ee->w = w;
ee->h = h;
evas_output_size_set(ee->evas, ee->w, ee->h);
evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
if (bdata->image)
{
bdata->pixels = evas_object_image_data_get(bdata->image, 1);
stride = evas_object_image_stride_get(bdata->image);
}
else
{
if (bdata->pixels)
bdata->free_func(bdata->data, bdata->pixels);
bdata->pixels =
bdata->alloc_func(bdata->data, ee->w * ee->h * sizeof(int));
stride = ee->w * sizeof(int);
}
einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas);
if (einfo)
{
if (ee->alpha)
einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32;
else
einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_RGB32;
einfo->info.dest_buffer = bdata->pixels;
einfo->info.dest_buffer_row_bytes = stride;
einfo->info.use_color_key = 0;
einfo->info.alpha_threshold = 0;
einfo->info.func.new_update_region = NULL;
einfo->info.func.free_update_region = NULL;
if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
{
ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
}
}
if (bdata->image)
evas_object_image_data_set(bdata->image, bdata->pixels);
else
bdata->resized = 1;
}
/* local subsystem functions */
static void
_win_unredirect(E_Comp_Win *cw)
{
E_CHECK(cw);
E_CHECK(cw->visible);
E_CHECK(!(cw->input_only));
E_CHECK(!(cw->invalid));
if (cw->obj)
{
evas_object_hide(cw->obj);
evas_object_del(cw->obj);
cw->obj = NULL;
}
if (cw->update_timeout)
{
ecore_timer_del(cw->update_timeout);
cw->update_timeout = NULL;
}
if (cw->native)
{
evas_object_image_native_surface_set(cw->obj, NULL);
cw->native = 0;
}
if (cw->pixmap)
{
ecore_x_pixmap_free(cw->pixmap);
cw->pixmap = 0;
cw->pw = 0;
cw->ph = 0;
}
if (cw->xim)
{
evas_object_image_size_set(cw->obj, 1, 1);
evas_object_image_data_set(cw->obj, NULL);
ecore_x_image_free(cw->xim);
cw->xim = NULL;
}
if (cw->redirected)
{
ecore_x_composite_unredirect_window
(cw->win, ECORE_X_COMPOSITE_UPDATE_MANUAL);
cw->redirected = 0;
}
if (cw->damage)
{
e_mod_comp_win_del_damage(cw, cw->damage);
ecore_x_damage_subtract(cw->damage, 0, 0);
ecore_x_damage_free(cw->damage);
cw->damage = 0;
}
}
EAPI Eina_Bool
efx_bumpmap(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
{
EFX *e;
Efx_Bumpmap_Data *ebd;
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
e = evas_object_data_get(obj, "efx-data");
if (!e)
e = efx_new(obj);
EINA_SAFETY_ON_NULL_RETURN_VAL(e, EINA_FALSE);
if (!e->bumpmap_data)
e->bumpmap_data = calloc(1, sizeof(Efx_Bumpmap_Data));
EINA_SAFETY_ON_NULL_RETURN_VAL(e->bumpmap_data, EINA_FALSE);
ebd = e->bumpmap_data;
ebd->e = e;
ebd->x = x;
ebd->y = y;
ebd->z = 30;
ebd->depth = 0x200;
ebd->red = 0x200;
ebd->green = 0x200;
ebd->blue = 0x200;
ebd->ambient = 0;
if (!ebd->img_data)
{
unsigned int *m;
int w;
int h;
evas_object_image_size_get(obj, &w, &h);
m = (unsigned int *)evas_object_image_data_get(obj, 1);
ebd->img_data = (unsigned int *)malloc(w * h * sizeof(unsigned int));
if (!ebd->img_data)
{
free(ebd);
return EINA_FALSE;
}
printf("memcpy\n");
memcpy(ebd->img_data, m, (w * h * sizeof(unsigned int)));
evas_object_image_data_set(obj, m);
}
_bumpmap(ebd);
return EINA_TRUE;
(void)efx_speed_str;
}
static Eina_Bool _ewk_view_single_smart_scrolls_process(Ewk_View_Smart_Data* smartData)
{
Evas_Coord imageWidth, imageHeight;
void* pixels = evas_object_image_data_get(smartData->backing_store, 1);
evas_object_image_size_get(smartData->backing_store, &imageWidth, &imageHeight);
const WTF::Vector<WebCore::IntSize>& scrollOffset = ewk_view_scroll_offsets_get(smartData->_priv);
const WTF::Vector<WebCore::IntRect>& rectsToScroll = ewk_view_scroll_rects_get(smartData->_priv);
for (size_t i = 0; i < scrollOffset.size(); ++i)
_ewk_view_single_scroll_process_single(smartData, pixels, imageWidth, imageHeight, scrollOffset[i], rectsToScroll[i]);
evas_object_image_data_set(smartData->backing_store, pixels);
return true;
}
void _eyelight_viewer_slideshow_slides_destroy(Eyelight_Viewer* pres)
{
int i;
int size = pres->slideshow_nb_slides;
for(i=0;i<size;i++)
{
if(pres->slideshow_image_thumbnails[i])
{
evas_object_image_data_set(pres->slideshow_image_thumbnails[i],NULL);
evas_object_del(pres->slideshow_image_thumbnails[i]);
}
}
evas_object_del(pres->slideshow_background);
EYELIGHT_FREE(pres->slideshow_image_thumbnails);
}
static bool _ewk_view_tiled_render_cb(void* data, Ewk_Tile* tile, const Eina_Rectangle* area)
{
Ewk_View_Private_Data* priv = static_cast<Ewk_View_Private_Data*>(data);
Eina_Rectangle rect = {area->x + tile->x, area->y + tile->y, area->w, area->h};
uint8_t* pixels = static_cast<uint8_t*>(evas_object_image_data_get(tile->image, true));
Ewk_Paint_Context* context = ewk_paint_context_from_image_data_new(pixels, tile->width, tile->height, tile->cspace);
ewk_paint_context_translate(context, -tile->x, -tile->y);
bool result = ewk_view_paint_contents(priv, context, &rect);
ewk_paint_context_free(context);
evas_object_image_data_set(tile->image, pixels);
return result;
}
static Eina_Bool _ewk_view_single_smart_scrolls_process(Ewk_View_Smart_Data* smartData)
{
const Ewk_Scroll_Request* sr;
const Ewk_Scroll_Request* sr_end;
Evas_Coord ow, oh;
size_t count;
void* pixels = evas_object_image_data_get(smartData->backing_store, 1);
evas_object_image_size_get(smartData->backing_store, &ow, &oh);
sr = ewk_view_scroll_requests_get(smartData->_priv, &count);
sr_end = sr + count;
for (; sr < sr_end; sr++)
_ewk_view_single_scroll_process_single(smartData, pixels, ow, oh, sr);
evas_object_image_data_set(smartData->backing_store, pixels);
return true;
}
static int
EvasDeinitMainloopCb( vout_display_t *vd )
{
vout_display_sys_t *sys = vd->sys;
if( sys->p_anim )
{
ecore_animator_del( sys->p_anim );
sys->p_anim = NULL;
}
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_IMAGE_RESIZE,
EvasResizeCb, vd );
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MOUSE_DOWN,
EventMouseDownCb, vd );
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MOUSE_UP,
EvasMouseUpCb, vd );
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MOUSE_MOVE,
EvasMouseMoveCb, vd );
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MULTI_DOWN,
EvasMultiDownCb, vd );
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MULTI_UP,
EvasMultiUpCb, vd );
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MULTI_MOVE,
EvasMultiMoveCb, vd );
#ifdef HAVE_EVAS_CALLBACK_KEY_UP
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_KEY_UP,
EvasKeyUpCb, vd );
#endif
if( !sys->b_evas_changed )
{
evas_object_image_data_set( sys->p_evas, NULL );
evas_object_image_pixels_dirty_set( sys->p_evas, 0 );
}
return 0;
}
static void
_emotion_image_data_zero(Evas_Object *img)
{
void *data = NULL;
data = evas_object_image_data_get(img, 1);
if (data)
{
int w, h, sz = 0;
Evas_Colorspace cs;
evas_object_image_size_get(img, &w, &h);
cs = evas_object_image_colorspace_get(img);
if (cs == EVAS_COLORSPACE_ARGB8888)
sz = w * h * 4;
if ((cs == EVAS_COLORSPACE_YCBCR422P601_PL) ||
(cs == EVAS_COLORSPACE_YCBCR422P709_PL))
sz = h * 2 * sizeof(unsigned char *);
if (sz != 0) memset(data, 0, sz);
}
evas_object_image_data_set(img, data);
}
static Evas_Object* differenceImageFromDifferenceBuffer(Evas* evas, unsigned char* buffer, int width, int height)
{
Evas_Object* image = evas_object_image_filled_add(evas);
if (!image)
abortWithErrorMessage("could not create difference image");
evas_object_image_size_set(image, width, height);
evas_object_image_colorspace_set(image, EVAS_COLORSPACE_ARGB8888);
unsigned char* diffPixels = static_cast<unsigned char*>(evas_object_image_data_get(image, EINA_TRUE));
const int rowStride = evas_object_image_stride_get(image);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
unsigned char* diffPixel = pixelFromImageData(diffPixels, rowStride, x, y);
diffPixel[Red] = diffPixel[Green] = diffPixel[Blue] = *buffer++;
diffPixel[Alpha] = 0xff;
}
}
evas_object_image_data_set(image, diffPixels);
return image;
}
static int
EvasImageSetup( vout_display_t *vd )
{
vout_display_sys_t *sys = vd->sys;
char *psz_fcc = var_InheritString( vd, "evas-image-chroma" );
if( psz_fcc )
{
vd->fmt.i_chroma = vlc_fourcc_GetCodecFromString( VIDEO_ES, psz_fcc );
free( psz_fcc );
}
switch( vd->fmt.i_chroma )
{
case VLC_CODEC_RGB32:
sys->u.evas.i_colorspace = EVAS_COLORSPACE_ARGB8888;
break;
/* Not implemented yet */
#if 0
case VLC_CODEC_RGB16:
sys->u.evas.i_colorspace = EVAS_COLORSPACE_RGB565_A5P;
break;
#endif
case VLC_CODEC_YUYV:
sys->u.evas.i_colorspace = EVAS_COLORSPACE_YCBCR422601_PL;
sys->u.evas.b_yuv = true;
break;
/* FIXME: SIGSEGV in evas_gl_common_texture_nv12_update */
#if 0
case VLC_CODEC_NV12:
sys->u.evas.i_colorspace = EVAS_COLORSPACE_YCBCR420NV12601_PL;
sys->u.evas.b_yuv = true;
break;
#endif
case VLC_CODEC_YV12:
sys->u.evas.i_colorspace = EVAS_COLORSPACE_YCBCR422P601_PL;
sys->u.evas.b_yuv = true;
break;
default:
case VLC_CODEC_I420:
sys->u.evas.i_colorspace = EVAS_COLORSPACE_YCBCR422P601_PL;
vd->fmt.i_chroma = VLC_CODEC_I420;
sys->u.evas.b_yuv = true;
break;
}
evas_object_image_colorspace_set( sys->p_evas, sys->u.evas.i_colorspace );
evas_object_image_data_set( sys->p_evas, NULL );
/* No rotation support with EvasImage */
sys->b_apply_rotation = true;
FmtUpdate( vd );
/* No aspect ratio support with EvasImage */
vd->info.has_pictures_invalid = true;
sys->pf_set_data = EvasImageSetData;
sys->pf_buffers_alloc = EvasImageBuffersAlloc;
sys->pf_buffers_free = EvasImageBuffersFree;
msg_Dbg( vd, "using evas_image" );
return 0;
}
void
epdf_page_render (Epdf_Page *page, Evas_Object *o)
{
SplashOutputDev *output_dev;
SplashColor white;
SplashColorPtr color_ptr;
Epdf_Document *doc;
unsigned int *m = NULL;
double hscale;
double vscale;
int rotate;
int width;
int height;
double t1,t2;
t1 = ecore_time_get();
white[0] = 255;
white[1] = 255;
white[2] = 255;
white[3] = 255;
if (!page->page || !page->page->isOk ())
return;
doc = page->doc;
output_dev = new SplashOutputDev(splashModeXBGR8, 4, gFalse, white);
output_dev->startDoc(doc->pdfdoc->getXRef ());
switch (page->orientation) {
case EPDF_PAGE_ORIENTATION_LANDSCAPE:
rotate = 90;
break;
case EPDF_PAGE_ORIENTATION_UPSIDEDOWN:
rotate = 180;
break;
case EPDF_PAGE_ORIENTATION_SEASCAPE:
rotate = 270;
break;
case EPDF_PAGE_ORIENTATION_PORTRAIT:
default:
rotate = 0;
break;
}
epdf_page_scale_get (page, &hscale, &vscale);
page->page->display (output_dev,
72.0 * hscale,
72.0 * vscale,
rotate,
false, false, false,
doc->pdfdoc->getCatalog ());
color_ptr = output_dev->getBitmap ()->getDataPtr ();
width = output_dev->getBitmap()->getWidth();
height = output_dev->getBitmap()->getHeight();
evas_object_image_size_set(o, width, height);
evas_object_image_fill_set(o, 0, 0, width, height);
m = (unsigned int *)evas_object_image_data_get(o, 1);
if (!m)
goto sortie;
memcpy (m, color_ptr, height * width * 4);
evas_object_image_data_set(o, m);
evas_object_image_data_update_add(o, 0, 0, width, height);
evas_object_resize(o, width, height);
// evas_object_image_alpha_set (o, 0);
sortie:
delete output_dev;
t2 = ecore_time_get();
printf ("time poppler: %f\n", t2-t1);
}
int captureScreen()
{
char dstpath[MAX_PATH_LENGTH];
char* scrimage;
int width, height;
Evas* ev = NULL;
Evas_Object* img;
screenshot_data sdata;
probeInfo_t probeInfo;
int ret = 0;
static pthread_mutex_t captureScreenLock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&captureScreenLock);
probeBlockStart();
setProbePoint(&probeInfo);
sdata.ximage = NULL;
scrimage = captureScreenShotX(&width, &height, &sdata);
if(scrimage != NULL)
{
ev = create_canvas(width, height);
if(likely(ev != NULL))
{
snprintf(dstpath, sizeof(dstpath),
SCREENSHOT_DIRECTORY "/%d_%d.png", getpid(),
probeInfo.eventIndex);
// make image buffer
if((img = evas_object_image_add(ev)) != NULL)
{
//image buffer set
evas_object_image_data_set(img, NULL);
evas_object_image_size_set(img, width, height);
evas_object_image_data_set(img, scrimage);
// resize image
if(height > MAX_HEIGHT)
{
width = width * MAX_HEIGHT / height;
height = MAX_HEIGHT;
evas_object_resize(img, width, height);
evas_object_image_fill_set(img, 0, 0, width, height);
}
evas_object_image_data_update_add(img, 0, 0, width, height);
//save file
if(evas_object_image_save(img, dstpath, NULL, "compress=5") != 0)
{
chmod(dstpath, 0777);
/* welcome to the hell */
log_t log;
PREPARE_LOCAL_BUF_THOUGH((char *)&log);
/* skip header */
LOCAL_BUF += offsetof(log_t, data);
/* pack screenshot name */
BUF_PTR = pack_string(LOCAL_BUF, dstpath); /* file name */
LOCAL_BUF = BUF_PTR;
/* pack probe */
PACK_COMMON_BEGIN(MSG_PROBE_SCREENSHOT, API_ID_captureScreen, "", 0);
PACK_COMMON_END('d', 0, 0, 0);
PACK_SCREENSHOT(dstpath, getOrientation());
SET_MSG_LEN();
log.length = GET_MSG_LEN() + MSG_LEN_OFFSET + strlen(dstpath) + 1;
/* send all message */
printLog(&log, MSG_IMAGE);
}
else
{
// captureScreen : evas_object_image_save failed
ret = -1;
}
}
else
{
// captureScreen : evas_object_image_add failed
ret = -1;
}
}
else
{
// captureScreen : create canvas failed
ret = -1;
}
}
else
{
// captureScreen : captureScreenShotX failed
ret = -1;
}
// release resources
releaseScreenShotX(&sdata);
if(ev)
destroy_canvas(ev);
probeBlockEnd();
pthread_mutex_unlock(&captureScreenLock);
return ret;
}
static float calculateDifference(Evas_Object* baselineImage, Evas_Object* actualImage, RefPtr<Evas_Object>& differenceImage)
{
int width, height, baselineWidth, baselineHeight;
evas_object_image_size_get(actualImage, &width, &height);
evas_object_image_size_get(baselineImage, &baselineWidth, &baselineHeight);
if (width != baselineWidth || height != baselineHeight) {
printf("Error, test and reference image have different sizes.\n");
return 100; // Completely different.
}
OwnArrayPtr<unsigned char> diffBuffer = adoptArrayPtr(new unsigned char[width * height]);
if (!diffBuffer)
abortWithErrorMessage("could not create difference buffer");
const int actualRowStride = evas_object_image_stride_get(actualImage);
const int baseRowStride = evas_object_image_stride_get(baselineImage);
unsigned numberOfDifferentPixels = 0;
float totalDistance = 0;
float maxDistance = 0;
unsigned char* actualPixels = static_cast<unsigned char*>(evas_object_image_data_get(actualImage, EINA_FALSE));
unsigned char* basePixels = static_cast<unsigned char*>(evas_object_image_data_get(baselineImage, EINA_FALSE));
unsigned char* currentDiffPixel = diffBuffer.get();
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
unsigned char* actualPixel = pixelFromImageData(actualPixels, actualRowStride, x, y);
unsigned char* basePixel = pixelFromImageData(basePixels, baseRowStride, x, y);
const float distance = calculatePixelDifference(basePixel, actualPixel);
*currentDiffPixel++ = static_cast<unsigned char>(distance * 255.0f);
if (distance >= 1.0f / 255.0f) {
++numberOfDifferentPixels;
totalDistance += distance;
maxDistance = std::max<float>(maxDistance, distance);
}
}
}
// When using evas_object_image_data_get(), a complementary evas_object_data_set() must be
// issued to balance the reference count, even if the image hasn't been changed.
evas_object_image_data_set(baselineImage, basePixels);
evas_object_image_data_set(actualImage, actualPixels);
// Compute the difference as a percentage combining both the number of
// different pixels and their difference amount i.e. the average distance
// over the entire image
float difference = 0;
if (numberOfDifferentPixels)
difference = 100.0f * totalDistance / (height * width);
if (difference <= gTolerance)
difference = 0;
else {
difference = roundf(difference * 100.0f) / 100.0f;
difference = std::max(difference, 0.01f); // round to 2 decimal places
differenceImage = adoptRef(differenceImageFromDifferenceBuffer(evas_object_evas_get(baselineImage), diffBuffer.get(), width, height));
}
return difference;
}
bool EflResources::copyResource( Evas_Object* const _image
, std::string const& _path
, bool const _keep_aspect
, int _width
, int _height ) const
{
bool result( true );
Evas_Object* object = nullptr;
if( 0 != preloaded_images__.count( _path ) )
object = preloaded_images__.find( _path )->second;
else
{
object = preloaded_images__.find( IMG_DIR "/placeholder.png" )->second;
LOGGER( "Could not find file among preloaded images: " + _path );
result = false;
}
int src_w = 0;
int src_h = 0;
evas_object_image_size_get( object
, &src_w
, &src_h );
evas_object_image_size_set( _image
, src_w
, src_h );
evas_object_image_alpha_set( _image
, evas_object_image_alpha_get( object ) );
evas_object_image_data_set( _image
, evas_object_image_data_get( object
, 0 ) );
if( _keep_aspect )
{
if( 0 == _width || 0 == _height )
{
evas_object_geometry_get( _image
, nullptr
, nullptr
, &_width
, &_height );
}
int new_w = 0;
int new_h = 0;
Utility::calculateImageSize( _width
, _height
, src_w
, src_h
, new_w
, new_h );
evas_object_resize( _image
, new_w
, new_h );
}
evas_object_image_pixels_dirty_set( _image
, 1 );
return result;
}
static void
_bumpmap(Efx_Bumpmap_Data *ebd)
{
Evas_Object *o;
int w;
int h;
int i, j;
int x;
int y;
int z;
int depth;
int red;
int green;
int blue;
int ambient;
double z_2, lightx, lighty;
int mx;
int my;
unsigned int *d1;
unsigned int *d2;
unsigned int *src;
unsigned int *mp;
unsigned int *mpy;
unsigned int *mpp;
x = ebd->x;
y = ebd->y;
z = ebd->z;
red = ebd->red / 0x100;
green = ebd->green / 0x100;
blue = ebd->blue / 0x100;
ambient = ebd->ambient / 0x100;
depth = ebd->depth / 0x100;
depth /= (255 * (255 + 255 + 255));
z_2 = z * z;
o = ebd->e->obj;
evas_object_image_size_get(o, &w, &h);
if ((!w) || (!h)) return;
d1 = malloc(w * h * sizeof(int));
memcpy(d1, ebd->img_data, w * h * sizeof(int));
src = d1;
d2 = malloc(w * h * sizeof(int));
memcpy(d2, ebd->img_data, w * h * sizeof(int));
mpp = d2;
my = h;
lighty = -y;
for (j = h; --j >= 0;)
{
mp = mpp;
mpp += w;
if (--my <= 0)
{
mpp -= w * h;
my = h;
}
mpy = mpp;
mx = w;
lightx = -x;
i = w - 1;
do
{
double x1, y_1, v;
int r, g, b, gr;
gr = A_VAL(mp) * (R_VAL(mp) + G_VAL(mp) + B_VAL(mp));
y_1 = depth * (double)(A_VAL(mpy) * (R_VAL(mpy) +
G_VAL(mpy) +
B_VAL(mpy)) -
gr);
mp++;
mpy++;
if (--mx <= 0)
{
mp -= w;
mpy -= w;
mx = w;
}
x1 = depth * (double)(A_VAL(mp) * (R_VAL(mp) +
G_VAL(mp) + B_VAL(mp)) - gr);
v = x1 * lightx + y_1 * lighty + z;
v /= sqrt((x1 * x1) + (y_1 * y_1) + 1.0);
v /= sqrt((lightx * lightx) + (lighty * lighty) + z_2);
v += ambient;
r = v * R_VAL(src) * red;
g = v * G_VAL(src) * green;
b = v * B_VAL(src) * blue;
if (r < 0)
r = 0;
else if (r > 255)
r = 255;
if (g < 0)
g = 0;
else if (g > 255)
g = 255;
if (b < 0)
b = 0;
else if (b > 255)
b = 255;
R_VAL(src) = r;
G_VAL(src) = g;
B_VAL(src) = b;
lightx++;
src++;
} while (--i >= 0);
lighty++;
}
unsigned int *m;
m = (unsigned int *)evas_object_image_data_get(o, 1);
memcpy(m, d1, w * h * sizeof(unsigned int));
evas_object_image_data_set(o, m);
evas_object_image_data_update_add(o, 0, 0, w, h);
free(d1);
free(d2);
}
void utils_slide_delete(List_Item *item)
{
int i = 0;
Eina_List *l;
List_Item *_item;
EINA_LIST_FOREACH(l_slides, l, _item)
{
if(item == _item)
break;
else
i++;
}
Evas_Object *lbl, *tb, *bt, *icon;
char buf[PATH_MAX];
snprintf(buf, sizeof(buf), "%s/theme.edj", PACKAGE_DATA_DIR);
_inwin_delete_slide = elm_win_inwin_add(win);
evas_object_show(_inwin_delete_slide);
elm_object_style_set(_inwin_delete_slide, "minimal");
tb = elm_table_add(win);
elm_win_inwin_content_set(_inwin_delete_slide, tb);
//icon
icon = edje_object_add(evas_object_evas_get(win));
edje_object_file_set(icon, buf, "list/slides/icon");
evas_object_size_hint_min_set(icon,1024*0.20,768*0.20);
evas_object_size_hint_max_set(icon,1024*0.20,768*0.20);
if(item->thumb)
{
int w = item->thumb->w;
int h = item->thumb->h;
int *image = calloc(w*h, sizeof(int));
memcpy(image, item->thumb->thumb, sizeof(int)*w*h);
const Evas_Object *o_image = edje_object_part_object_get(icon, "object.icon");
evas_object_image_filled_set((Evas_Object*)o_image,1);
evas_object_color_set((Evas_Object*)o_image,255,255,255,255);
evas_object_image_size_set((Evas_Object*)o_image, w, h);
evas_object_image_data_set((Evas_Object*)o_image, image);
edje_object_signal_emit(icon, "icon,show", "eyelight");
}
evas_object_show(icon);
elm_table_pack(tb, icon, 0, 0, 2, 1);
//
bt= elm_button_add(win);
elm_object_text_set(bt, "Invisible button to add a vertical space");
elm_table_pack(tb, bt, 0, 1, 1, 1);
lbl = elm_label_add(win);
elm_object_text_set(lbl, D_("Are you sure you want to delete this slide ?"));
elm_table_pack(tb, lbl, 0, 2, 2, 1);
evas_object_show(lbl);
bt= elm_button_add(win);
elm_object_text_set(bt, "Invisible button to add a vertical space");
elm_table_pack(tb, bt, 0, 3, 1, 1);
bt= elm_button_add(win);
elm_object_text_set(bt, D_("Yes, Delete the slide"));
evas_object_smart_callback_add(bt, "clicked", _utils_slide_delete_cb, item);
evas_object_color_set(bt, 255, 0, 0, 255);
elm_table_pack(tb, bt, 0, 4, 1, 1);
evas_object_show(bt);
bt= elm_button_add(win);
elm_object_text_set(bt, D_("No, do not delete the slide"));
evas_object_smart_callback_add(bt, "clicked", _utils_slide_delete_cancel_cb, item);
elm_table_pack(tb, bt, 1, 4, 1, 1);
evas_object_show(bt);
}
