static void
on_bus_element_cb (GstBus *bus, GstMessage *message,
GbpPlayer *player)
{
const GstStructure *structure;
const gchar *structure_name;
GstElement *sink;
structure = gst_message_get_structure (message);
if (structure == NULL)
return;
structure_name = gst_structure_get_name (structure);
#ifdef XP_MACOSX
if (!strcmp (structure_name, "have-ns-view") ||
!strcmp (structure_name, "have-ca-layer")) {
if (player->priv->xid != 0) {
gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (GST_ELEMENT (message->src)),
(gulong) player->priv->xid);
}
return;
}
#endif
if (!strcmp (structure_name, "prepare-xwindow-id")) {
sink = GST_ELEMENT (message->src);
gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (sink), player->priv->xid);
}
}
G_MODULE_EXPORT gboolean
preview_draw_cb(
GtkWidget *widget,
cairo_t *cr,
signal_user_data_t *ud)
{
#if defined(_ENABLE_GST)
#if GST_CHECK_VERSION(1, 0, 0)
if (ud->preview->live_enabled && ud->preview->state == PREVIEW_STATE_LIVE)
{
if (GST_STATE(ud->preview->play) >= GST_STATE_PAUSED)
{
GstElement *vsink;
GstVideoOverlay *vover;
g_object_get(ud->preview->play, "video-sink", &vsink, NULL);
if (GST_IS_BIN(vsink))
vover = GST_VIDEO_OVERLAY(gst_bin_get_by_interface(
GST_BIN(vsink), GST_TYPE_VIDEO_OVERLAY));
else
vover = GST_VIDEO_OVERLAY(vsink);
gst_video_overlay_expose(vover);
// For some reason, the exposed region doesn't always get
// cleaned up here. But a delayed gst_x_overlay_expose()
// takes care of it.
g_idle_add((GSourceFunc)delayed_expose_cb, ud);
}
return FALSE;
}
#else
if (ud->preview->live_enabled && ud->preview->state == PREVIEW_STATE_LIVE)
{
if (GST_STATE(ud->preview->play) >= GST_STATE_PAUSED)
{
GstElement *vsink;
GstXOverlay *xover;
g_object_get(ud->preview->play, "video-sink", &vsink, NULL);
if (GST_IS_BIN(vsink))
xover = GST_X_OVERLAY(gst_bin_get_by_interface(
GST_BIN(vsink), GST_TYPE_X_OVERLAY));
else
xover = GST_X_OVERLAY(vsink);
gst_x_overlay_expose(xover);
// For some reason, the exposed region doesn't always get
// cleaned up here. But a delayed gst_x_overlay_expose()
// takes care of it.
g_idle_add((GSourceFunc)delayed_expose_cb, ud);
}
return FALSE;
}
#endif
#endif
if (ud->preview->pix != NULL)
{
_draw_pixbuf(cr, ud->preview->pix);
}
return FALSE;
}
static gboolean
empathy_video_widget_draw (GtkWidget *widget,
cairo_t *cr)
{
EmpathyVideoWidget *self = EMPATHY_VIDEO_WIDGET (widget);
EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
GtkAllocation allocation;
if (priv->overlay == NULL)
{
gtk_widget_get_allocation (widget, &allocation);
gtk_render_frame (gtk_widget_get_style_context (widget), cr,
0, 0,
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
return TRUE;
}
gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (priv->overlay),
GDK_WINDOW_XID (gtk_widget_get_window (widget)));
gst_x_overlay_expose (GST_X_OVERLAY (priv->overlay));
return TRUE;
}
void GStreamerGWorld::setWindowOverlay(GstMessage* message)
{
GstObject* sink = GST_MESSAGE_SRC(message);
#ifndef GST_API_VERSION_1
if (!GST_IS_X_OVERLAY(sink))
#else
if (!GST_IS_VIDEO_OVERLAY(sink))
#endif
return;
if (g_object_class_find_property(G_OBJECT_GET_CLASS(sink), "force-aspect-ratio"))
g_object_set(sink, "force-aspect-ratio", TRUE, NULL);
if (m_videoWindow) {
m_videoWindow->prepareForOverlay(message);
#ifndef GST_API_VERSION_1
// gst_x_overlay_set_window_handle was introduced in -plugins-base
// 0.10.31, just like the macro for checking the version.
#ifdef GST_CHECK_PLUGINS_BASE_VERSION
gst_x_overlay_set_window_handle(GST_X_OVERLAY(sink), m_videoWindow->videoWindowId());
#else
gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(sink), m_videoWindow->videoWindowId());
#endif
#else
gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sink), m_videoWindow->videoWindowId());
#endif
}
}
static GstBusSyncReply
create_window(GstBus *bus, GstMessage *msg, gpointer data)
{
preview_t *preview = (preview_t*)data;
switch (GST_MESSAGE_TYPE(msg))
{
case GST_MESSAGE_ELEMENT:
{
#if GST_CHECK_VERSION(1, 0, 0)
if (!gst_is_video_overlay_prepare_window_handle_message(msg))
return GST_BUS_PASS;
gst_video_overlay_set_window_handle(
GST_VIDEO_OVERLAY(GST_MESSAGE_SRC(msg)), preview->xid);
#else
if (!gst_structure_has_name(msg->structure, "prepare-xwindow-id"))
return GST_BUS_PASS;
#if !defined(_WIN32)
gst_x_overlay_set_xwindow_id(
GST_X_OVERLAY(GST_MESSAGE_SRC(msg)), preview->xid);
#else
gst_directdraw_sink_set_window_id(
GST_X_OVERLAY(GST_MESSAGE_SRC(msg)), preview->xid);
#endif
#endif
gst_message_unref(msg);
return GST_BUS_DROP;
} break;
default:
{
} break;
}
return GST_BUS_PASS;
}
void
BasePlatformInterface::PrepareVideoWindow(GstMessage *aMessage)
{
GstElement *element = NULL;
GstXOverlay *xoverlay = NULL;
if (GST_IS_BIN (mVideoSink)) {
/* Get the actual implementing object from the bin */
element = gst_bin_get_by_interface(GST_BIN (mVideoSink),
GST_TYPE_X_OVERLAY);
}
else {
element = mVideoSink;
}
if (GST_IS_X_OVERLAY (element)) {
xoverlay = GST_X_OVERLAY (element);
LOG(("xoverlay interface found, setting video window"));
}
else {
LOG(("No xoverlay interface found, cannot set video window"));
return;
}
SetXOverlayWindowID(xoverlay);
ResizeToWindow();
}
void QGstreamerGLTextureRenderer::setWinId(WId id)
{
#ifdef GL_TEXTURE_SINK_DEBUG
qDebug() << Q_FUNC_INFO << id;
#endif
if (m_winId == id)
return;
bool oldReady = isReady();
m_winId = id;
if (m_videoSink && GST_IS_X_OVERLAY(m_videoSink)) {
//don't set winId in NULL state,
//texture sink opens xvideo port on set_xwindow_id,
//this fails if video resource is not granted by resource policy yet.
//state is changed to READY/PAUSED/PLAYING only after resource is granted.
GstState pendingState = GST_STATE_NULL;
GstState newState = GST_STATE_NULL;
GstStateChangeReturn res = gst_element_get_state(m_videoSink,
&newState,
&pendingState,
0);//don't block and return immediately
if (res != GST_STATE_CHANGE_FAILURE &&
newState != GST_STATE_NULL &&
pendingState != GST_STATE_NULL)
gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(m_videoSink), m_winId);
}
if (oldReady != isReady())
emit readyChanged(!oldReady);
}
Window
set_gst_sdl_video_overlay (GstElement *pipeline,
int x,
int y,
int width,
int height)
{
GstElement *videosink;
SDL_SysWMinfo sdl_info;
Window play_win;
sdl_info = get_sdl_wm_info ();
if (!sdl_info.version.major)
return 0;
g_object_get (pipeline, "video-sink", &videosink, NULL);
if (videosink && GST_IS_X_OVERLAY (videosink)) {
sdl_info.info.x11.lock_func ();
play_win = create_x11_subwindow (sdl_info.info.x11.display,
sdl_info.info.x11.window,
x, y, width, height);
sdl_info.info.x11.unlock_func ();
gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (videosink), play_win);
} else
play_win = 0;
g_object_unref (videosink);
return play_win;
}
static GstBusSyncReply
sync_bus_callback (GstBus * bus, GstMessage * message, gpointer data)
{
const GstStructure *st;
const GValue *image;
GstBuffer *buf = NULL;
guint8 *data_buf = NULL;
gchar *caps_string;
guint size = 0;
gchar *preview_filename = NULL;
FILE *f = NULL;
size_t written;
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ELEMENT:{
st = gst_message_get_structure (message);
if (st) {
if (gst_structure_has_name (message->structure, "prepare-xwindow-id")) {
if (!no_xwindow && window) {
gst_x_overlay_set_window_handle (GST_X_OVERLAY (GST_MESSAGE_SRC
(message)), window);
gst_message_unref (message);
message = NULL;
return GST_BUS_DROP;
}
} else if (gst_structure_has_name (st, "preview-image")) {
GST_DEBUG ("preview-image");
/* extract preview-image from msg */
image = gst_structure_get_value (st, "buffer");
if (image) {
buf = gst_value_get_buffer (image);
data_buf = GST_BUFFER_DATA (buf);
size = GST_BUFFER_SIZE (buf);
preview_filename = g_strdup_printf ("test_vga.rgb");
caps_string = gst_caps_to_string (GST_BUFFER_CAPS (buf));
g_print ("writing buffer to %s, elapsed: %.2fs, buffer caps: %s\n",
preview_filename, g_timer_elapsed (timer, NULL), caps_string);
g_free (caps_string);
f = g_fopen (preview_filename, "w");
if (f) {
written = fwrite (data_buf, size, 1, f);
if (!written) {
g_print ("error writing file\n");
}
fclose (f);
} else {
g_print ("error opening file for raw image writing\n");
}
g_free (preview_filename);
}
}
}
break;
}
default:
/* unhandled message */
break;
}
return GST_BUS_PASS;
}
static GstBusSyncReply
create_window (GstBus * bus, GstMessage * message, gpointer data)
{
GstGLClutterActor **actor = (GstGLClutterActor **) data;
static gint count = 0;
static GMutex *mutex = NULL;
// ignore anything but 'prepare-xwindow-id' element messages
if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT)
return GST_BUS_PASS;
if (!gst_structure_has_name (message->structure, "prepare-xwindow-id"))
return GST_BUS_PASS;
if (!mutex)
mutex = g_mutex_new ();
g_mutex_lock (mutex);
if (count < N_ACTORS) {
g_message ("adding actor %d", count);
gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (GST_MESSAGE_SRC (message)),
actor[count]->win);
clutter_threads_add_idle ((GSourceFunc) create_actor, actor[count]);
count++;
}
g_mutex_unlock (mutex);
gst_message_unref (message);
return GST_BUS_DROP;
}
bool QGstreamerGLTextureRenderer::processSyncMessage(const QGstreamerMessage &message)
{
GstMessage* gm = message.rawMessage();
if ((GST_MESSAGE_TYPE(gm) == GST_MESSAGE_ELEMENT) &&
gst_structure_has_name(gm->structure, "prepare-xwindow-id") &&
m_videoSink && GST_IS_X_OVERLAY(m_videoSink)) {
#ifdef GL_TEXTURE_SINK_DEBUG
qDebug() << Q_FUNC_INFO;
#endif
GstXOverlay *overlay = GST_X_OVERLAY(m_videoSink);
gst_x_overlay_set_xwindow_id(overlay, m_winId);
if (!m_displayRect.isEmpty()) {
gst_x_overlay_set_render_rectangle(overlay,
m_displayRect.x(),
m_displayRect.y(),
m_displayRect.width(),
m_displayRect.height());
}
GstPad *pad = gst_element_get_static_pad(m_videoSink,"sink");
m_bufferProbeId = gst_pad_add_buffer_probe(pad, G_CALLBACK(padBufferProbe), this);
return true;
}
return false;
}
void Pipeline::setResolution(Resolution value)
{
int width, height;
switch (value) {
case Low:
// QVGA
width = LOW_RES_WIDTH;
height = LOW_RES_HEIGHT;
break;
case Medium:
// VGA
width = MID_RES_WIDTH;
height = MID_RES_HEIGHT;
break;
case High:
// WVGA
width = HIGH_RES_WIDTH;
height = HIGH_RES_HEIGHT;
break;
default:
qCritical() << "Unsupported resolution value " << value;
return;
}
g_signal_emit_by_name(camerabin, "set-video-resolution-fps",
width, height, VIDEO_FRN, VIDEO_FRD, NULL);
// set new rendering position to the viewfinder
gst_x_overlay_set_render_rectangle(GST_X_OVERLAY(viewfinder),
32,
30,
560,
420);
}
/**
* gst_v4l2_xoverlay_prepare_xwindow_id:
* @v4l2object: the v4l2object
* @required: %TRUE if display is required (ie. TRUE for v4l2sink, but
* FALSE for any other element with optional overlay capabilities)
*
* Helper function to create a windo if none is set from the application.
*/
void
gst_v4l2_xoverlay_prepare_xwindow_id (GstV4l2Object * v4l2object,
gboolean required)
{
if (!GST_V4L2_IS_OVERLAY (v4l2object))
return;
gst_x_overlay_prepare_xwindow_id (GST_X_OVERLAY (v4l2object->element));
if (required && !v4l2object->xwindow_id) {
GstV4l2Xv *v4l2xv;
Window win;
int width, height;
long event_mask;
if (!v4l2object->xv && GST_V4L2_IS_OPEN (v4l2object))
gst_v4l2_xoverlay_open (v4l2object);
v4l2xv = v4l2object->xv;
/* if xoverlay is not supported, just bail */
if (!v4l2xv)
return;
/* xoverlay is supported, but we don't have a window.. so create one */
GST_DEBUG_OBJECT (v4l2object->element, "creating window");
g_mutex_lock (v4l2xv->mutex);
width = XDisplayWidth (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
height = XDisplayHeight (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
GST_DEBUG_OBJECT (v4l2object->element, "dpy=%p", v4l2xv->dpy);
win = XCreateSimpleWindow (v4l2xv->dpy,
DefaultRootWindow (v4l2xv->dpy),
0, 0, width, height, 0, 0,
XBlackPixel (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy)));
GST_DEBUG_OBJECT (v4l2object->element, "win=%lu", win);
event_mask = ExposureMask | StructureNotifyMask;
if (GST_IS_NAVIGATION (v4l2object->element)) {
event_mask |= PointerMotionMask |
KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask;
}
XSelectInput (v4l2xv->dpy, win, event_mask);
v4l2xv->event_id = g_timeout_add (45, event_refresh, v4l2object);
XMapRaised (v4l2xv->dpy, win);
XSync (v4l2xv->dpy, FALSE);
g_mutex_unlock (v4l2xv->mutex);
GST_DEBUG_OBJECT (v4l2object->element, "got window");
gst_v4l2_xoverlay_set_window_handle (v4l2object, win);
}
}
void QGstreamerVideoWindow::setDisplayRect(const QRect &rect)
{
m_displayRect = rect;
if (m_videoSink && GST_IS_X_OVERLAY(m_videoSink)) {
#if GST_VERSION_MICRO >= 29
if (m_displayRect.isEmpty())
gst_x_overlay_set_render_rectangle(GST_X_OVERLAY(m_videoSink), -1, -1, -1, -1);
else
gst_x_overlay_set_render_rectangle(GST_X_OVERLAY(m_videoSink),
m_displayRect.x(),
m_displayRect.y(),
m_displayRect.width(),
m_displayRect.height());
repaint();
#endif
}
}
int tsmf_window_create(TSMFGstreamerDecoder* decoder)
{
struct X11Handle* hdl;
if (decoder->media_type != TSMF_MAJOR_TYPE_VIDEO)
{
decoder->ready = TRUE;
return -3;
}
else
{
#if GST_VERSION_MAJOR > 0
GstVideoOverlay *overlay = GST_VIDEO_OVERLAY(decoder->outsink);
#else
GstXOverlay *overlay = GST_X_OVERLAY(decoder->outsink);
#endif
if (!decoder)
return -1;
if (!decoder->platform)
return -1;
hdl = (struct X11Handle*) decoder->platform;
if (!hdl->subwin)
{
int event, error;
hdl->subwin = XCreateSimpleWindow(hdl->disp, *(int *)hdl->xfwin, 0, 0, 1, 1, 0, 0, 0);
if (!hdl->subwin)
{
WLog_ERR(TAG, "Could not create subwindow!");
}
XMapWindow(hdl->disp, hdl->subwin);
XSync(hdl->disp, FALSE);
#if GST_VERSION_MAJOR > 0
gst_video_overlay_set_window_handle(overlay, hdl->subwin);
#else
gst_x_overlay_set_window_handle(overlay, hdl->subwin);
#endif
decoder->ready = TRUE;
#if defined(WITH_XEXT)
hdl->has_shape = XShapeQueryExtension(hdl->disp, &event, &error);
#endif
}
#if GST_VERSION_MAJOR > 0
gst_video_overlay_handle_events(overlay, TRUE);
#else
gst_x_overlay_handle_events(overlay, TRUE);
#endif
return 0;
}
}
static void
gst_vdp_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
VdpSink *vdp_sink;
g_return_if_fail (GST_IS_VDP_SINK (object));
vdp_sink = GST_VDP_SINK (object);
switch (prop_id) {
case PROP_DISPLAY:
vdp_sink->display_name = g_strdup (g_value_get_string (value));
break;
case PROP_SYNCHRONOUS:
vdp_sink->synchronous = g_value_get_boolean (value);
if (vdp_sink->device) {
GST_DEBUG_OBJECT (vdp_sink, "XSynchronize called with %s",
vdp_sink->synchronous ? "TRUE" : "FALSE");
g_mutex_lock (vdp_sink->x_lock);
XSynchronize (vdp_sink->device->display, vdp_sink->synchronous);
g_mutex_unlock (vdp_sink->x_lock);
}
break;
case PROP_PIXEL_ASPECT_RATIO:
{
GValue *tmp;
tmp = g_new0 (GValue, 1);
g_value_init (tmp, GST_TYPE_FRACTION);
if (!g_value_transform (value, tmp)) {
GST_WARNING_OBJECT (vdp_sink,
"Could not transform string to aspect ratio");
g_free (tmp);
} else {
GST_DEBUG_OBJECT (vdp_sink, "set PAR to %d/%d",
gst_value_get_fraction_numerator (tmp),
gst_value_get_fraction_denominator (tmp));
g_free (vdp_sink->par);
vdp_sink->par = tmp;
}
}
break;
case PROP_HANDLE_EVENTS:
gst_vdp_sink_set_event_handling (GST_X_OVERLAY (vdp_sink),
g_value_get_boolean (value));
break;
case PROP_HANDLE_EXPOSE:
vdp_sink->handle_expose = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
void GStreamerGWorld::setWindowOverlay(GstMessage* message)
{
GstObject* sink = GST_MESSAGE_SRC(message);
if (!GST_IS_X_OVERLAY(sink))
return;
if (g_object_class_find_property(G_OBJECT_GET_CLASS(sink), "force-aspect-ratio"))
g_object_set(sink, "force-aspect-ratio", TRUE, NULL);
if (m_videoWindow) {
m_videoWindow->prepareForOverlay(message);
#if GST_CHECK_VERSION(0, 10, 31) || GST_VERSION_NANO
gst_x_overlay_set_window_handle(GST_X_OVERLAY(sink), m_videoWindow->videoWindowId());
#else
gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(sink), m_videoWindow->videoWindowId());
#endif
}
}
static gboolean
empathy_video_widget_expose_event (GtkWidget *widget, GdkEventExpose *event)
{
EmpathyVideoWidget *self = EMPATHY_VIDEO_WIDGET (widget);
EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
if (event != NULL && event->count > 0)
return TRUE;
if (priv->overlay == NULL)
return TRUE;
gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (priv->overlay),
GDK_WINDOW_XID (widget->window));
gst_x_overlay_expose (GST_X_OVERLAY (priv->overlay));
return TRUE;
}
void Video_RX::run(){
emit displayed(video_sink,2);
gst_element_set_state(GST_ELEMENT(pipeline),GST_STATE_PLAYING);
gst_x_overlay_expose(GST_X_OVERLAY(video_sink));
new_video_rx_stream=true;
}
void QGstreamerGLTextureRenderer::repaintOverlay()
{
if (m_videoSink && GST_IS_X_OVERLAY(m_videoSink)) {
//don't call gst_x_overlay_expose if the sink is in null state
GstState state = GST_STATE_NULL;
GstStateChangeReturn res = gst_element_get_state(m_videoSink, &state, NULL, 1000000);
if (res != GST_STATE_CHANGE_FAILURE && state != GST_STATE_NULL) {
gst_x_overlay_expose(GST_X_OVERLAY(m_videoSink));
}
}
}
void X11Renderer::setOverlay()
{
if (m_videoSink && GST_IS_X_OVERLAY(m_videoSink)) {
WId windowId = m_renderWidget->winId();
// Even if we have created a winId at this point, other X applications
// need to be aware of it.
QApplication::syncX();
gst_x_overlay_set_xwindow_id ( GST_X_OVERLAY(m_videoSink) , windowId );
}
windowExposed();
m_overlaySet = true;
}
void QGstreamerGLTextureRenderer::setOverlayGeometry(const QRect &geometry)
{
if (m_displayRect != geometry) {
#ifdef GL_TEXTURE_SINK_DEBUG
qDebug() << Q_FUNC_INFO << geometry;
#endif
m_displayRect = geometry;
if (m_videoSink && GST_IS_X_OVERLAY(m_videoSink)) {
if (m_displayRect.isEmpty())
gst_x_overlay_set_render_rectangle(GST_X_OVERLAY(m_videoSink), -1, -1, -1, -1);
else
gst_x_overlay_set_render_rectangle(GST_X_OVERLAY(m_videoSink),
m_displayRect.x(),
m_displayRect.y(),
m_displayRect.width(),
m_displayRect.height());
repaintOverlay();
}
}
}
void VideoWidget::WindowExposed()
{
if (video_overlay_ && GST_IS_X_OVERLAY(video_overlay_))
{
// Expose the overlay (some sort of update)
qDebug() << name_ << " >> WindowExposed() called";
#ifdef Q_WS_X11
QApplication::syncX();
#endif
gst_x_overlay_expose(GST_X_OVERLAY(video_overlay_));
}
}
int main(int argc, char *argv[])
{
#if !GLIB_CHECK_VERSION (2, 31, 0)
if (!g_thread_supported ())
g_thread_init (NULL);
#endif
gst_init (&argc, &argv);
QApplication app(argc, argv);
app.connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit ()));
/* prepare the pipeline */
GstElement *pipeline = gst_pipeline_new ("xvoverlay");
GstElement *src = gst_element_factory_make ("videotestsrc", NULL);
GstElement *sink = find_video_sink ();
if (sink == NULL)
g_error ("Couldn't find a working video sink.");
gst_bin_add_many (GST_BIN (pipeline), src, sink, NULL);
gst_element_link (src, sink);
/* prepare the ui */
QWidget window;
window.resize(320, 240);
window.setWindowTitle("GstXOverlay Qt demo");
window.show();
WId xwinid = window.winId();
gst_x_overlay_set_window_handle (GST_X_OVERLAY (sink), xwinid);
/* run the pipeline */
GstStateChangeReturn sret = gst_element_set_state (pipeline,
GST_STATE_PLAYING);
if (sret == GST_STATE_CHANGE_FAILURE) {
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
/* Exit application */
QTimer::singleShot(0, QApplication::activeWindow(), SLOT(quit()));
}
int ret = app.exec();
window.hide();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
return ret;
}
/**
* gst_v4l2_xoverlay_prepare_xwindow_id:
* @v4l2object: the v4l2object
* @required: %TRUE if display is required (ie. TRUE for v4l2sink, but
* FALSE for any other element with optional overlay capabilities)
*
* Helper function to create a windo if none is set from the application.
*/
void
gst_v4l2_xoverlay_prepare_xwindow_id (GstV4l2Object * v4l2object,
gboolean required)
{
if (!GST_V4L2_IS_OVERLAY (v4l2object))
return;
gst_x_overlay_prepare_xwindow_id (GST_X_OVERLAY (v4l2object->element));
if (required && !v4l2object->xwindow_id) {
GstV4l2Xv *v4l2xv;
Window win;
int width, height;
if (!v4l2object->xv && GST_V4L2_IS_OPEN (v4l2object))
gst_v4l2_xoverlay_open (v4l2object);
v4l2xv = v4l2object->xv;
/* if xoverlay is not supported, just bail */
if (!v4l2xv)
return;
/* xoverlay is supported, but we don't have a window.. so create one */
GST_DEBUG_OBJECT (v4l2object->element, "creating window");
g_mutex_lock (v4l2xv->mutex);
width = XDisplayWidth (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
height = XDisplayHeight (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
GST_DEBUG_OBJECT (v4l2object->element, "dpy=%p", v4l2xv->dpy);
win = XCreateSimpleWindow (v4l2xv->dpy,
DefaultRootWindow (v4l2xv->dpy),
0, 0, width, height, 0, 0,
XBlackPixel (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy)));
GST_DEBUG_OBJECT (v4l2object->element, "win=%lu", win);
XMapRaised (v4l2xv->dpy, win);
XSync (v4l2xv->dpy, FALSE);
v4l2xv->internal_window = TRUE;
g_mutex_unlock (v4l2xv->mutex);
GST_DEBUG_OBJECT (v4l2object->element, "got window");
gst_v4l2_xoverlay_set_window_handle (v4l2object, win);
}
}
static gboolean
empathy_video_widget_expose_event (GtkWidget *widget, GdkEventExpose *event)
{
EmpathyVideoWidget *self = EMPATHY_VIDEO_WIDGET (widget);
EmpathyVideoWidgetPriv *priv = GET_PRIV (self);
if (event != NULL && event->count > 0)
return TRUE;
if (priv->overlay == NULL)
{
gdk_window_clear_area (gtk_widget_get_window (widget), 0, 0,
widget->allocation.width, widget->allocation.height);
return TRUE;
}
gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (priv->overlay),
GDK_WINDOW_XID (gtk_widget_get_window (widget)));
gst_x_overlay_expose (GST_X_OVERLAY (priv->overlay));
return TRUE;
}
static gboolean
bp_video_find_xoverlay (BansheePlayer *player)
{
GstElement *video_sink = NULL;
GstElement *xoverlay;
GstXOverlay *previous_xoverlay;
gboolean found_xoverlay;
g_object_get (player->playbin, "video-sink", &video_sink, NULL);
g_mutex_lock (player->video_mutex);
previous_xoverlay = player->xoverlay;
if (video_sink == NULL) {
player->xoverlay = NULL;
if (previous_xoverlay != NULL) {
gst_object_unref (previous_xoverlay);
}
g_mutex_unlock (player->video_mutex);
return FALSE;
}
xoverlay = GST_IS_BIN (video_sink)
? gst_bin_get_by_interface (GST_BIN (video_sink), GST_TYPE_X_OVERLAY)
: video_sink;
player->xoverlay = GST_IS_X_OVERLAY (xoverlay) ? GST_X_OVERLAY (xoverlay) : NULL;
if (previous_xoverlay != NULL) {
gst_object_unref (previous_xoverlay);
}
#if !defined(GDK_WINDOWING_WIN32) // We can't rely on aspect ratio from dshowvideosink
if (player->xoverlay != NULL && g_object_class_find_property (
G_OBJECT_GET_CLASS (player->xoverlay), "force-aspect-ratio")) {
g_object_set (G_OBJECT (player->xoverlay), "force-aspect-ratio", TRUE, NULL);
}
#endif
if (player->xoverlay != NULL && g_object_class_find_property (
G_OBJECT_GET_CLASS (player->xoverlay), "handle-events")) {
g_object_set (G_OBJECT (player->xoverlay), "handle-events", FALSE, NULL);
}
gst_object_unref (video_sink);
found_xoverlay = (player->xoverlay != NULL) ? TRUE : FALSE;
g_mutex_unlock (player->video_mutex);
return found_xoverlay;
}
G_MODULE_EXPORT gboolean
delayed_expose_cb(signal_user_data_t *ud)
{
GstElement *vsink;
GstXOverlay *xover;
if (!ud->preview->live_enabled)
return FALSE;
g_object_get(ud->preview->play, "video-sink", &vsink, NULL);
if (vsink == NULL)
return FALSE;
if (GST_IS_BIN(vsink))
xover = GST_X_OVERLAY(gst_bin_get_by_interface(
GST_BIN(vsink), GST_TYPE_X_OVERLAY));
else
xover = GST_X_OVERLAY(vsink);
gst_x_overlay_expose(xover);
// This function is initiated by g_idle_add. Must return false
// so that it is not called again
return FALSE;
}
gboolean VideoReceiver::busCall(GstBus *,
GstMessage *message,
gpointer data)
{
VideoReceiver *vr = static_cast<VideoReceiver *>(data);
GError *error = NULL;
gchar *debug = NULL;
switch (GST_MESSAGE_TYPE(message)) {
case GST_MESSAGE_ERROR:
gst_message_parse_error(message, &error, &debug);
qWarning("Error: %s", error->message);
g_error_free(error);
g_free(debug);
break;
case GST_MESSAGE_EOS:
// end-of-stream
// g_main_loop_quit(loop);
qWarning("%s: Warning: EOS", __FUNCTION__);
break;
case GST_MESSAGE_WARNING:
gst_message_parse_warning(message, &error, &debug);
if (error != NULL) {
qWarning("Warning: %s", error->message);
g_error_free(error);
}
if (debug != NULL) {
qDebug("Debug: %s", debug);
g_free(debug);
}
break;
case GST_MESSAGE_ELEMENT:
if (gst_structure_has_name(message->structure, "prepare-xwindow-id") && vr->xid != 0) {
qDebug("%s - prepare-xwindow-id", __FUNCTION__);
gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(GST_MESSAGE_SRC(message)), vr->xid);
}
break;
default:
// Unhandled message
//qWarning("Unhandled message type: %d", GST_MESSAGE_TYPE(message));
break;
}
return true;
}
static void gst_native_surface_finalize (JNIEnv *env, jobject thiz) {
CustomData *data = GET_CUSTOM_DATA (env, thiz, custom_data_field_id);
if (!data) return;
GST_DEBUG ("Releasing Native Window %p", data->native_window);
if (data->pipeline) {
gst_x_overlay_set_window_handle (GST_X_OVERLAY (data->pipeline), (guintptr)NULL);
gst_element_set_state (data->pipeline, GST_STATE_READY);
}
ANativeWindow_release (data->native_window);
data->native_window = NULL;
data->initialized = FALSE;
}
