gstreamer/subprojects/gst-plugins-bad/tests/examples/uvch264/test-uvch264.c

677 lines
21 KiB
C

#include <gst/gst.h>
#include <gtk/gtk.h>
#include <gdk/gdkx.h>
#include <gst/video/video.h>
#define WINDOW_GLADE "window.glade"
#define INT_PROPERTY_GLADE "int_property.glade"
#define ENUM_PROPERTY_GLADE "enum_property.glade"
#define BOOL_PROPERTY_GLADE "boolean_property.glade"
#define PROPERTY_TO_VBOX \
properties[i].dynamic ? GTK_BOX (dynamic_vbox) : GTK_BOX (static_vbox)
#define GET_WIDGET(object, type, name) \
type (gtk_builder_get_object ((object)->builder, name))
#define GET_PROP_WIDGET(type, name) GET_WIDGET (&(properties[i]), type, name)
static guint h264_xid, preview_xid;
typedef struct
{
GtkBuilder *builder;
GstElement *src;
enum
{ NONE, INT, ENUM, BOOL } type;
const gchar *property_name;
gboolean readonly;
gboolean dynamic;
} Prop;
typedef struct
{
GtkBuilder *builder;
GstElement *bin;
GstElement *src;
GstElement *identity;
GstElement *vid_capsfilter;
GstElement *vf_capsfilter;
} Main;
Prop properties[] = {
{NULL, NULL, INT, "initial-bitrate", FALSE, FALSE},
{NULL, NULL, INT, "slice-units", FALSE, FALSE},
{NULL, NULL, ENUM, "slice-mode", FALSE, FALSE},
{NULL, NULL, INT, "iframe-period", FALSE, FALSE},
{NULL, NULL, ENUM, "usage-type", FALSE, FALSE},
{NULL, NULL, ENUM, "entropy", FALSE, FALSE},
{NULL, NULL, BOOL, "enable-sei", FALSE, FALSE},
{NULL, NULL, INT, "num-reorder-frames", FALSE, FALSE},
{NULL, NULL, BOOL, "preview-flipped", FALSE, FALSE},
{NULL, NULL, INT, "leaky-bucket-size", FALSE, FALSE},
{NULL, NULL, INT, "num-clock-samples", FALSE, TRUE},
{NULL, NULL, ENUM, "rate-control", FALSE, TRUE},
{NULL, NULL, BOOL, "fixed-framerate", FALSE, TRUE},
{NULL, NULL, INT, "max-mbps", TRUE, TRUE},
{NULL, NULL, INT, "level-idc", FALSE, TRUE},
{NULL, NULL, INT, "peak-bitrate", FALSE, TRUE},
{NULL, NULL, INT, "average-bitrate", FALSE, TRUE},
{NULL, NULL, INT, "min-iframe-qp", FALSE, TRUE},
{NULL, NULL, INT, "max-iframe-qp", FALSE, TRUE},
{NULL, NULL, INT, "min-pframe-qp", FALSE, TRUE},
{NULL, NULL, INT, "max-pframe-qp", FALSE, TRUE},
{NULL, NULL, INT, "min-bframe-qp", FALSE, TRUE},
{NULL, NULL, INT, "max-bframe-qp", FALSE, TRUE},
{NULL, NULL, INT, "ltr-buffer-size", FALSE, TRUE},
{NULL, NULL, INT, "ltr-encoder-control", FALSE, TRUE},
};
static void set_drop_probability (Main * self);
static void get_all_properties (void);
static void probe_all_properties (gboolean playing);
/* Callbacks */
void on_button_toggled (GtkToggleButton * button, gpointer user_data);
void on_get_button_clicked (GtkButton * button, gpointer user_data);
void on_set_button_clicked (GtkButton * button, gpointer user_data);
void on_button_ready_clicked (GtkButton * button, gpointer user_data);
void on_button_null_clicked (GtkButton * button, gpointer user_data);
void on_button_playing_clicked (GtkButton * button, gpointer user_data);
void on_iframe_button_clicked (GtkButton * button, gpointer user_data);
void on_renegotiate_button_clicked (GtkButton * button, gpointer user_data);
void on_start_capture_button_clicked (GtkButton * button, gpointer user_data);
void on_stop_capture_button_clicked (GtkButton * button, gpointer user_data);
void on_window_destroyed (GtkWindow * window, gpointer user_data);
static GstEvent *
new_upstream_force_key_unit (GstClockTime running_time,
gboolean all_headers, guint count)
{
GstEvent *force_key_unit_event;
GstStructure *s;
s = gst_structure_new ("GstForceKeyUnit",
"running-time", GST_TYPE_CLOCK_TIME, running_time,
"all-headers", G_TYPE_BOOLEAN, all_headers,
"count", G_TYPE_UINT, count, NULL);
force_key_unit_event = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM, s);
return force_key_unit_event;
}
void
on_get_button_clicked (GtkButton * button, gpointer user_data)
{
Prop *property = user_data;
switch (property->type) {
case INT:
{
gchar *val;
gint val_int;
g_object_get (property->src, property->property_name, &val_int, NULL);
val = g_strdup_printf ("%d", val_int);
gtk_entry_set_text (GET_WIDGET (property, GTK_ENTRY, "value"), val);
g_free (val);
}
break;
case ENUM:
{
GParamSpec *param;
gint val;
g_object_get (property->src, property->property_name, &val, NULL);
param = g_object_class_find_property (G_OBJECT_GET_CLASS (property->src),
property->property_name);
if (G_IS_PARAM_SPEC_ENUM (param)) {
GEnumValue *values;
guint i = 0;
values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
while (values[i].value_name) {
if (values[i].value == val) {
gtk_combo_box_set_active (GET_WIDGET (property,
(GtkComboBox *), "value"), i);
break;
}
i++;
}
}
}
break;
case BOOL:
{
gboolean val;
g_object_get (property->src, property->property_name, &val, NULL);
gtk_toggle_button_set_active (GET_WIDGET (property,
(GtkToggleButton *), "value"), val);
}
break;
case NONE:
default:
break;
}
}
void
on_set_button_clicked (GtkButton * button, gpointer user_data)
{
Prop *property = user_data;
switch (property->type) {
case INT:
{
int val_int;
const gchar *val;
val = gtk_entry_get_text (GET_WIDGET (property, GTK_ENTRY, "value"));
val_int = (int) g_ascii_strtoll (val, NULL, 0);
g_object_set (property->src, property->property_name, val_int, NULL);
}
break;
case ENUM:
{
GParamSpec *param;
param = g_object_class_find_property (G_OBJECT_GET_CLASS (property->src),
property->property_name);
if (G_IS_PARAM_SPEC_ENUM (param)) {
GEnumValue *values;
guint val = 0;
values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
val = gtk_combo_box_get_active (GET_WIDGET (property,
(GtkComboBox *), "value"));
g_object_set (property->src, property->property_name,
values[val].value, NULL);
}
}
break;
case BOOL:
{
gboolean val;
val = gtk_toggle_button_get_active (GET_WIDGET (property,
(GtkToggleButton *), "value"));
g_object_set (property->src, property->property_name, val, NULL);
}
break;
case NONE:
default:
break;
}
get_all_properties ();
}
void
on_button_toggled (GtkToggleButton * button, gpointer user_data)
{
if (gtk_toggle_button_get_active (button))
gtk_button_set_label (GTK_BUTTON (button), " Enabled ");
else
gtk_button_set_label (GTK_BUTTON (button), " Disabled ");
}
static gboolean
set_caps (Main * self, gboolean send_event)
{
const gchar *h264_filter;
const gchar *raw_filter;
GstCaps *h264_caps = NULL;
GstCaps *raw_caps = NULL;
gboolean ret = TRUE;
h264_filter = gtk_entry_get_text (GET_WIDGET (self, GTK_ENTRY, "h264_caps"));
raw_filter =
gtk_entry_get_text (GET_WIDGET (self, GTK_ENTRY, "preview_caps"));
if (h264_filter)
h264_caps = gst_caps_from_string (h264_filter);
if (raw_filter)
raw_caps = gst_caps_from_string (raw_filter);
g_debug ("H264 caps : %s", gst_caps_to_string (h264_caps));
g_debug ("Preview caps : %s", gst_caps_to_string (raw_caps));
if (!h264_caps || !raw_caps) {
g_debug ("Invalid caps");
ret = FALSE;
goto end;
}
g_object_set (self->vid_capsfilter, "caps", h264_caps, NULL);
g_object_set (self->vf_capsfilter, "caps", raw_caps, NULL);
if (send_event) {
gst_element_send_event (GST_ELEMENT (self->src),
gst_event_new_reconfigure ());
}
end:
if (h264_caps)
gst_caps_unref (h264_caps);
if (raw_caps)
gst_caps_unref (raw_caps);
return ret;
}
void
on_button_ready_clicked (GtkButton * button, gpointer user_data)
{
Main *self = user_data;
set_caps (self, FALSE);
gst_element_set_state (self->bin, GST_STATE_READY);
probe_all_properties (FALSE);
get_all_properties ();
}
void
on_button_null_clicked (GtkButton * button, gpointer user_data)
{
Main *self = user_data;
gst_element_set_state (self->bin, GST_STATE_NULL);
probe_all_properties (FALSE);
get_all_properties ();
}
void
on_button_playing_clicked (GtkButton * button, gpointer user_data)
{
Main *self = user_data;
if (gst_element_set_state (self->bin, GST_STATE_PLAYING) ==
GST_STATE_CHANGE_FAILURE) {
g_debug ("Unable to go to state PLAYING");
}
set_caps (self, FALSE);
probe_all_properties (TRUE);
get_all_properties ();
set_drop_probability (self);
}
void
on_iframe_button_clicked (GtkButton * button, gpointer user_data)
{
Main *self = user_data;
GstEvent *event;
gboolean pps_sps;
set_drop_probability (self);
pps_sps = gtk_toggle_button_get_active (GET_WIDGET (self, (GtkToggleButton *),
"pps_sps"));
event = new_upstream_force_key_unit (GST_CLOCK_TIME_NONE, pps_sps, 0);
gst_element_send_event (GST_ELEMENT (self->src), event);
}
void
on_renegotiate_button_clicked (GtkButton * button, gpointer user_data)
{
Main *self = user_data;
set_caps (self, TRUE);
probe_all_properties (GST_STATE (self->bin) >= GST_STATE_PAUSED);
get_all_properties ();
}
void
on_start_capture_button_clicked (GtkButton * button, gpointer user_data)
{
Main *self = user_data;
set_caps (self, FALSE);
g_signal_emit_by_name (G_OBJECT (self->src), "start-capture", NULL);
probe_all_properties (GST_STATE (self->bin) >= GST_STATE_PAUSED);
get_all_properties ();
}
void
on_stop_capture_button_clicked (GtkButton * button, gpointer user_data)
{
Main *self = user_data;
set_caps (self, FALSE);
g_signal_emit_by_name (G_OBJECT (self->src), "stop-capture", NULL);
probe_all_properties (GST_STATE (self->bin) >= GST_STATE_PAUSED);
get_all_properties ();
}
void
on_window_destroyed (GtkWindow * window, gpointer user_data)
{
gtk_main_quit ();
}
static gboolean
_bus_callback (GstBus * bus, GstMessage * message, gpointer user_data)
{
const GstStructure *s = gst_message_get_structure (message);
GstObject *source = NULL;
if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT &&
gst_structure_has_name (s, "prepare-window-handle")) {
source = GST_MESSAGE_SRC (message);
if (!g_strcmp0 (gst_object_get_name (source), "h264_sink"))
gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (source),
h264_xid);
else
gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (source),
preview_xid);
}
return TRUE;
}
static void
set_drop_probability (Main * self)
{
const gchar *drop;
gdouble drop_probability = 0.0;
drop = gtk_entry_get_text (GET_WIDGET (self, GTK_ENTRY, "drop"));
drop_probability = g_ascii_strtod (drop, NULL);
g_debug ("Setting drop probability to : %f", drop_probability);
g_object_set (self->identity, "drop-probability", drop_probability, NULL);
}
static void
get_all_properties (void)
{
int i;
for (i = 0; i < G_N_ELEMENTS (properties); i++)
on_get_button_clicked (NULL, &properties[i]);
}
static void
probe_all_properties (gboolean playing)
{
int i;
for (i = 0; i < G_N_ELEMENTS (properties); i++) {
gboolean return_value, changeable, default_bool;
guint mask, minimum, maximum, default_int;
GParamSpec *param;
/* When playing, ignore static controls */
if (playing && !properties[i].dynamic)
continue;
switch (properties[i].type) {
case INT:
g_signal_emit_by_name (G_OBJECT (properties[i].src), "get-int-setting",
properties[i].property_name, &minimum, &default_int, &maximum,
&return_value, NULL);
if (return_value) {
gchar *min, *def, *max;
min = g_strdup_printf ("%d", minimum);
def = g_strdup_printf ("%d", default_int);
max = g_strdup_printf ("%d", maximum);
gtk_entry_set_text (GET_PROP_WIDGET (GTK_ENTRY, "minimum"), min);
gtk_entry_set_text (GET_PROP_WIDGET (GTK_ENTRY, "default"), def);
gtk_entry_set_text (GET_PROP_WIDGET (GTK_ENTRY, "maximum"), max);
g_free (min);
g_free (def);
g_free (max);
} else {
gtk_entry_set_text (GET_PROP_WIDGET (GTK_ENTRY, "minimum"), "");
gtk_entry_set_text (GET_PROP_WIDGET (GTK_ENTRY, "default"), "");
gtk_entry_set_text (GET_PROP_WIDGET (GTK_ENTRY, "maximum"), "");
}
break;
case ENUM:
g_signal_emit_by_name (G_OBJECT (properties[i].src), "get-enum-setting",
properties[i].property_name, &mask, &default_int, &return_value,
NULL);
param =
g_object_class_find_property (G_OBJECT_GET_CLASS (properties
[i].src), properties[i].property_name);
if (G_IS_PARAM_SPEC_ENUM (param)) {
GEnumValue *values;
guint j = 0;
values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
if (return_value) {
while (values[j].value_name) {
if (values[j].value == default_int) {
gtk_entry_set_text (GET_PROP_WIDGET (GTK_ENTRY, "default"),
values[j].value_name);
break;
}
j++;
}
} else {
gtk_entry_set_text (GET_PROP_WIDGET (GTK_ENTRY, "default"), "");
}
j = 0;
while (values[j].value_name) {
#if !GTK_CHECK_VERSION (2, 24, 0)
gtk_combo_box_remove_text (GET_PROP_WIDGET ((GtkComboBox *),
"value"), 0);
#else
gtk_combo_box_text_remove (GET_PROP_WIDGET ((GtkComboBoxText *),
"value"), 0);
#endif
j++;
}
j = 0;
while (values[j].value_name) {
gchar *val;
if (return_value && (mask & (1 << values[j].value)) != 0)
val = g_strdup_printf ("**%s**", values[j].value_name);
else
val = g_strdup (values[j].value_name);
#if !GTK_CHECK_VERSION (2, 24, 0)
gtk_combo_box_append_text (GET_PROP_WIDGET ((GtkComboBox *),
"value"), val);
#else
gtk_combo_box_text_append_text (GET_PROP_WIDGET ((GtkComboBoxText
*), "value"), val);
#endif
g_free (val);
j++;
}
}
break;
case BOOL:
g_signal_emit_by_name (G_OBJECT (properties[i].src),
"get-boolean-setting", properties[i].property_name,
&changeable, &default_bool, &return_value, NULL);
if (return_value) {
gtk_widget_set_sensitive (GET_PROP_WIDGET (GTK_WIDGET, "value"),
changeable);
gtk_widget_set_sensitive (GET_PROP_WIDGET (GTK_WIDGET, "get"),
changeable);
gtk_widget_set_sensitive (GET_PROP_WIDGET (GTK_WIDGET, "set"),
changeable);
gtk_toggle_button_set_active (GET_PROP_WIDGET ((GtkToggleButton *),
"default"), default_bool);
}
break;
case NONE:
default:
break;
}
}
}
int
main (int argc, char *argv[])
{
Main self = { NULL, NULL, NULL, NULL };
GstBus *bus = NULL;
GtkWidget *window, *static_vbox, *dynamic_vbox, *da;
gchar *drop;
gdouble drop_probability;
GdkWindow *gdk_win = NULL;
const char *device = "/dev/video0";
GError *error = NULL;
int i;
/* FIXME: add support for Gdk Wayland backend, code currently assumes X11 */
if (g_getenv ("GDK_BACKEND") == NULL)
g_setenv ("GDK_BACKEND", "x11", TRUE);
gtk_init (&argc, &argv);
gst_init (&argc, &argv);
if (argc > 1)
device = argv[1];
else
g_print ("Usage : %s [device]\nUsing default device : %s\n",
argv[0], device);
self.bin = gst_parse_launch ("uvch264src name=src src.vidsrc ! queue ! "
"capsfilter name=vid_cf ! identity name=identity ! decodebin ! "
"xvimagesink name=h264_sink async=false "
"src.vfsrc ! queue ! capsfilter name=vf_cf ! "
"xvimagesink name=preview_sink async=false", NULL);
if (!self.bin)
return -1;
/* Listen to the bus for messages */
bus = gst_element_get_bus (self.bin);
gst_bus_add_watch (bus, _bus_callback, self.bin);
gst_object_unref (bus);
self.src = gst_bin_get_by_name (GST_BIN (self.bin), "src");
self.identity = gst_bin_get_by_name (GST_BIN (self.bin), "identity");
self.vid_capsfilter = gst_bin_get_by_name (GST_BIN (self.bin), "vid_cf");
self.vf_capsfilter = gst_bin_get_by_name (GST_BIN (self.bin), "vf_cf");
self.builder = gtk_builder_new ();
gtk_builder_add_from_file (self.builder, WINDOW_GLADE, &error);
if (error) {
g_debug ("Unable to load glade file : %s", error->message);
goto end;
}
gtk_builder_connect_signals (self.builder, &self);
g_object_get (self.identity, "drop-probability", &drop_probability, NULL);
drop = g_strdup_printf ("%f", drop_probability);
gtk_entry_set_text (GET_WIDGET (&self, GTK_ENTRY, "drop"), drop);
g_free (drop);
window = GET_WIDGET (&self, GTK_WIDGET, "window");
static_vbox = GET_WIDGET (&self, GTK_WIDGET, "static");
dynamic_vbox = GET_WIDGET (&self, GTK_WIDGET, "dynamic");
da = GET_WIDGET (&self, GTK_WIDGET, "h264");
gtk_widget_realize (da);
gdk_win = gtk_widget_get_window (da);
h264_xid = GDK_WINDOW_XID (gdk_win);
da = GET_WIDGET (&self, GTK_WIDGET, "preview");
gtk_widget_realize (da);
gdk_win = gtk_widget_get_window (da);
preview_xid = GDK_WINDOW_XID (gdk_win);
set_caps (&self, FALSE);
g_object_set (self.src, "device", device, NULL);
if (gst_element_set_state (self.bin, GST_STATE_READY) ==
GST_STATE_CHANGE_FAILURE) {
g_debug ("Unable to go to state READY");
goto end;
}
for (i = 0; i < G_N_ELEMENTS (properties); i++) {
switch (properties[i].type) {
case INT:
properties[i].src = self.src;
properties[i].builder = gtk_builder_new ();
gtk_builder_add_from_file (properties[i].builder, INT_PROPERTY_GLADE,
NULL);
gtk_builder_connect_signals (properties[i].builder, &properties[i]);
gtk_box_pack_start (PROPERTY_TO_VBOX,
GET_PROP_WIDGET (GTK_WIDGET, "int-property"), TRUE, TRUE, 2);
gtk_label_set_label (GET_PROP_WIDGET (GTK_LABEL, "label"),
properties[i].property_name);
if (properties[i].readonly)
gtk_widget_set_sensitive (GET_PROP_WIDGET (GTK_WIDGET, "set"), FALSE);
break;
case ENUM:
properties[i].src = self.src;
properties[i].builder = gtk_builder_new ();
#if !GTK_CHECK_VERSION (2, 24, 0)
gtk_builder_add_from_file (properties[i].builder,
"enum_property_gtk2.glade", NULL);
#else
gtk_builder_add_from_file (properties[i].builder, ENUM_PROPERTY_GLADE,
NULL);
#endif
gtk_builder_connect_signals (properties[i].builder, &properties[i]);
gtk_box_pack_start (PROPERTY_TO_VBOX,
GET_PROP_WIDGET (GTK_WIDGET, "enum-property"), TRUE, TRUE, 2);
gtk_label_set_label (GET_PROP_WIDGET (GTK_LABEL, "label"),
properties[i].property_name);
#if !GTK_CHECK_VERSION (2, 24, 0)
{
GtkComboBox *combo_box;
GtkCellRenderer *cell;
GtkListStore *store;
combo_box = GET_PROP_WIDGET ((GtkComboBox *), "value");
store = gtk_list_store_new (1, G_TYPE_STRING);
gtk_combo_box_set_model (combo_box, GTK_TREE_MODEL (store));
g_object_unref (store);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
"text", 0, NULL);
}
#endif
if (properties[i].readonly)
gtk_widget_set_sensitive (GET_PROP_WIDGET (GTK_WIDGET, "set"), FALSE);
break;
case BOOL:
properties[i].src = self.src;
properties[i].builder = gtk_builder_new ();
gtk_builder_add_from_file (properties[i].builder, BOOL_PROPERTY_GLADE,
NULL);
gtk_builder_connect_signals (properties[i].builder, &properties[i]);
gtk_box_pack_start (PROPERTY_TO_VBOX,
GET_PROP_WIDGET (GTK_WIDGET, "boolean-property"), TRUE, TRUE, 2);
gtk_label_set_label (GET_PROP_WIDGET (GTK_LABEL, "label"),
properties[i].property_name);
if (properties[i].readonly)
gtk_widget_set_sensitive (GET_PROP_WIDGET (GTK_WIDGET, "set"), FALSE);
break;
case NONE:
default:
break;
}
}
probe_all_properties (FALSE);
get_all_properties ();
gtk_widget_show (window);
gtk_main ();
end:
g_object_unref (G_OBJECT (self.builder));
for (i = 0; i < G_N_ELEMENTS (properties); i++) {
if (properties[i].builder)
g_object_unref (G_OBJECT (properties[i].builder));
}
gst_element_set_state (self.bin, GST_STATE_NULL);
gst_object_unref (self.src);
gst_object_unref (self.identity);
gst_object_unref (self.vid_capsfilter);
gst_object_unref (self.vf_capsfilter);
gst_object_unref (self.bin);
return 0;
}