static gboolean _create_input_chain (GstGLMixerBin * self, struct input_chain *chain, GstPad * mixer_pad) { GstGLMixerBinClass *klass = GST_GL_MIXER_BIN_GET_CLASS (self); GstPad *pad; gboolean res = TRUE; gchar *name; chain->self = self; chain->mixer_pad = mixer_pad; chain->upload = gst_element_factory_make ("glupload", NULL); chain->in_convert = gst_element_factory_make ("glcolorconvert", NULL); res &= gst_bin_add (GST_BIN (self), chain->in_convert); res &= gst_bin_add (GST_BIN (self), chain->upload); pad = gst_element_get_static_pad (chain->in_convert, "src"); if (gst_pad_link (pad, mixer_pad) != GST_PAD_LINK_OK) { gst_object_unref (pad); return FALSE; } gst_object_unref (pad); res &= gst_element_link_pads (chain->upload, "src", chain->in_convert, "sink"); pad = gst_element_get_static_pad (chain->upload, "sink"); if (!pad) { return FALSE; } else { GST_DEBUG_OBJECT (self, "setting target sink pad %" GST_PTR_FORMAT, pad); name = gst_object_get_name (GST_OBJECT (mixer_pad)); if (klass->create_input_pad) { chain->ghost_pad = klass->create_input_pad (self, chain->mixer_pad); gst_object_set_name (GST_OBJECT (chain->ghost_pad), name); gst_ghost_pad_set_target (chain->ghost_pad, pad); } else { chain->ghost_pad = GST_GHOST_PAD (gst_ghost_pad_new (GST_PAD_NAME (chain->mixer_pad), pad)); } g_free (name); GST_OBJECT_LOCK (self); if (self->priv->running) gst_pad_set_active (GST_PAD (chain->ghost_pad), TRUE); GST_OBJECT_UNLOCK (self); gst_element_add_pad (GST_ELEMENT_CAST (self), GST_PAD (chain->ghost_pad)); gst_object_unref (pad); } gst_element_sync_state_with_parent (chain->upload); gst_element_sync_state_with_parent (chain->in_convert); return TRUE; }
GstElement *create_audio_sink() { GstElement *bin, *decoder = NULL; GstIterator *iter; GstIteratorResult res; GError *error = NULL; GstPad *pad; gpointer element = NULL; bin = gst_parse_launch_full("decodebin ! queue ! audioconvert \ ! audioresample \ ! autoaudiosink", NULL, 0, &error); if (!bin) { g_error("GStreamer: failed to parse audio sink pipeline\n"); return NULL; } gst_object_set_name(GST_OBJECT(bin), "audio-sink"); iter = gst_bin_iterate_elements(GST_BIN(bin)); res = gst_iterator_next (iter, &element); while (res == GST_ITERATOR_OK) { gchar *name; name = gst_object_get_name(GST_OBJECT (element)); if (name) { if (!strncmp(name, "decodebin", strlen("decodebin"))) { decoder = GST_ELEMENT(element); } g_printf("GS: audio sink element: %s \n", name); g_free (name); } gst_object_unref (element); element = NULL; res = gst_iterator_next (iter, &element); } gst_iterator_free (iter); if (!decoder) { /* mem leak */ g_printf("decoder element not found\n"); return NULL; } /* add ghostpad */ pad = gst_element_get_static_pad(decoder, "sink"); gst_element_add_pad(bin, gst_ghost_pad_new("sink", pad)); gst_object_unref(GST_OBJECT(pad)); return bin; }
static void gst_deinterlace2_set_method (GstDeinterlace2 * self, GstDeinterlace2Methods method) { if (self->method) { gst_child_proxy_child_removed (GST_OBJECT (self), GST_OBJECT (self->method)); gst_object_unparent (GST_OBJECT (self->method)); self->method = NULL; } switch (method) { case GST_DEINTERLACE2_TOMSMOCOMP: self->method = g_object_new (GST_TYPE_DEINTERLACE_TOMSMOCOMP, NULL); break; case GST_DEINTERLACE2_GREEDY_H: self->method = g_object_new (GST_TYPE_DEINTERLACE_GREEDY_H, NULL); break; case GST_DEINTERLACE2_GREEDY_L: self->method = g_object_new (GST_TYPE_DEINTERLACE_GREEDY_L, NULL); break; case GST_DEINTERLACE2_VFIR: self->method = g_object_new (GST_TYPE_DEINTERLACE_VFIR, NULL); break; case GST_DEINTERLACE2_LINEAR: self->method = g_object_new (GST_TYPE_DEINTERLACE_LINEAR, NULL); break; case GST_DEINTERLACE2_LINEAR_BLEND: self->method = g_object_new (GST_TYPE_DEINTERLACE_LINEAR_BLEND, NULL); break; case GST_DEINTERLACE2_SCALER_BOB: self->method = g_object_new (GST_TYPE_DEINTERLACE_SCALER_BOB, NULL); break; case GST_DEINTERLACE2_WEAVE: self->method = g_object_new (GST_TYPE_DEINTERLACE_WEAVE, NULL); break; case GST_DEINTERLACE2_WEAVE_TFF: self->method = g_object_new (GST_TYPE_DEINTERLACE_WEAVE_TFF, NULL); break; case GST_DEINTERLACE2_WEAVE_BFF: self->method = g_object_new (GST_TYPE_DEINTERLACE_WEAVE_BFF, NULL); break; default: GST_WARNING ("Invalid Deinterlacer Method"); return; } self->method_id = method; gst_object_set_name (GST_OBJECT (self->method), "method"); gst_object_set_parent (GST_OBJECT (self->method), GST_OBJECT (self)); gst_child_proxy_child_added (GST_OBJECT (self), GST_OBJECT (self->method)); }
/** * gst_plugin_feature_set_name: * @feature: a feature * @name: the name to set * * Sets the name of a plugin feature. The name uniquely identifies a feature * within all features of the same type. Renaming a plugin feature is not * allowed. A copy is made of the name so you should free the supplied @name * after calling this function. */ void gst_plugin_feature_set_name (GstPluginFeature * feature, const gchar * name) { g_return_if_fail (GST_IS_PLUGIN_FEATURE (feature)); g_return_if_fail (name != NULL); if (feature->name) { g_return_if_fail (strcmp (feature->name, name) == 0); } else { feature->name = g_strdup (name); } gst_object_set_name (GST_OBJECT (feature), feature->name); }
static gboolean _connect_sink_element (GstGLSinkBin * self) { gboolean res = TRUE; gst_object_set_name (GST_OBJECT (self->sink), "sink"); res &= gst_bin_add (GST_BIN (self), self->sink); res &= gst_element_link_pads (self->balance, "src", self->sink, "sink"); if (!res) GST_ERROR_OBJECT (self, "Failed to link sink element into the pipeline"); return res; }
static gboolean _connect_src_element (GstGLSrcBin * self) { gboolean res = TRUE; gst_object_set_name (GST_OBJECT (self->src), "src"); res &= gst_bin_add (GST_BIN (self), self->src); res &= gst_element_link_pads (self->src, "src", self->convert, "sink"); if (!res) GST_ERROR_OBJECT (self, "Failed to link src element into the pipeline"); return res; }
static void gst_object_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstObject *gstobject; gstobject = GST_OBJECT (object); switch (prop_id) { case ARG_NAME: gst_object_set_name (gstobject, g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void test_shutdown_for_factory (const gchar * factory_name) { GstElement *pipeline, *src, *q, *ac, *vis, *cf, *q2, *sink; GstCaps *caps; guint i; pipeline = gst_pipeline_new (NULL); src = gst_check_setup_element ("audiotestsrc"); q = gst_check_setup_element ("queue"); ac = gst_check_setup_element ("audioconvert"); GST_INFO ("Using %s", factory_name); vis = gst_check_setup_element (factory_name); cf = gst_check_setup_element ("capsfilter"); caps = gst_caps_new_simple ("video/x-raw-rgb", "width", G_TYPE_INT, 320, "height", G_TYPE_INT, 240, "framerate", GST_TYPE_FRACTION, 15, 1, NULL); g_object_set (cf, "caps", caps, NULL); gst_caps_unref (caps); q2 = gst_check_setup_element ("queue"); gst_object_set_name (GST_OBJECT (q2), "queue2"); sink = gst_check_setup_element ("fakesink"); /* don't want to sync against the clock, the more throughput the better */ g_object_set (src, "is-live", FALSE, NULL); g_object_set (sink, "sync", FALSE, NULL); gst_bin_add_many (GST_BIN (pipeline), src, q, ac, vis, cf, q2, sink, NULL); fail_if (!gst_element_link_many (src, q, ac, vis, cf, q2, sink, NULL)); /* now, wait until pipeline is running and then shut it down again; repeat; * this makes sure we can shut down cleanly while stuff is going on in the * chain function */ for (i = 0; i < 50; ++i) { gst_element_set_state (pipeline, GST_STATE_PAUSED); gst_element_get_state (pipeline, NULL, NULL, -1); gst_element_set_state (pipeline, GST_STATE_PLAYING); g_usleep (100); gst_element_set_state (pipeline, GST_STATE_NULL); } gst_object_unref (pipeline); }
static gboolean _connect_mixer_element (GstGLMixerBin * self) { gboolean res = TRUE; g_return_val_if_fail (self->priv->input_chains == NULL, FALSE); gst_object_set_name (GST_OBJECT (self->mixer), "mixer"); res &= gst_bin_add (GST_BIN (self), self->mixer); res &= gst_element_link_pads (self->mixer, "src", self->out_convert, "sink"); if (!res) GST_ERROR_OBJECT (self, "Failed to link mixer element into the pipeline"); gst_element_sync_state_with_parent (self->mixer); return res; }
void gss_vod_setup (GssServer * server) { GDir *dir; dir = g_dir_open (server->archive_dir, 0, NULL); if (dir) { const gchar *name = g_dir_read_name (dir); while (name) { if (g_str_has_suffix (name, ".webm")) { GssProgram *program; GssStream *stream; char *s; program = gss_server_add_program (server, name); program->is_archive = TRUE; stream = gss_stream_new (GSS_STREAM_TYPE_WEBM, 640, 360, 600); gss_program_add_stream (program, stream); s = g_strdup_printf ("%s-%dx%d-%dkbps%s.%s", GSS_OBJECT_NAME (program), stream->width, stream->height, stream->bitrate / 1000, gss_stream_type_get_mod (stream->type), gss_stream_type_get_ext (stream->type)); gst_object_set_name (GST_OBJECT (stream), s); g_free (s); s = g_strdup_printf ("/%s", GSS_OBJECT_NAME (stream)); gss_server_add_resource (GSS_OBJECT_SERVER (program), s, GSS_RESOURCE_HTTP_ONLY, gss_stream_type_get_content_type (stream->type), vod_resource_chunked, NULL, NULL, program); g_free (s); } name = g_dir_read_name (dir); } g_dir_close (dir); } }
/* thread function for threaded default name change test */ static gpointer thread_name_object_default (int *i) { int j; THREAD_START (); for (j = *i; j < num_objects; j += num_threads) { GstObject *o = GST_OBJECT (g_list_nth_data (object_list, j)); /* g_message ("THREAD %p: setting default name on object %d\n", g_thread_self (), j); */ gst_object_set_name (o, NULL); THREAD_SWITCH (); } /* thread is done, so let's return */ g_message ("THREAD %p: set name\n", g_thread_self ()); g_free (i); return NULL; }
/* thread function for threaded name change test */ static gpointer thread_name_object (GstObject * object) { gchar *thread_id = g_strdup_printf ("%p", g_thread_self ()); THREAD_START (); /* give main thread a head start */ g_usleep (100000); /* write our name repeatedly */ g_message ("THREAD %s: starting loop\n", thread_id); while (THREAD_TEST_RUNNING ()) { gst_object_set_name (object, thread_id); /* a minimal sleep invokes a thread switch */ THREAD_SWITCH (); } /* thread is done, so let's return */ g_message ("THREAD %s: set name\n", thread_id); g_free (thread_id); return NULL; }
static gboolean gst_object_set_name_default (GstObject * object) { const gchar *type_name; gint count; gchar *name, *tmp; gboolean result; GQuark q; /* to ensure guaranteed uniqueness across threads, only one thread * may ever assign a name */ G_LOCK (object_name_mutex); if (!object_name_counts) { g_datalist_init (&object_name_counts); } q = g_type_qname (G_OBJECT_TYPE (object)); count = GPOINTER_TO_INT (g_datalist_id_get_data (&object_name_counts, q)); g_datalist_id_set_data (&object_name_counts, q, GINT_TO_POINTER (count + 1)); G_UNLOCK (object_name_mutex); /* GstFooSink -> foosinkN */ type_name = g_quark_to_string (q); if (strncmp (type_name, "Gst", 3) == 0) type_name += 3; tmp = g_strdup_printf ("%s%d", type_name, count); name = g_ascii_strdown (tmp, -1); g_free (tmp); result = gst_object_set_name (object, name); g_free (name); return result; }
void gst_iir_equalizer_compute_frequencies (GstIirEqualizer * equ, guint new_count) { guint old_count, i; gdouble freq0, freq1, step; gchar name[20]; if (equ->freq_band_count == new_count) return; old_count = equ->freq_band_count; equ->freq_band_count = new_count; GST_DEBUG ("bands %u -> %u", old_count, new_count); if (old_count < new_count) { /* add new bands */ equ->bands = g_realloc (equ->bands, sizeof (GstObject *) * new_count); for (i = old_count; i < new_count; i++) { equ->bands[i] = g_object_new (GST_TYPE_IIR_EQUALIZER_BAND, NULL); /* otherwise they get names like 'iirequalizerband5' */ sprintf (name, "band%u", i); gst_object_set_name (GST_OBJECT (equ->bands[i]), name); GST_DEBUG ("adding band[%d]=%p", i, equ->bands[i]); gst_object_set_parent (GST_OBJECT (equ->bands[i]), GST_OBJECT (equ)); gst_child_proxy_child_added (GST_OBJECT (equ), GST_OBJECT (equ->bands[i])); } } else { /* free unused bands */ for (i = new_count; i < old_count; i++) { GST_DEBUG ("removing band[%d]=%p", i, equ->bands[i]); gst_child_proxy_child_removed (GST_OBJECT (equ), GST_OBJECT (equ->bands[i])); gst_object_unparent (GST_OBJECT (equ->bands[i])); equ->bands[i] = NULL; } } alloc_history (equ); /* set center frequencies and name band objects * FIXME: arg! we can't change the name of parented objects :( * application should read band->freq to get the name */ step = pow (HIGHEST_FREQ / LOWEST_FREQ, 1.0 / new_count); freq0 = LOWEST_FREQ; for (i = 0; i < new_count; i++) { freq1 = freq0 * step; equ->bands[i]->freq = freq0 + ((freq1 - freq0) / 2.0); equ->bands[i]->width = freq1 - freq0; GST_DEBUG ("band[%2d] = '%lf'", i, equ->bands[i]->freq); /* if(equ->bands[i]->freq<10000.0) sprintf (name,"%dHz",(gint)equ->bands[i]->freq); else sprintf (name,"%dkHz",(gint)(equ->bands[i]->freq/1000.0)); gst_object_set_name( GST_OBJECT (equ->bands[i]), name); GST_DEBUG ("band[%2d] = '%s'",i,name); */ freq0 = freq1; } equ->need_new_coefficients = TRUE; }
bool Object::setName(const char *name) { return gst_object_set_name(object<GstObject>(), name); }
static VALUE object_set_name(VALUE self, VALUE name) { return CBOOL2RVAL(gst_object_set_name(SELF(self), RVAL2CSTR(name))); }
GstElement *create_video_sink() { GstElement *bin, *decoder = NULL; GstIterator *iter; GstIteratorResult res; GError *error = NULL; GstPad *pad; gpointer element = NULL; const char* decoder_name; #ifndef DESKTOP /* create pipeline */ decoder_name = "tividdec20"; bin = gst_parse_launch_full("TIViddec2 genTimeStamps=FALSE \ engineName=decode \ codecName=h264dec numFrames=-1 \ ! videoscale method=0 \ ! video/x-raw-yuv, format=(fourcc)I420, width=320, height=240 \ ! ffmpegcolorspace \ ! video/x-raw-rgb, bpp=16 \ ! TIDmaiVideoSink displayStd=fbdev displayDevice=/dev/fb0 videoStd=QVGA \ videoOutput=LCD resizer=FALSE accelFrameCopy=TRUE", NULL, 0, &error); #else decoder_name = "decodebin"; bin = gst_parse_launch_full("decodebin \ ! videoscale method=0 \ ! video/x-raw-yuv, format=(fourcc)I420, width=320, height=240 \ ! xvimagesink", NULL, 0, &error); #endif if (!bin) { g_error("GStreamer: failed to parse video sink pipeline\n"); return NULL; } gst_object_set_name(GST_OBJECT(bin), "video-sink"); iter = gst_bin_iterate_elements(GST_BIN(bin)); res = gst_iterator_next (iter, &element); while (res == GST_ITERATOR_OK) { gchar *name; name = gst_object_get_name(GST_OBJECT (element)); if (name) { if (!strncmp(name, decoder_name, strlen(decoder_name))) { decoder = GST_ELEMENT(element); } g_printf("GS: video sink element: %s \n", name); g_free (name); } gst_object_unref (element); element = NULL; res = gst_iterator_next (iter, &element); } gst_iterator_free (iter); if (!decoder) { /* mem leak */ g_printf("decoder element not found\n"); return NULL; } /* add ghostpad */ pad = gst_element_get_static_pad (decoder, "sink"); gst_element_add_pad(bin, gst_ghost_pad_new("sink", pad)); gst_object_unref(GST_OBJECT(pad)); return bin; }