static void
gst_vaapi_decode_bin_handle_message (GstBin * bin, GstMessage * message)
{
GstVaapiDecodeBin *vaapidecbin = GST_VAAPI_DECODE_BIN (bin);
GstMessageType type;
GstContext *context = NULL;
const gchar *context_type;
GstVaapiDisplay *display = NULL;
type = GST_MESSAGE_TYPE (message);
if (type != GST_MESSAGE_HAVE_CONTEXT)
goto bail;
gst_message_parse_have_context (message, &context);
if (!context)
goto bail;
context_type = gst_context_get_context_type (context);
if (g_strcmp0 (context_type, GST_VAAPI_DISPLAY_CONTEXT_TYPE_NAME) != 0)
goto bail;
if (!gst_vaapi_video_context_get_display (context, &display))
goto bail;
vaapidecbin->has_vpp = gst_vaapi_display_has_video_processing (display);
/* the underlying VA driver implementation doesn't support video
* post-processing, hence we have to disable it */
if (!vaapidecbin->has_vpp) {
GST_WARNING_OBJECT (vaapidecbin, "VA driver doesn't support VPP");
if (!vaapidecbin->disable_vpp) {
vaapidecbin->disable_vpp = TRUE;
g_object_notify_by_pspec (G_OBJECT (vaapidecbin),
properties[PROP_DISABLE_VPP]);
}
}
activate_vpp (vaapidecbin);
bail:
GST_BIN_CLASS (gst_vaapi_decode_bin_parent_class)->handle_message (bin,
message);
}
static void
rb_mtp_sink_class_init (RBMTPSinkClass *klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
GstBinClass *bin_class;
gobject_class = G_OBJECT_CLASS (klass);
gobject_class->dispose = rb_mtp_sink_dispose;
gobject_class->finalize = rb_mtp_sink_finalize;
gobject_class->set_property = rb_mtp_sink_set_property;
gobject_class->get_property = rb_mtp_sink_get_property;
element_class = GST_ELEMENT_CLASS (klass);
element_class->change_state = rb_mtp_sink_change_state;
bin_class = GST_BIN_CLASS (klass);
bin_class->handle_message = rb_mtp_sink_handle_message;
g_object_class_install_property (gobject_class,
PROP_MTP_TRACK,
g_param_spec_pointer ("mtp-track",
"libmtp track",
"libmtp track",
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_FOLDER_PATH,
g_param_spec_pointer ("folder-path",
"folder path",
"upload folder path",
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DEVICE_THREAD,
g_param_spec_object ("device-thread",
"device-thread",
"device handling thread",
RB_TYPE_MTP_THREAD,
G_PARAM_READWRITE));
}
/* intercept the bus messages from our children. We watch for the ASYNC_START
* message with is posted by the elements (sinks) that require a reset of the
* running_time after a flush. ASYNC_START also brings the pipeline back into
* the PAUSED, pending PAUSED state. When the ASYNC_DONE message is received the
* pipeline will redistribute the new base_time and will bring the elements back
* to the desired state of the pipeline. */
static void
gst_pipeline_handle_message (GstBin * bin, GstMessage * message)
{
GstPipeline *pipeline = GST_PIPELINE_CAST (bin);
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_RESET_TIME:
{
GstClockTime running_time;
gst_message_parse_reset_time (message, &running_time);
/* reset our running time if we need to distribute a new base_time to the
* children. */
reset_start_time (pipeline, running_time);
break;
}
case GST_MESSAGE_CLOCK_LOST:
{
GstClock *clock;
gst_message_parse_clock_lost (message, &clock);
GST_OBJECT_LOCK (bin);
if (clock == GST_ELEMENT_CAST (bin)->clock) {
GST_DEBUG_OBJECT (bin, "Used clock '%s' got lost",
GST_OBJECT_NAME (clock));
pipeline->priv->update_clock = TRUE;
}
GST_OBJECT_UNLOCK (bin);
}
default:
break;
}
GST_BIN_CLASS (parent_class)->handle_message (bin, message);
}
static void
gst_hls_sink2_handle_message (GstBin * bin, GstMessage * message)
{
GstHlsSink2 *sink = GST_HLS_SINK2_CAST (bin);
switch (message->type) {
case GST_MESSAGE_ELEMENT:
{
const GstStructure *s = gst_message_get_structure (message);
if (message->src == GST_OBJECT_CAST (sink->splitmuxsink)) {
if (gst_structure_has_name (s, "splitmuxsink-fragment-opened")) {
g_free (sink->current_location);
sink->current_location =
g_strdup (gst_structure_get_string (s, "location"));
gst_structure_get_clock_time (s, "running-time",
&sink->current_running_time_start);
} else if (gst_structure_has_name (s, "splitmuxsink-fragment-closed")) {
GstClockTime running_time;
gchar *entry_location;
g_assert (strcmp (sink->current_location, gst_structure_get_string (s,
"location")) == 0);
gst_structure_get_clock_time (s, "running-time", &running_time);
GST_INFO_OBJECT (sink, "COUNT %d", sink->index);
if (sink->playlist_root == NULL) {
entry_location = g_path_get_basename (sink->current_location);
} else {
gchar *name = g_path_get_basename (sink->current_location);
entry_location = g_build_filename (sink->playlist_root, name, NULL);
g_free (name);
}
gst_m3u8_playlist_add_entry (sink->playlist, entry_location,
NULL, running_time - sink->current_running_time_start,
sink->index++, FALSE);
g_free (entry_location);
gst_hls_sink2_write_playlist (sink);
g_queue_push_tail (&sink->old_locations,
g_strdup (sink->current_location));
while (g_queue_get_length (&sink->old_locations) >
g_queue_get_length (sink->playlist->entries)) {
gchar *old_location = g_queue_pop_head (&sink->old_locations);
g_remove (old_location);
g_free (old_location);
}
}
}
break;
}
case GST_MESSAGE_EOS:{
sink->playlist->end_list = TRUE;
gst_hls_sink2_write_playlist (sink);
break;
}
default:
break;
}
GST_BIN_CLASS (parent_class)->handle_message (bin, message);
}
static void
gst_hls_sink2_class_init (GstHlsSink2Class * klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
GstBinClass *bin_class;
gobject_class = (GObjectClass *) klass;
element_class = GST_ELEMENT_CLASS (klass);
bin_class = GST_BIN_CLASS (klass);
gst_element_class_add_static_pad_template (element_class, &video_template);
gst_element_class_add_static_pad_template (element_class, &audio_template);
gst_element_class_set_static_metadata (element_class,
"HTTP Live Streaming sink", "Sink", "HTTP Live Streaming sink",
"Alessandro Decina <*****@*****.**>, "
"Sebastian Dröge <*****@*****.**>");
element_class->change_state = GST_DEBUG_FUNCPTR (gst_hls_sink2_change_state);
element_class->request_new_pad =
GST_DEBUG_FUNCPTR (gst_hls_sink2_request_new_pad);
element_class->release_pad = GST_DEBUG_FUNCPTR (gst_hls_sink2_release_pad);
bin_class->handle_message = gst_hls_sink2_handle_message;
gobject_class->dispose = gst_hls_sink2_dispose;
gobject_class->finalize = gst_hls_sink2_finalize;
gobject_class->set_property = gst_hls_sink2_set_property;
gobject_class->get_property = gst_hls_sink2_get_property;
g_object_class_install_property (gobject_class, PROP_LOCATION,
g_param_spec_string ("location", "File Location",
"Location of the file to write", DEFAULT_LOCATION,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_PLAYLIST_LOCATION,
g_param_spec_string ("playlist-location", "Playlist Location",
"Location of the playlist to write", DEFAULT_PLAYLIST_LOCATION,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_PLAYLIST_ROOT,
g_param_spec_string ("playlist-root", "Playlist Root",
"Location of the playlist to write", DEFAULT_PLAYLIST_ROOT,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_MAX_FILES,
g_param_spec_uint ("max-files", "Max files",
"Maximum number of files to keep on disk. Once the maximum is reached,"
"old files start to be deleted to make room for new ones.",
0, G_MAXUINT, DEFAULT_MAX_FILES,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_TARGET_DURATION,
g_param_spec_uint ("target-duration", "Target duration",
"The target duration in seconds of a segment/file. "
"(0 - disabled, useful for management of segment duration by the "
"streaming server)",
0, G_MAXUINT, DEFAULT_TARGET_DURATION,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_PLAYLIST_LENGTH,
g_param_spec_uint ("playlist-length", "Playlist length",
"Length of HLS playlist. To allow players to conform to section 6.3.3 "
"of the HLS specification, this should be at least 3. If set to 0, "
"the playlist will be infinite.",
0, G_MAXUINT, DEFAULT_PLAYLIST_LENGTH,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}
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 gboolean
gst_pipeline_do_latency (GstBin * bin)
{
GstPipeline *pipeline = GST_PIPELINE (bin);
GstQuery *query;
GstClockTime latency;
GstClockTime min_latency, max_latency;
gboolean res;
GST_OBJECT_LOCK (pipeline);
latency = pipeline->priv->latency;
GST_OBJECT_UNLOCK (pipeline);
if (latency == GST_CLOCK_TIME_NONE)
return GST_BIN_CLASS (parent_class)->do_latency (bin);
GST_DEBUG_OBJECT (pipeline, "querying latency");
query = gst_query_new_latency ();
if ((res = gst_element_query (GST_ELEMENT_CAST (pipeline), query))) {
gboolean live;
gst_query_parse_latency (query, &live, &min_latency, &max_latency);
GST_DEBUG_OBJECT (pipeline,
"got min latency %" GST_TIME_FORMAT ", max latency %"
GST_TIME_FORMAT ", live %d", GST_TIME_ARGS (min_latency),
GST_TIME_ARGS (max_latency), live);
if (max_latency < min_latency) {
/* this is an impossible situation, some parts of the pipeline might not
* work correctly. We post a warning for now. */
GST_ELEMENT_WARNING (pipeline, CORE, CLOCK, (NULL),
("Impossible to configure latency: max %" GST_TIME_FORMAT " < min %"
GST_TIME_FORMAT ". Add queues or other buffering elements.",
GST_TIME_ARGS (max_latency), GST_TIME_ARGS (min_latency)));
}
if (latency < min_latency) {
/* This is a problematic situation as we will most likely drop lots of
* data if we configure a too low latency */
GST_ELEMENT_WARNING (pipeline, CORE, CLOCK, (NULL),
("Configured latency is lower than detected minimum latency: configured %"
GST_TIME_FORMAT " < min %" GST_TIME_FORMAT,
GST_TIME_ARGS (latency), GST_TIME_ARGS (min_latency)));
}
} else {
/* this is not a real problem, we just don't configure any latency. */
GST_WARNING_OBJECT (pipeline, "failed to query latency");
}
gst_query_unref (query);
/* configure latency on elements */
res =
gst_element_send_event (GST_ELEMENT_CAST (pipeline),
gst_event_new_latency (latency));
if (res) {
GST_INFO_OBJECT (pipeline, "configured latency of %" GST_TIME_FORMAT,
GST_TIME_ARGS (latency));
} else {
GST_WARNING_OBJECT (pipeline,
"did not really configure latency of %" GST_TIME_FORMAT,
GST_TIME_ARGS (latency));
}
return res;
}
static void
gst_pipeline_class_init (GstPipelineClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
GstBinClass *gstbin_class = GST_BIN_CLASS (klass);
g_type_class_add_private (klass, sizeof (GstPipelinePrivate));
gobject_class->set_property = gst_pipeline_set_property;
gobject_class->get_property = gst_pipeline_get_property;
/**
* GstPipeline:delay:
*
* The expected delay needed for elements to spin up to the
* PLAYING state expressed in nanoseconds.
* see [gst_pipeline_set_delay]() for more information on this option.
*/
g_object_class_install_property (gobject_class, PROP_DELAY,
g_param_spec_uint64 ("delay", "Delay",
"Expected delay needed for elements "
"to spin up to PLAYING in nanoseconds", 0, G_MAXUINT64, DEFAULT_DELAY,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstPipeline:auto-flush-bus:
*
* Whether or not to automatically flush all messages on the
* pipeline's bus when going from READY to NULL state. Please see
* [gst_pipeline_set_auto_flush_bus]() for more information on this option.
*/
g_object_class_install_property (gobject_class, PROP_AUTO_FLUSH_BUS,
g_param_spec_boolean ("auto-flush-bus", "Auto Flush Bus",
"Whether to automatically flush the pipeline's bus when going "
"from READY into NULL state", DEFAULT_AUTO_FLUSH_BUS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstPipeline:latency:
*
* Latency to configure on the pipeline. See [gst_pipeline_set_latency]().
*
* Since: 1.6
*/
g_object_class_install_property (gobject_class, PROP_LATENCY,
g_param_spec_uint64 ("latency", "Latency",
"Latency to configure on the pipeline", 0, G_MAXUINT64,
DEFAULT_LATENCY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
gobject_class->dispose = gst_pipeline_dispose;
gst_element_class_set_static_metadata (gstelement_class, "Pipeline object",
"Generic/Bin",
"Complete pipeline object",
"Erik Walthinsen <*****@*****.**>, Wim Taymans <*****@*****.**>");
gstelement_class->change_state =
GST_DEBUG_FUNCPTR (gst_pipeline_change_state);
gstelement_class->provide_clock =
GST_DEBUG_FUNCPTR (gst_pipeline_provide_clock_func);
gstbin_class->handle_message =
GST_DEBUG_FUNCPTR (gst_pipeline_handle_message);
gstbin_class->do_latency = GST_DEBUG_FUNCPTR (gst_pipeline_do_latency);
}
static void
gst_hls_sink_handle_message (GstBin * bin, GstMessage * message)
{
GstHlsSink *sink = GST_HLS_SINK_CAST (bin);
switch (message->type) {
case GST_MESSAGE_ELEMENT:
{
const char *filename;
GstClockTime running_time, duration;
gboolean discont = FALSE;
gchar *entry_location;
const GstStructure *structure;
structure = gst_message_get_structure (message);
if (strcmp (gst_structure_get_name (structure), "GstMultiFileSink"))
break;
filename = gst_structure_get_string (structure, "filename");
gst_structure_get_clock_time (structure, "running-time", &running_time);
duration = running_time - sink->last_running_time;
sink->last_running_time = running_time;
GST_INFO_OBJECT (sink, "COUNT %d", sink->index);
if (sink->playlist_root == NULL)
entry_location = g_path_get_basename (filename);
else {
gchar *name = g_path_get_basename (filename);
entry_location = g_build_filename (sink->playlist_root, name, NULL);
g_free (name);
}
gst_m3u8_playlist_add_entry (sink->playlist, entry_location,
NULL, duration, sink->index, discont);
g_free (entry_location);
gst_hls_sink_write_playlist (sink);
/* multifilesink is starting a new file. It means that upstream sent a key
* unit and we can schedule the next key unit now.
*/
sink->waiting_fku = FALSE;
schedule_next_key_unit (sink);
/* multifilesink is an internal implementation detail. If applications
* need a notification, we should probably do our own message */
GST_DEBUG_OBJECT (bin, "dropping message %" GST_PTR_FORMAT, message);
gst_message_unref (message);
message = NULL;
break;
}
case GST_MESSAGE_EOS:{
sink->playlist->end_list = TRUE;
gst_hls_sink_write_playlist (sink);
break;
}
default:
break;
}
if (message)
GST_BIN_CLASS (parent_class)->handle_message (bin, message);
}
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);
}
static void
fs_rtp_conference_handle_message (
GstBin * bin,
GstMessage * message)
{
FsRtpConference *self = FS_RTP_CONFERENCE (bin);
if (!self->rtpbin)
goto out;
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ELEMENT:
{
const GstStructure *s = gst_message_get_structure (message);
/* we change the structure name and add the session ID to it */
if (gst_structure_has_name (s, "application/x-rtp-source-sdes") &&
gst_structure_has_field_typed (s, "session", G_TYPE_UINT) &&
gst_structure_has_field_typed (s, "ssrc", G_TYPE_UINT) &&
gst_structure_has_field_typed (s, "cname", G_TYPE_STRING))
{
guint session_id;
guint ssrc;
const GValue *val;
FsRtpSession *session;
const gchar *cname;
val = gst_structure_get_value (s, "session");
session_id = g_value_get_uint (val);
val = gst_structure_get_value (s, "ssrc");
ssrc = g_value_get_uint (val);
cname = gst_structure_get_string (s, "cname");
if (!ssrc || !cname)
{
GST_WARNING_OBJECT (self,
"Got GstRTPBinSDES without a ssrc or a cname (ssrc:%u cname:%p)",
ssrc, cname);
break;
}
session = fs_rtp_conference_get_session_by_id (self, session_id);
if (session) {
fs_rtp_session_associate_ssrc_cname (session, ssrc, cname);
g_object_unref (session);
} else {
GST_WARNING_OBJECT (self,"Our RtpBin announced a new association"
"for non-existent session %u for ssrc: %u and cname %s",
session_id, ssrc, cname);
}
}
else if (gst_structure_has_name (s, "dtmf-event-processed") ||
gst_structure_has_name (s, "dtmf-event-dropped"))
{
GList *item;
guint cookie;
GST_OBJECT_LOCK (self);
restart:
cookie = self->priv->sessions_cookie;
for (item = self->priv->sessions; item; item = item->next)
{
GST_OBJECT_UNLOCK (self);
if (fs_rtp_session_handle_dtmf_event_message (item->data, message))
{
gst_message_unref (message);
message = NULL;
goto out;
}
GST_OBJECT_LOCK (self);
if (cookie != self->priv->sessions_cookie)
goto restart;
}
GST_OBJECT_UNLOCK (self);
}
}
break;
case GST_MESSAGE_STREAM_STATUS:
{
GstStreamStatusType type;
guint i;
gst_message_parse_stream_status (message, &type, NULL);
switch (type)
{
case GST_STREAM_STATUS_TYPE_ENTER:
GST_OBJECT_LOCK (self);
for (i = 0; i < self->priv->threads->len; i++)
{
if (g_ptr_array_index (self->priv->threads, i) ==
g_thread_self ())
goto done;
}
g_ptr_array_add (self->priv->threads, g_thread_self ());
done:
GST_OBJECT_UNLOCK (self);
break;
case GST_STREAM_STATUS_TYPE_LEAVE:
GST_OBJECT_LOCK (self);
while (g_ptr_array_remove_fast (self->priv->threads,
g_thread_self ()));
GST_OBJECT_UNLOCK (self);
break;
default:
/* Do nothing */
break;
}
}
break;
default:
break;
}
out:
/* forward all messages to the parent */
if (message)
GST_BIN_CLASS (fs_rtp_conference_parent_class)->handle_message (bin,
message);
}
/**
* gst_deinit:
*
* Clean up any resources created by GStreamer in gst_init().
*
* It is normally not needed to call this function in a normal application
* as the resources will automatically be freed when the program terminates.
* This function is therefore mostly used by testsuites and other memory
* profiling tools.
*
* After this call GStreamer (including this method) should not be used anymore.
*/
void
gst_deinit (void)
{
GstBinClass *bin_class;
GstClock *clock;
GST_INFO ("deinitializing GStreamer");
if (gst_deinitialized) {
GST_DEBUG ("already deinitialized");
return;
}
#ifndef GST_DISABLE_GST_DEBUG
_priv_gst_tracing_deinit ();
#endif
g_thread_pool_set_max_unused_threads (0);
bin_class = GST_BIN_CLASS (g_type_class_peek (gst_bin_get_type ()));
if (bin_class->pool != NULL) {
g_thread_pool_free (bin_class->pool, FALSE, TRUE);
bin_class->pool = NULL;
}
gst_task_cleanup_all ();
g_slist_foreach (_priv_gst_preload_plugins, (GFunc) g_free, NULL);
g_slist_free (_priv_gst_preload_plugins);
_priv_gst_preload_plugins = NULL;
#ifndef GST_DISABLE_REGISTRY
g_list_foreach (_priv_gst_plugin_paths, (GFunc) g_free, NULL);
g_list_free (_priv_gst_plugin_paths);
_priv_gst_plugin_paths = NULL;
#endif
clock = gst_system_clock_obtain ();
gst_object_unref (clock);
gst_object_unref (clock);
_priv_gst_registry_cleanup ();
#ifndef GST_DISABLE_TRACE
_priv_gst_alloc_trace_deinit ();
#endif
g_type_class_unref (g_type_class_peek (gst_object_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_get_type ()));
g_type_class_unref (g_type_class_peek (gst_element_factory_get_type ()));
g_type_class_unref (g_type_class_peek (gst_element_get_type ()));
g_type_class_unref (g_type_class_peek (gst_tracer_factory_get_type ()));
g_type_class_unref (g_type_class_peek (gst_type_find_factory_get_type ()));
g_type_class_unref (g_type_class_peek (gst_bin_get_type ()));
g_type_class_unref (g_type_class_peek (gst_bus_get_type ()));
g_type_class_unref (g_type_class_peek (gst_task_get_type ()));
g_type_class_unref (g_type_class_peek (gst_object_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_bin_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_buffer_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_buffer_copy_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_bus_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_bus_sync_reply_get_type ()));
g_type_class_unref (g_type_class_peek (gst_caps_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_clock_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_clock_return_get_type ()));
g_type_class_unref (g_type_class_peek (gst_clock_entry_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_clock_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_debug_graph_details_get_type ()));
g_type_class_unref (g_type_class_peek (gst_state_get_type ()));
g_type_class_unref (g_type_class_peek (gst_state_change_return_get_type ()));
g_type_class_unref (g_type_class_peek (gst_state_change_get_type ()));
g_type_class_unref (g_type_class_peek (gst_element_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_core_error_get_type ()));
g_type_class_unref (g_type_class_peek (gst_library_error_get_type ()));
g_type_class_unref (g_type_class_peek (gst_plugin_dependency_flags_get_type
()));
g_type_class_unref (g_type_class_peek (gst_parse_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_resource_error_get_type ()));
g_type_class_unref (g_type_class_peek (gst_search_mode_get_type ()));
g_type_class_unref (g_type_class_peek (gst_stream_error_get_type ()));
g_type_class_unref (g_type_class_peek (gst_stream_status_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_structure_change_type_get_type
()));
g_type_class_unref (g_type_class_peek (gst_event_type_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_event_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_seek_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_seek_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_qos_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_format_get_type ()));
g_type_class_unref (g_type_class_peek (gst_debug_level_get_type ()));
g_type_class_unref (g_type_class_peek (gst_debug_color_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_iterator_result_get_type ()));
g_type_class_unref (g_type_class_peek (gst_iterator_item_get_type ()));
g_type_class_unref (g_type_class_peek (gst_message_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_meta_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_mini_object_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_link_return_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_link_check_get_type ()));
g_type_class_unref (g_type_class_peek (gst_flow_return_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_mode_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_direction_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_presence_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_template_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pipeline_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_plugin_error_get_type ()));
g_type_class_unref (g_type_class_peek (gst_plugin_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_rank_get_type ()));
g_type_class_unref (g_type_class_peek (gst_query_type_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_query_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_buffering_mode_get_type ()));
g_type_class_unref (g_type_class_peek (gst_tag_merge_mode_get_type ()));
g_type_class_unref (g_type_class_peek (gst_tag_flag_get_type ()));
g_type_class_unref (g_type_class_peek (gst_tag_scope_get_type ()));
g_type_class_unref (g_type_class_peek (gst_task_state_get_type ()));
g_type_class_unref (g_type_class_peek (gst_toc_entry_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_toc_scope_get_type ()));
g_type_class_unref (g_type_class_peek (gst_type_find_probability_get_type
()));
g_type_class_unref (g_type_class_peek (gst_uri_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_uri_error_get_type ()));
g_type_class_unref (g_type_class_peek (gst_parse_error_get_type ()));
g_type_class_unref (g_type_class_peek (gst_param_spec_fraction_get_type ()));
g_type_class_unref (g_type_class_peek (gst_progress_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_buffer_pool_acquire_flags_get_type
()));
g_type_class_unref (g_type_class_peek (gst_memory_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_map_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_caps_intersect_mode_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_probe_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_pad_probe_return_get_type ()));
g_type_class_unref (g_type_class_peek (gst_segment_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_scheduling_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_control_binding_get_type ()));
g_type_class_unref (g_type_class_peek (gst_control_source_get_type ()));
g_type_class_unref (g_type_class_peek (gst_toc_entry_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_toc_loop_type_get_type ()));
g_type_class_unref (g_type_class_peek (gst_lock_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_allocator_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_stream_flags_get_type ()));
g_type_class_unref (g_type_class_peek (gst_debug_color_mode_get_type ()));
gst_deinitialized = TRUE;
GST_INFO ("deinitialized GStreamer");
}
static void
fs_rtp_conference_class_init (FsRtpConferenceClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
FsBaseConferenceClass *baseconf_class = FS_BASE_CONFERENCE_CLASS (klass);
GstBinClass *gstbin_class = GST_BIN_CLASS (klass);
g_type_class_add_private (klass, sizeof (FsRtpConferencePrivate));
parent_class = g_type_class_peek_parent (klass);
baseconf_class->new_session =
GST_DEBUG_FUNCPTR (fs_rtp_conference_new_session);
baseconf_class->new_participant =
GST_DEBUG_FUNCPTR (fs_rtp_conference_new_participant);
gstbin_class->handle_message =
GST_DEBUG_FUNCPTR (fs_rtp_conference_handle_message);
gstelement_class->change_state =
GST_DEBUG_FUNCPTR (fs_rtp_conference_change_state);
gobject_class->finalize = GST_DEBUG_FUNCPTR (fs_rtp_conference_finalize);
gobject_class->dispose = GST_DEBUG_FUNCPTR (fs_rtp_conference_dispose);
gobject_class->set_property =
GST_DEBUG_FUNCPTR (fs_rtp_conference_set_property);
gobject_class->get_property =
GST_DEBUG_FUNCPTR (fs_rtp_conference_get_property);
gst_element_class_set_details (gstelement_class, &fs_rtp_conference_details);
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&fs_rtp_conference_sink_template));
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&fs_rtp_conference_src_template));
g_object_class_install_property (gobject_class, PROP_SDES_CNAME,
g_param_spec_string ("sdes-cname", "Canonical name",
"The CNAME for the RTP sessions",
NULL, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, PROP_SDES_NAME,
g_param_spec_string ("sdes-name", "SDES NAME",
"The NAME to put in SDES messages of this session",
NULL, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, PROP_SDES_EMAIL,
g_param_spec_string ("sdes-email", "SDES EMAIL",
"The EMAIL to put in SDES messages of this session",
NULL, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, PROP_SDES_PHONE,
g_param_spec_string ("sdes-phone", "SDES PHONE",
"The PHONE to put in SDES messages of this session",
NULL, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, PROP_SDES_LOCATION,
g_param_spec_string ("sdes-location", "SDES LOCATION",
"The LOCATION to put in SDES messages of this session",
NULL, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, PROP_SDES_TOOL,
g_param_spec_string ("sdes-tool", "SDES TOOL",
"The TOOL to put in SDES messages of this session",
NULL, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, PROP_SDES_NOTE,
g_param_spec_string ("sdes-note", "SDES NOTE",
"The NOTE to put in SDES messages of this session",
NULL, G_PARAM_READWRITE));
}
static void
empathy_audio_src_handle_message (GstBin *bin, GstMessage *message)
{
EmpathyGstAudioSrc *self = EMPATHY_GST_AUDIO_SRC (bin);
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT &&
GST_MESSAGE_SRC (message) == GST_OBJECT (priv->level))
{
const GstStructure *s;
const gchar *name;
const GValue *list;
guint i, len;
gdouble peak = -G_MAXDOUBLE;
gdouble rms = -G_MAXDOUBLE;
s = gst_message_get_structure (message);
name = gst_structure_get_name (s);
if (g_strcmp0 ("level", name) != 0)
goto out;
list = gst_structure_get_value (s, "peak");
len = gst_value_list_get_size (list);
for (i =0 ; i < len; i++)
{
const GValue *value;
gdouble db;
value = gst_value_list_get_value (list, i);
db = g_value_get_double (value);
peak = MAX (db, peak);
}
list = gst_structure_get_value (s, "rms");
len = gst_value_list_get_size (list);
for (i =0 ; i < len; i++)
{
const GValue *value;
gdouble db;
value = gst_value_list_get_value (list, i);
db = g_value_get_double (value);
rms = MAX (db, rms);
}
g_mutex_lock (priv->lock);
priv->peak_level = peak;
priv->rms_level = rms;
if (priv->idle_id == 0)
priv->idle_id = g_idle_add (empathy_audio_src_levels_updated, self);
g_mutex_unlock (priv->lock);
}
out:
GST_BIN_CLASS (empathy_audio_src_parent_class)->handle_message (bin,
message);
}
static void
rb_mtp_sink_handle_message (GstBin *bin, GstMessage *message)
{
/* when we get an EOS message from the fdsink, close the fd and upload the
* file to the device.
*/
if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_EOS) {
int fd;
struct stat stat_buf;
RBMTPSink *sink = RB_MTP_SINK (bin);
/* fill in the file size and close the fd */
g_object_get (sink->fdsink, "fd", &fd, NULL);
fstat (fd, &stat_buf);
sink->track->filesize = stat_buf.st_size;
close (fd);
rb_debug ("handling EOS from fdsink; file size is %" G_GUINT64_FORMAT, sink->track->filesize);
/* we can just block waiting for mtp thread operations to finish here
* as we're on a streaming thread.
*/
g_mutex_lock (sink->upload_mutex);
if (sink->folder_path != NULL) {
/* find or create the target folder.
* if this fails, we just upload to the default music folder
* rather than giving up entirely.
*/
sink->got_folder = FALSE;
rb_mtp_thread_create_folder (sink->device_thread,
(const char **)sink->folder_path,
(RBMtpCreateFolderCallback) folder_callback,
g_object_ref (sink),
g_object_unref);
while (sink->got_folder == FALSE) {
g_cond_wait (sink->upload_cond, sink->upload_mutex);
}
}
/* and upload the file */
sink->upload_done = FALSE;
rb_mtp_thread_upload_track (sink->device_thread,
sink->track,
sink->tempfile,
(RBMtpUploadCallback) upload_callback,
g_object_ref (sink),
g_object_unref);
while (sink->upload_done == FALSE) {
g_cond_wait (sink->upload_cond, sink->upload_mutex);
}
g_mutex_unlock (sink->upload_mutex);
/* post error message if the upload failed - this should get there before
* this EOS message does, so it should work OK.
*/
if (sink->upload_error != NULL) {
int code;
switch (sink->upload_error->code) {
case RB_MTP_THREAD_ERROR_NO_SPACE:
code = GST_RESOURCE_ERROR_NO_SPACE_LEFT;
break;
default:
case RB_MTP_THREAD_ERROR_SEND_TRACK:
code = GST_RESOURCE_ERROR_WRITE;
break;
}
GST_WARNING_OBJECT (sink, "error: %s", sink->upload_error->message);
gst_element_message_full (GST_ELEMENT (sink),
GST_MESSAGE_ERROR,
GST_RESOURCE_ERROR, code,
g_strdup (sink->upload_error->message), NULL,
__FILE__, GST_FUNCTION, __LINE__);
}
}
GST_BIN_CLASS (parent_class)->handle_message (bin, message);
}
static void
fps_display_sink_class_init (GstFPSDisplaySinkClass * klass)
{
GObjectClass *gobject_klass = G_OBJECT_CLASS (klass);
GstElementClass *gstelement_klass = GST_ELEMENT_CLASS (klass);
GstBinClass *bin_class = GST_BIN_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
gobject_klass->set_property = fps_display_sink_set_property;
gobject_klass->get_property = fps_display_sink_get_property;
gobject_klass->dispose = fps_display_sink_dispose;
bin_class->handle_message = fps_display_sink_handle_message;
g_object_class_install_property (gobject_klass, PROP_SYNC,
g_param_spec_boolean ("sync",
"Sync", "Sync on the clock (if the internally used sink doesn't "
"have this property it will be ignored", DEFAULT_SYNC,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
g_object_class_install_property (gobject_klass, PROP_TEXT_OVERLAY,
g_param_spec_boolean ("text-overlay",
"text-overlay",
"Whether to use text-overlay", TRUE,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
g_object_class_install_property (gobject_klass, PROP_VIDEO_SINK,
g_param_spec_object ("video-sink",
"video-sink",
"Video sink to use (Must only be called on NULL state)",
GST_TYPE_ELEMENT, G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
g_object_class_install_property (gobject_klass, PROP_FPS_UPDATE_INTERVAL,
g_param_spec_int ("fps-update-interval", "Fps update interval",
"Time between consecutive frames per second measures and update "
" (in ms). Should be set on NULL state", 1, G_MAXINT,
DEFAULT_FPS_UPDATE_INTERVAL_MS,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
g_object_class_install_property (gobject_klass, PROP_MAX_FPS,
g_param_spec_double ("max-fps", "Max fps",
"Maximum fps rate measured. Reset when going from NULL to READY."
"-1 means no measurement has yet been done", -1, G_MAXDOUBLE, -1,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (gobject_klass, PROP_MIN_FPS,
g_param_spec_double ("min-fps", "Min fps",
"Minimum fps rate measured. Reset when going from NULL to READY."
"-1 means no measurement has yet been done", -1, G_MAXDOUBLE, -1,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (gobject_klass, PROP_FRAMES_DROPPED,
g_param_spec_uint ("frames-dropped", "dropped frames",
"Number of frames dropped by the sink", 0, G_MAXUINT, 0,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (gobject_klass, PROP_FRAMES_RENDERED,
g_param_spec_uint ("frames-rendered", "rendered frames",
"Number of frames rendered", 0, G_MAXUINT, 0,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (gobject_klass, PROP_SILENT,
g_param_spec_boolean ("silent", "enable stdout output",
"Don't produce last_message events", DEFAULT_SILENT,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
g_object_class_install_property (gobject_klass, PROP_SIGNAL_FPS_MEASUREMENTS,
g_param_spec_boolean ("signal-fps-measurements",
"Signal fps measurements",
"If the fps-measurements signal should be emited.",
DEFAULT_SIGNAL_FPS_MEASUREMENTS,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
pspec_last_message = g_param_spec_string ("last-message", "Last Message",
"The message describing current status", DEFAULT_LAST_MESSAGE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (gobject_klass, PROP_LAST_MESSAGE,
pspec_last_message);
/**
* GstFPSDisplaySink::fps-measurements:
* @fpsdisplaysink: a #GstFPSDisplaySink
* @fps: The current measured fps
* @droprate: The rate at which buffers are being dropped
* @avgfps: The average fps
*
* Signals the application about the measured fps
*/
fpsdisplaysink_signals[SIGNAL_FPS_MEASUREMENTS] =
g_signal_new ("fps-measurements", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL,
G_TYPE_NONE, 3, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE);
gstelement_klass->change_state = fps_display_sink_change_state;
gst_element_class_add_pad_template (gstelement_klass,
gst_static_pad_template_get (&fps_display_sink_template));
gst_element_class_set_static_metadata (gstelement_klass,
"Measure and show framerate on videosink", "Sink/Video",
"Shows the current frame-rate and drop-rate of the videosink as overlay or text on stdout",
"Zeeshan Ali <*****@*****.**>, Stefan Kost <*****@*****.**>");
}