static GstStateChangeReturn dxr3spusink_change_state (GstElement * element, GstStateChange transition) { g_return_val_if_fail (GST_IS_DXR3SPUSINK (element), GST_STATE_CHANGE_FAILURE); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: if (!GST_OBJECT_FLAG_IS_SET (element, DXR3SPUSINK_OPEN)) { if (!dxr3spusink_open (DXR3SPUSINK (element))) { return GST_STATE_CHANGE_FAILURE; } } break; case GST_STATE_CHANGE_READY_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: break; case GST_STATE_CHANGE_READY_TO_NULL: if (GST_OBJECT_FLAG_IS_SET (element, DXR3SPUSINK_OPEN)) { dxr3spusink_close (DXR3SPUSINK (element)); } break; } if (GST_ELEMENT_CLASS (parent_class)->change_state) { return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); } return GST_STATE_CHANGE_SUCCESS; }
static void print_clocking_info (GstElement * element) { gboolean requires_clock, provides_clock; requires_clock = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_REQUIRE_CLOCK); provides_clock = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_PROVIDE_CLOCK); if (!requires_clock && !provides_clock) { n_print ("\n"); n_print ("Element has no clocking capabilities.\n"); return; } n_print ("\n"); n_print ("Clocking Interaction:\n"); if (requires_clock) { n_print (" element requires a clock\n"); } if (provides_clock) { GstClock *clock; clock = gst_element_get_clock (element); if (clock) { n_print (" element provides a clock: %s\n", GST_OBJECT_NAME (clock)); gst_object_unref (clock); } else n_print (" element is supposed to provide a clock but returned NULL\n"); } }
static void debug_dump_pad (GstPad * pad, const gchar * color_name, const gchar * element_name, GstDebugGraphDetails details, FILE * out, const gint indent) { GstPadTemplate *pad_templ; GstPadPresence presence; gchar *pad_name; const gchar *style_name; const gchar *spc = &spaces[MAX (sizeof (spaces) - (1 + indent * 2), 0)]; pad_name = debug_dump_make_object_name (GST_OBJECT (pad)); /* pad availability */ style_name = "filled,solid"; if ((pad_templ = gst_pad_get_pad_template (pad))) { presence = GST_PAD_TEMPLATE_PRESENCE (pad_templ); if (presence == GST_PAD_SOMETIMES) { style_name = "filled,dotted"; } else if (presence == GST_PAD_REQUEST) { style_name = "filled,dashed"; } } if (details & GST_DEBUG_GRAPH_SHOW_STATES) { gchar pad_flags[4]; const gchar *activation_mode = "-><"; /* check if pad flags */ pad_flags[0] = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_BLOCKED) ? 'B' : 'b'; pad_flags[1] = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_FLUSHING) ? 'F' : 'f'; pad_flags[2] = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_BLOCKING) ? 'B' : 'b'; pad_flags[3] = '\0'; fprintf (out, "%s %s_%s [color=black, fillcolor=\"%s\", label=\"%s\\n[%c][%s]\", height=\"0.2\", style=\"%s\"];\n", spc, element_name, pad_name, color_name, GST_OBJECT_NAME (pad), activation_mode[pad->mode], pad_flags, style_name); } else { fprintf (out, "%s %s_%s [color=black, fillcolor=\"%s\", label=\"%s\", height=\"0.2\", style=\"%s\"];\n", spc, element_name, pad_name, color_name, GST_OBJECT_NAME (pad), style_name); } g_free (pad_name); }
/** * gst_clock_wait_for_sync: * @clock: a GstClock * @timeout: timeout for waiting or %GST_CLOCK_TIME_NONE * * Waits until @clock is synced for reporting the current time. If @timeout * is %GST_CLOCK_TIME_NONE it will wait forever, otherwise it will time out * after @timeout nanoseconds. * * For asynchronous waiting, the GstClock::synced signal can be used. * * * This returns immediately with TRUE if GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC * is not set on the clock, or if the clock is already synced. * * Returns: %TRUE if waiting was successful, or %FALSE on timeout * * Since: 1.6 */ gboolean gst_clock_wait_for_sync (GstClock * clock, GstClockTime timeout) { gboolean timed_out = FALSE; g_return_val_if_fail (GST_IS_CLOCK (clock), FALSE); GST_OBJECT_LOCK (clock); if (!GST_OBJECT_FLAG_IS_SET (clock, GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC) || clock->priv->synced) { GST_OBJECT_UNLOCK (clock); return TRUE; } if (timeout != GST_CLOCK_TIME_NONE) { gint64 end_time = g_get_monotonic_time () + gst_util_uint64_scale (timeout, G_TIME_SPAN_SECOND, GST_SECOND); while (!clock->priv->synced && !timed_out) { timed_out = !g_cond_wait_until (&clock->priv->sync_cond, GST_OBJECT_GET_LOCK (clock), end_time); } } else { timed_out = FALSE; while (!clock->priv->synced) { g_cond_wait (&clock->priv->sync_cond, GST_OBJECT_GET_LOCK (clock)); } } GST_OBJECT_UNLOCK (clock); return !timed_out; }
static GstElement * gst_switch_select (GstSwitch * swit, GstPadTemplate * templ, const gchar * name, const GstCaps * caps) { GList *item = GST_BIN_CHILDREN (GST_BIN (swit)); GstElement *swcase = NULL; for (; item; item = g_list_next (item)) { GList *paditem = GST_ELEMENT_PADS (GST_ELEMENT (item->data)); GstPad *basepad = NULL, *pad = NULL; for (; paditem; paditem = g_list_next (paditem)) { pad = GST_PAD (paditem->data); if (GST_PAD_IS_SINK (pad) && !gst_pad_is_linked (pad) && !GST_OBJECT_FLAG_IS_SET (GST_OBJECT (pad), GST_SWITCH_PAD_FLAG_GHOSTED)) { basepad = pad; break; } } if (basepad) { swcase = GST_ELEMENT (item->data); break; } } if (!swcase) { swcase = gst_switch_request_new_case (swit, templ, caps); } return swcase; }
static gboolean dxr3videosink_open (Dxr3VideoSink * sink) { g_return_val_if_fail (!GST_OBJECT_FLAG_IS_SET (sink, DXR3VIDEOSINK_OPEN), FALSE); /* Compute the name of the video device file. */ sink->video_filename = g_strdup_printf ("/dev/em8300_mv-%d", sink->card_number); sink->video_fd = open (sink->video_filename, O_WRONLY); if (sink->video_fd < 0) { GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE, (_("Could not open video device \"%s\" for writing."), sink->video_filename), GST_ERROR_SYSTEM); return FALSE; } /* Open the control device. */ sink->control_filename = g_strdup_printf ("/dev/em8300-%d", sink->card_number); sink->control_fd = open (sink->control_filename, O_WRONLY); if (sink->control_fd < 0) { GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE, (_("Could not open control device \"%s\" for writing."), sink->control_filename), GST_ERROR_SYSTEM); return FALSE; } GST_OBJECT_FLAG_SET (sink, DXR3VIDEOSINK_OPEN); return TRUE; }
static GstClock * gst_pipeline_provide_clock_func (GstElement * element) { GstClock *clock = NULL; GstPipeline *pipeline = GST_PIPELINE (element); /* if we have a fixed clock, use that one */ GST_OBJECT_LOCK (pipeline); if (GST_OBJECT_FLAG_IS_SET (pipeline, GST_PIPELINE_FLAG_FIXED_CLOCK)) { clock = pipeline->fixed_clock; if (clock) gst_object_ref (clock); GST_OBJECT_UNLOCK (pipeline); GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline using fixed clock %p (%s)", clock, clock ? GST_STR_NULL (GST_OBJECT_NAME (clock)) : "-"); } else { GST_OBJECT_UNLOCK (pipeline); /* let the parent bin select a clock */ clock = GST_ELEMENT_CLASS (parent_class)->provide_clock (GST_ELEMENT (pipeline)); /* no clock, use a system clock */ if (!clock) { clock = gst_system_clock_obtain (); GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline obtained system clock: %p (%s)", clock, clock ? GST_STR_NULL (GST_OBJECT_NAME (clock)) : "-"); } else { GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline obtained clock: %p (%s)", clock, clock ? GST_STR_NULL (GST_OBJECT_NAME (clock)) : "-"); } } return clock; }
static GstMemory * _fallback_mem_copy (GstMemory * mem, gssize offset, gssize size) { GstMemory *copy; GstMapInfo sinfo, dinfo; GstAllocationParams params = { 0, mem->align, 0, 0, }; GstAllocator *allocator; if (!gst_memory_map (mem, &sinfo, GST_MAP_READ)) return NULL; if (size == -1) size = sinfo.size > offset ? sinfo.size - offset : 0; /* use the same allocator as the memory we copy */ allocator = mem->allocator; if (GST_OBJECT_FLAG_IS_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC)) allocator = NULL; copy = gst_allocator_alloc (allocator, size, ¶ms); if (!gst_memory_map (copy, &dinfo, GST_MAP_WRITE)) { GST_CAT_WARNING (GST_CAT_MEMORY, "could not write map memory %p", copy); gst_allocator_free (mem->allocator, copy); gst_memory_unmap (mem, &sinfo); return NULL; } GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "memcpy %" G_GSSIZE_FORMAT " memory %p -> %p", size, mem, copy); memcpy (dinfo.data, sinfo.data + offset, size); gst_memory_unmap (copy, &dinfo); gst_memory_unmap (mem, &sinfo); return copy; }
static void gst_multi_file_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMultiFileSrc *src = GST_MULTI_FILE_SRC (object); switch (prop_id) { case PROP_LOCATION: gst_multi_file_src_set_location (src, g_value_get_string (value)); break; case PROP_INDEX: GST_OBJECT_LOCK (src); /* index was really meant to be read-only, but for backwards-compatibility * we set start_index to make it work as it used to */ if (!GST_OBJECT_FLAG_IS_SET (src, GST_BASE_SRC_FLAG_STARTED)) src->start_index = g_value_get_int (value); else src->index = g_value_get_int (value); GST_OBJECT_UNLOCK (src); break; case PROP_START_INDEX: src->start_index = g_value_get_int (value); break; case PROP_STOP_INDEX: src->stop_index = g_value_get_int (value); break; case PROP_CAPS: { GstStructure *st = NULL; const GstCaps *caps = gst_value_get_caps (value); GstCaps *new_caps; if (caps == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (caps); } gst_caps_replace (&src->caps, new_caps); gst_pad_set_caps (GST_BASE_SRC_PAD (src), new_caps); if (new_caps && gst_caps_get_size (new_caps) == 1 && (st = gst_caps_get_structure (new_caps, 0)) && gst_structure_get_fraction (st, "framerate", &src->fps_n, &src->fps_d)) { GST_INFO_OBJECT (src, "Seting framerate to %d/%d", src->fps_n, src->fps_d); } else { src->fps_n = -1; src->fps_d = -1; } } break; case PROP_LOOP: src->loop = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void dxr3audiosink_close (Dxr3AudioSink * sink) { g_return_if_fail (GST_OBJECT_FLAG_IS_SET (sink, DXR3AUDIOSINK_OPEN)); if (close (sink->audio_fd) != 0) { GST_ELEMENT_ERROR (sink, RESOURCE, CLOSE, (_("Could not close audio device \"%s\"."), sink->audio_filename), GST_ERROR_SYSTEM); return; } if (close (sink->control_fd) != 0) { GST_ELEMENT_ERROR (sink, RESOURCE, CLOSE, (_("Could not close control device \"%s\"."), sink->audio_filename), GST_ERROR_SYSTEM); return; } GST_OBJECT_FLAG_UNSET (sink, DXR3AUDIOSINK_OPEN); g_free (sink->audio_filename); sink->audio_filename = NULL; g_free (sink->control_filename); sink->control_filename = NULL; /* Get rid of the padder, if any. */ if (sink->padder != NULL) { g_free (sink->padder); sink->padder = NULL; } }
/** * gst_clock_get_internal_time: * @clock: a #GstClock to query * * Gets the current internal time of the given clock. The time is returned * unadjusted for the offset and the rate. * * Returns: the internal time of the clock. Or GST_CLOCK_TIME_NONE when * given invalid input. * * MT safe. */ GstClockTime gst_clock_get_internal_time (GstClock * clock) { GstClockTime ret; GstClockClass *cclass; g_return_val_if_fail (GST_IS_CLOCK (clock), GST_CLOCK_TIME_NONE); if (G_UNLIKELY (GST_OBJECT_FLAG_IS_SET (clock, GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC) && !clock->priv->synced)) GST_CAT_WARNING_OBJECT (GST_CAT_CLOCK, clock, "clocked is not synchronized yet"); cclass = GST_CLOCK_GET_CLASS (clock); if (G_UNLIKELY (cclass->get_internal_time == NULL)) goto not_supported; ret = cclass->get_internal_time (clock); GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "internal time %" GST_TIME_FORMAT, GST_TIME_ARGS (ret)); return ret; /* ERRORS */ not_supported: { GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "internal time not supported, return 0"); return G_GINT64_CONSTANT (0); } }
/** * gst_clock_is_synced: * @clock: a GstClock * * Checks if the clock is currently synced. * * This returns if GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC is not set on the clock. * * Returns: %TRUE if the clock is currently synced * * Since: 1.6 */ gboolean gst_clock_is_synced (GstClock * clock) { g_return_val_if_fail (GST_IS_CLOCK (clock), TRUE); return !GST_OBJECT_FLAG_IS_SET (clock, GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC) || clock->priv->synced; }
static void send_flush_on_unlink (GstPad * pad, GstPad * peer, gpointer user_data) { if (GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_EOS)) { gst_pad_send_event (pad, gst_event_new_flush_start ()); gst_pad_send_event (pad, gst_event_new_flush_stop (FALSE)); } }
static GstElement * get_sink_element (GstBin * bin) { GstElement *e; GList *node; GST_INFO_OBJECT (bin, "looking for audio_sink"); for (node = GST_BIN_CHILDREN (bin); node; node = g_list_next (node)) { e = (GstElement *) node->data; if (GST_IS_BIN (e) && GST_OBJECT_FLAG_IS_SET (e, GST_ELEMENT_FLAG_SINK)) { return get_sink_element ((GstBin *) e); } if (GST_OBJECT_FLAG_IS_SET (e, GST_ELEMENT_FLAG_SINK)) { return e; } } return NULL; }
/** * gst_clock_set_master: * @clock: a #GstClock * @master: (allow-none): a master #GstClock * * Set @master as the master clock for @clock. @clock will be automatically * calibrated so that gst_clock_get_time() reports the same time as the * master clock. * * A clock provider that slaves its clock to a master can get the current * calibration values with gst_clock_get_calibration(). * * @master can be %NULL in which case @clock will not be slaved anymore. It will * however keep reporting its time adjusted with the last configured rate * and time offsets. * * Returns: %TRUE if the clock is capable of being slaved to a master clock. * Trying to set a master on a clock without the * #GST_CLOCK_FLAG_CAN_SET_MASTER flag will make this function return %FALSE. * * MT safe. */ gboolean gst_clock_set_master (GstClock * clock, GstClock * master) { GstClock **master_p; GstClockPrivate *priv; g_return_val_if_fail (GST_IS_CLOCK (clock), FALSE); g_return_val_if_fail (master != clock, FALSE); GST_OBJECT_LOCK (clock); /* we always allow setting the master to NULL */ if (master && !GST_OBJECT_FLAG_IS_SET (clock, GST_CLOCK_FLAG_CAN_SET_MASTER)) goto not_supported; GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "slaving %p to master clock %p", clock, master); GST_OBJECT_UNLOCK (clock); priv = clock->priv; GST_CLOCK_SLAVE_LOCK (clock); if (priv->clockid) { gst_clock_id_unschedule (priv->clockid); gst_clock_id_unref (priv->clockid); priv->clockid = NULL; } if (master) { priv->filling = TRUE; priv->time_index = 0; /* use the master periodic id to schedule sampling and * clock calibration. */ priv->clockid = gst_clock_new_periodic_id (master, gst_clock_get_time (master), priv->timeout); gst_clock_id_wait_async (priv->clockid, (GstClockCallback) gst_clock_slave_callback, gst_object_ref (clock), (GDestroyNotify) gst_object_unref); } GST_CLOCK_SLAVE_UNLOCK (clock); GST_OBJECT_LOCK (clock); master_p = &priv->master; gst_object_replace ((GstObject **) master_p, (GstObject *) master); GST_OBJECT_UNLOCK (clock); return TRUE; /* ERRORS */ not_supported: { GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "cannot be slaved to a master clock"); GST_OBJECT_UNLOCK (clock); return FALSE; } }
static void calculate_latency (GstElement * parent, GstPad * pad, guint64 ts) { if (parent && (!GST_IS_BIN (parent)) && GST_OBJECT_FLAG_IS_SET (parent, GST_ELEMENT_FLAG_SINK)) { GstEvent *ev = g_object_get_qdata ((GObject *) pad, latency_probe_id); log_latency (gst_event_get_structure (ev), pad, ts); gst_event_unref (ev); } }
static GstStateChangeReturn gst_artsdsink_change_state (GstElement * element, GstStateChange transition) { g_return_val_if_fail (GST_IS_ARTSDSINK (element), FALSE); /* if going down into NULL state, close the stream if it's open */ if (GST_STATE_PENDING (element) == GST_STATE_NULL) { if (GST_OBJECT_FLAG_IS_SET (element, GST_ARTSDSINK_OPEN)) gst_artsdsink_close_audio (GST_ARTSDSINK (element)); /* otherwise (READY or higher) we need to open the stream */ } else { if (!GST_OBJECT_FLAG_IS_SET (element, GST_ARTSDSINK_OPEN)) { if (!gst_artsdsink_open_audio (GST_ARTSDSINK (element))) return GST_STATE_CHANGE_FAILURE; } } if (GST_ELEMENT_CLASS (parent_class)->change_state) return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); return GST_STATE_CHANGE_SUCCESS; }
/** * Process a pad for connecting or disconnecting, it should be always called * whint the agnostic lock hold. * * @self: The #KmsAgnosticBin2 owner of the pad * @pad: The pad to be processed */ static gboolean kms_agnostic_bin2_process_pad (KmsAgnosticBin2 * self, GstPad * pad) { GstPad *peer = NULL; if (!GST_OBJECT_FLAG_IS_SET (pad, KMS_AGNOSTIC_PAD_STARTED)) { return FALSE; } if (!self->priv->started) { return FALSE; } GST_DEBUG_OBJECT (self, "Processing pad: %" GST_PTR_FORMAT, pad); if (pad == NULL) { return FALSE; } peer = gst_pad_get_peer (pad); if (peer != NULL) { GstPad *target = gst_ghost_pad_get_target (GST_GHOST_PAD (pad)); if (target) { GstCaps *caps = gst_pad_get_current_caps (pad); if (caps != NULL) { gboolean accepted; accepted = gst_pad_query_accept_caps (peer, caps); gst_caps_unref (caps); if (accepted) { GST_DEBUG_OBJECT (self, "No need to reconfigure pad %" GST_PTR_FORMAT, pad); g_object_unref (target); g_object_unref (peer); return FALSE; } remove_target_pad (pad); } g_object_unref (target); } kms_agnostic_bin2_link_pad (self, pad, peer); } return TRUE; }
static void send_latency_probe (GstElement * parent, GstPad * pad, guint64 ts) { if (parent && (!GST_IS_BIN (parent)) && GST_OBJECT_FLAG_IS_SET (parent, GST_ELEMENT_FLAG_SOURCE)) { GstEvent *latency_probe = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, gst_structure_new_id (latency_probe_id, latency_probe_pad, GST_TYPE_PAD, pad, latency_probe_ts, G_TYPE_UINT64, ts, NULL)); gst_pad_push_event (pad, latency_probe); } }
static void on_notify_caps (GstPad * pad, GParamSpec * pspec, GstElement * pay) { GstCaps *caps; g_object_get (pad, "caps", &caps, NULL); GST_DEBUG ("notify %" GST_PTR_FORMAT, caps); if (caps) { if (!GST_OBJECT_FLAG_IS_SET (pay, FLAG_HAVE_CAPS)) { g_signal_emit_by_name (pay, "pad-added", pad); g_signal_emit_by_name (pay, "no-more-pads", NULL); GST_OBJECT_FLAG_SET (pay, FLAG_HAVE_CAPS); } gst_caps_unref (caps); } else { if (GST_OBJECT_FLAG_IS_SET (pay, FLAG_HAVE_CAPS)) { g_signal_emit_by_name (pay, "pad-removed", pad); GST_OBJECT_FLAG_UNSET (pay, FLAG_HAVE_CAPS); } } }
static GstStateChangeReturn gst_festival_change_state (GstElement * element, GstStateChange transition) { g_return_val_if_fail (GST_IS_FESTIVAL (element), GST_STATE_CHANGE_FAILURE); if (GST_STATE_PENDING (element) == GST_STATE_NULL) { if (GST_OBJECT_FLAG_IS_SET (element, GST_FESTIVAL_OPEN)) { GST_DEBUG ("Closing connection "); gst_festival_close (GST_FESTIVAL (element)); } } else { if (!GST_OBJECT_FLAG_IS_SET (element, GST_FESTIVAL_OPEN)) { GST_DEBUG ("Opening connection "); if (!gst_festival_open (GST_FESTIVAL (element))) return GST_STATE_CHANGE_FAILURE; } } if (GST_ELEMENT_CLASS (parent_class)->change_state) return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); return GST_STATE_CHANGE_SUCCESS; }
static GstStateChangeReturn gst_sctp_base_sink_change_state (GstElement * element, GstStateChange transition) { GstSCTPBaseSink *self = GST_SCTP_BASE_SINK (element); GstStateChangeReturn ret; if (transition == GST_STATE_CHANGE_NULL_TO_READY) { GST_SCTP_BASE_SINK_LOCK (self); gst_sctp_base_sink_create_socket (self); if (!GST_OBJECT_FLAG_IS_SET (self, GST_SCTP_BASE_SINK_OPEN)) { GST_SCTP_BASE_SINK_UNLOCK (self); return GST_STATE_CHANGE_FAILURE; } gst_sctp_base_sink_configure_sinks (self); GST_SCTP_BASE_SINK_UNLOCK (self); } /* Let parent class manage the state transition. Parent will initialize */ /* children when transitioning from NULL state onward or it will release */ /* children's resources when transitioning from PLAYING state backwards */ ret = GST_ELEMENT_CLASS (gst_sctp_base_sink_parent_class)->change_state (element, transition); if (transition == GST_STATE_CHANGE_READY_TO_NULL) { GST_SCTP_BASE_SINK_LOCK (self); gst_sctp_base_sink_destroy_socket (self); if (GST_OBJECT_FLAG_IS_SET (self, GST_SCTP_BASE_SINK_OPEN)) { GST_SCTP_BASE_SINK_UNLOCK (self); return GST_STATE_CHANGE_FAILURE; } GST_SCTP_BASE_SINK_UNLOCK (self); } return ret; }
static GstStateChangeReturn dxr3audiosink_change_state (GstElement * element, GstStateChange transition) { g_return_val_if_fail (GST_IS_DXR3AUDIOSINK (element), GST_STATE_CHANGE_FAILURE); if (GST_STATE_PENDING (element) == GST_STATE_NULL) { if (GST_OBJECT_FLAG_IS_SET (element, DXR3AUDIOSINK_OPEN)) { dxr3audiosink_close (DXR3AUDIOSINK (element)); } } else { if (!GST_OBJECT_FLAG_IS_SET (element, DXR3AUDIOSINK_OPEN)) { if (!dxr3audiosink_open (DXR3AUDIOSINK (element))) { return GST_STATE_CHANGE_FAILURE; } } } if (GST_ELEMENT_CLASS (parent_class)->change_state) { return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); } return GST_STATE_CHANGE_SUCCESS; }
/** * gst_clock_set_synced: * @clock: a GstClock * @synced: if the clock is synced * * Sets @clock to synced and emits the GstClock::synced signal, and wakes up any * thread waiting in gst_clock_wait_for_sync(). * * This function must only be called if GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC * is set on the clock, and is intended to be called by subclasses only. * * Since: 1.6 */ void gst_clock_set_synced (GstClock * clock, gboolean synced) { g_return_if_fail (GST_IS_CLOCK (clock)); g_return_if_fail (GST_OBJECT_FLAG_IS_SET (clock, GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC)); GST_OBJECT_LOCK (clock); if (clock->priv->synced != ! !synced) { clock->priv->synced = ! !synced; g_cond_signal (&clock->priv->sync_cond); GST_OBJECT_UNLOCK (clock); g_signal_emit (clock, gst_clock_signals[SIGNAL_SYNCED], 0, ! !synced); } else { GST_OBJECT_UNLOCK (clock); } }
static void dxr3videosink_write_data (Dxr3VideoSink * sink, guint cut) { guint size, written; guint8 *data; g_return_if_fail (sink->cur_buf != NULL); if (GST_OBJECT_FLAG_IS_SET (sink, DXR3VIDEOSINK_OPEN)) { if (sink->cur_ts != GST_CLOCK_TIME_NONE) { guint pts; /* fprintf (stderr, "------ Video Time %.04f\n", */ /* (double) sink->cur_ts / GST_SECOND); */ pts = (guint) GSTTIME_TO_MPEGTIME (sink->cur_ts); ioctl (sink->video_fd, EM8300_IOCTL_VIDEO_SETPTS, &pts); sink->cur_ts = GST_CLOCK_TIME_NONE; } data = GST_BUFFER_DATA (sink->cur_buf); size = sink->scan_pos - cut; g_assert (size <= GST_BUFFER_SIZE (sink->cur_buf)); /* We should always write data that corresponds to whole MPEG video sintactical elements. They should always start with an MPEG start code. */ g_assert (size >= 4 && data[0] == 0 && data[1] == 0 && data[2] == 1); while (size > 0) { written = write (sink->video_fd, data, size); if (written < 0) { GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (_("Could not write to device \"%s\"."), sink->video_filename), GST_ERROR_SYSTEM); break; } size = size - written; data = data + written; }; } dxr3videosink_discard_data (sink, cut); }
static void gst_sctp_base_sink_destroy_socket (GstSCTPBaseSink * self) { GError *err = NULL; if (!GST_OBJECT_FLAG_IS_SET (self, GST_SCTP_BASE_SINK_OPEN)) return; if (self->priv->socket != NULL) { GST_DEBUG_OBJECT (self, "closing socket"); if (!g_socket_close (self->priv->socket, &err)) { GST_ERROR_OBJECT (self, "Failed to close socket: %s", err->message); g_clear_error (&err); } g_clear_object (&self->priv->socket); } GST_OBJECT_FLAG_UNSET (self, GST_SCTP_BASE_SINK_OPEN); }
static void do_push_event_pre (GstTracer * self, guint64 ts, GstPad * pad, GstEvent * ev) { GstPad *peer_pad = GST_PAD_PEER (pad); GstElement *parent = get_real_pad_parent (peer_pad); if (parent && (!GST_IS_BIN (parent)) && GST_OBJECT_FLAG_IS_SET (parent, GST_ELEMENT_FLAG_SINK)) { if (GST_EVENT_TYPE (ev) == GST_EVENT_CUSTOM_DOWNSTREAM) { const GstStructure *data = gst_event_get_structure (ev); if (gst_structure_get_name_id (data) == latency_probe_id) { /* store event and calculate latency when the buffer that follows * has been processed */ g_object_set_qdata ((GObject *) peer_pad, latency_probe_id, gst_event_ref (ev)); } } } }
static void dxr3spusink_chain (GstPad * pad, GstData * _data) { GstBuffer *buf = GST_BUFFER (_data); Dxr3SpuSink *sink; gint bytes_written = 0; g_return_if_fail (pad != NULL); g_return_if_fail (GST_IS_PAD (pad)); g_return_if_fail (buf != NULL); sink = DXR3SPUSINK (gst_pad_get_parent (pad)); if (GST_IS_EVENT (buf)) { dxr3spusink_handle_event (pad, GST_EVENT (buf)); return; } if (GST_OBJECT_FLAG_IS_SET (sink, DXR3SPUSINK_OPEN)) { /* If we have PTS information for the SPU unit, register it now. The card needs the PTS to be written *before* the actual data. */ if (GST_BUFFER_TIMESTAMP (buf) != GST_CLOCK_TIME_NONE) { guint pts = (guint) GSTTIME_TO_MPEGTIME (GST_BUFFER_TIMESTAMP (buf)); ioctl (sink->spu_fd, EM8300_IOCTL_SPU_SETPTS, &pts); } bytes_written = write (sink->spu_fd, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf)); if (bytes_written < GST_BUFFER_SIZE (buf)) { fprintf (stderr, "dxr3spusink: Warning: %d bytes should be written," " only %d bytes written\n", GST_BUFFER_SIZE (buf), bytes_written); } } gst_buffer_unref (buf); }
static void dxr3videosink_close (Dxr3VideoSink * sink) { g_return_if_fail (GST_OBJECT_FLAG_IS_SET (sink, DXR3VIDEOSINK_OPEN)); if (close (sink->video_fd) != 0) { GST_ELEMENT_ERROR (sink, RESOURCE, CLOSE, (_("Could not close video device \"%s\"."), sink->video_filename), GST_ERROR_SYSTEM); return; } if (close (sink->control_fd) != 0) { GST_ELEMENT_ERROR (sink, RESOURCE, CLOSE, (_("Could not close control device \"%s\"."), sink->control_filename), GST_ERROR_SYSTEM); return; } GST_OBJECT_FLAG_UNSET (sink, DXR3VIDEOSINK_OPEN); free (sink->video_filename); sink->video_filename = NULL; }
static void print_blacklist (void) { GList *plugins, *cur; gint count = 0; g_print ("%s\n", _("Blacklisted files:")); plugins = gst_registry_get_plugin_list (gst_registry_get ()); for (cur = plugins; cur != NULL; cur = g_list_next (cur)) { GstPlugin *plugin = (GstPlugin *) (cur->data); if (GST_OBJECT_FLAG_IS_SET (plugin, GST_PLUGIN_FLAG_BLACKLISTED)) { g_print (" %s\n", gst_plugin_get_name (plugin)); count++; } } g_print ("\n"); g_print (_("Total count: ")); g_print (ngettext ("%d blacklisted file", "%d blacklisted files", count), count); g_print ("\n"); gst_plugin_list_free (plugins); }