GST_END_TEST GST_START_TEST (check_properties) { GstElement *filterelement, *filter; GstElementFactory *factory; gchar *filter_factory; filterelement = gst_element_factory_make ("filterelement", NULL); /* Default value for filter factory must be NULL */ g_object_get (G_OBJECT (filterelement), "filter_factory", &filter_factory, NULL); GST_DEBUG ("Got filter_factory property value : %s", filter_factory); fail_unless (filter_factory == NULL); /* Default value for filter must be NULL */ g_object_get (G_OBJECT (filterelement), "filter", &filter, NULL); GST_DEBUG ("Got filter property value : %" GST_PTR_FORMAT, filter); fail_unless (filter == NULL); /* Set factory */ filter_factory = "videoflip"; GST_DEBUG ("Setting property uri to : %s", filter_factory); g_object_set (G_OBJECT (filterelement), "filter_factory", filter_factory, NULL); g_object_get (G_OBJECT (filterelement), "filter", &filter, NULL); fail_unless (filter != NULL); factory = gst_element_get_factory (filter); fail_unless (factory != NULL); GST_DEBUG ("Got factory: %s", GST_OBJECT_NAME (factory)); fail_unless (g_strcmp0 (filter_factory, GST_OBJECT_NAME (factory)) == 0); GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (filterelement), GST_DEBUG_GRAPH_SHOW_ALL, "filter"); /* Reset factory */ filter_factory = "videocrop"; GST_DEBUG ("Setting property uri to : %s", filter_factory); g_object_set (G_OBJECT (filterelement), "filter_factory", filter_factory, NULL); g_object_get (G_OBJECT (filterelement), "filter", &filter, NULL); fail_unless (filter != NULL); factory = gst_element_get_factory (filter); fail_unless (factory != NULL); GST_DEBUG ("Got factory: %s", GST_OBJECT_NAME (factory)); /* Factory changes are not allowed */ fail_unless (g_strcmp0 (filter_factory, GST_OBJECT_NAME (factory))); gst_object_unref (filterelement); }
static void conference_element_added (FsElementAddedNotifier *notifier, GstBin *bin, GstElement *element, gpointer user_data) { GstElementFactory *factory; const gchar *name; factory = gst_element_get_factory (element); name = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)); if (!tp_strdiff (name, "x264enc")) { /* Ensure that the encoder creates the baseline profile */ g_object_set (element, "byte-stream", TRUE, "bframes", 0, "b-adapt", FALSE, "cabac", FALSE, "dct8x8", FALSE, NULL); } else if (!tp_strdiff (name, "gstrtpbin")) { /* Lower the jitterbuffer latency to make it more suitable for video * conferencing */ g_object_set (element, "latency", 100, NULL); } }
static struct device_resources find_source (GstElement* self) { struct device_resources res = {}; res.color.max = 255; /* if camera_src is not set we assume that the first default camera src found shall be used */ GstElement* e = GST_ELEMENT(gst_object_get_parent(GST_OBJECT(self))); GList* l = GST_BIN(e)->children; while (1==1) { const char* name = g_type_name(gst_element_factory_get_element_type(gst_element_get_factory(l->data))); if (g_strcmp0(name, "GstTcamSrc") == 0) { GST_INFO("Found tcam source element"); res.source_element = l->data; break; } if (g_list_next(l) == NULL) break; l = g_list_next(l); } update_device_resources(&res); return res; }
static void element_setup (GstElement * playbin, GstElement * element, GQueue * elts) { GstElementFactory *f = gst_element_get_factory (element); g_queue_push_tail (elts, f ? GST_OBJECT_NAME (f) : GST_OBJECT_NAME (element)); }
GstElement* tcam_gst_find_camera_src (GstElement* element) { GstPad* orig_pad = gst_element_get_static_pad(element, "sink"); GstPad* src_pad = gst_pad_get_peer(orig_pad); g_object_unref(orig_pad); if (!src_pad) { // this means we have reached a dead end where no valid tcamsrc exists return nullptr; } GstElement* el = gst_pad_get_parent_element(src_pad); gst_object_unref(src_pad); GstElement* ret; const char* name = g_type_name(gst_element_factory_get_element_type(gst_element_get_factory(el))); if (g_strcmp0(name, "GstTcamSrc") == 0) { return el; } ret = tcam_gst_find_camera_src(el); gst_object_unref(el); return ret; }
static GstElement * kms_av_muxer_create_muxer (KmsAVMuxer * self) { switch (KMS_BASE_MEDIA_MUXER_GET_PROFILE (self)) { case KMS_RECORDING_PROFILE_WEBM: case KMS_RECORDING_PROFILE_WEBM_VIDEO_ONLY: case KMS_RECORDING_PROFILE_WEBM_AUDIO_ONLY: return gst_element_factory_make ("webmmux", NULL); case KMS_RECORDING_PROFILE_MP4: case KMS_RECORDING_PROFILE_MP4_VIDEO_ONLY: case KMS_RECORDING_PROFILE_MP4_AUDIO_ONLY:{ GstElement *mux = gst_element_factory_make ("mp4mux", NULL); GstElementFactory *file_sink_factory = gst_element_factory_find ("filesink"); GstElementFactory *sink_factory = gst_element_get_factory (self->priv->sink); if ((gst_element_factory_get_element_type (sink_factory) != gst_element_factory_get_element_type (file_sink_factory))) { g_object_set (mux, "faststart", TRUE, NULL); } g_object_unref (file_sink_factory); return mux; } case KMS_RECORDING_PROFILE_JPEG_VIDEO_ONLY: return gst_element_factory_make ("jifmux", NULL); default: GST_ERROR_OBJECT (self, "No valid recording profile set"); return NULL; } }
static void mutate_playbin (RBVisualizerPlugin *plugin, GstElement *playbin) { GstElement *current_vis_plugin; GstElement *current_video_sink; int playbin_flags; if (playbin == plugin->playbin) return; rb_debug ("mutating playbin"); /* check no one has already set the playbin properties we're interested in */ g_object_get (playbin, "vis-plugin", ¤t_vis_plugin, "video-sink", ¤t_video_sink, "flags", &playbin_flags, NULL); /* ignore fakesinks */ if (current_video_sink != NULL) { const char *factoryname; GstElementFactory *factory; factory = gst_element_get_factory (current_video_sink); factoryname = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)); if (strcmp (factoryname, "fakesink") == 0) { g_object_unref (current_video_sink); current_video_sink = NULL; } } if ((current_vis_plugin != NULL) || (current_video_sink != NULL)) { g_warning ("sink and/or vis plugin already set on playbin"); if (current_vis_plugin) g_object_unref (current_vis_plugin); if (current_video_sink) g_object_unref (current_video_sink); return; } /* detach from old playbin (this should never really happen) */ if (plugin->playbin) { g_object_unref (plugin->playbin); } /* attach to new playbin */ plugin->playbin = g_object_ref (playbin); g_object_set (plugin->playbin, "video-sink", plugin->sink, NULL); /* start visualizer if it's supposed to be running */ if (plugin->visualizer != NULL) { playbin_flags |= PLAYBIN2_FLAG_VIS; g_object_set (plugin->playbin, "flags", playbin_flags, "vis-plugin", plugin->visualizer, NULL); } }
static const gchar * factory_name_from_element (GstElement *element) { GstElementFactory *factory = gst_element_get_factory (element); if (factory) return gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)); else return NULL; }
static void test_position (InsanityTest * test, GstBuffer * buf) { GstQuery *query; GstClockTimeDiff diff; if (GST_BUFFER_PTS_IS_VALID (buf) == FALSE) return; if (GST_CLOCK_TIME_IS_VALID (glob_first_pos_point) == FALSE) { glob_first_pos_point = gst_segment_to_stream_time (&glob_last_segment, glob_last_segment.format, GST_BUFFER_PTS (buf)); } glob_expected_pos = gst_segment_to_stream_time (&glob_last_segment, glob_last_segment.format, GST_BUFFER_PTS (buf)); diff = ABS (GST_CLOCK_DIFF (glob_expected_pos, glob_first_pos_point)); if (diff < glob_playback_duration * GST_SECOND) return; query = gst_query_new_position (GST_FORMAT_TIME); if (gst_element_query (glob_pipeline, query)) { gint64 pos; GstFormat fmt; GstClockTimeDiff diff; gst_query_parse_position (query, &fmt, &pos); diff = ABS (GST_CLOCK_DIFF (glob_expected_pos, pos)); if (diff <= POSITION_THRESHOLD) { insanity_test_validate_checklist_item (test, "position-detection", TRUE, NULL); } else { gchar *validate_msg = g_strdup_printf ("Found position: %" GST_TIME_FORMAT " expected: %" GST_TIME_FORMAT, GST_TIME_ARGS (pos), GST_TIME_ARGS (glob_expected_pos)); insanity_test_validate_checklist_item (test, "position-detection", FALSE, validate_msg); g_free (validate_msg); } } else { LOG (test, "%s Does not handle position queries (position-detection \"SKIP\")", gst_element_factory_get_metadata (gst_element_get_factory (glob_demuxer), GST_ELEMENT_METADATA_LONGNAME)); } next_test (test); }
static gint find_composition_func (const GValue * velement) { GstElement *element = g_value_get_object (velement); GstElementFactory *fac = gst_element_get_factory (element); const gchar *name = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (fac)); if (g_strcmp0 (name, "gnlcomposition") == 0) return 0; return 1; }
gboolean rb_gst_encoder_set_encoding_style (GstElement *encoder, const char *style) { GstElementFactory *factory; char *group_name; char **keys; int i; factory = gst_element_get_factory (encoder); group_name = g_strdup_printf (ENCODER_STYLE_SETTINGS_PREFIX "%s-%s", gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)), style); rb_debug ("applying settings from %s", group_name); keys = g_key_file_get_keys (get_target_keyfile (), group_name, NULL, NULL); if (keys == NULL) { rb_debug ("nothing to apply"); g_free (group_name); return FALSE; } for (i = 0; keys[i] != NULL; i++) { GParamSpec *pspec; GValue v = {0,}; char *value; pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (encoder), keys[i]); if (pspec == NULL) { rb_debug ("couldn't find property %s", keys[i]); continue; } value = g_key_file_get_string (get_target_keyfile (), group_name, keys[i], NULL); if (value == NULL) { rb_debug ("couldn't get value for property %s", keys[i]); continue; } g_value_init (&v, pspec->value_type); if (gst_value_deserialize (&v, value)) { rb_debug ("applying value \"%s\" to property %s", value, keys[i]); g_object_set_property (G_OBJECT (encoder), keys[i], &v); } else { rb_debug ("couldn't deserialize value \"%s\" for property %s", value, keys[i]); } g_value_unset (&v); } g_strfreev (keys); g_free (group_name); return TRUE; }
GstElement * _owr_payload_create_encoder(OwrPayload *payload) { GstElement *encoder = NULL; gchar *element_name = NULL; GstElementFactory *factory; const gchar *factory_name; g_return_val_if_fail(payload, NULL); switch (payload->priv->codec_type) { case OWR_CODEC_TYPE_H264: encoder = try_codecs(h264_encoders, "encoder"); g_return_val_if_fail(encoder, NULL); factory = gst_element_get_factory(encoder); factory_name = gst_plugin_feature_get_name(factory); if (!strcmp(factory_name, "openh264enc")) { g_object_set(encoder, "gop-size", 0, NULL); gst_util_set_object_arg(G_OBJECT(encoder), "rate-control", "bitrate"); g_object_bind_property(payload, "bitrate", encoder, "bitrate", G_BINDING_SYNC_CREATE); } else if (!strcmp(factory_name, "x264enc")) { g_object_bind_property_full(payload, "bitrate", encoder, "bitrate", G_BINDING_SYNC_CREATE, binding_transform_to_kbps, NULL, NULL, NULL); g_object_set(encoder, "tune", 0x04 /* zero-latency */, NULL); } else if (!strcmp(factory_name, "vtenc_h264")) { g_object_bind_property_full(payload, "bitrate", encoder, "bitrate", G_BINDING_SYNC_CREATE, binding_transform_to_kbps, NULL, NULL, NULL); } else { /* Assume bits/s instead of kbit/s */ g_object_bind_property(payload, "bitrate", encoder, "bitrate", G_BINDING_SYNC_CREATE); } g_object_set(payload, "bitrate", evaluate_bitrate_from_payload(payload), NULL); break; case OWR_CODEC_TYPE_VP8: encoder = try_codecs(vp8_encoders, "encoder"); g_return_val_if_fail(encoder, NULL); g_object_set(encoder, "end-usage", 1, "deadline", G_GINT64_CONSTANT(1), "lag-in-frames", 0, "error-resilient", 1, "keyframe-mode", 0, NULL); g_object_bind_property(payload, "bitrate", encoder, "target-bitrate", G_BINDING_SYNC_CREATE); g_object_set(payload, "bitrate", evaluate_bitrate_from_payload(payload), NULL); break; default: element_name = g_strdup_printf("encoder_%s_%u", OwrCodecTypeEncoderElementName[payload->priv->codec_type], get_unique_id()); encoder = gst_element_factory_make(OwrCodecTypeEncoderElementName[payload->priv->codec_type], element_name); g_free(element_name); g_return_val_if_fail(encoder, NULL); break; } return encoder; }
nsresult GStreamerReader::CheckSupportedFormats() { bool done = false; bool unsupported = false; GstIterator *it = gst_bin_iterate_recurse(GST_BIN(mPlayBin)); while (!done) { GstElement* element; GstIteratorResult res = gst_iterator_next(it, (void **)&element); switch(res) { case GST_ITERATOR_OK: { GstElementFactory* factory = gst_element_get_factory(element); if (factory) { const char* klass = gst_element_factory_get_klass(factory); GstPad* pad = gst_element_get_pad(element, "sink"); if (pad) { GstCaps* caps = gst_pad_get_negotiated_caps(pad); if (caps) { /* check for demuxers but ignore elements like id3demux */ if (strstr (klass, "Demuxer") && !strstr(klass, "Metadata")) unsupported = !GStreamerFormatHelper::Instance()->CanHandleContainerCaps(caps); else if (strstr (klass, "Decoder")) unsupported = !GStreamerFormatHelper::Instance()->CanHandleCodecCaps(caps); gst_caps_unref(caps); } gst_object_unref(pad); } } gst_object_unref(element); done = unsupported; break; } case GST_ITERATOR_RESYNC: unsupported = false; done = false; break; case GST_ITERATOR_ERROR: done = true; break; case GST_ITERATOR_DONE: done = true; break; } } return unsupported ? NS_ERROR_FAILURE : NS_OK; }
GstElement * _bp_equalizer_new (BansheePlayer *player) { GstElement *equalizer; if (player->equalizer_status == BP_EQ_STATUS_DISABLED) { return NULL; } if (player->equalizer_status == BP_EQ_STATUS_UNCHECKED || player->equalizer_status == BP_EQ_STATUS_USE_BUILTIN) { equalizer = gst_element_factory_make ("banshee-equalizer", "banshee-equalizer"); if (equalizer != NULL) { if (player->equalizer_status == BP_EQ_STATUS_UNCHECKED) { player->equalizer_status = BP_EQ_STATUS_USE_BUILTIN; bp_debug ("Using built-in equalizer element"); } return equalizer; } } if (player->equalizer_status == BP_EQ_STATUS_UNCHECKED || player->equalizer_status == BP_EQ_STATUS_USE_SYSTEM) { equalizer = gst_element_factory_make ("equalizer-10bands", "equalizer-10bands"); if (equalizer != NULL) { GstElementFactory *efactory = NULL; if (player->equalizer_status == BP_EQ_STATUS_USE_SYSTEM) { return equalizer; } efactory = gst_element_get_factory (equalizer); if (gst_plugin_feature_check_version (GST_PLUGIN_FEATURE (efactory), 0, 10, 9)) { bp_debug ("Using system (gst-plugins-good) equalizer element"); player->equalizer_status = BP_EQ_STATUS_USE_SYSTEM; return equalizer; } bp_debug ("Buggy system equalizer found. gst-plugins-good 0.10.9 or better " "required, or build Banshee with the built-in equalizer."); gst_object_unref (equalizer); } else { bp_debug ("No system equalizer found"); } } bp_debug ("No suitable equalizer element could be found, disabling EQ for this session"); player->equalizer_status = BP_EQ_STATUS_DISABLED; return NULL; }
static void add_element_used (InsanityGstPipelineTest * ptest, GstElement * element) { GstElementFactory *factory; const char *factory_name; char label[32], *element_name; GValue string_value = { 0 }; GstElement *parent; /* Only add once */ element_name = gst_element_get_name (element); if (g_hash_table_lookup_extended (ptest->priv->elements_used, element_name, NULL, NULL)) { g_free (element_name); return; } g_hash_table_insert (ptest->priv->elements_used, g_strdup (element_name), NULL); ptest->priv->element_count++; g_value_init (&string_value, G_TYPE_STRING); factory = gst_element_get_factory (element); factory_name = factory ? gst_element_factory_get_metadata (factory, GST_ELEMENT_METADATA_LONGNAME) : "(no factory)"; g_value_take_string (&string_value, element_name); snprintf (label, sizeof (label), "elements-used.%u.name", ptest->priv->element_count); insanity_test_set_extra_info (INSANITY_TEST (ptest), label, &string_value); g_value_reset (&string_value); g_value_set_string (&string_value, factory_name); snprintf (label, sizeof (label), "elements-used.%u.factory", ptest->priv->element_count); insanity_test_set_extra_info (INSANITY_TEST (ptest), label, &string_value); g_value_reset (&string_value); parent = GST_ELEMENT (gst_element_get_parent (element)); if (parent) { g_value_take_string (&string_value, gst_element_get_name (parent)); snprintf (label, sizeof (label), "elements-used.%u.parent", ptest->priv->element_count); insanity_test_set_extra_info (INSANITY_TEST (ptest), label, &string_value); g_value_reset (&string_value); gst_object_unref (parent); } }
static void unvalidate_seeking_tests (InsanityTest * test) { gchar *message = g_strdup_printf ("%s not seekable in %s mode", gst_element_factory_get_metadata (gst_element_get_factory (glob_demuxer), GST_ELEMENT_METADATA_LONGNAME), pipeline_mode_get_name (glob_push_mode)); insanity_test_validate_checklist_item (test, "fast-forward", TRUE, message); insanity_test_validate_checklist_item (test, "fast-backward", TRUE, message); insanity_test_validate_checklist_item (test, "backward-playback", TRUE, message); g_free (message); }
static gint find_hlsdemux (GValue * value, gpointer user_data) { GstElement *e = GST_ELEMENT (g_value_get_object (value)); GstObject *fact = GST_OBJECT (gst_element_get_factory (e)); gchar *name = gst_object_get_name (fact); if (g_strcmp0 (name, "hlsdemux") == 0) { g_free (name); return 0; } g_free (name); return 1; }
void GStreamerReader::ElementAddedCb(GstBin *aPlayBin, GstElement *aElement, gpointer aUserData) { GstElementFactory *factory = gst_element_get_factory(aElement); if (!factory) return; const gchar *name = gst_plugin_feature_get_name(GST_PLUGIN_FEATURE(factory)); if (name && !strcmp(name, "uridecodebin")) { g_signal_connect(G_OBJECT(aElement), "autoplug-sort", G_CALLBACK(GStreamerReader::ElementFilterCb), aUserData); } }
static void element_added (FsElementAddedNotifier *notif, GstBin *bin, GstElement *element, gpointer user_data) { GstElementFactory *fact = gst_element_get_factory (element); if (!fact) return; if (strcmp (gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (fact)), "theoradec")) return; ts_fail_unless (decoder_count == 0); decoder_count++; }
struct device_resources find_source (GstElement* self) { struct device_resources res = {}; res.color.max = 255; /* if camera_src is not set we assume that the first default camera src found shall be used */ GstElement* e = GST_ELEMENT( gst_object_get_parent(GST_OBJECT(self))); GList* l = GST_BIN(e)->children; while (1==1) { const char* name = g_type_name(gst_element_factory_get_element_type (gst_element_get_factory(l->data))); if (g_strcmp0(name, CAMERASRC_USB) == 0) { GST_LOG_OBJECT(self, "Found v4l2 device"); res.source_type = V4L2; res.source_element = l->data; break; } if (g_strcmp0(name, CAMERASRC_NETWORK) == 0) { GST_LOG_OBJECT(self, "Found aravis device"); res.source_type = ARAVIS; res.source_element = l->data; break; } if (g_list_next(l) == NULL) break; l = g_list_next(l); } if (res.source_type == UNKNOWN) { GST_LOG_OBJECT(self, "Unknown source type"); } update_device_resources (&res); return res; }
static gpointer rb_audiocd_load_songs (RBAudioCdSource *source) { RBAudioCdSourcePrivate *priv = AUDIOCD_SOURCE_GET_PRIVATE (source); RhythmDB *db; GVolume *volume; g_object_get (source, "volume", &volume, NULL); priv->device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); g_object_unref (volume); db = get_db_for_source (source); rb_debug ("loading Audio CD from %s", priv->device_path); /* create a cdda gstreamer element, to get cd info from */ priv->cdda = gst_element_make_from_uri (GST_URI_SRC, "cdda://", NULL); if (!priv->cdda) { gdk_threads_enter (); rb_error_dialog (NULL, _("Couldn't load Audio CD"), _("Rhythmbox could not get access to the CD device.")); gdk_threads_leave (); goto error_out; } rb_debug ("cdda longname: %s", gst_element_factory_get_longname (gst_element_get_factory (priv->cdda))); g_object_set (G_OBJECT (priv->cdda), "device", priv->device_path, NULL); priv->pipeline = gst_pipeline_new ("pipeline"); priv->fakesink = gst_element_factory_make ("fakesink", "fakesink"); gst_bin_add_many (GST_BIN (priv->pipeline), priv->cdda, priv->fakesink, NULL); gst_element_link (priv->cdda, priv->fakesink); /* disable paranoia (if using cdparanoia) since we're only reading track information here. * this reduces cdparanoia's cache size, so the process is much faster. */ if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "paranoia-mode")) g_object_set (source, "paranoia-mode", 0, NULL); if (rb_audiocd_scan_songs (source, db)) rb_audiocd_load_metadata (source, db); error_out: g_object_unref (db); g_object_unref (source); return NULL; }
bool ofGstUtils::setPipelineWithSink(GstElement * pipeline, GstElement * sink, bool isStream_){ gstPipeline = pipeline; gstSink = sink; isStream = isStream_; if(gstSink){ gst_base_sink_set_sync(GST_BASE_SINK(gstSink), true); } if(gstSink && string(gst_plugin_feature_get_name( GST_PLUGIN_FEATURE(gst_element_get_factory(gstSink))))=="appsink"){ isAppSink = true; }else{ isAppSink = false; } return startPipeline(); }
static gboolean mixer_filter_func (GstMixer * mixer, gpointer user_data) { GstElementFactory *factory; const gchar *long_name; gchar *devname = NULL; gchar *name; gint *p_count = (gint *) user_data; /* fetch name */ if (g_object_class_find_property (G_OBJECT_GET_CLASS (G_OBJECT (mixer)), "device-name")) { g_object_get (mixer, "device-name", &devname, NULL); GST_DEBUG ("device name: %s", GST_STR_NULL (devname)); } else { devname = NULL; GST_DEBUG ("device name unknown, no 'device-name' property"); } factory = gst_element_get_factory (GST_ELEMENT (mixer)); long_name = gst_element_factory_get_longname (factory); if (devname) { name = g_strdup_printf ("%s (%s)", devname, long_name); g_free (devname); } else { gchar *title; *p_count += 1; title = g_strdup_printf (_("Unknown Volume Control %d"), *p_count); name = g_strdup_printf ("%s (%s)", title, long_name); g_free (title); } g_object_set_data_full (G_OBJECT (mixer), "mate-volume-control-name", name, (GDestroyNotify) g_free); GST_DEBUG ("Adding '%s' to list of available mixers", name); gst_element_set_state (GST_ELEMENT (mixer), GST_STATE_NULL); return TRUE; /* add mixer to list */ }
static gint find_by_factory_func(gconstpointer p_value_ptr, gconstpointer p_user_data) { GValue const *value = static_cast < GValue const* > (p_value_ptr); std::string const *expected_factory_name = static_cast < std::string const * > (p_user_data); GstElement *elem = GST_ELEMENT(g_value_get_object(value)); GST_OBJECT_LOCK(elem); GstElementFactory *factory = gst_element_get_factory(elem); gchar const *factory_name = gst_plugin_feature_get_name(factory); gint result = (factory_name == *expected_factory_name) ? 0 : 1; GST_OBJECT_UNLOCK(elem); return result; }
static char * make_bundle_name (GstObject * obj, const gchar * name) { GstElementFactory *factory; gchar *basename, *s, *bundle; factory = gst_element_get_factory ((GstElement *) obj); basename = g_strdup (gst_element_factory_get_metadata (factory, GST_ELEMENT_METADATA_LONGNAME)); s = basename; while ((s = strchr (s, ' '))) { *s = '_'; } bundle = g_strjoin (NULL, basename, "_", name, ".preset.lv2", NULL); g_free (basename); return bundle; }
static void remove_on_unlinked_async (gpointer data, gpointer not_used) { GstElement *elem = GST_ELEMENT_CAST (data); GstObject *parent = gst_object_get_parent (GST_OBJECT (elem)); gst_element_set_locked_state (elem, TRUE); if (g_strcmp0 (GST_OBJECT_NAME (gst_element_get_factory (elem)), "queue") == 0) { g_object_set (G_OBJECT (elem), "flush-on-eos", TRUE, NULL); gst_element_send_event (elem, gst_event_new_eos ()); } gst_element_set_state (elem, GST_STATE_NULL); if (parent != NULL) { gst_bin_remove (GST_BIN (parent), elem); g_object_unref (parent); } g_object_unref (data); }
void CameraBinAudioEncoder::applySettings(GstElement *encoder) { GObjectClass * const objectClass = G_OBJECT_GET_CLASS(encoder); const char * const name = gst_plugin_feature_get_name( GST_PLUGIN_FEATURE(gst_element_get_factory(encoder))); const bool isVorbis = qstrcmp(name, "vorbisenc") == 0; const int bitRate = m_actualAudioSettings.bitRate(); if (!isVorbis && bitRate == -1) { // Bit rate is invalid, don't evaluate the remaining conditions unless the encoder is // vorbisenc which is known to accept -1 as an unspecified bitrate. } else if (g_object_class_find_property(objectClass, "bitrate")) { g_object_set(G_OBJECT(encoder), "bitrate", bitRate, NULL); } else if (g_object_class_find_property(objectClass, "target-bitrate")) { g_object_set(G_OBJECT(encoder), "target-bitrate", bitRate, NULL); } if (isVorbis) { static const double qualities[] = { 0.1, 0.3, 0.5, 0.7, 1.0 }; g_object_set(G_OBJECT(encoder), "quality", qualities[m_actualAudioSettings.quality()], NULL); } }
void GstUtils::set_element_property_in_bin(GstElement *bin, const gchar *factory_name, const gchar *property_name, gboolean property_value) { if (!GST_IS_BIN(bin)) return; if (g_list_length(GST_BIN_CHILDREN(GST_BIN(bin))) > 0) { GList *child = nullptr, *children = GST_BIN_CHILDREN(GST_BIN(bin)); for (child = children; child != nullptr; child = g_list_next(child)) { GstElement *current_element = GST_ELEMENT(child->data); GstElementFactory *factory = gst_element_get_factory(current_element); // g_print ("The '%s' element is a member of the category %s.\n" // "Description: %s\n", // gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (sub_factory)), // gst_element_factory_get_klass (sub_factory), // gst_element_factory_get_description (sub_factory)); if (g_strcmp0(factory_name, gst_plugin_feature_get_name(GST_PLUGIN_FEATURE(factory))) == 0) { g_debug("GstUtils: setting property for %s", factory_name); g_object_set(G_OBJECT(current_element), property_name, property_value, nullptr); } if (GST_IS_BIN(current_element)) { // recursive GstUtils::set_element_property_in_bin(current_element, factory_name, property_name, property_value); } } } }
GstElement * GstUtils::get_first_element_from_factory_name(GstBin *bin, const std::string &factory_name) { if (!GST_IS_BIN(bin)) { g_warning("%s: first argument is not a bin", __FUNCTION__); return nullptr; } if (g_list_length(GST_BIN_CHILDREN(bin)) == 0) { g_warning("%s: bin has no child", __FUNCTION__); return nullptr; } GList *child = nullptr, *children = GST_BIN_CHILDREN(GST_BIN(bin)); for (child = children; child != nullptr; child = g_list_next(child)) { GstElement *current_element = GST_ELEMENT(child->data); GstElementFactory *factory = gst_element_get_factory(current_element); if (factory_name == gst_plugin_feature_get_name(GST_PLUGIN_FEATURE(factory))) { return current_element; } } g_warning("%s: no element found for %s", __FUNCTION__, factory_name.c_str()); return nullptr; }
static gint create_encoder_pipeline (Encoder *encoder) { GstElement *pipeline, *element; Bin *bin; Link *link; GSList *bins, *links, *elements; GstElementFactory *element_factory; GType type; EncoderStream *stream; GstAppSrcCallbacks callbacks = { need_data_callback, NULL, NULL }; GstAppSinkCallbacks encoder_appsink_callbacks = { NULL, NULL, new_sample_callback }; GstCaps *caps; GstBus *bus; pipeline = gst_pipeline_new (NULL); /* add element to pipeline first. */ bins = encoder->bins; while (bins != NULL) { bin = bins->data; elements = bin->elements; while (elements != NULL) { element = elements->data; if (!gst_bin_add (GST_BIN (pipeline), element)) { GST_ERROR ("add element %s to bin %s error.", gst_element_get_name (element), bin->name); return 1; } elements = g_slist_next (elements); } bins = g_slist_next (bins); } /* then links element. */ bins = encoder->bins; while (bins != NULL) { bin = bins->data; element = bin->first; element_factory = gst_element_get_factory (element); type = gst_element_factory_get_element_type (element_factory); stream = NULL; if (g_strcmp0 ("GstAppSrc", g_type_name (type)) == 0) { GST_INFO ("Encoder appsrc found."); stream = encoder_get_stream (encoder, bin->name); gst_app_src_set_callbacks (GST_APP_SRC (element), &callbacks, stream, NULL); } element = bin->last; element_factory = gst_element_get_factory (element); type = gst_element_factory_get_element_type (element_factory); if ((g_strcmp0 ("GstAppSink", g_type_name (type)) == 0) || (g_strcmp0 ("GstHlsSink", g_type_name (type)) == 0) || (g_strcmp0 ("GstFileSink", g_type_name (type)) == 0)) { GstPad *pad; if (g_strcmp0 ("GstAppSink", g_type_name (type)) == 0) { GST_INFO ("Encoder appsink found."); gst_app_sink_set_callbacks (GST_APP_SINK (element), &encoder_appsink_callbacks, encoder, NULL); } pad = gst_element_get_static_pad (element, "sink"); gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, encoder_appsink_event_probe, encoder, NULL); } links = bin->links; while (links != NULL) { link = links->data; GST_INFO ("link element: %s -> %s", link->src_name, link->sink_name); if (link->caps != NULL) { caps = gst_caps_from_string (link->caps); gst_element_link_filtered (link->src, link->sink, caps); gst_caps_unref (caps); } else { gst_element_link (link->src, link->sink); } links = g_slist_next (links); } bins = g_slist_next (bins); } bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); gst_bus_add_watch (bus, bus_callback, encoder); g_object_unref (bus); encoder->pipeline = pipeline; return 0; }