static gboolean
parse_options (int *argc, char *argv[])
{
GOptionContext *ctx;
gboolean success;
GError *error = NULL;
ctx = g_option_context_new (" - encoder test options");
if (!ctx)
return FALSE;
g_option_context_add_group (ctx, gst_init_get_option_group ());
g_option_context_add_main_entries (ctx, g_options, NULL);
g_option_context_set_help_enabled (ctx, TRUE);
success = g_option_context_parse (ctx, argc, &argv, &error);
if (!success) {
g_printerr ("Option parsing failed: %s\n", error->message);
g_error_free (error);
goto bail;
}
if (!g_codec_str)
g_codec_str = g_strdup ("h264");
if (!g_output_file_name)
g_output_file_name = generate_output_filename (g_codec_str);
bail:
g_option_context_free (ctx);
return success;
}
int main (int argc, char **argv)
{
GOptionGroup *options;
GOptionContext *context;
GError *error = NULL;
GMainLoop *loop;
GstElement *play;
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
g_set_application_name (_("Audio Preview"));
g_setenv("PULSE_PROP_application.icon_name", "totem", TRUE);
g_setenv("PULSE_PROP_media.role", "music", TRUE);
context = g_option_context_new ("Plays audio passed on the standard input or the filename passed on the command-line");
options = gst_init_get_option_group ();
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, options);
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {
g_print ("couldn't parse command-line options: %s\n", error->message);
g_error_free (error);
return 1;
}
if (g_fatal_warnings) {
GLogLevelFlags fatal_mask;
fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
g_log_set_always_fatal (fatal_mask);
}
if (show_mimetype == TRUE) {
print_mimetypes ();
return 0;
}
if (filenames != NULL && g_strv_length (filenames) != 1) {
char *help;
help = g_option_context_get_help (context, FALSE, NULL);
g_print ("%s", help);
g_free (help);
return 1;
}
play = gst_element_factory_make ("playbin", "play");
setup_play (play);
setup_filename (play);
setup_errors (play);
totem_resources_monitor_start (NULL, -1);
gst_element_set_state (play, GST_STATE_PLAYING);
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
return 0;
}
int
main (int argc,
char *argv[])
{
gboolean silent = FALSE;
gchar *savefile = NULL;
GOptionContext *ctx;
GError *err = NULL;
GOptionEntry entries[] = {
{ "silent", 's', 0, G_OPTION_ARG_NONE, &silent,
"do not output status information", NULL },
{ "output", 'o', 0, G_OPTION_ARG_STRING, &savefile,
"save xml representation of pipeline to FILE and exit", "FILE" },
{ NULL }
};
ctx = g_option_context_new ("- Your application");
g_option_context_add_main_entries (ctx, entries, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Failed to initialize: %s\n", err->message);
g_error_free (err);
return 1;
}
printf ("Run me with --help to see the Application options appended.\n");
return 0;
}
int
main (int argc, char **argv)
{
static const GOptionEntry test_goptions[] = {
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL},
{NULL, '\0', 0, 0, NULL, NULL, NULL}
};
GOptionContext *ctx;
GError *opt_err = NULL;
gtk_init (&argc, &argv);
/* command line option parsing */
ctx = g_option_context_new (" VIDEOFILE");
g_option_context_add_group (ctx, gst_init_get_option_group ());
g_option_context_add_main_entries (ctx, test_goptions, NULL);
if (!g_option_context_parse (ctx, &argc, &argv, &opt_err)) {
g_error ("Error parsing command line options: %s", opt_err->message);
return -1;
}
if (filenames == NULL || filenames[0] == NULL || filenames[0][0] == '\0') {
g_printerr ("Please specify a path to a video file\n\n");
return -1;
}
run_gui (filenames[0]);
g_free (filenames);
g_option_context_free (ctx);
return 0;
}
static GOptionContext *
gth_application_create_option_context (void)
{
GOptionContext *context;
static gsize initialized = FALSE;
context = g_option_context_new (N_("— Image browser and viewer"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
if (g_once_init_enter (&initialized)) {
g_option_context_add_group (context, gtk_get_option_group (TRUE));
#ifdef HAVE_CLUTTER
g_option_context_add_group (context, clutter_get_option_group_without_init ());
g_option_context_add_group (context, gtk_clutter_get_option_group ());
#endif
#ifdef HAVE_GSTREAMER
g_option_context_add_group (context, gst_init_get_option_group ());
#endif
g_once_init_leave (&initialized, TRUE);
}
return context;
}
gboolean
video_output_init (int *argc, char *argv[], GOptionEntry * options)
{
GOptionContext *ctx;
gboolean success;
#if !GLIB_CHECK_VERSION(2,31,0)
if (!g_thread_supported ())
g_thread_init (NULL);
#endif
ctx = g_option_context_new ("- test options");
if (!ctx)
return FALSE;
g_option_context_add_group (ctx, gst_init_get_option_group ());
g_option_context_add_main_entries (ctx, g_options, NULL);
if (options)
g_option_context_add_main_entries (ctx, options, NULL);
success = g_option_context_parse (ctx, argc, &argv, NULL);
g_option_context_free (ctx);
if (g_list_outputs) {
list_outputs ();
exit (0);
}
return success;
}
/**
* games_sound_add_option_group:
* @context: a #GOptionContext
*
* Adds the GStreamer option group to @context.
*/
void
games_sound_add_option_group (GOptionContext *context)
{
#ifdef HAVE_GSTREAMER
g_option_context_add_group (context, gst_init_get_option_group ());
#endif /* HAVE_GSTREAMER */
}
int
main (int argc, char *argv[])
{
GMainLoop *loop;
GstRTSPServer *server;
GstRTSPMountPoints *mounts;
GstRTSPMediaFactory *factory;
GOptionContext *optctx;
GError *error = NULL;
optctx = g_option_context_new ("<launch line> - Test RTSP Server, Launch\n\n"
"Example: \"( decodebin name=depay0 ! autovideosink )\"");
g_option_context_add_main_entries (optctx, entries, NULL);
g_option_context_add_group (optctx, gst_init_get_option_group ());
if (!g_option_context_parse (optctx, &argc, &argv, &error)) {
g_printerr ("Error parsing options: %s\n", error->message);
return -1;
}
if (argc < 2) {
g_print ("%s\n", g_option_context_get_help (optctx, TRUE, NULL));
return 1;
}
g_option_context_free (optctx);
loop = g_main_loop_new (NULL, FALSE);
/* create a server instance */
server = gst_rtsp_server_new ();
/* get the mount points for this server, every server has a default object
* that be used to map uri mount points to media factories */
mounts = gst_rtsp_server_get_mount_points (server);
/* make a media factory for a test stream. The default media factory can use
* gst-launch syntax to create pipelines.
* any launch line works as long as it contains elements named depay%d. Each
* element with depay%d names will be a stream */
factory = gst_rtsp_media_factory_new ();
gst_rtsp_media_factory_set_transport_mode (factory,
GST_RTSP_TRANSPORT_MODE_RECORD);
gst_rtsp_media_factory_set_launch (factory, argv[1]);
gst_rtsp_media_factory_set_latency (factory, 2000);
/* attach the test factory to the /test url */
gst_rtsp_mount_points_add_factory (mounts, "/test", factory);
/* don't need the ref to the mapper anymore */
g_object_unref (mounts);
/* attach the server to the default maincontext */
gst_rtsp_server_attach (server, NULL);
/* start serving */
g_print ("stream ready at rtsp://127.0.0.1:%s/test\n", port);
g_main_loop_run (loop);
return 0;
}
int
main (int argc, char *argv[])
{
GstElementFactory *factory;
GOptionEntry options[] = {
GST_TOOLS_GOPTION_VERSION,
{NULL}
};
GOptionContext *ctx;
GError *err = NULL;
setlocale (LC_ALL, "");
#if !GLIB_CHECK_VERSION (2, 31, 0)
g_thread_init (NULL);
#endif
gst_tools_set_prgname ("gst-xmlinspect");
ctx = g_option_context_new ("[ELEMENT-NAME]");
g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
g_option_context_free (ctx);
gst_tools_print_version ("gst-xmlinspect");
/* if no arguments, print out all elements */
if (argc == 1) {
GList *features, *f;
features = gst_registry_get_feature_list (gst_registry_get_default (),
GST_TYPE_ELEMENT_FACTORY);
PUT_STRING (0, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
for (f = features; f != NULL; f = f->next)
print_element_info (GST_ELEMENT_FACTORY (f->data));
gst_plugin_feature_list_free (features);
return 0;
}
/* else we try to get a factory */
factory = gst_element_factory_find (argv[1]);
/* if there's a factory, print out the info */
if (factory) {
PUT_STRING (0, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
return print_element_info (factory);
}
/* otherwise, error out */
g_printerr ("no such element '%s'\n", argv[1]);
return -1;
}
int
main (int argc, char **argv)
{
GError *err = NULL;
GOptionContext *ctx;
GESPipeline *pipeline;
GMainLoop *mainloop;
gdouble duration = DEFAULT_DURATION;
char *path = NULL, *text;
guint64 color;
gdouble xpos = DEFAULT_POS, ypos = DEFAULT_POS;
GOptionEntry options[] = {
{"duration", 'd', 0, G_OPTION_ARG_DOUBLE, &duration,
"duration of segment", "seconds"},
{"path", 'p', 0, G_OPTION_ARG_STRING, &path,
"path to file", "path"},
{"text", 't', 0, G_OPTION_ARG_STRING, &text,
"text to render", "text"},
{"color", 'c', 0, G_OPTION_ARG_INT64, &color,
"color of the text", "color"},
{"xpos", 'x', 0, G_OPTION_ARG_DOUBLE, &xpos,
"horizontal position of the text", "color"},
{"ypos", 'y', 0, G_OPTION_ARG_DOUBLE, &ypos,
"vertical position of the text", "color"},
{NULL}
};
ctx = g_option_context_new ("- file segment playback with text overlay");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing %s\n", err->message);
exit (1);
}
if (argc > 1) {
g_print ("%s", g_option_context_get_help (ctx, TRUE, NULL));
exit (0);
}
g_option_context_free (ctx);
ges_init ();
if (path == NULL)
g_error ("Must specify --path=/path/to/media/file option\n");
pipeline = make_timeline (path, duration, text, color, xpos, ypos);
mainloop = g_main_loop_new (NULL, FALSE);
g_timeout_add_seconds ((duration) + 1, (GSourceFunc) g_main_loop_quit,
mainloop);
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
g_main_loop_run (mainloop);
return 0;
}
int main (int argc, char *argv[])
{
SourceAppData data;
data.port = 7236;
GOptionEntry main_entries[] =
{
{ "rtsp_port", 0, 0, G_OPTION_ARG_INT, &(data.port), "Specify optional RTSP port number, 7236 by default", "rtsp_port"},
{ NULL }
};
GOptionContext* context = g_option_context_new ("- WFD desktop source demo application\n");
g_option_context_add_main_entries (context, main_entries, NULL);
g_option_context_add_group (context, gst_init_get_option_group ());
GError* error = NULL;
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_print ("option parsing failed: %s\n", error->message);
g_option_context_free(context);
exit (1);
}
g_option_context_free(context);
GMainLoop *main_loop = g_main_loop_new(NULL, TRUE);
g_unix_signal_add(SIGINT, _sig_handler, main_loop);
g_unix_signal_add(SIGTERM, _sig_handler, main_loop);
GIOChannel* io_channel = g_io_channel_unix_new (STDIN_FILENO);
g_io_add_watch(io_channel, G_IO_IN, _user_input_handler, &data);
g_io_channel_unref(io_channel);
// Create a information element for a simple WFD Source
// FIXME: is this correct? maybe we're supposed to actively scan for
// WFD sinks instead
P2P::InformationElement ie;
auto sub_element = P2P::new_subelement(P2P::DEVICE_INFORMATION);
auto dev_info = (P2P::DeviceInformationSubelement*)sub_element;
dev_info->session_management_control_port = htons(data.port);
dev_info->maximum_throughput = htons(50);
dev_info->field1.device_type = P2P::SOURCE;
dev_info->field1.session_availability = true;
ie.add_subelement (sub_element);
std::cout << "Registering Wifi Source on port with IE " << ie.to_string() << std::endl;
// register the P2P service with connman
auto array = ie.serialize ();
data.connman.reset(new ConnmanClient (array));
if (create_source(&data))
g_main_loop_run (main_loop);
g_main_loop_unref (main_loop);
return 0;
}
int
main (int argc, gchar ** argv)
{
GError *err = NULL;
GOptionEntry options[] = {
{NULL}
};
GOptionContext *ctx;
GMainLoop *mainloop;
GstBus *bus;
ctx = g_option_context_new ("tests thumbnail supoprt (produces no output)");
g_option_context_set_summary (ctx, "");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
g_option_context_free (ctx);
exit (1);
}
g_option_context_free (ctx);
/* Initialize the GStreamer Editing Services */
ges_init ();
/* Create the pipeline */
pipeline = create_timeline ();
if (!pipeline)
exit (-1);
ges_pipeline_set_mode (pipeline, TIMELINE_MODE_PREVIEW);
/* Play the pipeline */
mainloop = g_main_loop_new (NULL, FALSE);
g_print ("thumbnailing every 1 seconds\n");
g_timeout_add (1000, thumbnail_cb, pipeline);
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_message_cb), mainloop);
if (gst_element_set_state (GST_ELEMENT (pipeline),
GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
g_print ("Failed to start the encoding\n");
return 1;
}
g_main_loop_run (mainloop);
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_NULL);
gst_object_unref (pipeline);
return 0;
}
int
main (int argc, char *argv[])
{
GError *err = NULL;
gint cpu_usage = 100;
GstTranscoder *transcoder;
gchar *src_uri, *dest_uri;
GOptionContext *ctx;
GOptionEntry options[] = {
{"cpu-usage", 'c', 0, G_OPTION_ARG_INT, &cpu_usage,
"The CPU usage to target in the transcoding process", NULL},
{NULL}
};
g_set_prgname ("gst-play");
ctx = g_option_context_new ("<source uri> <destination uri> "
"<encoding target name>[/<encoding profile name>]");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
g_clear_error (&err);
g_option_context_free (ctx);
return 1;
}
if (argc != 4) {
g_print ("%s", g_option_context_get_help (ctx, TRUE, NULL));
g_option_context_free (ctx);
return -1;
}
g_option_context_free (ctx);
src_uri = ensure_uri (argv[1]);
dest_uri = ensure_uri (argv[2]);
transcoder = gst_transcoder_new (src_uri, dest_uri, argv[3]);
gst_transcoder_set_cpu_usage (transcoder, cpu_usage);
g_signal_connect (transcoder, "position-updated",
G_CALLBACK (position_updated_cb), NULL);
g_assert (transcoder);
gst_transcoder_run (transcoder, &err);
if (err)
GST_ERROR ("Badam %s", err->message);
return 0;
}
int
main (int argc, char **argv)
{
GError *err = NULL;
GList *profiles = NULL;
GUPnPDLNADiscoverer *discover;
GOptionEntry options[] = {
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
"Print (very) verbose output", NULL},
{"relaxed", 'r', 0, G_OPTION_ARG_NONE, &relaxed,
"Read profiles in relaxed mode (only useful with -v)", NULL},
{NULL}
};
GOptionContext *ctx;
if (!g_thread_supported ())
g_thread_init(NULL);
ctx = g_option_context_new (" - program to list all the DLNA profiles supported by gupnp-dlna");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
g_option_context_free (ctx);
gst_init (&argc, &argv);
discover = gupnp_dlna_discoverer_new ((GstClockTime) GST_SECOND,
relaxed,
TRUE);
profiles = (GList *) gupnp_dlna_discoverer_list_profiles (discover);
if (!verbose) {
g_print (" %-30s%s\n", "Name", "MIME type");
g_print ("---------------------------------------------------"
"---------------------\n");
}
g_list_foreach (profiles, (GFunc) print_profile, NULL);
g_print ("\nProfiles with a '*' against their name are extended "
"(non-standard) profiles.\n\n");
g_object_unref (discover);
return 0;
}
int main(int argc, char** argv)
{
// Options parser
GOptionContext* ctx = g_option_context_new("streamplay");
const gchar** remaining_args = NULL;
GOptionEntry entries[] = {
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY,
&remaining_args, NULL, "FILE" },
{ NULL, '\0', 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
g_option_context_add_main_entries(ctx, entries, NULL);
g_option_context_add_group(ctx, gst_init_get_option_group() );
GError* err = NULL;
if(!g_option_context_parse(ctx, &argc, &argv, &err)) {
std::cerr << "Argument error:" << err->message << std::endl;
g_error_free(err);
return 1;
}
if(! remaining_args) { // Missing url argument
std::cerr << "Usage: [uri]" << std::endl;
return 1;
}
const gchar* uri = remaining_args[0];
// GStreamer version info
guint major, minor, micro, nano;
gst_init(&argc, &argv);
gst_version(&major, &minor, µ, &nano);
const gchar *nano_str = "";
switch(nano) {
case 1:
nano_str = "(CVS)";
break;
case 2:
nano_str = "(Prerelease)";
break;
}
std::cout << "Using GStreamer " << major << "." << minor << "." << micro << " " << nano_str << std::endl;
// Start main loop
{
loop = g_main_loop_new(NULL, FALSE);
InternetRadio radio(uri, loop);
g_main_loop_run(loop);
}
g_main_loop_unref(loop);
return 0;
}
int
main (int argc, char **argv)
{
ArvViewer *viewer;
int status;
GOptionContext *context;
GError *error = NULL;
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
arv_g_thread_init (NULL);
gtk_init (&argc, &argv);
gst_init (&argc, &argv);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, arv_viewer_option_entries, NULL);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_add_group (context, gst_init_get_option_group ());
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_option_context_free (context);
g_print ("Option parsing failed: %s\n", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
g_option_context_free (context);
arv_debug_enable (arv_viewer_option_debug_domains);
viewer = arv_viewer_new ();
if (!ARV_IS_VIEWER (viewer))
return EXIT_FAILURE;
arv_viewer_set_options (viewer,
arv_viewer_option_auto_socket_buffer,
!arv_viewer_option_no_packet_resend,
arv_viewer_option_packet_timeout,
arv_viewer_option_frame_retention);
notify_init ("Aravis Viewer");
status = g_application_run (G_APPLICATION (viewer), argc, argv);
g_object_unref (viewer);
notify_uninit ();
return status;
}
gint main (gint argc, gchar *argv[])
{
//initialise threads before any gtk stuff (because not using gtk_init)
g_thread_init(NULL);
/*this is more complicated than plain gtk_init/gst_init, so that options from
all over can be gathered and presented together.
*/
GOptionGroup *gst_opts = gst_init_get_option_group();
GOptionGroup *gtk_opts = gtk_get_option_group(TRUE);
GOptionContext *ctx = g_option_context_new("...!");
g_option_context_add_main_entries(ctx, entries, NULL);
g_option_context_add_group(ctx, gst_opts);
g_option_context_add_group(ctx, gtk_opts);
GError *error = NULL;
if (!g_option_context_parse(ctx, &argc, &argv, &error)){
g_print ("Error initializing: %s\n", GST_STR_NULL(error->message));
exit (1);
}
g_option_context_free(ctx);
GMainLoop *loop = g_main_loop_new(NULL, FALSE);
windows_t windows;
windows.realised = 0;
int i;
for (i = 0; i < option_screens; i++){
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "realize",
G_CALLBACK(video_widget_realize_cb), &windows);
/* set up sink here */
GstElement *sink = gst_element_factory_make("ximagesink", NULL);
set_up_window(loop, window, i + option_first_screen);
windows.gtk_windows[i] = window;
windows.sinks[i] = sink;
}
GstElement *pipeline = (GstElement *)make_multi_pipeline(&windows, option_screens);
GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
gst_bus_add_watch(bus, (GstBusFunc)bus_call, &windows);
gst_object_unref(bus);
gst_element_set_state(pipeline, GST_STATE_PLAYING);
g_main_loop_run(loop);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
return 0;
}
int
main (int argc, char *argv[])
{
gchar **filenames = NULL;
guint num, i;
GError *err = NULL;
GOptionContext *ctx;
GOptionEntry options[] = {
GST_TOOLS_GOPTION_VERSION,
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL},
{NULL}
};
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
#if !GLIB_CHECK_VERSION (2, 31, 0)
g_thread_init (NULL);
#endif
gst_tools_set_prgname ("gst-typefind");
ctx = g_option_context_new ("FILES");
g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
exit (1);
}
g_option_context_free (ctx);
gst_tools_print_version ("gst-typefind");
if (filenames == NULL || *filenames == NULL) {
g_print ("Please give a filename to typefind\n\n");
return 1;
}
num = g_strv_length (filenames);
for (i = 0; i < num; ++i) {
typefind_file (filenames[i]);
}
g_strfreev (filenames);
return 0;
}
/**
* @brief Parse command line arguments.
*/
static void
gst_switch_ui_parse_args (int *argc, char **argv[])
{
GOptionContext *context;
GError *error = NULL;
context = g_option_context_new ("");
g_option_context_add_main_entries (context, entries, "gst-switch-ui");
g_option_context_add_group (context, gst_init_get_option_group ());
if (!g_option_context_parse (context, argc, argv, &error)) {
g_print ("option parsing failed: %s\n", error->message);
exit (1);
}
g_option_context_free (context);
}
static void
options(int argc, char *argv[]) {
GOptionGroup *gst_opts = gst_init_get_option_group();
GOptionGroup *gtk_opts = gtk_get_option_group(TRUE);
GOptionContext *ctx = g_option_context_new("...!");
g_option_context_add_main_entries(ctx, entries, NULL);
g_option_context_add_group(ctx, gst_opts);
g_option_context_add_group(ctx, gtk_opts);
GError *error = NULL;
if (!g_option_context_parse(ctx, &argc, &argv, &error)) {
GST_WARNING("Error initializing: %s\n", GST_STR_NULL(error->message));
exit (1);
}
g_option_context_free(ctx);
}
gboolean
process_args (int argc, char *argv[],
gchar * file_list[], gboolean * fullscreen, GOptionContext * context)
{
gboolean version = FALSE;
guint c, index, pos = 0;
GOptionEntry entries[] = {
{"fullscreen", 'f', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, fullscreen,
"Fullscreen mode", NULL},
{"version", 'v', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, &version,
"Print version", NULL},
{NULL}
};
GError *err = NULL;
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_add_group (context, gst_init_get_option_group ());
g_option_context_add_group (context, clutter_get_option_group ());
// Command line arguments.
if (!g_option_context_parse (context, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
g_error_free (err);
goto quit;
}
if (version) {
g_print ("snappy version %s\n", VERSION);
goto quit;
}
// File arguments
if (argc < 2) {
g_print ("%s", g_option_context_get_help (context, TRUE, NULL));
goto quit;
}
for (index = 1; index < argc; index++) {
file_list[pos] = argv[index];
g_debug ("Adding file: %s\n", file_list[pos]);
pos++;
}
return TRUE;
quit:
return FALSE;
}
gint
main (gint argc,
gchar *argv[])
{
GOptionContext *ctx;
GtkWidget *win;
GList *elements;
/* i18n */
bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
g_thread_init (NULL);
ctx = g_option_context_new ("mate-volume-control");
g_option_context_add_main_entries(ctx, entries, GETTEXT_PACKAGE);
g_option_context_add_group (ctx, gst_init_get_option_group ());
g_option_context_parse(ctx, &argc, &argv, NULL);
g_option_context_free(ctx);
gtk_init (&argc, &argv);
gtk_window_set_default_icon_name ("multimedia-volume-control");
if (!(elements = create_mixer_collection ())) {
win = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("No volume control GStreamer plugins and/or devices found."));
gtk_widget_show (win);
gtk_dialog_run (GTK_DIALOG (win));
gtk_widget_destroy (win);
return -1;
}
/* window contains everything automagically */
win = mate_volume_control_window_new (elements);
if (page != NULL)
mate_volume_control_window_set_page(win, page);
g_signal_connect (win, "destroy", G_CALLBACK (cb_destroy), NULL);
g_signal_connect (win, "check_resize", G_CALLBACK (cb_check_resize), NULL);
gtk_widget_show (win);
gtk_main ();
return 0;
}
gint
main (gint argc, gchar **argv)
{
GOptionContext *context;
GOptionGroup *gstreamer_group, *gtk_group;
GError *err = NULL;
context = g_option_context_new ("gtk-demo-app");
/* get command line options from GStreamer and add them to the group */
gstreamer_group = gst_init_get_option_group ();
g_option_context_add_group (context, gstreamer_group);
gtk_group = gtk_get_option_group (TRUE);
g_option_context_add_group (context, gtk_group);
/* add our own options. If you are using gettext for translation of your
* strings, use GETTEXT_PACKAGE here instead of NULL */
g_option_context_add_main_entries (context, cmd_options, NULL);
/* now parse the commandline options, note that this already
* calls gtk_init() and gst_init() */
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
/* any filenames we got passed on the command line? parse them! */
if (cmd_filenames != NULL) {
guint i, num;
num = g_strv_length (cmd_filenames);
for (i = 0; i < num; ++i) {
/* do something with the filename ... */
g_print ("Adding to play queue: %s\n", cmd_filenames[i]);
}
g_strfreev (cmd_filenames);
cmd_filenames = NULL;
}
/*** block b from ../../../docs/manual/appendix-integration.xml ***/
return 0;
/*** block c from ../../../docs/manual/appendix-integration.xml ***/
}
int
main(int argc, char ** argv)
{
GOptionContext *context;
GError *gerror = NULL;
int count = 0;
error = 0;
gst_init (&argc, &argv);
GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, GST_DEFAULT_NAME, 0,
GST_DEFAULT_NAME);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_add_group (context, gst_init_get_option_group () );
if (!g_option_context_parse (context, &argc, &argv, &gerror) ) {
GST_ERROR ("option parsing failed: %s\n", gerror->message);
g_option_context_free (context);
g_error_free (gerror);
return 1;
}
g_option_context_free (context);
loop = g_main_loop_new (NULL, TRUE);
while (count < times && !g_atomic_int_get (&error)) {
execute_test (count++);
GST_INFO ("Executed %d times", count);
if (g_atomic_int_get (&error)) {
GST_ERROR ("Test terminated with error");
} else {
GST_INFO ("Test terminated correctly");
}
}
g_main_loop_unref (loop);
return error;
}
int
main (int argc, gchar ** argv)
{
gchar **filenames = NULL;
GOptionEntry options[] = {
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL},
{NULL}
};
GOptionContext *ctx;
GError *err = NULL;
guint i, num;
gst_init (&argc, &argv);
if (argc == 1) {
g_printerr ("Usage: %s FILE.JPG [FILE2.JPG] [FILE..JPG]\n", argv[0]);
return -1;
}
ctx = g_option_context_new ("JPEG FILES");
g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
exit (1);
}
g_option_context_free (ctx);
if (filenames == NULL || *filenames == NULL) {
g_printerr ("Please provide one or more filenames.");
return 1;
}
num = g_strv_length (filenames);
for (i = 0; i < num; ++i) {
process_file (filenames[i]);
}
g_strfreev (filenames);
return 0;
}
int
main (int argc, char *argv[])
{
GError *error = NULL;
GOptionContext *context;
GstSwitchUI *switchui;
GMainLoop *main_loop;
//if (!g_thread_supported ()) g_thread_init(NULL);
context = g_option_context_new ("- FIXME");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gst_init_get_option_group ());
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_print ("option parsing failed: %s\n", error->message);
exit (1);
}
g_option_context_free (context);
switchui = gst_switchui_new ();
if (argc > 1) {
gchar *uri;
if (gst_uri_is_valid (argv[1])) {
uri = g_strdup (argv[1]);
} else {
uri = g_filename_to_uri (argv[1], NULL, NULL);
}
gst_switchui_create_pipeline_playbin (switchui, uri);
g_free (uri);
} else {
gst_switchui_create_pipeline (switchui);
}
gst_switchui_start (switchui);
main_loop = g_main_loop_new (NULL, TRUE);
switchui->main_loop = main_loop;
g_main_loop_run (main_loop);
exit (0);
}
int
main (int argc, char **argv)
{
GtkWidget *window, *hbox, *combo, *edit, *test;
GConfClient *gconf;
GOptionContext *context;
GError *error = NULL;
g_thread_init (NULL);
context = g_option_context_new (NULL);
g_option_context_add_group (context, gst_init_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {
g_print ("%s\nRun '%s --help' to see a full list of available command line options.\n",
error->message, argv[0]);
g_error_free (error);
g_option_context_free (context);
exit (1);
}
g_option_context_free (context);
gconf = gconf_client_get_default ();
gnome_media_profiles_init (gconf);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
combo = gm_audio_profile_choose_new ();
edit = gtk_button_new_with_mnemonic ("_Edit Profiles");
test = gtk_button_new_with_mnemonic ("_Test");
g_signal_connect (edit, "clicked", (GCallback) edit_clicked_cb, window);
g_signal_connect (test, "clicked", (GCallback) test_clicked_cb, combo);
g_signal_connect (edit, "destroy", (GCallback) gtk_main_quit, NULL);
hbox = gtk_hbox_new (FALSE, 7);
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), test, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), edit, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (window), hbox);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
int
main (int argc, char *argv[])
{
GError *error = NULL;
GOptionContext *context;
GstPlayRegion *PlayRegion;
GMainLoop *main_loop;
if (argc < 2) {
g_print ("usage: %s <uri>\n", argv[0]);
return -1;
}
context = g_option_context_new ("- FIXME");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gst_init_get_option_group ());
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_print ("option parsing failed: %s\n", error->message);
exit (1);
}
g_option_context_free (context);
PlayRegion = gst_PlayRegion_new ();
gchar *uri;
if (gst_uri_is_valid (argv[1])) {
uri = g_strdup (argv[1]);
} else {
uri = g_filename_to_uri (argv[1], NULL, NULL);
}
gst_PlayRegion_create_pipeline (PlayRegion, uri);
g_free (uri);
gst_PlayRegion_start (PlayRegion);
main_loop = g_main_loop_new (NULL, TRUE);
PlayRegion->main_loop = main_loop;
g_main_loop_run (main_loop);
exit (0);
}
static GOptionContext *
goo_application_create_option_context (void)
{
GOptionContext *options_context;
static gsize initialized = FALSE;
options_context = g_option_context_new (N_("Play CDs and save the tracks to disk as files"));
g_option_context_set_translation_domain (options_context, GETTEXT_PACKAGE);
g_option_context_set_ignore_unknown_options (options_context, TRUE);
g_option_context_add_main_entries (options_context, options, GETTEXT_PACKAGE);
if (g_once_init_enter (&initialized)) {
g_option_context_add_group (options_context, gtk_get_option_group (TRUE));
g_option_context_add_group (options_context, gst_init_get_option_group ());
g_once_init_leave (&initialized, TRUE);
}
return options_context;
}
gint
main (gint argc, gchar ** argv)
{
GOptionContext *opt_ctx;
GstClock *clock;
GError *err = NULL;
opt_ctx = g_option_context_new ("- GStreamer PTP clock test app");
g_option_context_add_main_entries (opt_ctx, opt_entries, NULL);
g_option_context_add_group (opt_ctx, gst_init_get_option_group ());
if (!g_option_context_parse (opt_ctx, &argc, &argv, &err))
g_error ("Error parsing options: %s", err->message);
g_clear_error (&err);
g_option_context_free (opt_ctx);
if (!gst_ptp_init (GST_PTP_CLOCK_ID_NONE, NULL))
g_error ("failed to init ptp");
if (stats)
gst_ptp_statistics_callback_add (stats_cb, NULL, NULL);
clock = gst_ptp_clock_new ("test-clock", domain);
gst_clock_wait_for_sync (GST_CLOCK (clock), GST_CLOCK_TIME_NONE);
while (TRUE) {
GstClockTime local, remote;
GstClockTimeDiff diff;
local = g_get_real_time () * 1000;
remote = gst_clock_get_time (clock);
diff = GST_CLOCK_DIFF (local, remote);
g_print ("local: %" GST_TIME_FORMAT " ptp: %" GST_TIME_FORMAT " diff: %s%"
GST_TIME_FORMAT "\n", GST_TIME_ARGS (local), GST_TIME_ARGS (remote),
(diff < 0 ? "-" : " "), GST_TIME_ARGS (ABS (diff)));
g_usleep (100000);
}
return 0;
}
