C++ 将gstreamer摄像头馈送数据绑定到c+中的正确GTK窗口+；

我无法在顶级GTK窗口中读取摄像头提要，但我能够在另一个窗口中读取，即在可执行二进制对象中（不知道如何读取）

#包括
#包括
#包括
#包括
#如果已定义（GDK_窗口化_X11）
#包括
#已定义elif（GDK\u窗口化\u WIN32）
#包括
#elif定义（GDK_加窗_石英）
#包括
#恩迪夫
静态空隙
按钮\状态\空\ cb（GtkWidget*小部件，GstElement*管道）
{
gst\元素\集合\状态（管道，gst\状态\空）；
g_print（“GST_STATE_NULL\n”）；
}
静态空隙
按钮状态就绪cb（GtkWidget*小部件，GstElement*管道）
{
gst元件设置状态（管道、gst状态准备就绪）；
g_print（“GST_STATE_READY\n”）；
}
静态空隙
按钮状态暂停cb（GtkWidget*小部件，GstElement*管道）
{
gst元素设置状态（管道、gst状态暂停）；
g_print（“GST_STATE_暂停\n”）；
}
静态空隙
按钮\状态\播放\ cb（GtkWidget*小部件，GstElement*管道）
{
gst元素设置状态（管道、gst状态）；
g_print（“GST_STATE_PLAYING\n”）；
}
静态空隙
结束\u流\u cb（GstBus*总线、GstMessage*消息、GstElement*管道）
{
g_打印（“流结束\n”）；
gst\元素\集合\状态（管道，gst\状态\空）；
gst_对象_unref（管道）；
gtk_main_quit（）；
}
静态空隙
销毁cb（GtkWidget*小部件、GdkEvent*事件、GstElement*管道）
{
g_打印（“关闭”）；
gst\元素\集合\状态（管道，gst\状态\空）；
gst_对象_unref（管道）；
gtk_main_quit（）；
}
静态void实现_cb（GtkWidget*小部件、GstElement*接收器）
{
GdkWindow*窗口=gtk_小部件_获取_窗口（小部件）；
玻璃窗把手；
如果（！gdk_window_确保_native（window））
g_错误（“无法创建GstXOverlay所需的本机窗口！”）；
#如果已定义（GDK_WINDOWING_WIN32）
窗口句柄=（guintpttr）GDK\u窗口句柄（窗口）；
#elif定义（GDK_加窗_石英）
window\u handle=gdk\u quartz\u window\u get\u nsview（窗口）；
#elif已定义（GDK_窗口化_X11）
window\u handle=GDK\u window\u XID（window）；
#恩迪夫
gst_视频_叠加_设置_窗口_句柄（gst_视频_叠加（接收器）、窗口_句柄）；
}
int
main（int argc，char*argv[]）
{
GdkWindow*视频窗口；
古龙茶；
GtkWidget*窗口、*窗口控制、*视频窗口、*tr；
GtkWidget*按钮状态为空，*按钮状态为就绪；
GtkWidget*按钮状态暂停，*按钮状态播放；
GtkWidget*网格，*面积；
GstElement*管道，*sin；
GstElement*videosrc，*上传，*效果，*视频接收器；
GSTStateChangeRet；
GSTCAP*上限；
GstBus*总线；
#如果GST\U GL\U已定义了\U窗口\U X11&&定义（GDK\U窗口\U X11）
XInitThreads（）；
#恩迪夫
gst_init（&argc，&argv）；
gtk_init（&argc，&argv）；
管道=gst_管道_新（“管道”）；
//窗口，其中包含绘制视频的区域
窗口=gtk_窗口_新建（gtk_窗口_顶层）；
gtk_窗口设置默认大小（gtk_窗口（窗口），640480）；
gtk_窗口移动（gtk_窗口（窗口），300，10）；
gtk_窗口_设置_标题（gtk_窗口（窗口），“gtkgstwidget”）；
//窗口来控制状态
窗口控制=gtk窗口新建（gtk窗口顶层）；
gtk_窗口设置可调整大小（gtk_窗口（窗口控制），错误）；
gtk_窗口移动（gtk_窗口（窗口控制），10，10）；
grid=gtk_grid_new（）；
gtk_容器添加（gtk_容器（窗口控制），网格）；
//控制状态为空
按钮状态为空=gtk按钮为新，带有标签（“GST状态为空”）；
g_信号连接（g_对象（按钮状态为空），“点击”，
G_回调（按钮_状态_null_cb），管道）；
gtk_网格连接（gtk_网格（网格）、按钮_状态_null、0、1、1、1）；
gtk_小部件_显示（按钮_状态_空）；
//控制状态就绪
按钮状态就绪=gtk按钮新，带有标签（“GST状态就绪”）；
g_信号连接（g_对象（按钮状态就绪），“点击”，
G_回调（按钮_状态_就绪_cb），管道）；
gtk_网格连接（gtk_网格（网格），按钮_状态_就绪，0,2,1,1）；
gtk_小部件_显示（按钮_状态_就绪）；
//控制状态暂停
按钮状态暂停=带有“GST状态暂停”标签的gtk按钮新按钮；
g_信号连接（g_对象（按钮状态已暂停），“单击”，
G_回调（按钮_状态_暂停_cb），管道）；
gtk_网格连接（gtk_网格（网格），按钮_状态_暂停，0,3,1,1）；
gtk_小部件_显示（按钮_状态_暂停）；
//控制状态播放
按钮状态播放=带有标签的gtk按钮新建（“GST状态播放”）；
g_信号连接（g_对象（按钮状态播放），“点击”，
G_回调（按钮_状态_播放_cb），管道）；
gtk_网格连接（gtk_网格（网格），按钮_状态_播放，0,4,1,1）；
//gtk_小部件_显示（按钮_状态_播放）；
gtk_widget_show（网格）；
gtk_widget_show（窗口控制）；
g_信号连接（g_对象（窗口），“删除事件”，g_回调（销毁\u cb），
管道）；
//配置管道
videosrc=gst元素工厂制造（“v4l2src”、“v4l2src”）；
上传=gst元素工厂制造（“视频转换”、“视频转换”）；
影响=gst元素工厂制造（“视频秤”、“视频秤”）；
videosink=gst元素工厂制造（“autovideosink”、“autovideosink”）；
g_对象集（videosrc，“设备”，“/dev/video0”，空）；
g_object_get（videosink，“小部件”&区域，空）；
gtk_容器添加（gtk_容器（窗口），区域）；
gtk_小部件_实现（区域）；
//GtkWidget*root_pane=gtk_overlay_new（）；
//gtk_容器添加（gtk_容器（窗口），根窗格）；
//面积=gtk_图纸_面积_新（）；
//g_object_get（videosink，“小部件”&区域，空）；
//gtk_容器添加（gtk_容器（根窗格），区域）；
//g_object_get（videosink，“小部件”&窗口，空）；
//gtk_容器添加（gtk_容器（窗口），区域）；
//g_对象_unref（区域）；
caps=gst\U caps\U new\U simple（“视频/x-raw”，“宽度”，G\U类型，640，
“高度”，G_TYPE_INT，480，“格式”，G_TYPE_字符串，“RGBA”，
“帧率”，GST_类型_分数，30，1，空）；
gst_bin_add_many（gst_bin（管道）、videosrc、上传、效果、videosink、，
无效）；
如果（！gst\u元素\u li
#include <gtk/gtk.h>
#include <gst/gst.h>

#include <gst/video/videooverlay.h>
#include <gdk/gdk.h>
#if defined (GDK_WINDOWING_X11)
#include <gdk/gdkx.h>
#elif defined (GDK_WINDOWING_WIN32)
#include <gdk/gdkwin32.h>
#elif defined (GDK_WINDOWING_QUARTZ)
#include <gdk/gdkquartz.h>
#endif

static void
button_state_null_cb (GtkWidget * widget, GstElement * pipeline)
{
  gst_element_set_state (pipeline, GST_STATE_NULL);
  g_print ("GST_STATE_NULL\n");
}

static void
button_state_ready_cb (GtkWidget * widget, GstElement * pipeline)
{
  gst_element_set_state (pipeline, GST_STATE_READY);
  g_print ("GST_STATE_READY\n");
}

static void
button_state_paused_cb (GtkWidget * widget, GstElement * pipeline)
{
  gst_element_set_state (pipeline, GST_STATE_PAUSED);
  g_print ("GST_STATE_PAUSED\n");
}

static void
button_state_playing_cb (GtkWidget * widget, GstElement * pipeline)
{
  gst_element_set_state (pipeline, GST_STATE_PLAYING);
  g_print ("GST_STATE_PLAYING\n");
}

static void
end_stream_cb (GstBus * bus, GstMessage * message, GstElement * pipeline)
{
  g_print ("End of stream\n");

  gst_element_set_state (pipeline, GST_STATE_NULL);
  gst_object_unref (pipeline);

  gtk_main_quit ();
}

static void
destroy_cb (GtkWidget * widget, GdkEvent * event, GstElement * pipeline)
{
  g_print ("Close\n");

  gst_element_set_state (pipeline, GST_STATE_NULL);
  gst_object_unref (pipeline);

  gtk_main_quit ();
}

static void realize_cb (GtkWidget *widget, GstElement *sink)
{
  GdkWindow *window = gtk_widget_get_window (widget);
  guintptr window_handle;

  if (!gdk_window_ensure_native (window))
    g_error ("Couldn't create native window needed for GstXOverlay!");

#if defined (GDK_WINDOWING_WIN32)
    window_handle = (guintptr)GDK_WINDOW_HWND (window);
#elif defined (GDK_WINDOWING_QUARTZ)
      window_handle = gdk_quartz_window_get_nsview (window);
#elif defined (GDK_WINDOWING_X11)
        window_handle = GDK_WINDOW_XID (window);
#endif

  gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (sink), window_handle);
}

int
main (int argc, char *argv[])
{
    GdkWindow *video_window_xwindow;
    gulong embed_xid;
  GtkWidget *window, *window_control, *video_window , *tr;
  GtkWidget *button_state_null, *button_state_ready;
  GtkWidget *button_state_paused, *button_state_playing;
  GtkWidget *grid, *area;
  GstElement *pipeline, *sin;
  GstElement *videosrc, *upload, *effect, *videosink;
  GstStateChangeReturn ret;
  GstCaps *caps;
  GstBus *bus;

#if GST_GL_HAVE_WINDOW_X11 && defined(GDK_WINDOWING_X11)
  XInitThreads ();
#endif

  gst_init (&argc, &argv);
  gtk_init (&argc, &argv);

  pipeline = gst_pipeline_new ("pipeline");

  //window that contains an area where the video is drawn
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);
  gtk_window_move (GTK_WINDOW (window), 300, 10);
  gtk_window_set_title (GTK_WINDOW (window), "gtkgstwidget");

  //window to control the states
  window_control = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_resizable (GTK_WINDOW (window_control), FALSE);
  gtk_window_move (GTK_WINDOW (window_control), 10, 10);
  grid = gtk_grid_new ();
  gtk_container_add (GTK_CONTAINER (window_control), grid);

  //control state null
  button_state_null = gtk_button_new_with_label ("GST_STATE_NULL");
  g_signal_connect (G_OBJECT (button_state_null), "clicked",
      G_CALLBACK (button_state_null_cb), pipeline);
  gtk_grid_attach (GTK_GRID (grid), button_state_null, 0, 1, 1, 1);
  gtk_widget_show (button_state_null);

  //control state ready
  button_state_ready = gtk_button_new_with_label ("GST_STATE_READY");
  g_signal_connect (G_OBJECT (button_state_ready), "clicked",
      G_CALLBACK (button_state_ready_cb), pipeline);
  gtk_grid_attach (GTK_GRID (grid), button_state_ready, 0, 2, 1, 1);
  gtk_widget_show (button_state_ready);

  //control state paused
  button_state_paused = gtk_button_new_with_label ("GST_STATE_PAUSED");
  g_signal_connect (G_OBJECT (button_state_paused), "clicked",
      G_CALLBACK (button_state_paused_cb), pipeline);
  gtk_grid_attach (GTK_GRID (grid), button_state_paused, 0, 3, 1, 1);
  gtk_widget_show (button_state_paused);

  //control state playing
  button_state_playing = gtk_button_new_with_label ("GST_STATE_PLAYING");
  g_signal_connect (G_OBJECT (button_state_playing), "clicked",
      G_CALLBACK (button_state_playing_cb), pipeline);
  gtk_grid_attach (GTK_GRID (grid), button_state_playing, 0, 4, 1, 1);
  //gtk_widget_show (button_state_playing);

  gtk_widget_show (grid);
  gtk_widget_show (window_control);

  g_signal_connect (G_OBJECT (window), "delete-event", G_CALLBACK (destroy_cb),
      pipeline);

  //configure the pipeline
  videosrc = gst_element_factory_make ("v4l2src", "v4l2src");
  upload = gst_element_factory_make ("videoconvert", "videoconvert");
  effect = gst_element_factory_make ("videoscale", "videoscale");
  videosink = gst_element_factory_make ("autovideosink", "autovideosink");
  
  g_object_set (videosrc, "device", "/dev/video0", NULL);
 
    g_object_get (videosink, "widget", &area, NULL);
    gtk_container_add (GTK_CONTAINER (window), area);

    gtk_widget_realize(area);
    
    //GtkWidget *root_pane = gtk_overlay_new();
    //gtk_container_add(GTK_CONTAINER(window), root_pane);
    //area=gtk_drawing_area_new();
    //g_object_get (videosink, "widget", &area, NULL);
    //gtk_container_add(GTK_CONTAINER(root_pane), area);

  //g_object_get (videosink, "widget", &window, NULL);
  //gtk_container_add (GTK_CONTAINER (window), area);
  //g_object_unref (area);

  caps = gst_caps_new_simple ("video/x-raw", "width", G_TYPE_INT, 640,
      "height", G_TYPE_INT, 480, "format", G_TYPE_STRING, "RGBA",
      "framerate", GST_TYPE_FRACTION, 30, 1, NULL);

  gst_bin_add_many (GST_BIN (pipeline), videosrc, upload, effect, videosink,
      NULL);

  if (!gst_element_link_filtered (videosrc, upload, caps)) {
    //gst_caps_unref (caps);
    g_warning ("Failed to link videosrc to glfiltercube!\n");
    //return -1;
  }
  gst_caps_unref (caps);

  if (!gst_element_link_many (upload, effect, videosink, NULL)) {
    g_warning ("Failed to link videosrc to glfiltercube!\n");
    return -1;
  }
  if (!gst_element_link_many (videosrc,upload, effect, videosink, NULL)) {
    g_warning ("Failed to link videosrc to glfiltercube!\n");
    //return -1;
  }
  //set window id on this event
  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
  g_signal_connect (bus, "message::error", G_CALLBACK (end_stream_cb),
      pipeline);
  g_signal_connect (bus, "message::warning", G_CALLBACK (end_stream_cb),
      pipeline);
  g_signal_connect (bus, "message::eos", G_CALLBACK (end_stream_cb), pipeline);
  gst_object_unref (bus);

  //start
  ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
  if (ret == GST_STATE_CHANGE_FAILURE) {
    g_print ("Failed to start up pipeline!\n");
    return -1;
  }

  gtk_widget_show_all (window);

  gtk_main ();
  gst_deinit ();
  return 0;
}