#define SIZE_FOR_UPDATE_VISIBILITY sizeof(gchar)
#define EPIPE_REQUEST_LIMIT 20
+#ifdef DUMP_IMG
+int util_write_rawdata (const char *file, const void *data, unsigned int size);
+typedef struct _BufferInfo
+{
+ Display *dpy;
+ Pixmap pixmap;
+ int width;
+ int height;
+
+ /* Dri2 */
+ int drm_fd;
+ tbm_bufmgr bufmgr;
+ void *virtual;
+ DRI2Buffer *dri2_buffers;
+ tbm_bo bo;
+} BufferInfo;
+
+static BufferInfo *g_bufinfo[NUM_OF_PIXMAP];
+void * gst_evaspixmapsink_get_buffer (Display *dpy, Pixmap pixmap, int width, int height, int i);
+void gst_evaspixmapsink_free_buffer (int i);
+static Bool gst_evaspixmapsink_init_dri2 (BufferInfo *bufinfo);
+int g_cnt;
+#endif
+
/* macro ******************************************************/
#define EVASPIXMAPSINK_SET_PIXMAP_ID_TO_GEM_INFO( x_evaspixmapsink, x_pixmap_id ) \
do \
#define GST_IS_EVASPIXMAP_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_EVASPIXMAP_BUFFER))
#define GST_EVASPIXMAP_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_EVASPIXMAP_BUFFER, GstEvasPixmapBuffer))
+static int log_warn_count = 0;
+
+Display *g_my_disp;
+
static int get_millis_time()
{
struct timespec tp;
static void
ecore_pipe_callback_handler (void *data, void *buffer, unsigned int nbyte)
{
+ if (!data ) {
+ GST_WARNING ("data is NULL..");
+ return;
+ }
+
GstEvasPixmapSink *evaspixmapsink = (GstEvasPixmapSink*)data;
GST_DEBUG_OBJECT (evaspixmapsink,"[START] Evas_Object(0x%x)", evaspixmapsink->eo);
- MMTA_ACUM_ITEM_BEGIN("evaspixmapsink - ecore thread cb : TOTAL", FALSE);
int i = 0;
guint idx = 0;
GstXPixmap *xpixmap = NULL;
- if (!data ) {
- GST_WARNING_OBJECT (evaspixmapsink,"data is NULL..");
- return;
- }
+ g_mutex_lock (evaspixmapsink->flow_lock);
+
evaspixmapsink->epipe_request_count--;
if (!evaspixmapsink->eo) {
GST_WARNING_OBJECT (evaspixmapsink,"evas object is NULL..");
+ g_mutex_unlock (evaspixmapsink->flow_lock);
+ return;
+ }
+
+ if (!evaspixmapsink->xcontext) {
+ GST_WARNING_OBJECT (evaspixmapsink,"xcontext is NULL..");
+ g_mutex_unlock (evaspixmapsink->flow_lock);
return;
}
GST_INFO_OBJECT (evaspixmapsink, "object show");
}
}
+ g_mutex_unlock (evaspixmapsink->flow_lock);
return;
}
surf.type = EVAS_NATIVE_SURFACE_X11;
surf.data.x11.visual = ecore_x_default_visual_get(ecore_x_display_get(), ecore_x_default_screen_get());
surf.data.x11.pixmap = evaspixmapsink->xpixmap[idx]->pixmap;
- __ta__("evaspixmapsink - ecore thread cb : _native_surface_set(LINK)", evas_object_image_native_surface_set(evaspixmapsink->eo, &surf); );
+ evas_object_image_native_surface_set(evaspixmapsink->eo, &surf);
evaspixmapsink->do_link = FALSE;
} else {
GST_WARNING_OBJECT (evaspixmapsink,"pixmap is NULL..");
+ g_mutex_unlock (evaspixmapsink->flow_lock);
return;
}
for (i = 0; i < evaspixmapsink->num_of_pixmaps; i++) {
if (evaspixmapsink->eo) {
evas_object_image_native_surface_set(evaspixmapsink->eo, NULL);
}
- __ta__("evaspixmapsink - ecore thread cb : _native_surface_set", evas_object_image_native_surface_set(evaspixmapsink->eo, &surf); );
+ evas_object_image_native_surface_set(evaspixmapsink->eo, &surf);
GST_LOG_OBJECT (evaspixmapsink,"update, native_surface_set of xpixmap[%d]",idx);
if (evaspixmapsink->last_updated_idx == -1) {
xpixmap->damaged_time = 0;
evaspixmapsink->last_updated_idx = idx;
}
- MMTA_ACUM_ITEM_BEGIN("evaspixmapsink evas_object_image update", FALSE);
- evas_object_image_pixels_dirty_set (evaspixmapsink->eo, 1);
evas_object_image_fill_set(evaspixmapsink->eo, 0, 0, evaspixmapsink->w, evaspixmapsink->h);
evas_object_image_data_update_add(evaspixmapsink->eo, 0, 0, evaspixmapsink->w, evaspixmapsink->h);
- MMTA_ACUM_ITEM_END("evaspixmapsink evas_object_image update", FALSE);
//GST_LOG_OBJECT (evaspixmapsink,"request to update : pixmap idx(%d), ref(%d)", idx, xpixmap->ref);
} else {
GST_ERROR_OBJECT (evaspixmapsink,"pixmap is NULL..");
g_mutex_unlock (evaspixmapsink->pixmap_ref_lock);
}
- MMTA_ACUM_ITEM_END("evaspixmapsink - ecore thread cb : TOTAL", FALSE);
-
GST_DEBUG_OBJECT (evaspixmapsink,"[END]");
+ g_mutex_unlock (evaspixmapsink->flow_lock);
}
static inline gboolean
evaspixmapsink->gem_info[i].ref_pixmap = 0;
}
}
+
+ /**
+ * Pixmap is reallocated.
+ * But native surface has old pixmap.
+ * In this case, evas can rendering with old pixmap.
+ * That makes broken image in the window.
+ * So I just unset evas native surface.
+ */
+ if (evaspixmapsink->eo) {
+ evas_object_image_native_surface_set(evaspixmapsink->eo, NULL);
+ evas_object_image_data_set(evaspixmapsink->eo, NULL);
+ }
#ifdef COMPARE_RATIO
}
#endif
}
- if (GST_STATE(evaspixmapsink) == GST_STATE_PAUSED) {
+ if (GST_STATE(evaspixmapsink) >= GST_STATE_PAUSED) {
gst_evaspixmap_buffer_put (evaspixmapsink, evaspixmapsink->evas_pixmap_buf);
}
char error_msg[1024];
XGetErrorText (display, xevent->error_code, error_msg, 1024);
- GST_ERROR ("evaspixmapsink triggered an XError. error(%s), display(%p), xevent->request_code(%d)", error_msg, display, xevent->request_code);
- error_caught = TRUE;
+ if (display != g_my_disp) {
+ GST_WARNING ("evaspixmapsink triggered an XError. but display(%p) is not ours(%p), just skip it. error(%s), xevent->request_code(%d)", display, g_my_disp, error_msg, xevent->request_code);
+ } else {
+ GST_ERROR ("evaspixmapsink triggered an XError. error(%s), display(%p), xevent->request_code(%d)", error_msg, display, xevent->request_code);
+ error_caught = TRUE;
+ }
return 0;
}
+#ifdef DUMP_IMG
+int util_write_rawdata(const char *file, const void *data, unsigned int size)
+{
+ FILE *fp;
+
+ fp = fopen(file, "wb");
+ if (fp == NULL)
+ {
+ GST_WARNING("fopen fail... size : %d", size);
+ return -1;
+ }
+ fwrite((char*)data, sizeof(char), size, fp);
+ fclose(fp);
+
+ return 0;
+}
+
+void *
+gst_evaspixmapsink_get_buffer (Display *dpy, Pixmap pixmap, int width, int height, int i)
+{
+ if (g_bufinfo[i]!=NULL)
+ {
+ GST_ERROR("g_bufinfo!=NULL %p", g_bufinfo[i]);
+ exit (-1);
+ }
+
+ g_bufinfo[i] = calloc (1, sizeof (BufferInfo));
+
+ g_bufinfo[i]->dpy = dpy;
+ g_bufinfo[i]->pixmap = pixmap;
+ g_bufinfo[i]->width = width;
+ g_bufinfo[i]->height = height;
+
+ if (!gst_evaspixmapsink_init_dri2 (g_bufinfo[i]))
+ {
+ free (g_bufinfo[i]);
+ g_bufinfo[i] = NULL;
+ return NULL;
+ }
+
+ if (g_bufinfo[i]->virtual == NULL)
+ {
+ GST_ERROR("g_bufinfo->virtual == NULL");
+ exit (-1);
+ }
+
+ return g_bufinfo[i]->virtual;
+}
+
+void
+gst_evaspixmapsink_free_buffer (int i)
+{
+ if (g_bufinfo[i] == NULL)
+ {
+ GST_ERROR("g_bufinfo == NULL");
+ exit (-1);
+ }
+
+ if (g_bufinfo[i]==NULL)
+ {
+ GST_ERROR("g_bufinfo==NULL");
+ exit (-1);
+ }
+
+ if (g_bufinfo[i])
+ {
+ if (g_bufinfo[i]->bo)
+ tbm_bo_unref(g_bufinfo[i]->bo);
+ if (g_bufinfo[i]->dri2_buffers)
+ free(g_bufinfo[i]->dri2_buffers);
+ if (g_bufinfo[i]->bufmgr)
+ tbm_bufmgr_deinit (g_bufinfo[i]->bufmgr);
+ if (g_bufinfo[i]->drm_fd >= 0)
+ close (g_bufinfo[i]->drm_fd);
+ }
+
+ XSync (g_bufinfo[i]->dpy, 0);
+ free (g_bufinfo[i]);
+ g_bufinfo[i] = NULL;
+}
+
+static Bool gst_evaspixmapsink_init_dri2 (BufferInfo *bufinfo)
+{
+ int screen;
+ int dri2_base = 0;
+ int dri2_err_base = 0;
+ int dri2Major, dri2Minor;
+ char *driverName = NULL, *deviceName = NULL;
+ unsigned int attachments[1];
+ int dri2_count, dri2_out_count;
+ int dri2_width, dri2_height;
+ drm_magic_t magic;
+ tbm_bo_handle bo_handle;
+ screen = DefaultScreen(bufinfo->dpy);
+ if (!DRI2QueryExtension (bufinfo->dpy, &dri2_base, &dri2_err_base))
+ {
+ GST_ERROR ("no DRI2 extension. !!\n");
+ goto fail_init_dri2;
+ }
+ if (!DRI2QueryVersion (bufinfo->dpy, &dri2Major, &dri2Minor))
+ {
+ GST_ERROR ("fail : DRI2QueryVersion !!\n");
+ goto fail_init_dri2;
+ }
+ if (!DRI2Connect (bufinfo->dpy, RootWindow(bufinfo->dpy, screen), &driverName, &deviceName))
+ {
+ GST_ERROR ("fail : DRI2Connect !!\n");
+ goto fail_init_dri2;
+ } /* drm_fd */
+ bufinfo->drm_fd = open (deviceName, O_RDWR);
+ if (bufinfo->drm_fd < 0)
+ {
+ GST_ERROR ("fail : open drm device (%s)\n", deviceName);
+ goto fail_init_dri2;
+ }
+ /* get the drm magic */
+ drmGetMagic(bufinfo->drm_fd, &magic);
+ if (!DRI2Authenticate(bufinfo->dpy, RootWindow(bufinfo->dpy, screen), magic))
+ {
+ GST_ERROR ("fail : DRI2Authenticate (%d)\n", magic);
+ goto fail_init_dri2;
+ }
+ /* bufmgr */
+ bufinfo->bufmgr = tbm_bufmgr_init (bufinfo->drm_fd);
+ if (!bufinfo->bufmgr)
+ {
+ GST_ERROR ("fail : init buffer manager \n");
+ goto fail_init_dri2;
+ }
+ DRI2CreateDrawable (bufinfo->dpy, bufinfo->pixmap);
+ attachments[0] = DRI2BufferFrontLeft;
+ dri2_count = 1;
+ bufinfo->dri2_buffers = DRI2GetBuffers (bufinfo->dpy, bufinfo->pixmap, &dri2_width, &dri2_height,
+ attachments, dri2_count, &dri2_out_count);
+ if (!bufinfo->dri2_buffers)
+ {
+ GST_ERROR ("fail : get buffers\n");
+ goto fail_init_dri2;
+ }
+ if (!bufinfo->dri2_buffers[0].name)
+ {
+ GST_ERROR ("fail : a handle of the dri2 buffer is null \n ");
+ goto fail_init_dri2;
+ }
+ bufinfo->bo = tbm_bo_import (bufinfo->bufmgr, bufinfo->dri2_buffers[0].name);
+ if (!bufinfo->bo)
+ {
+ GST_ERROR ("fail : import bo (key:%d)\n", bufinfo->dri2_buffers[0].name);
+ goto fail_init_dri2;
+ }
+ /* virtual */
+ bo_handle = tbm_bo_map(bufinfo->bo, TBM_DEVICE_CPU, TBM_OPTION_WRITE);
+ if(!bo_handle.ptr)
+ {
+ GST_ERROR ("fail : tbm_bo_map");
+ goto fail_init_dri2;
+ }
+ tbm_bo_unmap (bufinfo->bo);
+
+ bufinfo->virtual = (void *)bo_handle.ptr;
+ if (!bufinfo->virtual)
+ {
+ GST_ERROR ("fail : map \n");
+ goto fail_init_dri2;
+ }
+
+ free (driverName);
+ free (deviceName);
+
+ return True;
+
+ fail_init_dri2:
+ if (driverName)
+ free (driverName);
+ if (deviceName)
+ free (deviceName);
+ if (bufinfo->bo)
+ tbm_bo_unref(bufinfo->bo);
+ if (bufinfo->dri2_buffers)
+ free(bufinfo->dri2_buffers);
+ if (bufinfo->bufmgr)
+ tbm_bufmgr_deinit (bufinfo->bufmgr);
+ if (bufinfo->drm_fd >= 0)
+ close (bufinfo->drm_fd);
+ return False;
+}
+#endif
+
#ifdef HAVE_XSHM
/* This function checks that it is actually really possible to create an image
using XShm */
int ret = 0;
int idx = 0;
GstXPixmap *xpixmap = NULL;
-
- MMTA_ACUM_ITEM_BEGIN("evaspixmapsink evaspixmap_buffer_put()", FALSE);
+ int i = 0;
/* We take the flow_lock. If expose is in there we don't want to run
concurrently from the data flow thread */
if (G_UNLIKELY (evaspixmapsink->xpixmap[idx] == NULL)) {
GST_WARNING_OBJECT (evaspixmapsink, "xpixmap is NULL. Skip buffer_put." );
g_mutex_unlock(evaspixmapsink->flow_lock);
- return FALSE;
+ return TRUE;
}
if (evaspixmapsink->visible == FALSE) {
GST_WARNING_OBJECT (evaspixmapsink, "visible is FALSE. Skip buffer_put." );
break;
}
+ g_mutex_lock (evaspixmapsink->x_lock);
+
/* set display rotation */
if (atom_rotation == None) {
atom_rotation = XInternAtom(evaspixmapsink->xcontext->disp, "_USER_WM_PORT_ATTRIBUTE_ROTATION", False);
}
-
ret = XvSetPortAttribute(evaspixmapsink->xcontext->disp, evaspixmapsink->xcontext->xv_port_id, atom_rotation, rotate);
if (ret != Success) {
GST_ERROR_OBJECT( evaspixmapsink, "XvSetPortAttribute failed[%d]. disp[%x],xv_port_id[%d],atom[%x],rotate[%d]",
ret, evaspixmapsink->xcontext->disp, evaspixmapsink->xcontext->xv_port_id, atom_rotation, rotate );
- return FALSE;
}
/* set display flip */
ret, evaspixmapsink->xcontext->disp, evaspixmapsink->xcontext->xv_port_id, atom_vflip, set_vflip);
}
+ g_mutex_unlock (evaspixmapsink->x_lock);
+
} else {
result.x = result.y = 0;
result.w = evaspixmapsink->xpixmap[idx]->width;
GST_INFO_OBJECT (evaspixmapsink, "USE ORIGIN SIZE, no geometry method, no rotation/flip" );
}
+ if((evaspixmapsink->result_prev.w != 0 && evaspixmapsink->result_prev.h != 0)
+ && (evaspixmapsink->src_prev.w==src_origin.w && evaspixmapsink->src_prev.h==src_origin.h)
+ && (evaspixmapsink->result_prev.w!=result.w || evaspixmapsink->result_prev.h!=result.h))
+ {
+ GST_WARNING("It will execute XFillRectangle..... evaspixmapsink->result_prev.w : %d, evaspixmapsink->result_prev.h: %d, result.w : %d, result.h : %d",
+ evaspixmapsink->result_prev.w, evaspixmapsink->result_prev.h, result.w, result.h);
+ for (i = 0; i < evaspixmapsink->num_of_pixmaps; i++) {
+ XFillRectangle (evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->pixmap, evaspixmapsink->xpixmap[i]->gc,
+ 0, 0, evaspixmapsink->xpixmap[i]->width, evaspixmapsink->xpixmap[i]->height);
+ GST_LOG_OBJECT (evaspixmapsink,"fill black to xpixmap[%d] with size(w:%d,h:%d)", evaspixmapsink->xpixmap[i]->pixmap,
+ evaspixmapsink->xpixmap[i]->width, evaspixmapsink->xpixmap[i]->height);
+ }
+ }
g_mutex_lock (evaspixmapsink->x_lock);
/* We scale to the pixmap's geometry */
GST_WARNING_OBJECT (evaspixmapsink, "visible is FALSE. skip this image..." );
}
}
+
+ evaspixmapsink->src_prev.w = src_origin.w;
+ evaspixmapsink->src_prev.h = src_origin.h;
+
+ evaspixmapsink->result_prev.w = result.w;
+ evaspixmapsink->result_prev.h = result.h;
+
XSync (evaspixmapsink->xcontext->disp, FALSE);
g_mutex_unlock (evaspixmapsink->x_lock);
g_mutex_unlock (evaspixmapsink->flow_lock);
- MMTA_ACUM_ITEM_END("evaspixmapsink evaspixmap_buffer_put()", FALSE);
-
return TRUE;
}
int i = 0;
Display *disp = NULL;
+#ifdef DUMP_IMG
+ int ret = 0;
+ char file_name[128];
+ char *dump_data;
+#endif
+
+
GST_OBJECT_LOCK (evaspixmapsink);
if (evaspixmapsink->xcontext && evaspixmapsink->xcontext->disp) {
xpixmap->damaged_time = (gint)get_millis_time();
}
g_mutex_unlock(evaspixmapsink->pixmap_ref_lock);
- GST_DEBUG_OBJECT (evaspixmapsink,"event_handler : got a damage event for pixmap(%d), refcount(%d), damaged_time(%d)",
- xpixmap->pixmap, xpixmap->ref, xpixmap->damaged_time);
+ if (GST_STATE(evaspixmapsink) < GST_STATE_PLAYING || log_warn_count < 20) {
+ GST_WARNING_OBJECT (evaspixmapsink,"event_handler : got a damage event for pixmap(%d), refcount(%d), damaged_time(%d)",
+ xpixmap->pixmap, xpixmap->ref, xpixmap->damaged_time);
+ } else {
+ GST_DEBUG_OBJECT (evaspixmapsink,"event_handler : got a damage event for pixmap(%d), refcount(%d), damaged_time(%d)",
+ xpixmap->pixmap, xpixmap->ref, xpixmap->damaged_time);
+ }
if (evaspixmapsink->epipe_request_count > EPIPE_REQUEST_LIMIT) {
GST_WARNING_OBJECT (evaspixmapsink,"event_handler : epipe_request_count(%d), skip ecore_pipe_write()", evaspixmapsink->epipe_request_count);
} else {
- __ta__("evaspixmapsink ecore_pipe_write", ecore_pipe_write(evaspixmapsink->epipe, evaspixmapsink, sizeof(GstEvasPixmapSink)););
+ ecore_pipe_write(evaspixmapsink->epipe, evaspixmapsink, sizeof(GstEvasPixmapSink));
evaspixmapsink->epipe_request_count++;
- GST_DEBUG_OBJECT (evaspixmapsink,"event_handler : after call ecore_pipe_write() for pixmap(%d)", xpixmap->pixmap);
+ if (GST_STATE(evaspixmapsink) < GST_STATE_PLAYING || log_warn_count < 20 ) {
+ GST_WARNING_OBJECT (evaspixmapsink,"event_handler : after call ecore_pipe_write() for pixmap(%d)", xpixmap->pixmap);
+ log_warn_count++;
+ } else {
+ GST_DEBUG_OBJECT (evaspixmapsink,"event_handler : after call ecore_pipe_write() for pixmap(%d)", xpixmap->pixmap);
+ }
}
g_mutex_lock (evaspixmapsink->x_lock);
XDamageSubtract (evaspixmapsink->xcontext->disp, evaspixmapsink->damage[i], None, None );
g_mutex_unlock (evaspixmapsink->x_lock);
+#ifdef DUMP_IMG
+ int dump_w = evaspixmapsink->w + (32 - (evaspixmapsink->w%32)); // for multiples of 32
+ if(g_cnt<100)
+ {
+ evaspixmapsink->pixmap_addr[i] = gst_evaspixmapsink_get_buffer(evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->pixmap, dump_w, evaspixmapsink->h, i);
+ GST_ERROR("<DUMP_%2.2d> pixmap[%d] addr %p (w : %d, h : %d)", g_cnt, i, evaspixmapsink->pixmap_addr[i], dump_w, evaspixmapsink->h);
+ sprintf(file_name, "/opt/usr/media/DUMP_%2.2d.dump", g_cnt);
+
+ dump_data = g_malloc(dump_w * evaspixmapsink->h * 4);
+ memcpy (dump_data, evaspixmapsink->pixmap_addr[i], dump_w * evaspixmapsink->h * 4);
+
+ ret = util_write_rawdata(file_name, dump_data, dump_w * evaspixmapsink->h * 4);
+ if (ret) {
+ GST_ERROR_OBJECT (evaspixmapsink, "util_write_rawdata() failed");
+ }
+ else
+ g_cnt++;
+ g_free(dump_data);
+
+ if (g_bufinfo[i]) {
+ gst_evaspixmapsink_free_buffer (i);
+ g_bufinfo[i] = NULL;
+ }
+ evaspixmapsink->pixmap_addr[i] = NULL;
+ }
+#endif
if (evaspixmapsink->buf_shared_type == BUF_SHARE_METHOD_FD) {
if (GST_STATE(evaspixmapsink) == GST_STATE_PLAYING) {
drm_fini_close_gem_handle(evaspixmapsink, xpixmap->pixmap);
g_mutex_lock (evaspixmapsink->x_lock);
xcontext->disp = XOpenDisplay (evaspixmapsink->display_name);
-
if (!xcontext->disp) {
g_mutex_unlock (evaspixmapsink->x_lock);
g_free (xcontext);
GST_ELEMENT_ERROR (evaspixmapsink, RESOURCE, WRITE, ("Could not initialise Xv output"), ("Could not open display"));
return NULL;
}
+ GST_WARNING_OBJECT (evaspixmapsink,"Display(0x%x) is opened", xcontext->disp);
+ g_my_disp = xcontext->disp;
xcontext->screen = DefaultScreenOfDisplay (xcontext->disp);
xcontext->screen_num = DefaultScreen (xcontext->disp);
xcontext->visual = DefaultVisual (xcontext->disp, xcontext->screen_num);
xcontext->root = DefaultRootWindow (xcontext->disp);
xcontext->white = XWhitePixel (xcontext->disp, xcontext->screen_num);
- xcontext->black = XBlackPixel (xcontext->disp, xcontext->screen_num);
xcontext->depth = DefaultDepthOfScreen (xcontext->screen);
xcontext->width = DisplayWidth (xcontext->disp, xcontext->screen_num);
g_free (xcontext);
GST_ELEMENT_ERROR (evaspixmapsink, RESOURCE, SETTINGS,
("Could not initialise Xv output"), ("Could not get pixel formats"));
+ g_my_disp = NULL;
return NULL;
}
g_free (xcontext->par);
g_free (xcontext);
/* GST_ELEMENT_ERROR is thrown by gst_evaspixmapsink_get_xv_support */
+ g_my_disp = NULL;
return NULL;
}
#ifdef HAVE_XSHM
XvUngrabPort (xcontext->disp, xcontext->xv_port_id, 0);
XCloseDisplay (xcontext->disp);
+ g_my_disp = NULL;
g_mutex_unlock (evaspixmapsink->x_lock);
evaspixmapsink->aligned_width = video_width;
evaspixmapsink->aligned_height = video_height;
+ /* get combine prop of hevc */
+ if(gst_structure_get_int (structure, "yuvcombine", &(evaspixmapsink->need_combine_data)))
+ {
+ GST_INFO_OBJECT(evaspixmapsink, "need combine data : %d", evaspixmapsink->need_combine_data);
+ }
+ else
+ {
+ /*Not need to combine data, just directly copy*/
+ evaspixmapsink->need_combine_data = 0;
+ }
+
/* get enable-last-buffer */
g_object_get(G_OBJECT(evaspixmapsink), "enable-last-buffer", &enable_last_buffer, NULL);
GST_INFO_OBJECT (evaspixmapsink,"current enable-last-buffer : %d", enable_last_buffer);
evaspixmapsink->fps_n = gst_value_get_fraction_numerator (fps);
evaspixmapsink->fps_d = gst_value_get_fraction_denominator (fps);
- evaspixmapsink->video_width = video_width;
- evaspixmapsink->video_height = video_height;
+ if (evaspixmapsink->video_width != video_width || evaspixmapsink->video_height != video_height) {
+ evaspixmapsink->src_prev.w = evaspixmapsink->video_width = video_width;
+ evaspixmapsink->src_prev.h = evaspixmapsink->video_height = video_height;
+ evaspixmapsink->need_to_fill_black = TRUE;
+ }
im_format = gst_evaspixmapsink_get_format_from_caps (evaspixmapsink, caps);
if (im_format == -1) {
/* call XSynchronize with the current value of synchronous */
GST_DEBUG_OBJECT (evaspixmapsink,"XSynchronize called with %s", evaspixmapsink->synchronous ? "TRUE" : "FALSE");
+ g_mutex_lock (evaspixmapsink->x_lock);
XSynchronize (evaspixmapsink->xcontext->disp, evaspixmapsink->synchronous);
+ g_mutex_unlock (evaspixmapsink->x_lock);
gst_evaspixmapsink_update_colorbalance (evaspixmapsink);
g_mutex_unlock (evaspixmapsink->flow_lock);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
GST_WARNING_OBJECT (evaspixmapsink,"GST_STATE_CHANGE_PLAYING_TO_PAUSED");
+ log_warn_count = 0;
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
case GST_STATE_CHANGE_READY_TO_NULL:
GST_WARNING_OBJECT (evaspixmapsink,"GST_STATE_CHANGE_READY_TO_NULL");
+ g_mutex_lock (evaspixmapsink->flow_lock);
gst_evaspixmapsink_reset(evaspixmapsink);
+ g_mutex_unlock (evaspixmapsink->flow_lock);
/* close drm */
drm_fini(evaspixmapsink);
break;
}
}
+static void
+gst_evaspixmapsink_combine_i420_scmn_data(GstEvasPixmapSink *evaspixmapsink, GstBuffer *buf)
+{
+ unsigned int outsize = 0;
+ unsigned char *temp_outbuf = evaspixmapsink->evas_pixmap_buf->xvimage->data;
+ int cnt = 0, j = 0;
+ unsigned char *temp_imgb;
+ SCMN_IMGB *imgb = NULL;
+ int stride, w, h, i;
+
+ GST_DEBUG("Begin");
+
+ imgb = (SCMN_IMGB *)GST_BUFFER_DATA(buf);
+ if(imgb == NULL || imgb->a[0] == NULL)
+ {
+ return;
+ }
+
+ stride = GST_ROUND_UP_4 (imgb->w[0]);
+ h = imgb->h[0];
+ w = imgb->w[0];
+ /*Y plane copy */
+ for (i = 0; i < h; i++)
+ {
+ memcpy (temp_outbuf + i * stride, imgb->a[0] + i * imgb->s[0], w);
+ }
+
+ temp_outbuf += GST_ROUND_UP_4 (imgb->w[0]) * GST_ROUND_UP_2 (imgb->h[0]);
+
+ stride = GST_ROUND_UP_4 (GST_ROUND_UP_2 (imgb->w[0]) / 2);
+ h = GST_ROUND_UP_2 (imgb->h[0]) / 2;
+ w = GST_ROUND_UP_2 (imgb->w[0]) / 2;
+ /* Cb plane copy */
+ for (i = 0; i < h; i++)
+ {
+ memcpy (temp_outbuf + i * stride, imgb->a[1] + i * imgb->s[1], w);
+ }
+
+ temp_outbuf += GST_ROUND_UP_4 (GST_ROUND_UP_2 (imgb->w[0]) / 2) * (GST_ROUND_UP_2 (imgb->h[0]) / 2);
+ /* Same stride, height, width as above */
+ /* Cr plane copy */
+ for (i = 0; i < h; i++)
+ {
+ memcpy (temp_outbuf + i * stride, imgb->a[2] + i * imgb->s[2], w);
+ }
+
+ outsize = imgb->w[0] * imgb->h[0]* 3 >> 1;
+ evaspixmapsink->evas_pixmap_buf->size = MIN(outsize, evaspixmapsink->evas_pixmap_buf->size);
+
+ GST_DEBUG("End");
+}
+
static GstFlowReturn
gst_evaspixmapsink_show_frame (GstVideoSink *vsink, GstBuffer *buf)
{
SCMN_IMGB *scmn_imgb = NULL;
gint format = 0;
- MMTA_ACUM_ITEM_BEGIN("evaspixmapsink gst_evaspixmapsink_show_frame()", FALSE);
-
evaspixmapsink = GST_EVASPIXMAPSINK (vsink);
+ if (GST_STATE(evaspixmapsink) < GST_STATE_PLAYING || log_warn_count < 20) {
+ GST_WARNING_OBJECT (evaspixmapsink, "enter >>>" );
+ }
+
if( evaspixmapsink->stop_video ) {
GST_INFO_OBJECT (evaspixmapsink, "Stop video is TRUE. so skip show frame..." );
- return GST_FLOW_OK;
+ goto skip_frame;
}
if (!evaspixmapsink->evas_pixmap_buf) {
scmn_imgb = (SCMN_IMGB *)GST_BUFFER_MALLOCDATA(buf);
if(scmn_imgb == NULL) {
GST_DEBUG_OBJECT (evaspixmapsink, "scmn_imgb is NULL. Skip buffer put..." );
- return GST_FLOW_OK;
+ goto skip_frame;
}
/* skip buffer if aligned size is smaller than size of caps */
if (scmn_imgb->s[0] < evaspixmapsink->video_width || scmn_imgb->e[0] < evaspixmapsink->video_height) {
GST_WARNING_OBJECT (evaspixmapsink,"invalid size[caps:%dx%d,aligned:%dx%d]. Skip this buffer...",
evaspixmapsink->video_width, evaspixmapsink->video_height, scmn_imgb->s[0], scmn_imgb->e[0]);
- return GST_FLOW_OK;
+ goto skip_frame;
}
evaspixmapsink->aligned_width = scmn_imgb->s[0];
evaspixmapsink->aligned_height = scmn_imgb->e[0];
scmn_imgb = (SCMN_IMGB *)GST_BUFFER_MALLOCDATA(buf);
if (scmn_imgb == NULL) {
GST_DEBUG_OBJECT (evaspixmapsink, "scmn_imgb is NULL. Skip buffer put..." );
- return GST_FLOW_OK;
+ goto skip_frame;
}
if (scmn_imgb->buf_share_method == BUF_SHARE_METHOD_PADDR) {
}
} else {
GST_WARNING_OBJECT (evaspixmapsink, "Not supported, buf_share_method(%d)", scmn_imgb->buf_share_method);
- return GST_FLOW_OK;
+ goto skip_frame;
}
if (!img_data->YBuf) {
GST_WARNING_OBJECT (evaspixmapsink, "img_data->YBuf is NULL. skip buffer put..." );
- return GST_FLOW_OK;
+ goto skip_frame;
}
GST_LOG_OBJECT(evaspixmapsink, "YBuf[%d], CbBuf[%d], CrBuf[%d]",
img_data->YBuf, img_data->CbBuf, img_data->CrBuf );
} else {
GST_WARNING_OBJECT (evaspixmapsink, "xvimage->data is NULL. skip buffer put..." );
- return GST_FLOW_OK;
+ goto skip_frame;
}
break;
}
evaspixmapsink->buf_shared_type = BUF_SHARE_METHOD_NONE;
}
GST_DEBUG_OBJECT (evaspixmapsink,"Normal format activated. fourcc = %d", evaspixmapsink->evas_pixmap_buf->im_format);
- __ta__("evaspixmapsink memcpy in _show_frame", memcpy (evaspixmapsink->evas_pixmap_buf->xvimage->data, GST_BUFFER_DATA (buf),
- MIN (GST_BUFFER_SIZE (buf), evaspixmapsink->evas_pixmap_buf->size)););
+ if(evaspixmapsink->need_combine_data == 1)
+ {
+ gst_evaspixmapsink_combine_i420_scmn_data(evaspixmapsink, buf);
+ }
+ else
+ {
+ memcpy (evaspixmapsink->evas_pixmap_buf->xvimage->data,
+ GST_BUFFER_DATA (buf),
+ MIN (GST_BUFFER_SIZE (buf), evaspixmapsink->evas_pixmap_buf->size));
+ }
break;
}
}
- if (!gst_evaspixmap_buffer_put (evaspixmapsink, evaspixmapsink->evas_pixmap_buf)) {
- MMTA_ACUM_ITEM_END("evaspixmapsink gst_evaspixmapsink_show_frame()", FALSE);
- return GST_FLOW_OK;
- }
+ gst_evaspixmap_buffer_put (evaspixmapsink, evaspixmapsink->evas_pixmap_buf);
- MMTA_ACUM_ITEM_END("evaspixmapsink gst_evaspixmapsink_show_frame()", FALSE);
+skip_frame:
+
+ if (GST_STATE(evaspixmapsink) < GST_STATE_PLAYING || log_warn_count < 20) {
+ GST_WARNING_OBJECT (evaspixmapsink, "leave <<<" );
+ }
return GST_FLOW_OK;
unsigned int xw = 0;
unsigned int xh = 0;
int i = 0;
+ XGCValues gc_values_black;
+ gc_values_black.foreground = 0xff000000;
+#ifdef DUMP_IMG
+ int ret = 0;
+ char file_name[128];
+ char *dump_data;
+ int dump_w = 0;
+#endif
GST_DEBUG_OBJECT (evaspixmapsink,"[START]");
evaspixmapsink->xcontext = gst_evaspixmapsink_xcontext_get (evaspixmapsink);
if (!evaspixmapsink->xcontext) {
GST_ERROR_OBJECT (evaspixmapsink,"could not get xcontext..");
+ g_mutex_unlock (evaspixmapsink->flow_lock);
return FALSE;
}
}
if (evaspixmapsink->xpixmap[i]->width == evas_object_width && evaspixmapsink->xpixmap[i]->height == evas_object_height) {
GST_WARNING_OBJECT (evaspixmapsink,"pixmap was already created(w:%d, h:%d), skip it..",
evaspixmapsink->xpixmap[i]->width, evaspixmapsink->xpixmap[i]->height);
- for (i = 0; i < evaspixmapsink->num_of_pixmaps; i++) {
- XSetForeground (evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->gc, evaspixmapsink->xcontext->black);
- XFillRectangle (evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->pixmap, evaspixmapsink->xpixmap[i]->gc,
- 0, 0, evaspixmapsink->xpixmap[i]->width, evaspixmapsink->xpixmap[i]->height);
- GST_LOG_OBJECT (evaspixmapsink,"fill black to xpixmap[%d] with size(w:%d,h:%d)", evaspixmapsink->xpixmap[i]->pixmap,
- evaspixmapsink->xpixmap[i]->width, evaspixmapsink->xpixmap[i]->height);
+ if (evaspixmapsink->need_to_fill_black) {
+ for (i = 0; i < evaspixmapsink->num_of_pixmaps; i++) {
+ g_mutex_lock (evaspixmapsink->x_lock);
+ XFillRectangle (evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->pixmap, evaspixmapsink->xpixmap[i]->gc,
+ 0, 0, evaspixmapsink->xpixmap[i]->width, evaspixmapsink->xpixmap[i]->height);
+ GST_LOG_OBJECT (evaspixmapsink,"fill black to xpixmap[%d] with size(w:%d,h:%d)", evaspixmapsink->xpixmap[i]->pixmap,
+ evaspixmapsink->xpixmap[i]->width, evaspixmapsink->xpixmap[i]->height);
+#ifdef DUMP_IMG
+ dump_w = evaspixmapsink->xpixmap[i]->width + (32 - (evaspixmapsink->xpixmap[i]->width%32)); // for multiples of 32
+ if(g_cnt<100)
+ {
+ evaspixmapsink->pixmap_addr[i] = gst_evaspixmapsink_get_buffer(evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->pixmap, dump_w, evaspixmapsink->xpixmap[i]->height, i);
+ GST_ERROR("<DUMP_%2.2d> pixmap[%d] addr %p (w : %d, h : %d)", g_cnt, i, evaspixmapsink->pixmap_addr[i], dump_w, evaspixmapsink->xpixmap[i]->height);
+ sprintf(file_name, "/opt/usr/media/DUMP_%2.2d.dump", g_cnt);
+
+ dump_data = g_malloc(dump_w * evaspixmapsink->xpixmap[i]->height * 4);
+ memcpy (dump_data, evaspixmapsink->pixmap_addr[i], dump_w * evaspixmapsink->xpixmap[i]->height * 4);
+
+ ret = util_write_rawdata(file_name, dump_data, dump_w * evaspixmapsink->xpixmap[i]->height * 4);
+ if (ret) {
+ GST_ERROR_OBJECT (evaspixmapsink, "util_write_rawdata() failed");
+ }
+ else
+ g_cnt++;
+ g_free(dump_data);
+
+ if (g_bufinfo[i]) {
+ gst_evaspixmapsink_free_buffer (i);
+ g_bufinfo[i] = NULL;
+ }
+ evaspixmapsink->pixmap_addr[i] = NULL;
+ }
+#endif
+ g_mutex_unlock (evaspixmapsink->x_lock);
+ }
+ evaspixmapsink->need_to_fill_black = FALSE;
}
goto SKIP_LINK;
}
}
goto GO_OUT_OF_FUNC;
}
+ evaspixmapsink->need_to_fill_black = FALSE;
GST_INFO_OBJECT (evaspixmapsink,"creation pixmap_id[%d]:%d success", i, pixmap_id[i]);
GST_DEBUG_OBJECT (evaspixmapsink,"evas_object_width(%d),evas_object_height(%d),pixmap:%d,depth:%d",
evas_object_width,evas_object_height,pixmap_id[i],DefaultDepth(dpy, DefaultScreen(dpy)));
if (evaspixmapsink->xpixmap[i]->pixmap && pixmap_id[i] != evaspixmapsink->xpixmap[i]->pixmap) {
g_mutex_unlock (evaspixmapsink->x_lock);
g_mutex_lock (evaspixmapsink->pixmap_ref_lock);
+
/* If we reset another pixmap, do below */
+ if (evaspixmapsink->xpixmap[i]->prev_pixmap) {
+ GST_LOG_OBJECT (evaspixmapsink,"Free pixmap(%d), gc(%x), destroy previous damage(%d)",
+ evaspixmapsink->xpixmap[i]->prev_pixmap, evaspixmapsink->xpixmap[i]->prev_gc, evaspixmapsink->prev_damage[i]);
+ g_mutex_lock (evaspixmapsink->x_lock);
+ XFreePixmap(evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->prev_pixmap);
+ XFreeGC (evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->prev_gc);
+ XDamageDestroy(evaspixmapsink->xcontext->disp, evaspixmapsink->prev_damage[i]);
+ XSync(evaspixmapsink->xcontext->disp, FALSE);
+ g_mutex_unlock (evaspixmapsink->x_lock);
+ evaspixmapsink->prev_damage[i] = NULL;
+ }
evaspixmapsink->xpixmap[i]->prev_pixmap = evaspixmapsink->xpixmap[i]->pixmap;
evaspixmapsink->xpixmap[i]->prev_gc = evaspixmapsink->xpixmap[i]->gc;
evaspixmapsink->xpixmap[i]->pixmap = 0;
evaspixmapsink->xpixmap[i]->ref = 0;
evaspixmapsink->xpixmap[i]->damaged_time = 0;
+
g_mutex_unlock (evaspixmapsink->pixmap_ref_lock);
g_mutex_lock (evaspixmapsink->x_lock);
}
for (i = 0; i < evaspixmapsink->num_of_pixmaps; i++) {
/* Set pixmap id and create GC */
evaspixmapsink->xpixmap[i]->pixmap = pixmap_id[i];
- evaspixmapsink->xpixmap[i]->gc = XCreateGC(dpy, evaspixmapsink->xpixmap[i]->pixmap, 0,0);
+ evaspixmapsink->xpixmap[i]->gc = XCreateGC(dpy, evaspixmapsink->xpixmap[i]->pixmap, GCForeground, &gc_values_black);
evaspixmapsink->xpixmap[i]->width = xw;
evaspixmapsink->xpixmap[i]->height = xh;
i, evaspixmapsink->xpixmap[i]->pixmap, evaspixmapsink->xpixmap[i]->gc, i, evaspixmapsink->damage[i]);
/* Fill blackcolor for the new pixmap */
- XSetForeground (evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->gc, evaspixmapsink->xcontext->black);
XFillRectangle (evaspixmapsink->xcontext->disp, pixmap_id[i], evaspixmapsink->xpixmap[i]->gc,
0, 0, evaspixmapsink->w, evaspixmapsink->h);
GST_LOG_OBJECT (evaspixmapsink,"fill black to xpixmap[%d] with size(w:%d,h:%d)", pixmap_id[i],
evaspixmapsink->w, evaspixmapsink->h);
+
+#ifdef DUMP_IMG
+ dump_w = evaspixmapsink->w + (32 - (evaspixmapsink->w%32)); // for multiples of 32
+ if(g_cnt<100)
+ {
+ evaspixmapsink->pixmap_addr[i] = gst_evaspixmapsink_get_buffer(evaspixmapsink->xcontext->disp, evaspixmapsink->xpixmap[i]->pixmap, dump_w, evaspixmapsink->h, i);
+ GST_ERROR("<DUMP_%2.2d> pixmap[%d] addr %p (w : %d, h : %d)", g_cnt, i, evaspixmapsink->pixmap_addr[i], dump_w, evaspixmapsink->h);
+ sprintf(file_name, "/opt/usr/media/DUMP_%2.2d.dump", g_cnt);
+
+ dump_data = g_malloc(dump_w * evaspixmapsink->h * 4);
+ memcpy (dump_data, evaspixmapsink->pixmap_addr[i], dump_w * evaspixmapsink->h * 4);
+
+ ret = util_write_rawdata(file_name, dump_data, dump_w * evaspixmapsink->h * 4);
+ if (ret) {
+ GST_ERROR_OBJECT (evaspixmapsink, "util_write_rawdata() failed");
+ }
+ else
+ g_cnt++;
+ g_free(dump_data);
+
+ if (g_bufinfo[i]) {
+ gst_evaspixmapsink_free_buffer (i);
+ g_bufinfo[i] = NULL;
+ }
+ evaspixmapsink->pixmap_addr[i] = NULL;
+ }
+#endif
}
XSync(dpy, FALSE);
case PROP_SYNCHRONOUS:
evaspixmapsink->synchronous = g_value_get_boolean (value);
if (evaspixmapsink->xcontext) {
+ g_mutex_lock (evaspixmapsink->x_lock);
XSynchronize (evaspixmapsink->xcontext->disp, evaspixmapsink->synchronous);
+ g_mutex_unlock (evaspixmapsink->x_lock);
GST_DEBUG_OBJECT (evaspixmapsink,"XSynchronize called with %s", evaspixmapsink->synchronous ? "TRUE" : "FALSE");
}
break;
break;
case PROP_VISIBLE:
{
- Eina_Bool r;
+ Eina_Bool r = EINA_FALSE;
gboolean visible = g_value_get_boolean (value);
GST_INFO_OBJECT (evaspixmapsink,"evaspixmapsink->visible(%d), new value of visible(%d)", evaspixmapsink->visible, visible);
if (evaspixmapsink->visible != visible) {
}
} else {
r = ecore_pipe_write (evaspixmapsink->epipe, &evaspixmapsink->update_visibility, SIZE_FOR_UPDATE_VISIBILITY);
+ if (r == EINA_FALSE) {
+ GST_WARNING ("Failed to ecore_pipe_write() for updating visibility)\n");
+ }
evaspixmapsink->epipe_request_count++;
}
- if (r == EINA_FALSE) {
- GST_WARNING ("Failed to ecore_pipe_write() for updating visibility)\n");
- }
+
if (!visible) {
int i = 0;
g_mutex_lock( evaspixmapsink->flow_lock );
for (i = 0; i < evaspixmapsink->num_of_pixmaps; i++) {
if(evaspixmapsink->damage[i]) {
+ g_mutex_lock (evaspixmapsink->x_lock);
XDamageDestroy(evaspixmapsink->xcontext->disp, evaspixmapsink->damage[i]);
+ g_mutex_unlock (evaspixmapsink->x_lock);
evaspixmapsink->damage[i] = NULL;
}
}
}
for (i = 0; i < evaspixmapsink->num_of_pixmaps; i++) {
+#ifdef DUMP_IMG
+ if (g_bufinfo[i]) {
+ gst_evaspixmapsink_free_buffer (i);
+ g_bufinfo[i] = NULL;
+ }
+ evaspixmapsink->pixmap_addr[i] = NULL;
+#endif
gst_evaspixmapsink_xpixmap_clear (evaspixmapsink, evaspixmapsink->xpixmap[i]);
gst_evaspixmapsink_xpixmap_destroy (evaspixmapsink, evaspixmapsink->xpixmap[i]);
evaspixmapsink->xpixmap[i] = NULL;
}
if (evaspixmapsink->eo) {
evas_object_image_native_surface_set(evaspixmapsink->eo, NULL);
+ evas_object_image_data_set(evaspixmapsink->eo, NULL);
evaspixmapsink->eo = NULL;
}
+ if (evaspixmapsink->epipe) {
+ ecore_pipe_del (evaspixmapsink->epipe);
+ evaspixmapsink->epipe = NULL;
+ }
+
evaspixmapsink->render_rect.x = evaspixmapsink->render_rect.y =
evaspixmapsink->render_rect.w = evaspixmapsink->render_rect.h = 0;
evaspixmapsink->have_render_rect = FALSE;
g_mutex_free (evaspixmapsink->pixmap_ref_lock);
evaspixmapsink->pixmap_ref_lock = NULL;
}
- if (evaspixmapsink->epipe) {
- ecore_pipe_del (evaspixmapsink->epipe);
- evaspixmapsink->epipe = NULL;
- }
GST_DEBUG_OBJECT (evaspixmapsink,"[END]");
G_OBJECT_CLASS (parent_class)->finalize (object);
- MMTA_ACUM_ITEM_SHOW_RESULT_TO(MMTA_SHOW_FILE);
- MMTA_RELEASE();
}
static void
for (i = 0; i < NUM_OF_PIXMAP; i++) {
evaspixmapsink->xpixmap[i] = NULL;
evaspixmapsink->damage[i] = 0;
+#ifdef DUMP_IMG
+ g_bufinfo[i] = NULL;
+ evaspixmapsink->pixmap_addr[i] = NULL;
+#endif
}
evaspixmapsink->evas_pixmap_buf = NULL;
evaspixmapsink->fps_d = 0;
evaspixmapsink->video_width = 0;
evaspixmapsink->video_height = 0;
+ evaspixmapsink->need_to_fill_black = FALSE;
evaspixmapsink->x_lock = g_mutex_new ();
evaspixmapsink->flow_lock = g_mutex_new ();
evaspixmapsink->buf_shared_type = BUF_SHARE_METHOD_NONE;
- MMTA_INIT();
+ memset(&evaspixmapsink->src_prev, 0, sizeof (GstVideoRectangle));
+ memset(&evaspixmapsink->result_prev, 0, sizeof (GstVideoRectangle));
+
+#ifdef DUMP_IMG
+ g_cnt = 0;
+#endif
GST_DEBUG_OBJECT (evaspixmapsink,"[END]");
}
projects / framework / multimedia / gst-plugins-ext0.10.git / blobdiff