void test_find_element()
{
GstElementFactory *element_factory;
//xmlfile = "test_find_element";
std_log(LOG_FILENAME_LINE, "Test Started test_find_element");
element_factory = gst_element_factory_find ("identity");
fail_if (element_factory == NULL, "Failed to find identity element factory");
fail_if (GST_OBJECT_REFCOUNT_VALUE (element_factory) != 2,
"Refcount of plugin in registry+feature should be 2");
gst_object_unref (element_factory);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
gboolean
sj_extractor_supports_profile (GstEncodingProfile *profile)
{
/* TODO: take a GError to return a message if the profile isn't supported */
const gchar *profile_name = gst_encoding_profile_get_name (profile);
if (strcmp (profile_name, "mp3") == 0) {
GstElementFactory *factory = gst_element_factory_find ("lamemp3enc");
if (factory == NULL)
return FALSE;
g_object_unref (factory);
factory = gst_element_factory_find ("xingmux");
if (factory == NULL)
return FALSE;
g_object_unref (factory);
factory = gst_element_factory_find ("id3v2mux");
if (factory == NULL)
return FALSE;
g_object_unref (factory);
return TRUE;
}
return !rb_gst_check_missing_plugins(profile, NULL, NULL);
}
static gboolean
_check_element_factory (gchar *name)
{
GstElementFactory *fact = NULL;
g_return_val_if_fail (name, FALSE);
fact = gst_element_factory_find (name);
if (fact)
gst_object_unref (fact);
return (fact != NULL);
}
/// Find the best available audio resampler on the system
static std::string
findResampler()
{
std::string resampler = "ffaudioresample";
GstElementFactory* factory = gst_element_factory_find(resampler.c_str());
if (!factory) {
resampler = "speexresample";
factory = gst_element_factory_find(resampler.c_str());
if (!factory) {
log_error(_("The best available resampler is 'audioresample'."
" Please install gstreamer-ffmpeg 0.10.4 or newer, or you"
" may experience long delays in audio playback!"));
resampler = "audioresample";
}
}
if (factory) {
gst_object_unref(factory);
}
return resampler;
}
void GstVideoPlayerBackend::enableFactory(const gchar *name, gboolean enable)
{
GstRegistry *registry = gst_registry_get_default();
if (!registry)
return;
GstElementFactory *factory = gst_element_factory_find(name);
if (!factory)
return;
if (enable)
gst_plugin_feature_set_rank(GST_PLUGIN_FEATURE(factory), GST_RANK_PRIMARY + 1);
else
gst_plugin_feature_set_rank(GST_PLUGIN_FEATURE(factory), GST_RANK_NONE);
gst_registry_add_feature(registry, GST_PLUGIN_FEATURE(factory));
}
static void
fs_msn_cam_recv_conference_init (FsMsnCamRecvConference *self)
{
FsMsnConference *conf = FS_MSN_CONFERENCE (self);
GstElementFactory *fact = NULL;
GST_DEBUG_OBJECT (conf, "fs_msn_cam_recv_conference_init");
conf->max_direction = FS_DIRECTION_RECV;
fact = gst_element_factory_find ("mimenc");
if (fact)
gst_object_unref (fact);
else
g_set_error (&conf->missing_element_error,
FS_ERROR, FS_ERROR_CONSTRUCTION,
"mimenc missing");
}
static const char *
swfdec_audio_decoder_get_resampler (void)
{
/* FIXME: This is hardcoded as there's no autopluggable way to get the
* best resampler by rank.
* Even if there were, audioresample (which has the highest rank) is so slow
* it takes roughly a second to resample stuff that ffaudioresample does in
* 0.05 seconds.
*/
static const char *options[] = { "ffaudioresample", "speexresample", "audioresample" };
guint i;
for (i = 0; i < G_N_ELEMENTS (options); i++) {
GstElementFactory *factory = gst_element_factory_find (options[i]);
if (factory) {
gst_object_unref (factory);
return options[i];
}
}
SWFDEC_ERROR ("no resampling element found. Check that GStreamer's base plugins are installed.");
return NULL;
}
AbstractRenderer *DeviceManager::createVideoRenderer(VideoWidget *parent)
{
#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES)
if (m_videoSinkWidget == "opengl") {
return new GLRenderer(parent);
} else
#endif
if (m_videoSinkWidget == "software") {
return new WidgetRenderer(parent);
}
#ifdef Q_WS_X11
else if (m_videoSinkWidget == "xwindow") {
return new X11Renderer(parent);
} else {
GstElementFactory *srcfactory = gst_element_factory_find("ximagesink");
if (srcfactory) {
return new X11Renderer(parent);
}
}
#endif
return new WidgetRenderer(parent);
}
/**
* gst_element_factory_make:
* @factoryname: a named factory to instantiate
* @name: (allow-none): name of new element, or %NULL to automatically create
* a unique name
*
* Create a new element of the type defined by the given element factory.
* If name is %NULL, then the element will receive a guaranteed unique name,
* consisting of the element factory name and a number.
* If name is given, it will be given the name supplied.
*
* Returns: (transfer floating) (nullable): new #GstElement or %NULL
* if unable to create element
*/
GstElement *
gst_element_factory_make (const gchar * factoryname, const gchar * name)
{
GstElementFactory *factory;
GstElement *element;
g_return_val_if_fail (factoryname != NULL, NULL);
g_return_val_if_fail (gst_is_initialized (), NULL);
GST_LOG ("gstelementfactory: make \"%s\" \"%s\"",
factoryname, GST_STR_NULL (name));
factory = gst_element_factory_find (factoryname);
if (factory == NULL)
goto no_factory;
GST_LOG_OBJECT (factory, "found factory %p", factory);
element = gst_element_factory_create (factory, name);
if (element == NULL)
goto create_failed;
gst_object_unref (factory);
return element;
/* ERRORS */
no_factory:
{
GST_WARNING ("no such element factory \"%s\"!", factoryname);
return NULL;
}
create_failed:
{
GST_INFO_OBJECT (factory, "couldn't create instance!");
gst_object_unref (factory);
return NULL;
}
}
QGstreamerVideoEncode::QGstreamerVideoEncode(QGstreamerCaptureSession *session)
:QVideoEncoderControl(session), m_session(session)
{
QList<QByteArray> codecCandidates;
codecCandidates << "video/mpeg4"; //"video/h264" << "video/xvid" << "video/mpeg4" << "video/mpeg1" << "video/mpeg2" << "video/theora";
m_elementNames["video/mpeg4"] = "dspmp4venc";
m_codecOptions["video/mpeg4"] = QStringList() << "quantizer";
foreach( const QByteArray& codecName, codecCandidates ) {
QByteArray elementName = m_elementNames[codecName];
GstElementFactory *factory = gst_element_factory_find(elementName.constData());
if (factory) {
m_codecs.append(codecName);
const gchar *descr = gst_element_factory_get_description(factory);
m_codecDescriptions.insert(codecName, QString::fromUtf8(descr));
m_streamTypes.insert(codecName,
QGstreamerMediaContainerControl::supportedStreamTypes(factory, GST_PAD_SRC));
gst_object_unref(GST_OBJECT(factory));
}
}
GstCaps* find_input_caps_dutils (GstCaps* available_caps,
GstCaps* wanted_caps,
bool& /*requires_bayer*/,
bool& requires_vidoeconvert,
bool& /*requires_jpegdec*/,
bool& requires_dutils,
bool& requires_biteater)
{
requires_vidoeconvert = true;
GstElementFactory* dutils = gst_element_factory_find("tcamdutils");
if (dutils)
{
// check if only dutils suffice
if (gst_element_factory_can_src_any_caps(dutils, wanted_caps)
&& gst_element_factory_can_sink_any_caps(dutils, available_caps))
{
requires_dutils = true;
gst_object_unref(dutils);
GstElementFactory* biteater = gst_element_factory_find("tcambiteater");
// check if dutils + biteater suffice
if (!tcam_gst_contains_bayer_8_bit(available_caps)
&& ((tcam_gst_contains_bayer_12_bit(available_caps)
|| tcam_gst_contains_bayer_16_bit(available_caps)))
&& gst_element_factory_can_src_any_caps(biteater, wanted_caps))
{
requires_biteater = true;
gst_object_unref(biteater);
return available_caps;
}
else // dutils only
{
gst_object_unref(biteater);
GstCaps* ret;
if (!gst_caps_is_fixed(available_caps))
{
if (!gst_caps_is_empty(wanted_caps) &&
g_strcmp0(gst_caps_to_string(wanted_caps), "NULL") != 0)
{
GstCaps* possible_matches = create_caps_for_formats(available_caps, wanted_caps);
if (!possible_matches || gst_caps_is_empty(possible_matches))
{
tcam_error("No possible matches for dutils.");
return nullptr;
}
ret = gst_caps_intersect(available_caps, possible_matches);
gst_caps_unref(possible_matches);
}
else
{
ret = tcam_gst_find_largest_caps(available_caps);
}
}
else // is fixed
{
ret = gst_caps_copy(available_caps);
}
if (!ret)
{
// TODO not compatible
tcam_error("No intersecting caps between dutils and src");
return nullptr;
}
return ret;
}
gst_object_unref(biteater);
}
gst_object_unref(dutils);
}
tcam_error("Could not create dutils.");
return nullptr;
}
static void
dvb_base_bin_class_init (DvbBaseBinClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
GstBinClass *bin_class;
DvbBaseBinClass *dvbbasebin_class;
GstElementFactory *dvbsrc_factory;
GObjectClass *dvbsrc_class;
typedef struct
{
guint prop_id;
const gchar *prop_name;
} ProxyedProperty;
ProxyedProperty *walk;
ProxyedProperty proxyed_properties[] = {
{PROP_ADAPTER, "adapter"},
{PROP_FRONTEND, "frontend"},
{PROP_DISEQC_SRC, "diseqc-source"},
{PROP_FREQUENCY, "frequency"},
{PROP_POLARITY, "polarity"},
{PROP_SYMBOL_RATE, "symbol-rate"},
#ifndef GST_REMOVE_DEPRECATED
{PROP_BANDWIDTH, "bandwidth"},
#endif
{PROP_CODE_RATE_HP, "code-rate-hp"},
{PROP_CODE_RATE_LP, "code-rate-lp"},
{PROP_GUARD, "guard"},
{PROP_MODULATION, "modulation"},
{PROP_TRANS_MODE, "trans-mode"},
{PROP_HIERARCHY, "hierarchy"},
{PROP_INVERSION, "inversion"},
{PROP_STATS_REPORTING_INTERVAL, "stats-reporting-interval"},
{PROP_TUNING_TIMEOUT, "tuning-timeout"},
{PROP_DELSYS, "delsys"},
{PROP_PILOT, "pilot"},
{PROP_ROLLOFF, "rolloff"},
{PROP_STREAM_ID, "stream-id"},
{PROP_BANDWIDTH_HZ, "bandwidth-hz"},
{PROP_ISDBT_LAYER_ENABLED, "isdbt-layer-enabled"},
{PROP_ISDBT_PARTIAL_RECEPTION, "isdbt-partial-reception"},
{PROP_ISDBT_SOUND_BROADCASTING, "isdbt-sound-broadcasting"},
{PROP_ISDBT_SB_SUBCHANNEL_ID, "isdbt-sb-subchannel-id"},
{PROP_ISDBT_SB_SEGMENT_IDX, "isdbt-sb-segment-idx"},
{PROP_ISDBT_SB_SEGMENT_COUNT, "isdbt-sb-segment-count"},
{PROP_ISDBT_LAYERA_FEC, "isdbt-layera-fec"},
{PROP_ISDBT_LAYERA_MODULATION, "isdbt-layera-modulation"},
{PROP_ISDBT_LAYERA_SEGMENT_COUNT, "isdbt-layera-segment-count"},
{PROP_ISDBT_LAYERA_TIME_INTERLEAVING, "isdbt-layera-time-interleaving"},
{PROP_ISDBT_LAYERB_FEC, "isdbt-layerb-fec"},
{PROP_ISDBT_LAYERB_MODULATION, "isdbt-layerb-modulation"},
{PROP_ISDBT_LAYERB_SEGMENT_COUNT, "isdbt-layerb-segment-count"},
{PROP_ISDBT_LAYERB_TIME_INTERLEAVING, "isdbt-layerb-time-interleaving"},
{PROP_ISDBT_LAYERC_FEC, "isdbt-layerc-fec"},
{PROP_ISDBT_LAYERC_MODULATION, "isdbt-layerc-modulation"},
{PROP_ISDBT_LAYERC_SEGMENT_COUNT, "isdbt-layerc-segment-count"},
{PROP_ISDBT_LAYERC_TIME_INTERLEAVING, "isdbt-layerc-time-interleaving"},
{PROP_LNB_SLOF, "lnb-slof"},
{PROP_LNB_LOF1, "lnb-lof1"},
{PROP_LNB_LOF2, "lnb-lof2"},
{PROP_INTERLEAVING, "interleaving"},
{0, NULL}
};
bin_class = GST_BIN_CLASS (klass);
bin_class->handle_message = dvb_base_bin_handle_message;
element_class = GST_ELEMENT_CLASS (klass);
element_class->change_state = dvb_base_bin_change_state;
element_class->request_new_pad = dvb_base_bin_request_new_pad;
element_class->release_pad = dvb_base_bin_release_pad;
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&program_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&src_template));
gst_element_class_set_static_metadata (element_class, "DVB bin",
"Source/Bin/Video",
"Access descramble and split DVB streams",
"Alessandro Decina <*****@*****.**>\n"
"Reynaldo H. Verdejo Pinochet <*****@*****.**>");
gobject_class = G_OBJECT_CLASS (klass);
gobject_class->set_property = dvb_base_bin_set_property;
gobject_class->get_property = dvb_base_bin_get_property;
gobject_class->dispose = dvb_base_bin_dispose;
gobject_class->finalize = dvb_base_bin_finalize;
dvbbasebin_class = (DvbBaseBinClass *) klass;
dvbbasebin_class->do_tune = dvb_base_bin_do_tune;
/* install dvbsrc properties */
dvbsrc_factory = gst_element_factory_find ("dvbsrc");
dvbsrc_class =
g_type_class_ref (gst_element_factory_get_element_type (dvbsrc_factory));
walk = proxyed_properties;
while (walk->prop_name != NULL) {
GParamSpec *pspec;
GParamSpec *our_pspec;
pspec = g_object_class_find_property (dvbsrc_class, walk->prop_name);
if (pspec != NULL) {
GType param_type = G_PARAM_SPEC_TYPE (pspec);
if (param_type == G_TYPE_PARAM_INT) {
GParamSpecInt *src_pspec = G_PARAM_SPEC_INT (pspec);
our_pspec = g_param_spec_int (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
pspec->flags);
} else if (param_type == G_TYPE_PARAM_UINT) {
GParamSpecUInt *src_pspec = G_PARAM_SPEC_UINT (pspec);
our_pspec = g_param_spec_uint (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
pspec->flags);
} else if (param_type == G_TYPE_PARAM_UINT64) {
GParamSpecUInt64 *src_pspec = G_PARAM_SPEC_UINT64 (pspec);
our_pspec = g_param_spec_uint64 (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
pspec->flags);
} else if (param_type == G_TYPE_PARAM_STRING) {
GParamSpecString *src_pspec = G_PARAM_SPEC_STRING (pspec);
our_pspec = g_param_spec_string (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->default_value, pspec->flags);
} else if (param_type == G_TYPE_PARAM_ENUM) {
GParamSpecEnum *src_pspec = G_PARAM_SPEC_ENUM (pspec);
our_pspec = g_param_spec_enum (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
pspec->value_type, src_pspec->default_value, pspec->flags);
} else {
GST_ERROR ("Unsupported property type %s for property %s",
g_type_name (param_type), g_param_spec_get_name (pspec));
++walk;
continue;
}
g_object_class_install_property (gobject_class, walk->prop_id, our_pspec);
} else {
g_warning ("dvbsrc has no property named %s", walk->prop_name);
}
++walk;
}
g_type_class_unref (dvbsrc_class);
g_object_class_install_property (gobject_class, PROP_PROGRAM_NUMBERS,
g_param_spec_string ("program-numbers",
"Program Numbers",
"Colon separated list of programs", "", G_PARAM_READWRITE));
/**
* DvbBaseBin::tuning-start:
* @dvbbasebin: the element on which the signal is emitted
*
* Signal emited when the element first attempts to tune the
* frontend tunner to a given frequency.
*/
dvb_base_bin_signals[SIGNAL_TUNING_START] =
g_signal_new ("tuning-start", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
/**
* DvbBaseBin::tuning-done:
* @dvbbasebin: the element on which the signal is emitted
*
* Signal emited when the tunner has successfully got a lock on a signal.
*/
dvb_base_bin_signals[SIGNAL_TUNING_DONE] =
g_signal_new ("tuning-done", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
/**
* DvbBaseBin::tuning-fail:
* @dvbbasebin: the element on which the signal is emitted
*
* Signal emited when the tunner failed to get a lock on the
* signal.
*/
dvb_base_bin_signals[SIGNAL_TUNING_FAIL] =
g_signal_new ("tuning-fail", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
/**
* DvbBaseBin::tune:
* @dvbbasesink: the element on which the signal is emitted
*
* Signal emited from the application to the element, instructing it
* to tune.
*/
dvb_base_bin_signals[SIGNAL_TUNE] =
g_signal_new ("tune", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (DvbBaseBinClass, do_tune),
NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
}
int
main (int argc,
char *argv[])
{
gst_init (&argc, &argv);
GstElementFactory *factory = gst_element_factory_find("ffmpegcolorspace");
const GList *list = gst_element_factory_get_static_pad_templates(factory);
while (NULL != list) {
GstStaticPadTemplate *templ = (GstStaticPadTemplate *)list->data;
// name
g_print("+++ template name %s\n", templ->name_template);
// direction
g_print ("direction: ");
switch (templ->direction) {
case GST_PAD_UNKNOWN:
g_print ("unknown\n");
break;
case GST_PAD_SRC:
g_print ("src\n");
break;
case GST_PAD_SINK:
g_print ("sink\n");
break;
default:
g_print ("this is a bug\n");
break;
}
// presence
g_print ("presence: ");
switch (templ->presence) {
case GST_PAD_ALWAYS:
g_print ("always\n");
break;
case GST_PAD_SOMETIMES:
g_print ("sometimes\n");
break;
case GST_PAD_REQUEST:
g_print ("request\n");
break;
default:
g_print ("this is a bug\n");
break;
}
// caps
GstCaps *caps = gst_static_caps_get(&templ->static_caps);
// copying for removing fields in struture
GstCaps *copy = gst_caps_copy(caps);
gst_caps_unref(caps);
guint size = gst_caps_get_size(copy);
guint i = 0;
g_print("size %u\n", size);
for (; i < size; i++) {
GstStructure *structure = gst_caps_get_structure(copy, i);
gst_structure_remove_fields(structure,
"format", "width", "height", "framerate",
NULL);
GstCaps *copy_nth = gst_caps_copy_nth(copy, i);
gchar *caps_str = gst_caps_to_string(copy_nth);
g_print(" caps num %u is %s\n", i, caps_str);
g_free(caps_str);
gst_caps_unref(copy_nth);
}
gst_caps_unref(copy);
list = g_list_next(list);
}
gst_object_unref(factory);
gst_deinit(); // for memory testing
return 0;
}
int
main (int argc, char *argv[])
{
gboolean print_all = FALSE;
gboolean do_print_blacklist = FALSE;
gboolean plugin_name = FALSE;
gboolean print_aii = FALSE;
gboolean uri_handlers = FALSE;
gboolean check_exists = FALSE;
gchar *min_version = NULL;
guint minver_maj = GST_VERSION_MAJOR;
guint minver_min = GST_VERSION_MINOR;
guint minver_micro = 0;
#ifndef GST_DISABLE_OPTION_PARSING
GOptionEntry options[] = {
{"print-all", 'a', 0, G_OPTION_ARG_NONE, &print_all,
N_("Print all elements"), NULL},
{"print-blacklist", 'b', 0, G_OPTION_ARG_NONE, &do_print_blacklist,
N_("Print list of blacklisted files"), NULL},
{"print-plugin-auto-install-info", '\0', 0, G_OPTION_ARG_NONE, &print_aii,
N_("Print a machine-parsable list of features the specified plugin "
"or all plugins provide.\n "
"Useful in connection with external automatic plugin "
"installation mechanisms"), NULL},
{"plugin", '\0', 0, G_OPTION_ARG_NONE, &plugin_name,
N_("List the plugin contents"), NULL},
{"exists", '\0', 0, G_OPTION_ARG_NONE, &check_exists,
N_("Check if the specified element or plugin exists"), NULL},
{"atleast-version", '\0', 0, G_OPTION_ARG_STRING, &min_version,
N_
("When checking if an element or plugin exists, also check that its "
"version is at least the version specified"), NULL},
{"uri-handlers", 'u', 0, G_OPTION_ARG_NONE, &uri_handlers,
N_
("Print supported URI schemes, with the elements that implement them"),
NULL},
GST_TOOLS_GOPTION_VERSION,
{NULL}
};
GOptionContext *ctx;
GError *err = NULL;
#endif
setlocale (LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
/* avoid glib warnings when inspecting deprecated properties */
g_setenv ("G_ENABLE_DIAGNOSTIC", "0", FALSE);
g_set_prgname ("gst-inspect-" GST_API_VERSION);
#ifndef GST_DISABLE_OPTION_PARSING
ctx = g_option_context_new ("[ELEMENT-NAME | PLUGIN-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_printerr ("Error initializing: %s\n", err->message);
g_clear_error (&err);
g_option_context_free (ctx);
return -1;
}
g_option_context_free (ctx);
#else
gst_init (&argc, &argv);
#endif
gst_tools_print_version ();
if (print_all && argc > 1) {
g_printerr ("-a requires no extra arguments\n");
return -1;
}
if (uri_handlers && argc > 1) {
g_printerr ("-u requires no extra arguments\n");
return -1;
}
/* --atleast-version implies --exists */
if (min_version != NULL) {
if (sscanf (min_version, "%u.%u.%u", &minver_maj, &minver_min,
&minver_micro) < 2) {
g_printerr ("Can't parse version '%s' passed to --atleast-version\n",
min_version);
return -1;
}
check_exists = TRUE;
}
if (check_exists) {
int exit_code;
if (argc == 1) {
g_printerr ("--exists requires an extra command line argument\n");
exit_code = -1;
} else {
if (!plugin_name) {
GstPluginFeature *feature;
feature = gst_registry_lookup_feature (gst_registry_get (), argv[1]);
if (feature != NULL && gst_plugin_feature_check_version (feature,
minver_maj, minver_min, minver_micro)) {
exit_code = 0;
} else {
exit_code = 1;
}
} else {
/* FIXME: support checking for plugins too */
g_printerr ("Checking for plugins is not supported yet\n");
exit_code = -1;
}
}
return exit_code;
}
/* if no arguments, print out list of elements */
if (uri_handlers) {
print_all_uri_handlers ();
} else if (argc == 1 || print_all) {
if (do_print_blacklist)
print_blacklist ();
else {
if (print_aii)
print_all_plugin_automatic_install_info ();
else
print_element_list (print_all);
}
} else {
/* else we try to get a factory */
GstElementFactory *factory;
GstPlugin *plugin;
const char *arg = argv[argc - 1];
int retval;
if (!plugin_name) {
factory = gst_element_factory_find (arg);
/* if there's a factory, print out the info */
if (factory) {
retval = print_element_info (factory, print_all);
gst_object_unref (factory);
} else {
retval = print_element_features (arg);
}
} else {
retval = -1;
}
/* otherwise check if it's a plugin */
if (retval) {
plugin = gst_registry_find_plugin (gst_registry_get (), arg);
/* if there is such a plugin, print out info */
if (plugin) {
if (print_aii) {
print_plugin_automatic_install_info (plugin);
} else {
print_plugin_info (plugin);
print_plugin_features (plugin);
}
} else {
GError *error = NULL;
if (g_file_test (arg, G_FILE_TEST_EXISTS)) {
plugin = gst_plugin_load_file (arg, &error);
if (plugin) {
if (print_aii) {
print_plugin_automatic_install_info (plugin);
} else {
print_plugin_info (plugin);
print_plugin_features (plugin);
}
} else {
g_printerr (_("Could not load plugin file: %s\n"), error->message);
g_clear_error (&error);
return -1;
}
} else {
g_printerr (_("No such element or plugin '%s'\n"), arg);
return -1;
}
}
}
}
return 0;
}
int
main (int argc, char *argv[])
{
gboolean print_all = FALSE;
gboolean print_aii = FALSE;
GOptionEntry options[] = {
{"print-all", 'a', 0, G_OPTION_ARG_NONE, &print_all,
N_("Print all elements"), NULL},
{"print-plugin-auto-install-info", '\0', 0, G_OPTION_ARG_NONE, &print_aii,
N_("Print a machine-parsable list of features the specified plugin "
"provides.\n "
"Useful in connection with external automatic plugin "
"installation mechanisms"), NULL},
GST_TOOLS_GOPTION_VERSION,
{NULL}
};
GOptionContext *ctx;
GError *err = NULL;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (!g_thread_supported ())
g_thread_init (NULL);
ctx = g_option_context_new ("[ELEMENT-NAME | PLUGIN-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-inspect");
if (print_all && argc > 2) {
g_print ("-a requires no extra arguments\n");
return 1;
}
/* if no arguments, print out list of elements */
if (argc == 1 || print_all) {
print_element_list (print_all);
/* else we try to get a factory */
} else {
GstElementFactory *factory;
GstPlugin *plugin;
const char *arg = argv[argc - 1];
int retval;
factory = gst_element_factory_find (arg);
/* if there's a factory, print out the info */
if (factory) {
retval = print_element_info (factory, print_all);
gst_object_unref (factory);
} else {
retval = print_element_features (arg);
}
/* otherwise check if it's a plugin */
if (retval) {
plugin = gst_default_registry_find_plugin (arg);
/* if there is such a plugin, print out info */
if (plugin) {
if (print_aii) {
print_plugin_automatic_install_info (plugin);
} else {
print_plugin_info (plugin);
print_plugin_features (plugin);
}
} else {
GError *error = NULL;
if (g_file_test (arg, G_FILE_TEST_EXISTS)) {
plugin = gst_plugin_load_file (arg, &error);
if (plugin) {
if (print_aii) {
print_plugin_automatic_install_info (plugin);
} else {
print_plugin_info (plugin);
print_plugin_features (plugin);
}
} else {
g_print (_("Could not load plugin file: %s\n"), error->message);
g_error_free (error);
return -1;
}
} else {
g_print (_("No such element or plugin '%s'\n"), arg);
return -1;
}
}
}
}
return 0;
}
/* insert given codec_cap list into list_codecs and list_codec_blueprints */
static void
parse_codec_cap_list (GList *list, FsMediaType media_type)
{
GList *walk;
CodecCap *codec_cap;
FsCodec *codec;
CodecBlueprint *codec_blueprint;
gint i;
gchar *tmp;
GstElementFactory *tmpfact;
/* go thru all common caps */
for (walk = list; walk; walk = g_list_next (walk))
{
codec_cap = (CodecCap *)(walk->data);
codec = g_slice_new0 (FsCodec);
codec->id = FS_CODEC_ID_ANY;
codec->clock_rate = 0;
for (i = 0; i < gst_caps_get_size (codec_cap->rtp_caps); i++)
{
GstStructure *structure = gst_caps_get_structure (codec_cap->rtp_caps, i);
gst_structure_foreach (structure, extract_field_data,
(gpointer) codec);
}
if (!codec->encoding_name)
{
GstStructure *caps = gst_caps_get_structure (codec_cap->rtp_caps, 0);
const gchar *encoding_name = codec->encoding_name ? codec->encoding_name
: gst_structure_get_string (caps, "encoding-name");
GST_DEBUG ("skipping codec %s/%s, no encoding name specified"
" (pt: %d clock_rate:%u",
media_type == FS_MEDIA_TYPE_AUDIO ? "audio" : "video",
encoding_name ? encoding_name : "unknown", codec->id,
codec->clock_rate);
encoding_name = NULL;
fs_codec_destroy (codec);
continue;
}
switch (codec->media_type) {
case FS_MEDIA_TYPE_VIDEO:
if (!validate_h263_codecs (codec_cap)) {
fs_codec_destroy (codec);
continue;
}
break;
case FS_MEDIA_TYPE_AUDIO:
if (!validate_amr_codecs (codec_cap)) {
fs_codec_destroy (codec);
continue;
}
break;
default:
break;
}
another:
codec_blueprint = g_slice_new0 (CodecBlueprint);
codec_blueprint->codec = codec;
codec_blueprint->media_caps = gst_caps_copy (codec_cap->caps);
codec_blueprint->rtp_caps = gst_caps_copy (codec_cap->rtp_caps);
codec_blueprint->send_pipeline_factory =
copy_element_list (codec_cap->element_list2);
codec_blueprint->receive_pipeline_factory =
copy_element_list (codec_cap->element_list1);
/* Lets add the converters at the beginning of the encoding pipelines */
if (media_type == FS_MEDIA_TYPE_VIDEO)
{
tmpfact = gst_element_factory_find ("ffmpegcolorspace");
if (tmpfact)
{
codec_blueprint->send_pipeline_factory = g_list_append (
codec_blueprint->send_pipeline_factory,
g_list_append (NULL, tmpfact));
}
tmpfact = gst_element_factory_find ("videoscale");
if (tmpfact)
{
codec_blueprint->send_pipeline_factory = g_list_append (
codec_blueprint->send_pipeline_factory,
g_list_append (NULL, tmpfact));
}
}
else if (media_type == FS_MEDIA_TYPE_AUDIO)
{
tmpfact = gst_element_factory_find ("audioconvert");
if (tmpfact)
{
codec_blueprint->send_pipeline_factory = g_list_append (
codec_blueprint->send_pipeline_factory,
g_list_append (NULL, tmpfact));
}
tmpfact = gst_element_factory_find ("audioresample");
if (tmpfact)
{
codec_blueprint->send_pipeline_factory = g_list_append (
codec_blueprint->send_pipeline_factory,
g_list_append (NULL, tmpfact));
}
tmpfact = gst_element_factory_find ("audioconvert");
if (tmpfact)
{
codec_blueprint->send_pipeline_factory = g_list_append (
codec_blueprint->send_pipeline_factory,
g_list_append (NULL, tmpfact));
}
}
/* insert new information into tables */
list_codec_blueprints[media_type] = g_list_append (
list_codec_blueprints[media_type], codec_blueprint);
GST_DEBUG ("adding codec %s with pt %d, send_pipeline %p, receive_pipeline %p",
codec->encoding_name, codec->id,
codec_blueprint->send_pipeline_factory,
codec_blueprint->receive_pipeline_factory);
tmp = gst_caps_to_string (codec_blueprint->media_caps);
GST_DEBUG ("media_caps: %s", tmp);
g_free (tmp);
tmp = gst_caps_to_string (codec_blueprint->rtp_caps);
GST_DEBUG ("rtp_caps: %s", tmp);
g_free (tmp);
debug_pipeline (codec_blueprint->send_pipeline_factory);
debug_pipeline (codec_blueprint->receive_pipeline_factory);
if (!g_ascii_strcasecmp (codec->encoding_name, "H263-1998")) {
codec = fs_codec_copy (codec);
g_free (codec->encoding_name);
codec->encoding_name = g_strdup ("H263-N800");
goto another;
}
}
}
// TODO: bayer and videoconvert should consider eachother
GstCaps* find_input_caps (GstCaps* available_caps,
GstCaps* wanted_caps,
bool& requires_bayer,
bool& requires_vidoeconvert,
bool& requires_jpegdec,
bool& requires_dutils,
bool& requires_biteater,
bool use_dutils
)
{
requires_bayer = false;
requires_vidoeconvert = false;
requires_jpegdec = false;
requires_dutils = false;
requires_biteater = false;
requires_bayer = false;
if (!GST_IS_CAPS(available_caps))
{
return nullptr;
}
if (wanted_caps == nullptr || gst_caps_is_empty(wanted_caps))
{
GST_INFO("No sink caps specified. Continuing with caps from source device.");
wanted_caps = gst_caps_copy(available_caps);
}
// GstCaps* intersect = gst_caps_intersect(available_caps, wanted_caps);
// if (!gst_caps_is_empty(intersect))
// {
// return intersect;
// }
// gst_caps_unref(intersect);
GstElementFactory* dutils = gst_element_factory_find("tcamdutils");
if (use_dutils && dutils)
{
gst_object_unref(dutils);
return find_input_caps_dutils(available_caps,
wanted_caps,
requires_bayer,
requires_vidoeconvert,
requires_jpegdec,
requires_dutils,
requires_biteater);
}
GstElementFactory* debayer = gst_element_factory_find("bayer2rgb");
if (debayer)
{
if (gst_element_factory_can_src_any_caps(debayer, wanted_caps)
&& gst_element_factory_can_sink_any_caps(debayer, available_caps))
{
requires_bayer = true;
// wanted_caps can be fixed, etc.
// thus change name to be compatible to bayer2rgb sink pad
// and create a correct intersection
GstCaps* temp = gst_caps_copy(wanted_caps);
gst_caps_change_name(temp, "video/x-bayer");
GstCaps* ret = gst_caps_intersect(available_caps, temp);
gst_caps_unref(temp);
gst_object_unref(debayer);
return ret;
}
}
gst_object_unref(debayer);
GstElementFactory* convert = gst_element_factory_find("videoconvert");
if (convert)
{
if (gst_element_factory_can_src_any_caps(convert, wanted_caps)
&& gst_element_factory_can_sink_any_caps(convert, available_caps))
{
// this intersection check is to ensure that we can't just pass
// the caps through and really need this additional element
GstCaps* intersect = gst_caps_intersect(available_caps, wanted_caps);
if (!gst_caps_is_empty(intersect))
{
return intersect;
}
gst_caps_unref(intersect);
requires_vidoeconvert = true;
// wanted_caps can be fixed, etc.
GstCaps* in = get_caps_from_element_name("videoconvert", "sink");
// this removes things like jpeg
GstCaps* ret = gst_caps_intersect(available_caps, in);
GstCaps* temp = gst_caps_copy(wanted_caps);
for (unsigned int i = 0; i < gst_caps_get_size(temp); ++i)
{
gst_structure_remove_field(gst_caps_get_structure(temp, i), "format");
}
GstCaps* ret2 = gst_caps_intersect(ret, temp);
gst_caps_unref(in);
gst_caps_unref(ret);
gst_object_unref(convert);
return ret2;
}
gst_object_unref(convert);
}
GstElementFactory* jpegdec = gst_element_factory_find("jpegdec");
if (jpegdec)
{
if (gst_element_factory_can_src_any_caps(jpegdec, wanted_caps)
&& gst_element_factory_can_sink_any_caps(jpegdec, available_caps))
{
requires_jpegdec = true;
requires_vidoeconvert = true;
// wanted_caps can be fixed, etc.
// thus change name to be compatible to jpegdec sink pad
// and create a correct intersection
GstCaps* temp = gst_caps_copy(wanted_caps);
gst_caps_change_name(temp, "image/jpeg");
for (unsigned int i = 0; i < gst_caps_get_size(temp); ++i)
{
gst_structure_remove_field(gst_caps_get_structure(temp, i), "format");
}
GstCaps* ret = gst_caps_intersect(available_caps, temp);
gst_caps_unref(temp);
gst_object_unref(jpegdec);
return ret;
}
gst_object_unref(jpegdec);
}
GstCaps* intersect = gst_caps_intersect(available_caps, wanted_caps);
if (!gst_caps_is_empty(intersect))
{
return intersect;
}
gst_caps_unref(intersect);
return nullptr;
}
static CodecBlueprint *
load_codec_blueprint (FsMediaType media_type, gchar **in, gsize *size) {
CodecBlueprint *codec_blueprint = g_slice_new0 (CodecBlueprint);
gchar *tmp;
gint tmp_size;
int i;
gint id;
gchar *encoding_name = NULL;
guint clock_rate;
READ_CHECK (read_codec_blueprint_int
(in, size, &(id)));
READ_CHECK (read_codec_blueprint_string
(in, size, &(encoding_name)));
READ_CHECK (read_codec_blueprint_uint
(in, size, &(clock_rate)));
codec_blueprint->codec = fs_codec_new (id, encoding_name, media_type,
clock_rate);
g_free (encoding_name);
READ_CHECK (read_codec_blueprint_uint
(in, size, &(codec_blueprint->codec->channels)));
READ_CHECK (read_codec_blueprint_int (in, size, &tmp_size));
for (i = 0; i < tmp_size; i++) {
gchar *name, *value;
READ_CHECK (read_codec_blueprint_string (in, size, &(name)));
READ_CHECK (read_codec_blueprint_string (in, size, &(value)));
fs_codec_add_optional_parameter (codec_blueprint->codec, name, value);
g_free (name);
g_free (value);
}
READ_CHECK (read_codec_blueprint_string (in, size, &tmp));
codec_blueprint->media_caps = gst_caps_from_string (tmp);
g_free (tmp);
READ_CHECK (read_codec_blueprint_string (in, size, &tmp));
codec_blueprint->rtp_caps = gst_caps_from_string (tmp);
g_free (tmp);
READ_CHECK (read_codec_blueprint_int (in, size, &tmp_size));
for (i = 0; i < tmp_size; i++) {
int j, tmp_size2;
GList *tmplist = NULL;
READ_CHECK (read_codec_blueprint_int (in, size, &tmp_size2));
for (j = 0; j < tmp_size2; j++) {
GstElementFactory *fact = NULL;
READ_CHECK (read_codec_blueprint_string (in, size, &(tmp)));
fact = gst_element_factory_find (tmp);
g_free (tmp);
if (!fact)
goto error;
tmplist = g_list_append (tmplist, fact);
}
codec_blueprint->send_pipeline_factory =
g_list_append (codec_blueprint->send_pipeline_factory, tmplist);
}
READ_CHECK (read_codec_blueprint_int (in, size, &tmp_size));
for (i = 0; i < tmp_size; i++) {
int j, tmp_size2;
GList *tmplist = NULL;
READ_CHECK (read_codec_blueprint_int (in, size, &tmp_size2));
for (j = 0; j < tmp_size2; j++) {
GstElementFactory *fact = NULL;
READ_CHECK (read_codec_blueprint_string (in, size, &(tmp)));
fact = gst_element_factory_find (tmp);
g_free (tmp);
if (!fact)
goto error;
tmplist = g_list_append (tmplist, fact);
}
codec_blueprint->receive_pipeline_factory =
g_list_append (codec_blueprint->receive_pipeline_factory, tmplist);
}
GST_DEBUG ("adding codec %s with pt %d, send_pipeline %p, receive_pipeline %p",
codec_blueprint->codec->encoding_name, codec_blueprint->codec->id,
codec_blueprint->send_pipeline_factory,
codec_blueprint->receive_pipeline_factory);
return codec_blueprint;
error:
codec_blueprint_destroy (codec_blueprint);
return NULL;
}
/*!
* \brief CvCapture_GStreamer::open Open the given file with gstreamer
* \param type CvCapture type. One of CV_CAP_GSTREAMER_*
* \param filename Filename to open in case of CV_CAP_GSTREAMER_FILE
* \return boolean. Specifies if opening was succesful.
*
* In case of CV_CAP_GSTREAMER_V4L(2), a pipelin is constructed as follows:
* v4l2src ! autoconvert ! appsink
*
*
* The 'filename' parameter is not limited to filesystem paths, and may be one of the following:
*
* - a normal filesystem path:
* e.g. video.avi or /path/to/video.avi or C:\\video.avi
* - an uri:
* e.g. file:///path/to/video.avi or rtsp:///path/to/stream.asf
* - a gstreamer pipeline description:
* e.g. videotestsrc ! videoconvert ! appsink
* the appsink name should be either 'appsink0' (the default) or 'opencvsink'
*
* When dealing with a file, CvCapture_GStreamer will not drop frames if the grabbing interval
* larger than the framerate period. (Unlike the uri or manual pipeline description, which assume
* a live source)
*
* The pipeline will only be started whenever the first frame is grabbed. Setting pipeline properties
* is really slow if we need to restart the pipeline over and over again.
*
* TODO: the 'type' parameter is imo unneeded. for v4l2, filename 'v4l2:///dev/video0' can be used.
* I expect this to be the same for CV_CAP_GSTREAMER_1394. Is anyone actually still using v4l (v1)?
*
*/
bool CvCapture_GStreamer::open( int type, const char* filename )
{
CV_FUNCNAME("cvCaptureFromCAM_GStreamer");
__BEGIN__;
gst_initializer::init();
bool file = false;
bool stream = false;
bool manualpipeline = false;
char *uri = NULL;
uridecodebin = NULL;
GstElementFactory * testfac;
GstStateChangeReturn status;
if (type == CV_CAP_GSTREAMER_V4L){
testfac = gst_element_factory_find("v4lsrc");
if (!testfac){
return false;
}
g_object_unref(G_OBJECT(testfac));
filename = "v4lsrc ! "COLOR_ELEM" ! appsink";
}
if (type == CV_CAP_GSTREAMER_V4L2){
testfac = gst_element_factory_find("v4l2src");
if (!testfac){
return false;
}
g_object_unref(G_OBJECT(testfac));
filename = "v4l2src ! "COLOR_ELEM" ! appsink";
}
// test if we have a valid uri. If so, open it with an uridecodebin
// else, we might have a file or a manual pipeline.
// if gstreamer cannot parse the manual pipeline, we assume we were given and
// ordinary file path.
if(!gst_uri_is_valid(filename))
{
uri = realpath(filename, NULL);
stream = false;
if(uri)
{
uri = g_filename_to_uri(uri, NULL, NULL);
if(uri)
{
file = true;
}
else
{
CV_WARN("GStreamer: Error opening file\n");
close();
return false;
}
}
else
{
GError *err = NULL;
uridecodebin = gst_parse_launch(filename, &err);
if(!uridecodebin)
{
fprintf(stderr, "GStreamer: Error opening bin: %s\n", err->message);
return false;
}
stream = true;
manualpipeline = true;
}
} else {
stream = true;
uri = g_strdup(filename);
}
bool element_from_uri = false;
if(!uridecodebin)
{
// At this writing, the v4l2 element (and maybe others too) does not support caps renegotiation.
// This means that we cannot use an uridecodebin when dealing with v4l2, since setting
// capture properties will not work.
// The solution (probably only until gstreamer 1.2) is to make an element from uri when dealing with v4l2.
gchar * protocol = gst_uri_get_protocol(uri);
if (!strcasecmp(protocol , "v4l2"))
{
#if GST_VERSION_MAJOR == 0
uridecodebin = gst_element_make_from_uri(GST_URI_SRC, uri, "src");
#else
uridecodebin = gst_element_make_from_uri(GST_URI_SRC, uri, "src", NULL);
#endif
element_from_uri = true;
}else{
uridecodebin = gst_element_factory_make("uridecodebin", NULL);
g_object_set(G_OBJECT(uridecodebin), "uri", uri, NULL);
}
g_free(protocol);
if(!uridecodebin) {
//fprintf(stderr, "GStreamer: Error opening bin: %s\n", err->message);
close();
return false;
}
}
if(manualpipeline)
{
GstIterator *it = NULL;
#if GST_VERSION_MAJOR == 0
it = gst_bin_iterate_sinks(GST_BIN(uridecodebin));
if(gst_iterator_next(it, (gpointer *)&sink) != GST_ITERATOR_OK) {
CV_ERROR(CV_StsError, "GStreamer: cannot find appsink in manual pipeline\n");
return false;
}
#else
it = gst_bin_iterate_sinks (GST_BIN(uridecodebin));
gboolean done = FALSE;
GstElement *element = NULL;
gchar* name = NULL;
GValue value = G_VALUE_INIT;
while (!done) {
switch (gst_iterator_next (it, &value)) {
case GST_ITERATOR_OK:
element = GST_ELEMENT (g_value_get_object (&value));
name = gst_element_get_name(element);
if (name){
if(strstr(name, "opencvsink") != NULL || strstr(name, "appsink") != NULL) {
sink = GST_ELEMENT ( gst_object_ref (element) );
done = TRUE;
}
g_free(name);
}
g_value_unset (&value);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (it);
break;
case GST_ITERATOR_ERROR:
case GST_ITERATOR_DONE:
done = TRUE;
break;
}
}
gst_iterator_free (it);
if (!sink){
CV_ERROR(CV_StsError, "GStreamer: cannot find appsink in manual pipeline\n");
return false;
}
#endif
pipeline = uridecodebin;
}
else
{
pipeline = gst_pipeline_new(NULL);
// videoconvert (in 0.10: ffmpegcolorspace, in 1.x autovideoconvert)
//automatically selects the correct colorspace conversion based on caps.
color = gst_element_factory_make(COLOR_ELEM, NULL);
sink = gst_element_factory_make("appsink", NULL);
gst_bin_add_many(GST_BIN(pipeline), uridecodebin, color, sink, NULL);
if(element_from_uri) {
if(!gst_element_link(uridecodebin, color)) {
CV_ERROR(CV_StsError, "GStreamer: cannot link color -> sink\n");
gst_object_unref(pipeline);
pipeline = NULL;
return false;
}
}else{
g_signal_connect(uridecodebin, "pad-added", G_CALLBACK(newPad), color);
}
if(!gst_element_link(color, sink)) {
CV_ERROR(CV_StsError, "GStreamer: cannot link color -> sink\n");
gst_object_unref(pipeline);
pipeline = NULL;
return false;
}
}
//TODO: is 1 single buffer really high enough?
gst_app_sink_set_max_buffers (GST_APP_SINK(sink), 1);
gst_app_sink_set_drop (GST_APP_SINK(sink), stream);
//do not emit signals: all calls will be synchronous and blocking
gst_app_sink_set_emit_signals (GST_APP_SINK(sink), 0);
#if GST_VERSION_MAJOR == 0
caps = gst_caps_new_simple("video/x-raw-rgb",
"bpp", G_TYPE_INT, 24,
"red_mask", G_TYPE_INT, 0x0000FF,
"green_mask", G_TYPE_INT, 0x00FF00,
"blue_mask", G_TYPE_INT, 0xFF0000,
NULL);
#else
// support 1 and 3 channel 8 bit data, as well as bayer (also 1 channel, 8bit)
caps = gst_caps_from_string("video/x-raw, format=(string){BGR, GRAY8}; video/x-bayer,format=(string){rggb,bggr,grbg,gbrg}");
#endif
gst_app_sink_set_caps(GST_APP_SINK(sink), caps);
gst_caps_unref(caps);
// For video files only: set pipeline to PAUSED state to get its duration
if (file)
{
status = gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PAUSED);
if (status == GST_STATE_CHANGE_ASYNC)
{
// wait for status update
GstState st1;
GstState st2;
status = gst_element_get_state(pipeline, &st1, &st2, GST_CLOCK_TIME_NONE);
}
if (status == GST_STATE_CHANGE_FAILURE)
{
handleMessage(pipeline);
gst_object_unref(pipeline);
pipeline = NULL;
CV_ERROR(CV_StsError, "GStreamer: unable to start pipeline\n");
return false;
}
GstFormat format;
format = GST_FORMAT_DEFAULT;
#if GST_VERSION_MAJOR == 0
if(!gst_element_query_duration(sink, &format, &duration))
#else
if(!gst_element_query_duration(sink, format, &duration))
#endif
{
handleMessage(pipeline);
CV_WARN("GStreamer: unable to query duration of stream");
duration = -1;
return true;
}
}
else
{
duration = -1;
}
__END__;
return true;
}
static void
dvb_base_bin_class_init (DvbBaseBinClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
GstBinClass *bin_class;
GstElementFactory *dvbsrc_factory;
GObjectClass *dvbsrc_class;
typedef struct
{
guint prop_id;
const gchar *prop_name;
} ProxyedProperty;
ProxyedProperty *walk;
ProxyedProperty proxyed_properties[] = {
{PROP_ADAPTER, "adapter"},
{PROP_FRONTEND, "frontend"},
{PROP_DISEQC_SRC, "diseqc-source"},
{PROP_FREQUENCY, "frequency"},
{PROP_POLARITY, "polarity"},
{PROP_SYMBOL_RATE, "symbol-rate"},
{PROP_BANDWIDTH, "bandwidth"},
{PROP_CODE_RATE_HP, "code-rate-hp"},
{PROP_CODE_RATE_LP, "code-rate-lp"},
{PROP_GUARD, "guard"},
{PROP_MODULATION, "modulation"},
{PROP_TRANS_MODE, "trans-mode"},
{PROP_HIERARCHY, "hierarchy"},
{PROP_INVERSION, "inversion"},
{PROP_STATS_REPORTING_INTERVAL, "stats-reporting-interval"},
{0, NULL}
};
bin_class = GST_BIN_CLASS (klass);
bin_class->handle_message = dvb_base_bin_handle_message;
element_class = GST_ELEMENT_CLASS (klass);
element_class->change_state = dvb_base_bin_change_state;
gobject_class = G_OBJECT_CLASS (klass);
gobject_class->set_property = dvb_base_bin_set_property;
gobject_class->get_property = dvb_base_bin_get_property;
gobject_class->dispose = dvb_base_bin_dispose;
gobject_class->finalize = dvb_base_bin_finalize;
/* install dvbsrc properties */
dvbsrc_factory = gst_element_factory_find ("dvbsrc");
dvbsrc_class = g_type_class_ref (dvbsrc_factory->type);
walk = proxyed_properties;
while (walk->prop_name != NULL) {
GParamSpec *pspec;
GParamSpec *our_pspec;
pspec = g_object_class_find_property (dvbsrc_class, walk->prop_name);
if (pspec != NULL) {
GType param_type = G_PARAM_SPEC_TYPE (pspec);
if (param_type == G_TYPE_PARAM_INT) {
GParamSpecInt *src_pspec = G_PARAM_SPEC_INT (pspec);
our_pspec = g_param_spec_int (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
pspec->flags);
} else if (param_type == G_TYPE_PARAM_UINT) {
GParamSpecUInt *src_pspec = G_PARAM_SPEC_UINT (pspec);
our_pspec = g_param_spec_uint (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
pspec->flags);
} else if (param_type == G_TYPE_PARAM_STRING) {
GParamSpecString *src_pspec = G_PARAM_SPEC_STRING (pspec);
our_pspec = g_param_spec_string (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->default_value, pspec->flags);
} else if (param_type == G_TYPE_PARAM_ENUM) {
GParamSpecEnum *src_pspec = G_PARAM_SPEC_ENUM (pspec);
our_pspec = g_param_spec_enum (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
pspec->value_type, src_pspec->default_value, pspec->flags);
} else {
GST_ERROR ("Unsupported property type %d for property %s",
param_type, g_param_spec_get_name (pspec));
++walk;
continue;
}
g_object_class_install_property (gobject_class, walk->prop_id, our_pspec);
} else {
g_warning ("dvbsrc has no property named %s", walk->prop_name);
}
++walk;
}
g_type_class_unref (dvbsrc_class);
g_object_class_install_property (gobject_class, PROP_PROGRAM_NUMBERS,
g_param_spec_string ("program-numbers",
"Program Numbers",
"Colon separated list of programs", "", G_PARAM_READWRITE));
}
static GList*
fs_rtp_dtmf_event_source_class_add_blueprint (FsRtpSpecialSourceClass *klass,
GList *blueprints)
{
GList *item;
GList *already_done = NULL;
GstElementFactory *fact = NULL;
GList *new_blueprints = NULL;
fact = gst_element_factory_find ("rtpdtmfsrc");
if (fact)
{
gst_object_unref (fact);
}
else
{
GST_CAT_WARNING (fsrtpconference_disco,
"Could not find rtpdtmfsrc, will not offer DTMF events");
return blueprints;
}
fact = gst_element_factory_find ("rtpdtmfdepay");
if (!fact)
GST_CAT_WARNING (fsrtpconference_disco,
"Could not find rtpdtmfdepay, will not be able to receive DTMF events");
for (item = g_list_first (blueprints);
item;
item = g_list_next (item))
{
CodecBlueprint *bp = item->data;
GList *done_item = NULL;
gboolean skip = FALSE;
CodecBlueprint *new_bp = NULL;
if (bp->codec->media_type != FS_MEDIA_TYPE_AUDIO)
continue;
if (!g_ascii_strcasecmp (bp->codec->encoding_name, "telephone-event"))
continue;
if (bp->codec->clock_rate == 0)
continue;
for (done_item = g_list_first (already_done);
done_item;
done_item = g_list_next (done_item))
{
if (GPOINTER_TO_UINT (done_item->data) == bp->codec->clock_rate)
{
skip = TRUE;
break;
}
}
if (skip)
continue;
new_bp = g_slice_new0 (CodecBlueprint);
new_bp->codec = fs_codec_new (FS_CODEC_ID_ANY, "telephone-event",
FS_MEDIA_TYPE_AUDIO, bp->codec->clock_rate);
fs_codec_add_optional_parameter (new_bp->codec, "events", "0-15");
new_bp->rtp_caps = fs_codec_to_gst_caps (new_bp->codec);
new_bp->media_caps = gst_caps_new_any ();
if (fact)
new_bp->receive_pipeline_factory = g_list_prepend (NULL,
g_list_prepend (NULL, gst_object_ref (fact)));
new_blueprints = g_list_append (new_blueprints, new_bp);
already_done = g_list_prepend (already_done,
GUINT_TO_POINTER (bp->codec->clock_rate));
}
if (fact)
gst_object_unref (fact);
g_list_free (already_done);
blueprints = g_list_concat (blueprints, new_blueprints);
return blueprints;
}