GStreamer教程-基础教程5：GUI工具包集成

最新推荐文章于 2025-05-27 13:49:44 发布
最新推荐文章于 2025-05-27 13:49:44 发布
阅读量2.1k 收藏
点赞数
文章标签： c++ 实时音视频 ui

目标

       本教程展示如何将GStreamer集成到图形用户界面(GUI)工具包中，如GTK+。基本上，GStreamer负责媒体回放，而GUI工具包处理用户交互。最有趣的部分是两个库必须交互的部分：指示GStreamer将视频输出到GTK+窗口，并将用户操作转发到GStreamer。

       特别是，你会学到:

  • 如何告诉GStreamer将视频输出到特定的窗口(而不是创建自己的窗口)。

  • 如何使用来自GStreamer的信息不断刷新GUI。

  • 如何从GStreamer的多个线程更新GUI，这是大多数GUI工具包禁止的操作。

  • 一种只订阅您感兴趣的消息的机制，而不是通知所有消息。

引言

       我们将使用GTK+工具包构建一个媒体播放器，但是这些概念也适用于其他工具包，例如Qt。了解GTK+的基本知识将有助于理解本教程。

       重点是告诉GStreamer将视频输出到我们选择的窗口。具体的机制取决于操作系统(或者更确切地说，取决于窗口系统)，但是GStreamer为了平台独立性提供了一个抽象层。这种独立性来自于GstVideoOverlay接口，它允许应用程序告诉视频接收器应该接收渲染的窗口的处理程序。

GObject接口
       GObject接口(GStreamer使用的接口)是元素可以实现的一组函数。如果是，那么就说它支持特定的接口。例如，视频接收器通常创建自己的窗口来显示视频，但是，如果它们也能够呈现到外部窗口，那么它们可以选择实现GstVideoOverlay接口并提供指定此外部窗口的函数。从应用程序开发人员的角度来看，如果支持某种接口，就可以使用它，而不用考虑是哪种元素实现它。此外，如果您正在使用playbin，它将自动公开其内部元素支持的一些接口：您可以直接在playbin上使用您的接口函数，而不知道谁在实现它们！

       另一个问题是GUI工具包通常只允许通过主线程(或应用程序)操作图形化的“小部件”，而GStreamer通常产生多个线程来处理不同的任务。从回调内部调用GTK+函数通常会失败，因为回调在调用线程中执行，而调用线程不需要是主线程。这个问题可以通过在回调中在GStreamer总线上发布消息来解决：消息将由主线程接收，然后主线程将做出相应的反应。

       最后，到目前为止，我们已经注册了一个handle_message函数，每当消息出现在总线上时，都会调用该函数，这迫使我们解析每条消息，以查看它是否对我们感兴趣。在本教程中，使用了一种不同的方法为每种消息注册回调，因此整体上的解析和代码更少。

一个GTK+中的媒体播放器

       让我们基于playbin编写一个非常简单的媒体播放器，这次，使用GUI！

       将这段代码复制到一个名为basic-tutorial-5.c的文本文件中（或在GStreamer安装中找到它）。

basic-tutorial-5.c

#include <string.h>

#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

/* Structure to contain all our information, so we can pass it around */
typedef struct _CustomData {
  GstElement *playbin;           /* Our one and only pipeline */

  GtkWidget *slider;              /* Slider widget to keep track of current position */
  GtkWidget *streams_list;        /* Text widget to display info about the streams */
  gulong slider_update_signal_id; /* Signal ID for the slider update signal */

  GstState state;                 /* Current state of the pipeline */
  gint64 duration;                /* Duration of the clip, in nanoseconds */
} CustomData;

/* This function is called when the GUI toolkit creates the physical window that will hold the video.
 * At this point we can retrieve its handler (which has a different meaning depending on the windowing system)
 * and pass it to GStreamer through the VideoOverlay interface. */
static void realize_cb (GtkWidget *widget, CustomData *data) {
  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 GstVideoOverlay!");

  /* Retrieve window handler from GDK */
#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
  /* Pass it to playbin, which implements VideoOverlay and will forward it to the video sink */
  gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (data->playbin), window_handle);
}

/* This function is called when the PLAY button is clicked */
static void play_cb (GtkButton *button, CustomData *data) {
  gst_element_set_state (data->playbin, GST_STATE_PLAYING);
}

/* This function is called when the PAUSE button is clicked */
static void pause_cb (GtkButton *button, CustomData *data) {
  gst_element_set_state (data->playbin, GST_STATE_PAUSED);
}

/* This function is called when the STOP button is clicked */
static void stop_cb (GtkButton *button, CustomData *data) {
  gst_element_set_state (data->playbin, GST_STATE_READY);
}

/* This function is called when the main window is closed */
static void delete_event_cb (GtkWidget *widget, GdkEvent *event, CustomData *data) {
  stop_cb (NULL, data);
  gtk_main_quit ();
}

/* This function is called everytime the video window needs to be redrawn (due to damage/exposure,
 * rescaling, etc). GStreamer takes care of this in the PAUSED and PLAYING states, otherwise,
 * we simply draw a black rectangle to avoid garbage showing up. */
static gboolean draw_cb (GtkWidget *widget, cairo_t *cr, CustomData *data) {
  if (data->state < GST_STATE_PAUSED) {
    GtkAllocation allocation;

    /* Cairo is a 2D graphics library which we use here to clean the video window.
     * It is used by GStreamer for other reasons, so it will always be available to us. */
    gtk_widget_get_allocation (widget, &allocation);
    cairo_set_source_rgb (cr, 0, 0, 0);
    cairo_rectangle (cr, 0, 0, allocation.width, allocation.height);
    cairo_fill (cr);
  }

  return FALSE;
}

/* This function is called when the slider changes its position. We perform a seek to the
 * new position here. */
static void slider_cb (GtkRange *range, CustomData *data) {
  gdouble value = gtk_range_get_value (GTK_RANGE (data->slider));
  gst_element_seek_simple (data->playbin, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
      (gint64)(value * GST_SECOND));
}

/* This creates all the GTK+ widgets that compose our application, and registers the callbacks */
static void create_ui (CustomData *data) {
  GtkWidget *main_window;  /* The uppermost window, containing all other windows */
  GtkWidget *video_window; /* The drawing area where the video will be shown */
  GtkWidget *main_box;     /* VBox to hold main_hbox and the controls */
  GtkWidget *main_hbox;    /* HBox to hold the video_window and the stream info text widget */
  GtkWidget *controls;     /* HBox to hold the buttons and the slider */
  GtkWidget *play_button, *pause_button, *stop_button; /* Buttons */

  main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  g_signal_connect (G_OBJECT (main_window), "delete-event", G_CALLBACK (delete_event_cb), data);

  video_window = gtk_drawing_area_new ();
  gtk_widget_set_double_buffered (video_window, FALSE);
  g_signal_connect (video_window, "realize", G_CALLBACK (realize_cb), data);
  g_signal_connect (video_window, "draw", G_CALLBACK (draw_cb), data);

  play_button = gtk_button_new_from_icon_name ("media-playback-start", GTK_ICON_SIZE_SMALL_TOOLBAR);
  g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb), data);

  pause_button = gtk_button_new_from_icon_name ("media-playback-pause", GTK_ICON_SIZE_SMALL_TOOLBAR);
  g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb), data);

  stop_button = gtk_button_new_from_icon_name ("media-playback-stop", GTK_ICON_SIZE_SMALL_TOOLBAR);
  g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data);

  data->slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
  gtk_scale_set_draw_value (GTK_SCALE (data->slider), 0);
  data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data);

  data->streams_list = gtk_text_view_new ();
  gtk_text_view_set_editable (GTK_TEXT_VIEW (data->streams_list), FALSE);

  controls = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_box_pack_start (GTK_BOX (controls), play_button, FALSE, FALSE, 2);
  gtk_box_pack_start (GTK_BOX (controls), pause_button, FALSE, FALSE, 2);
  gtk_box_pack_start (GTK_BOX (controls), stop_button, FALSE, FALSE, 2);
  gtk_box_pack_start (GTK_BOX (controls), data->slider, TRUE, TRUE, 2);

  main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_box_pack_start (GTK_BOX (main_hbox), video_window, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (main_hbox), data->streams_list, FALSE, FALSE, 2);

  main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  gtk_box_pack_start (GTK_BOX (main_box), main_hbox, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (main_box), controls, FALSE, FALSE, 0);
  gtk_container_add (GTK_CONTAINER (main_window), main_box);
  gtk_window_set_default_size (GTK_WINDOW (main_window), 640, 480);

  gtk_widget_show_all (main_window);
}

/* This function is called periodically to refresh the GUI */
static gboolean refresh_ui (CustomData *data) {
  gint64 current = -1;

  /* We do not want to update anything unless we are in the PAUSED or PLAYING states */
  if (data->state < GST_STATE_PAUSED)
    return TRUE;

  /* If we didn't know it yet, query the stream duration */
  if (!GST_CLOCK_TIME_IS_VALID (data->duration)) {
    if (!gst_element_query_duration (data->playbin, GST_FORMAT_TIME, &data->duration)) {
      g_printerr ("Could not query current duration.\n");
    } else {
      /* Set the range of the slider to the clip duration, in SECONDS */
      gtk_range_set_range (GTK_RANGE (data->slider), 0, (gdouble)data->duration / GST_SECOND);
    }
  }

  if (gst_element_query_position (data->playbin, GST_FORMAT_TIME, &current)) {
    /* Block the "value-changed" signal, so the slider_cb function is not called
     * (which would trigger a seek the user has not requested) */
    g_signal_handler_block (data->slider, data->slider_update_signal_id);
    /* Set the position of the slider to the current pipeline position, in SECONDS */
    gtk_range_set_value (GTK_RANGE (data->slider), (gdouble)current / GST_SECOND);
    /* Re-enable the signal */
    g_signal_handler_unblock (data->slider, data->slider_update_signal_id);
  }
  return TRUE;
}

/* This function is called when new metadata is discovered in the stream */
static void tags_cb (GstElement *playbin, gint stream, CustomData *data) {
  /* We are possibly in a GStreamer working thread, so we notify the main
   * thread of this event through a message in the bus */
  gst_element_post_message (playbin,
    gst_message_new_application (GST_OBJECT (playbin),
      gst_structure_new_empty ("tags-changed")));
}

/* This function is called when an error message is posted on the bus */
static void error_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
  GError *err;
  gchar *debug_info;

  /* Print error details on the screen */
  gst_message_parse_error (msg, &err, &debug_info);
  g_printerr ("Error received from element %s: %s\n", GST_OBJECT_NAME (msg->src), err->message);
  g_printerr ("Debugging information: %s\n", debug_info ? debug_info : "none");
  g_clear_error (&err);
  g_free (debug_info);

  /* Set the pipeline to READY (which stops playback) */
  gst_element_set_state (data->playbin, GST_STATE_READY);
}

/* This function is called when an End-Of-Stream message is posted on the bus.
 * We just set the pipeline to READY (which stops playback) */
static void eos_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
  g_print ("End-Of-Stream reached.\n");
  gst_element_set_state (data->playbin, GST_STATE_READY);
}

/* This function is called when the pipeline changes states. We use it to
 * keep track of the current state. */
static void state_changed_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
  GstState old_state, new_state, pending_state;
  gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state);
  if (GST_MESSAGE_SRC (msg) == GST_OBJECT (data->playbin)) {
    data->state = new_state;
    g_print ("State set to %s\n", gst_element_state_get_name (new_state));
    if (old_state == GST_STATE_READY && new_state == GST_STATE_PAUSED) {
      /* For extra responsiveness, we refresh the GUI as soon as we reach the PAUSED state */
      refresh_ui (data);
    }
  }
}

/* Extract metadata from all the streams and write it to the text widget in the GUI */
static void analyze_streams (CustomData *data) {
  gint i;
  GstTagList *tags;
  gchar *str, *total_str;
  guint rate;
  gint n_video, n_audio, n_text;
  GtkTextBuffer *text;

  /* Clean current contents of the widget */
  text = gtk_text_view_get_buffer (GTK_TEXT_VIEW (data->streams_list));
  gtk_text_buffer_set_text (text, "", -1);

  /* Read some properties */
  g_object_get (data->playbin, "n-video", &n_video, NULL);
  g_object_get (data->playbin, "n-audio", &n_audio, NULL);
  g_object_get (data->playbin, "n-text", &n_text, NULL);

  for (i = 0; i < n_video; i++) {
    tags = NULL;
    /* Retrieve the stream's video tags */
    g_signal_emit_by_name (data->playbin, "get-video-tags", i, &tags);
    if (tags) {
      total_str = g_strdup_printf ("video stream %d:\n", i);
      gtk_text_buffer_insert_at_cursor (text, total_str, -1);
      g_free (total_str);
      gst_tag_list_get_string (tags, GST_TAG_VIDEO_CODEC, &str);
      total_str = g_strdup_printf ("  codec: %s\n", str ? str : "unknown");
      gtk_text_buffer_insert_at_cursor (text, total_str, -1);
      g_free (total_str);
      g_free (str);
      gst_tag_list_free (tags);
    }
  }

  for (i = 0; i < n_audio; i++) {
    tags = NULL;
    /* Retrieve the stream's audio tags */
    g_signal_emit_by_name (data->playbin, "get-audio-tags", i, &tags);
    if (tags) {
      total_str = g_strdup_printf ("\naudio stream %d:\n", i);
      gtk_text_buffer_insert_at_cursor (text, total_str, -1);
      g_free (total_str);
      if (gst_tag_list_get_string (tags, GST_TAG_AUDIO_CODEC, &str)) {
        total_str = g_strdup_printf ("  codec: %s\n", str);
        gtk_text_buffer_insert_at_cursor (text, total_str, -1);
        g_free (total_str);
        g_free (str);
      }
      if (gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_CODE, &str)) {
        total_str = g_strdup_printf ("  language: %s\n", str);
        gtk_text_buffer_insert_at_cursor (text, total_str, -1);
        g_free (total_str);
        g_free (str);
      }
      if (gst_tag_list_get_uint (tags, GST_TAG_BITRATE, &rate)) {
        total_str = g_strdup_printf ("  bitrate: %d\n", rate);
        gtk_text_buffer_insert_at_cursor (text, total_str, -1);
        g_free (total_str);
      }
      gst_tag_list_free (tags);
    }
  }

  for (i = 0; i < n_text; i++) {
    tags = NULL;
    /* Retrieve the stream's subtitle tags */
    g_signal_emit_by_name (data->playbin, "get-text-tags", i, &tags);
    if (tags) {
      total_str = g_strdup_printf ("\nsubtitle stream %d:\n", i);
      gtk_text_buffer_insert_at_cursor (text, total_str, -1);
      g_free (total_str);
      if (gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_CODE, &str)) {
        total_str = g_strdup_printf ("  language: %s\n", str);
        gtk_text_buffer_insert_at_cursor (text, total_str, -1);
        g_free (total_str);
        g_free (str);
      }
      gst_tag_list_free (tags);
    }
  }
}

/* This function is called when an "application" message is posted on the bus.
 * Here we retrieve the message posted by the tags_cb callback */
static void application_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
  if (g_strcmp0 (gst_structure_get_name (gst_message_get_structure (msg)), "tags-changed") == 0) {
    /* If the message is the "tags-changed" (only one we are currently issuing), update
     * the stream info GUI */
    analyze_streams (data);
  }
}

int main(int argc, char *argv[]) {
  CustomData data;
  GstStateChangeReturn ret;
  GstBus *bus;

  /* Initialize GTK */
  gtk_init (&argc, &argv);

  /* Initialize GStreamer */
  gst_init (&argc, &argv);

  /* Initialize our data structure */
  memset (&data, 0, sizeof (data));
  data.duration = GST_CLOCK_TIME_NONE;

  /* Create the elements */
  data.playbin = gst_element_factory_make ("playbin", "playbin");

  if (!data.playbin) {
    g_printerr ("Not all elements could be created.\n");
    return -1;
  }

  /* Set the URI to play */
  g_object_set (data.playbin, "uri", "https://www.freedesktop.org/software/gstreamer-sdk/data/media/sintel_trailer-480p.webm", NULL);

  /* Connect to interesting signals in playbin */
  g_signal_connect (G_OBJECT (data.playbin), "video-tags-changed", (GCallback) tags_cb, &data);
  g_signal_connect (G_OBJECT (data.playbin), "audio-tags-changed", (GCallback) tags_cb, &data);
  g_signal_connect (G_OBJECT (data.playbin), "text-tags-changed", (GCallback) tags_cb, &data);

  /* Create the GUI */
  create_ui (&data);

  /* Instruct the bus to emit signals for each received message, and connect to the interesting signals */
  bus = gst_element_get_bus (data.playbin);
  gst_bus_add_signal_watch (bus);
  g_signal_connect (G_OBJECT (bus), "message::error", (GCallback)error_cb, &data);
  g_signal_connect (G_OBJECT (bus), "message::eos", (GCallback)eos_cb, &data);
  g_signal_connect (G_OBJECT (bus), "message::state-changed", (GCallback)state_changed_cb, &data);
  g_signal_connect (G_OBJECT (bus), "message::application", (GCallback)application_cb, &data);
  gst_object_unref (bus);

  /* Start playing */
  ret = gst_element_set_state (data.playbin, GST_STATE_PLAYING);
  if (ret == GST_STATE_CHANGE_FAILURE) {
    g_printerr ("Unable to set the pipeline to the playing state.\n");
    gst_object_unref (data.playbin);
    return -1;
  }

  /* Register a function that GLib will call every second */
  g_timeout_add_seconds (1, (GSourceFunc)refresh_ui, &data);

  /* Start the GTK main loop. We will not regain control until gtk_main_quit is called. */
  gtk_main ();

  /* Free resources */
  gst_element_set_state (data.playbin, GST_STATE_NULL);
  gst_object_unref (data.playbin);
  return 0;
}

代码演练

       关于本教程的结构，我们将不再使用前向函数定义:函数将在使用之前定义。此外，为了解释清楚，代码片段的呈现顺序并不总是与程序顺序相匹配。使用行号来定位完整代码中的代码段。

#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/gdkquartzwindow.h>
#endif

       首先值得注意的是，我们不再完全独立于平台。我们需要为将要使用的窗口系统包含适当的GDK头文件。幸运的是，受支持的窗口系统并不多，因此这三行代码通常就足够了：用于Linux的X11，用于Windows的Win32和用于Mac OSX的Quartz。

       本教程主要由回调函数组成，将从GStreamer或GTK+调用这些回调函数，因此让我们回顾一下主函数，它注册所有这些回调函数。

int main(int argc, char *argv[]) {
  CustomData data;
  GstStateChangeReturn ret;
  GstBus *bus;

  /* Initialize GTK */
  gtk_init (&argc, &argv);

  /* Initialize GStreamer */
  gst_init (&argc, &argv);

  /* Initialize our data structure */
  memset (&data, 0, sizeof (data));
  data.duration = GST_CLOCK_TIME_NONE;

  /* Create the elements */
  data.playbin = gst_element_factory_make ("playbin", "playbin");

  if (!data.playbin) {
    g_printerr ("Not all elements could be created.\n");
    return -1;
  }

  /* Set the URI to play */
  g_object_set (data.playbin, "uri", "https://www.freedesktop.org/software/gstreamer-sdk/data/media/sintel_trailer-480p.webm", NULL);

       标准GStreamer初始化和playbin管道创建，以及GTK+初始化。没什么新东西。

  /* Connect to interesting signals in playbin */
  g_signal_connect (G_OBJECT (data.playbin), "video-tags-changed", (GCallback) tags_cb, &data);
  g_signal_connect (G_OBJECT (data.playbin), "audio-tags-changed", (GCallback) tags_cb, &data);
  g_signal_connect (G_OBJECT (data.playbin), "text-tags-changed", (GCallback) tags_cb, &data);

       我们感兴趣的是在流上出现新标记(元数据)时得到通知。为了简单起见，我们将从同一个回调tags_cb处理所有类型的标记（视频、音频和文本）。

/* Create the GUI */
create_ui (&data);

       所有GTK+小部件的创建和信号注册都在这个函数中进行。它只包含与gtk相关的函数调用，因此我们将跳过它的定义。它所注册的信号传递用户命令，如下所示，在检查回调时。

  /* Instruct the bus to emit signals for each received message, and connect to the interesting signals */
  bus = gst_element_get_bus (data.playbin);
  gst_bus_add_signal_watch (bus);
  g_signal_connect (G_OBJECT (bus), "message::error", (GCallback)error_cb, &data);
  g_signal_connect (G_OBJECT (bus), "message::eos", (GCallback)eos_cb, &data);
  g_signal_connect (G_OBJECT (bus), "message::state-changed", (GCallback)state_changed_cb, &data);
  g_signal_connect (G_OBJECT (bus), "message::application", (GCallback)application_cb, &data);
  gst_object_unref (bus);

       在回放教程1：Playbin使用中，gst_bus_add_watch()用于注册一个函数，该函数接收发送到GStreamer总线的每条消息。我们可以通过使用信号来实现更细的粒度，这允许我们只注册我们感兴趣的消息。通过调用gst_bus_add_signal_watch()，我们指示总线在每次接收到消息时发出一个信号。该信号的名称为message::detail，其中detail是触发信号发射的消息。例如，当总线接收到EOS消息时，它会发出一个带有名称message::EOS的信号。

       本教程将使用Signals的详细信息仅注册到我们关心的消息。如果已经注册到消息信号，就会收到每条消息的通知，就像gst_bus_add_watch()所做的那样。

       请记住，为了使总线监视工作(无论是gst_bus_add_watch()还是gst_bus_add_signal_watch())，必须运行GLib主循环。在本例中，它隐藏在GTK+主循环中。

/* Register a function that GLib will call every second */
g_timeout_add_seconds (1, (GSourceFunc)refresh_ui, &data);

       在将控制转移到GTK+之前，我们使用g_timeout_add_seconds()来注册另一个回调，这一次带有超时，因此每秒钟都会调用一次。我们将使用它从refresh_ui函数刷新GUI。

       在此之后，我们完成了设置，可以启动GTK+主循环。当有趣的事情发生时，我们将从回调中重新获得控制权。让我们回顾一下回调函数。每个回调函数都有不同的签名，这取决于调用它的人。您可以在信号的文档中查找签名(参数的含义和返回值)。

/* This function is called when the GUI toolkit creates the physical window that will hold the video.
 * At this point we can retrieve its handler (which has a different meaning depending on the windowing system)
 * and pass it to GStreamer through the VideoOverlay interface. */
static void realize_cb (GtkWidget *widget, CustomData *data) {
  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 GstVideoOverlay!");

  /* Retrieve window handler from GDK */
#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
  /* Pass it to playbin, which implements VideoOverlay and will forward it to the video sink */
  gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (data->playbin), window_handle);
}

       代码注释自己说话。在应用程序生命周期的这一点上，我们知道GStreamer应该渲染视频的窗口的句柄(是X11的XID，窗口的HWND或石英的NSView)。我们简单地从窗口系统中检索它，并使用gst_video_overlay_set_window_handle()通过GstVideoOverlay接口将它传递给playbin。Playbin将定位视频接收器并将处理程序传递给它，因此它不会创建自己的窗口并使用这个窗口。

       这里没什么可看的了；playbin和GstVideoOverlay真的简化了这个过程很多!

/* This function is called when the PLAY button is clicked */
static void play_cb (GtkButton *button, CustomData *data) {
  gst_element_set_state (data->playbin, GST_STATE_PLAYING);
}

/* This function is called when the PAUSE button is clicked */
static void pause_cb (GtkButton *button, CustomData *data) {
  gst_element_set_state (data->playbin, GST_STATE_PAUSED);
}

/* This function is called when the STOP button is clicked */
static void stop_cb (GtkButton *button, CustomData *data) {
  gst_element_set_state (data->playbin, GST_STATE_READY);
}

       这三个小回调函数与GUI中的PLAY、PAUSE和STOP按钮相关联。他们只是将管道设置为相应的状态。注意，在STOP状态下，我们将管道设置为READY。我们本可以将管道一直降低到NULL状态，但是，这样的转换会稍微慢一些，因为一些资源(如音频设备)将需要释放和重新获取。

/* This function is called when the main window is closed */
static void delete_event_cb (GtkWidget *widget, GdkEvent *event, CustomData *data) {
  stop_cb (NULL, data);
  gtk_main_quit ();
}

       gtk_main_quit()最终将调用main中的gtk_main_run()来终止，在本例中，这将完成程序。在这里，我们在主窗口关闭时调用它，在停止管道之后(只是为了整洁)。

/* This function is called everytime the video window needs to be redrawn (due to damage/exposure,
 * rescaling, etc). GStreamer takes care of this in the PAUSED and PLAYING states, otherwise,
 * we simply draw a black rectangle to avoid garbage showing up. */
static gboolean draw_cb (GtkWidget *widget, cairo_t *cr, CustomData *data) {
  if (data->state < GST_STATE_PAUSED) {
    GtkAllocation allocation;

    /* Cairo is a 2D graphics library which we use here to clean the video window.
     * It is used by GStreamer for other reasons, so it will always be available to us. */
    gtk_widget_get_allocation (widget, &allocation);
    cairo_set_source_rgb (cr, 0, 0, 0);
    cairo_rectangle (cr, 0, 0, allocation.width, allocation.height);
    cairo_fill (cr);
  }

  return FALSE;
}

       当有数据流(处于PAUSED和PLAYING状态)时，视频接收器负责刷新视频窗口的内容。然而，在其他情况下，它不会，所以我们必须这样做。在本例中，我们只是用一个黑色矩形填充窗口。

/* This function is called when the slider changes its position. We perform a seek to the
 * new position here. */
static void slider_cb (GtkRange *range, CustomData *data) {
  gdouble value = gtk_range_get_value (GTK_RANGE (data->slider));
  gst_element_seek_simple (data->playbin, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
      (gint64)(value * GST_SECOND));
}

       通过GStreamer和GTK+的协作，我们可以非常轻松地实现一个复杂的GUI元素，如搜索条(或允许搜索的滑块)。如果滑块被拖到一个新位置，告诉GStreamer使用gst_element_seek_simple()寻找到该位置(如基础教程4:时间管理中所见)。滑块已经设置好，所以它的值表示秒数。

       值得一提的是，某些性能(和响应能力)可以通过做一些节流来获得，也就是说，不响应每一个用户请求。由于seek操作一定会花费一些时间，因此在执行一个seek操作后，最好等待半秒钟(例如)，然后再允许执行另一个。否则，如果用户疯狂地拖动滑块，应用程序可能看起来没有响应，这将不允许任何查找在新的队列之前完成。

/* This function is called periodically to refresh the GUI */
static gboolean refresh_ui (CustomData *data) {
  gint64 current = -1;

  /* We do not want to update anything unless we are in the PAUSED or PLAYING states */
  if (data->state < GST_STATE_PAUSED)
    return TRUE;

       此函数将移动滑块以反映媒体的当前位置。首先，如果我们不在PLAYING状态，我们在这里没有什么可做的(另外，位置和持续时间查询通常会失败)。

/* If we didn't know it yet, query the stream duration */
if (!GST_CLOCK_TIME_IS_VALID (data->duration)) {
  if (!gst_element_query_duration (data->playbin, GST_FORMAT_TIME, &data->duration)) {
    g_printerr ("Could not query current duration.\n");
  } else {
    /* Set the range of the slider to the clip duration, in SECONDS */
    gtk_range_set_range (GTK_RANGE (data->slider), 0, (gdouble)data->duration / GST_SECOND);
  }
}

       如果我们不知道剪辑的持续时间，我们会恢复它，所以我们可以为滑动条设置范围。

if (gst_element_query_position (data->playbin, GST_FORMAT_TIME, &current)) {
  /* Block the "value-changed" signal, so the slider_cb function is not called
   * (which would trigger a seek the user has not requested) */
  g_signal_handler_block (data->slider, data->slider_update_signal_id);
  /* Set the position of the slider to the current pipeline position, in SECONDS */
  gtk_range_set_value (GTK_RANGE (data->slider), (gdouble)current / GST_SECOND);
  /* Re-enable the signal */
  g_signal_handler_unblock (data->slider, data->slider_update_signal_id);
}
return TRUE;

       我们查询当前管道的位置，并相应地设置滑块的位置。这将触发值变化信号的发射，我们使用该信号来知道用户何时在拖动滑块。因为我们不希望请求发生，除非用户请求，所以我们使用g_signal_handler_block()和g_signal_handler_unblock()在此操作期间禁用改变值的信号发射。

       从这个函数返回TRUE将使它在将来继续被调用。如果返回FALSE，计时器将被移除。

/* This function is called when new metadata is discovered in the stream */
static void tags_cb (GstElement *playbin, gint stream, CustomData *data) {
  /* We are possibly in a GStreamer working thread, so we notify the main
   * thread of this event through a message in the bus */
  gst_element_post_message (playbin,
    gst_message_new_application (GST_OBJECT (playbin),
      gst_structure_new_empty ("tags-changed")));
}

       这是本教程的关键点之一。当在媒体中发现新标记时，这个函数将被调用，来自流线程，也就是说，来自应用程序(或主线程)之外的线程。这里我们要做的是更新一个GTK+小部件以反映这些新信息，但是GTK+不允许从主线程以外的线程进行操作。

       解决方案是让playbin在总线上发布消息并返回到调用线程。在适当的时候，主线程将接收此消息并更新GTK。

       gst_element_post_message()使GStreamer元素将给定的消息发布到总线       

       gst_message_new_application()创建一个APPLICATION类型的新消息。GStreamer消息有不同的类型，这个特定的类型是保留给应用程序的：它将不受GStreamer的影响通过总线。类型列表可以在GstMessageType文档中找到。

       消息可以通过其嵌入的GstStructure(这是一种非常灵活的数据容器)交付其他信息。在这里，我们使用gst_structure_new()创建了一个新结构，并将其命名为tags-changed，以避免在发送其他应用程序消息时产生混淆。

       稍后，一旦进入主线程，总线将接收到此消息并发出message::application信号，我们已经将其关联到application_cb函数:

/* This function is called when an "application" message is posted on the bus.
 * Here we retrieve the message posted by the tags_cb callback */
static void application_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
  if (g_strcmp0 (gst_structure_get_name (gst_message_get_structure (msg)), "tags-changed") == 0) {
    /* If the message is the "tags-changed" (only one we are currently issuing), update
     * the stream info GUI */
    analyze_streams (data);
  }
}

       一旦我确定它是标记更改的消息，我们就调用analyze_streams函数，该函数也在回放教程1:Playbin用法中使用，并且在那里有更详细的介绍。它基本上从流中恢复标记，并将它们写入GUI的文本小部件中。

       error_cb、eos_cb和state_changed_cb实际上不值得解释，因为它们的功能与前面所有教程中相同，但现在使用了自己的函数。

       就是这样！本教程中的代码量可能看起来令人生畏，但所需的概念很少而且简单。如果您遵循了前面的教程并对GTK有一点了解，那么您可能已经理解了这篇教程，现在您可以使用自己的媒体播放器了！

练习

       如果这个媒体播放器对您来说不够好，请尝试将显示关于流的信息的文本小部件更改为适当的列表视图(或树视图)。然后，当用户选择一个不同的流，使GStreamer切换流！要切换流，你需要阅读播放教程1：Playbin的用法。

结论

       本教程展示了：

  • 如何使用gst_video_overlay_set_window_handle()将视频输出到特定的窗口句柄。

  • 如何通过向g_timeout_add_seconds()注册一个超时回调来定期刷新GUI。

  • 如何通过gst_element_post_message()总线以应用程序消息的方式将信息传递给主线程。

  • 如何使用gst_bus_add_signal_watch()使总线发出信号，并使用信号细节区分所有消息类型，从而只通知感兴趣的消息。

       这允许您建立一个有点完整的媒体播放器与适当的图形用户界面。

       下面的基本教程继续关注其他单独的GStreamer主题

       很高兴你能来这里，期待很快能与你再见！

tangyzh
关注
GStreamer基础教程1：Hello World
ZONGXP的博客
03-04 2345
目标 没有比在屏幕上打印“ Hello World”更好的关于软件库的第一印象了！ 但是由于我们正在处理多媒体框架，所以我们将改为播放视频。 不要被下面的代码量吓到了：只有4行可以完成实际工作。剩下的就是清理代码，在C语言中，这总是有些冗长。 事不宜迟，为您的第一个GStreamer应用程序做准备... Hello World 将此代码复制到一个名为basic-tutorial-1.c...
GStreamer基础教程5：集成GUI工具
ZONGXP的博客
03-12 1295
目标 本教程展示了如何在GStreamer集成一个GUI（比如：GTK+）。最基本的原则是GStreamer处理多媒体的播放而GUI处理和用户的交互。在这个教程里面，我们可以学到： 如何告诉GStreamer输出视频到一个window 如何持续的刷新GUI 在GStreamer多线程时如何保持UI的更新 一个仅发送给你订阅的消息而不是所有消息的机制 介绍 我们下面就用GTK+这样一个G...
GStreamer——教程——基础教程5：GUI toolkit integration
FREEDOM_X的专栏
06-17 1021
在这里，我们使用gst_structure_new()创建一个新的结构，并将其命名为tags-changed，以避免在我们想要发送其他应用程序消息的情况下混淆。最后，到目前为止，我们已经注册了一个handle_message函数，每当总线上出现一条消息时就会调用它，这迫使我们解析每条消息以查看它是否对我们感兴趣。注意，在停止状态中，我们将管道设置为就绪状态。在将控制权转移给GTK+之前，我们使用g_timeout_add_seconds()再次注册回调，这次是带有超时的回调，所以它每秒被调用一次。
GStreamer开发笔记（一）：GStreamer介绍，在windows平台部署安装，打开usb摄像头对比测试
最新发布
weixin_40216260的博客
05-27 43
GStreamer是一个用于构建媒体处理组件图的库。它支持的应用范围从简单的Ogg/Vorbis播放、音频/视频流到复杂的音频（混合）和视频（非线性编辑）处理。应用程序可以透明地利用编解码器和滤波器技术的进步。开发人员可以通过编写一个具有干净、通用接口的简单插件来添加新的编解码器和过滤器。GStreamer是在LGPL下发布的。1.x系列是API和ABI稳定的，取代了以前稳定的0.10系列。两者都可以并行安装。
GStreamer——教程——基础教程3：Dynamic pipelines
FREEDOM_X的专栏
06-17 1268
正如您将要看到的，本教程中的管道在设置为播放状态之前尚未完全构建。这没关系。如果我们不采取进一步行动，数据将到达管道末端，管道将生成错误消息并停止。但我们将采取进一步行动.....在这个例子中我们将打开一个多路复用的文件，音频和视频被存储在同一个容器文件中。负责打开此类容器的element称为解复用器，容器格式的一些示例有Matroska（MKV）、Quick Time（QT、MOV）、Ogg或Advanced Systems Format（ASF、WMV、WMA）。
GStreamer基础教程01 - Hello World
weixin_30788731的博客
06-12 229
摘要 在面对一个新的软件库时，第一步通常实现一个“hello world”程序，来了解库的用法。对于GStreamer，我们可以实现一个极简的播放器，来了解GStreamer的使用。 环境配置 为了快速掌握Gstreamer相关的知识，我们优先选择Ubuntu作为我们的开发环境，其他平台的开发会在后续文章单独介绍。如果还没有Ubuntu虚拟机，可以在OSBoxes中直接下载U...
GSTREAMER入门教程
gzyuan86的博客
10-15 1821
简介 工具及环境 示例 编程接口 总结
Zynq图形界面开发教程：UG1144-PetaLinux工具的GUI支持全面解析
![Zynq图形界面开发教程：UG1144-PetaLinux工具的GUI支持全面解析]...本论文详细介绍了Zynq与PetaLinux的集成与应用，从环境搭建到图形用户界面(GUI)设计的基础知识和实践开发。首先，阐述了
gStreamer 官方教程资源大全
技术联盟
05-07 369
https://blog.csdn.net/quicmous/article/details/115748391 入门教程：Basic tutorials 这里列一个GStreamer入门课程清单，大家按需选择吧。 基础教程1：Hello world！—— 惯例性的 “Hello world” 程序 基本教程2：GStreamer概念 基础教程3：动态管道 基础教程4：时间管理 基础教程5: GUI工具包集成 基础教程6：媒体格式和Pad功能 基本教程7：多线程和Pad可用性 基础教程8：管道短路操作
Gstreamer应用开发手册1：关于Gstreamer
ZONGXP的博客
04-28 2364
在之前的Gstreamer基础教程中，介绍了gstreamer基础相关的知识，目的是起到入门的作用。接下来在应用开发手册系列教程中，将更多的从技术角度，介绍更多的概念和功能，起到更好的学习效果。 1 什么是gstreamer GStreamer 是一个创建流媒体应用程序的框架。其基本设计思想来自于俄勒冈(Oregon)研究生学院有关视频管道的创意, 同时也借鉴了 DirectShow 的设计思...
OMAP-L138入门指南：开发与应用实战
本指南是针对OMAP-L138芯片的软件开发入门教程，专为初次使用该平台的开发者设计。它详细地介绍了如何在OMAP-L138开发板上进行软件开发，并提供了丰富的示例和步骤来帮助读者快速上手。 1. **欢迎与概述**：章节一...
gstreamer教程
u011337602的博客
11-24 321
gstreamer plugin英文的教程可通过以下链接查看，后面我会按照这个教程尝试总结以下学习经验 https://gstreamer.freedesktop.org/documentation/plugin-development/index.html 关于插件的编写教程请查看 Plugin Write's Guide ...
GStreamer基础教程之GStreamer工具
m_wordPlan的博客
07-25 2010
目标 GStreamer自带了一些使用方便和完全必要的工具。本教程无代码，并且教我们如下内容： 如何在不适用C语言，使用命令行来构建并运行GStreamer管道。 如何找出GStreamer可用的元素及其相应元素的capabilities. 如何发现媒体文件的内部结构。 介绍 这些工具位于 GStreamer 二进制文件的 bin 目录中。所以，如果想执行这些工具，除了将此目录添加到系统环境变量($PATH)，否则只能在bin目录中命令行执行相关工具。 为了允许GStreamer多版本在同一个系
GStreamer基础教程01——Hello World
10-26 272
1、实现网络视频播放 #include &lt;gst/gst.h&gt; #include &lt;stdio.h&gt; int main(int argc, char *argv[]) { GstElement *pipeline; GstBus *bus; GstMessage *msg; /* Initialize GStreamer */ gst_init(&am...
GStreamer基础教程
chilv的专栏
01-16 758
1. gstreamer  tutorials网站： https://gstreamer.freedesktop.org/documentation/tutorials/basic/index.html github 地址： https://github.com/Kurento/gstreamer/ 网上翻译的相关文章： http://blog.csdn.net/saku
GStreamer——教程——基础教程12：Streaming
FREEDOM_X的专栏
06-18 1062
在流媒体播放时，媒体数据块解码后立即排队等待呈现。这意味着，如果某个数据块延迟（在互联网上非常常见的情况），则呈现队列可能会耗尽，导致媒体播放停滞。通用解决方案是构建一个“缓冲区”，即允许在开始播放之前将一定数量的媒体数据块排队。这样，虽然播放开始会稍有延迟，但如果某些数据块延迟，由于队列中有更多的数据块等待，播放不会受到影响。事实证明，这个解决方案已经在GStreamer中实现，但之前的教程并没有从中受益。
GStreamer基础教程10：GStreamer工具
ZONGXP的博客
03-12 1772
目标 GStreamer提供了一系列方便使用的工具。这篇教程里不牵涉任何代码，但还是会讲一些有用的内容： 如何在命令行下建立一个pipeline——完全不使用C 如何找出一个element的Capabilities 如何发现一个媒体文件的内部结构 介绍 这些工具就位于SDK的bin目录下。你需要把这个目录加入PATH变量，或者把当前目前切换到GStreamer SDK的bin目录。 打...
GStreamer——教程——基础教程10：GStreamer tools
FREEDOM_X的专栏
06-18 1566
这些工具位于GStreamer二进制文件的bin目录中。您需要转到此目录才能执行它们，因为它没有被添加到系统的PATH环境变量中（以避免过多地污染它）。只需打开终端（或控制台窗口），转到您的GStreamer安装的bin目录（再次阅读安装GStreamer部分以找出它在哪里）， 您可以开始输入本教程中给出的命令了。在Linux，您应该使用安装在您的 分发，工具应该安装一个名为gstreamer1在Fedora风格发行版上，或在Debian/Ubuntu风格。分布。
GStreamer——教程——基础教程1：Hello World
FREEDOM_X的专栏
06-14 1001
这个函数将解析一条文本形式表示的pipeline并将其转化成一条真实的pipeline，使用起来十分便利。事实上，这个功能是非常方便，有一个完全围绕它构建的工具，您将获得非常熟悉（请参阅。是一个特殊的 element，它具备一个pipeline的所有特点，既有source，又有sink。如果您输入了错误的URI，或者文件不存在，或者您缺少一个插件，GStreamer提供了几种通知机制，但我们在本例中唯一要做的就是在出错时退出，所以不要期望太多反馈。，它是我们要播放的媒体的URI。尝试将其更改为某些内容。
在Windows平台部署Gstreamer及其MP3/Audio播放器示例教程
安装包可能包括 Gstreamer 的核心库、基础插件以及一些开发工具和示例代码。 安装过程中，需注意环境变量的设置，以便在命令行中使用 Gstreamer 相关工具。例如，在系统变量中添加 Gstreamer 的 bin 目录到 PATH ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值