static void gst_raw_parse_reset (GstRawParse * rp) { rp->n_frames = 0; rp->discont = TRUE; rp->negotiated = FALSE; gst_segment_init (&rp->segment, GST_FORMAT_TIME); gst_adapter_clear (rp->adapter); }
/** * gst_segment_new: * * Allocate a new #GstSegment structure and initialize it using * gst_segment_init(). * * Free-function: gst_segment_free * * Returns: (transfer full): a new #GstSegment, free with gst_segment_free(). */ GstSegment * gst_segment_new (void) { GstSegment *result; result = g_slice_new0 (GstSegment); gst_segment_init (result, GST_FORMAT_UNDEFINED); return result; }
static void gst_visual_reset (GstVisual * visual) { gst_adapter_clear (visual->adapter); gst_segment_init (&visual->segment, GST_FORMAT_UNDEFINED); GST_OBJECT_LOCK (visual); visual->proportion = 1.0; visual->earliest_time = -1; GST_OBJECT_UNLOCK (visual); }
static void gst_goom_reset (GstGoom * goom) { gst_adapter_clear (goom->adapter); gst_segment_init (&goom->segment, GST_FORMAT_UNDEFINED); GST_OBJECT_LOCK (goom); goom->proportion = 1.0; goom->earliest_time = -1; GST_OBJECT_UNLOCK (goom); }
static gboolean gst_app_sink_stop (GstBaseSink * psink) { GstAppSink *appsink = GST_APP_SINK_CAST (psink); GstAppSinkPrivate *priv = appsink->priv; g_mutex_lock (&priv->mutex); GST_DEBUG_OBJECT (appsink, "stopping"); priv->flushing = TRUE; priv->started = FALSE; gst_app_sink_flush_unlocked (appsink); gst_buffer_replace (&priv->preroll, NULL); gst_caps_replace (&priv->preroll_caps, NULL); gst_caps_replace (&priv->last_caps, NULL); gst_segment_init (&priv->preroll_segment, GST_FORMAT_UNDEFINED); gst_segment_init (&priv->last_segment, GST_FORMAT_UNDEFINED); g_mutex_unlock (&priv->mutex); return TRUE; }
static void gst_segment_clip_reset (GstSegmentClip * self) { GstSegmentClipClass *klass = GST_SEGMENT_CLIP_GET_CLASS (self); GST_DEBUG_OBJECT (self, "Resetting internal state"); gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED); if (klass->reset) klass->reset (self); }
static void gst_base_video_decoder_init (GstBaseVideoDecoder * base_video_decoder, GstBaseVideoDecoderClass * base_video_decoder_class) { GstPadTemplate *pad_template; GstPad *pad; GST_DEBUG ("gst_base_video_decoder_init"); pad_template = gst_element_class_get_pad_template (GST_ELEMENT_CLASS (base_video_decoder_class), "sink"); g_return_if_fail (pad_template != NULL); base_video_decoder->sinkpad = pad = gst_pad_new_from_template (pad_template, "sink"); gst_element_add_pad (GST_ELEMENT (base_video_decoder), pad); gst_pad_set_chain_function (pad, gst_base_video_decoder_chain); gst_pad_set_event_function (pad, gst_base_video_decoder_sink_event); gst_pad_set_setcaps_function (pad, gst_base_video_decoder_sink_setcaps); gst_pad_set_query_function (pad, gst_base_video_decoder_sink_query); if (base_video_decoder_class->create_srcpad) { base_video_decoder->srcpad = pad = base_video_decoder_class->create_srcpad (base_video_decoder, base_video_decoder_class); } else { pad_template = gst_element_class_get_pad_template (GST_ELEMENT_CLASS (base_video_decoder_class), "src"); g_return_if_fail (pad_template != NULL); base_video_decoder->srcpad = pad = gst_pad_new_from_template (pad_template, "src"); } gst_element_add_pad (GST_ELEMENT (base_video_decoder), pad); gst_pad_set_event_function (pad, gst_base_video_decoder_src_event); gst_pad_set_query_type_function (pad, gst_base_video_decoder_get_query_types); gst_pad_set_query_function (pad, gst_base_video_decoder_src_query); gst_pad_use_fixed_caps (pad); base_video_decoder->input_adapter = gst_adapter_new (); gst_segment_init (&base_video_decoder->segment, GST_FORMAT_TIME); base_video_decoder->current_frame = gst_base_video_decoder_new_frame (base_video_decoder); /* properties */ base_video_decoder->packetized = FALSE; base_video_decoder->sink_clipping = TRUE; }
static void gst_selector_pad_reset (GstSelectorPad * pad) { GST_OBJECT_LOCK (pad); pad->active = FALSE; pad->eos = FALSE; pad->segment_pending = FALSE; pad->discont = FALSE; gst_segment_init (&pad->segment, GST_FORMAT_UNDEFINED); GST_OBJECT_UNLOCK (pad); }
static void reset_pad (gpointer data, gpointer user_data) { GstPad *pad = data; FsFunnelPadPrivate *priv = gst_pad_get_element_private (pad); GST_OBJECT_LOCK (pad); gst_segment_init (&priv->segment, GST_FORMAT_UNDEFINED); GST_OBJECT_UNLOCK (pad); gst_object_unref (pad); }
static GstStateChangeReturn gst_rtp_base_payload_change_state (GstElement * element, GstStateChange transition) { GstRTPBasePayload *rtpbasepayload; GstRTPBasePayloadPrivate *priv; GstStateChangeReturn ret; rtpbasepayload = GST_RTP_BASE_PAYLOAD (element); priv = rtpbasepayload->priv; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: gst_segment_init (&rtpbasepayload->segment, GST_FORMAT_UNDEFINED); if (priv->seqnum_offset_random) rtpbasepayload->seqnum_base = g_random_int_range (0, G_MAXUINT16); else rtpbasepayload->seqnum_base = rtpbasepayload->seqnum_offset; priv->next_seqnum = rtpbasepayload->seqnum_base; rtpbasepayload->seqnum = rtpbasepayload->seqnum_base; if (priv->ssrc_random) rtpbasepayload->current_ssrc = g_random_int (); else rtpbasepayload->current_ssrc = rtpbasepayload->ssrc; if (priv->ts_offset_random) rtpbasepayload->ts_base = g_random_int (); else rtpbasepayload->ts_base = rtpbasepayload->ts_offset; rtpbasepayload->timestamp = rtpbasepayload->ts_base; g_atomic_int_set (&rtpbasepayload->priv->notified_first_timestamp, 1); priv->base_offset = GST_BUFFER_OFFSET_NONE; break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: g_atomic_int_set (&rtpbasepayload->priv->notified_first_timestamp, 1); break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static gboolean mpegts_base_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { gboolean res = TRUE; gboolean hard; MpegTSBase *base = GST_MPEGTS_BASE (parent); GST_DEBUG_OBJECT (base, "Got event %s", gst_event_type_get_name (GST_EVENT_TYPE (event))); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEGMENT: gst_event_copy_segment (event, &base->segment); GST_DEBUG_OBJECT (base, "Received segment %" GST_SEGMENT_FORMAT, &base->segment); /* Check if we need to switch PCR/PTS handling */ if (base->segment.format == GST_FORMAT_TIME) { base->packetizer->calculate_offset = FALSE; base->packetizer->calculate_skew = TRUE; } else { base->packetizer->calculate_offset = TRUE; base->packetizer->calculate_skew = FALSE; } res = GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, event); break; case GST_EVENT_STREAM_START: gst_event_unref (event); break; case GST_EVENT_EOS: res = GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, event); res = gst_mpegts_base_handle_eos (base); break; case GST_EVENT_CAPS: /* FIXME, do something */ gst_event_unref (event); break; case GST_EVENT_FLUSH_STOP: res = GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, event); hard = (base->mode != BASE_MODE_SEEKING); mpegts_packetizer_flush (base->packetizer, hard); mpegts_base_flush (base, hard); gst_segment_init (&base->segment, GST_FORMAT_UNDEFINED); base->seen_pat = FALSE; break; default: res = GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, event); } /* Always return TRUE for sticky events */ if (GST_EVENT_IS_STICKY (event)) res = TRUE; return res; }
static gboolean gst_dvbsub_overlay_event_video (GstPad * pad, GstObject * parent, GstEvent * event) { gboolean ret = FALSE; GstDVBSubOverlay *render = GST_DVBSUB_OVERLAY (parent); GST_DEBUG_OBJECT (pad, "received video event %s", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS: { GstCaps *caps; gst_event_parse_caps (event, &caps); ret = gst_dvbsub_overlay_setcaps_video (pad, caps); gst_event_unref (event); break; } case GST_EVENT_SEGMENT: { GstSegment seg; GST_DEBUG_OBJECT (render, "received new segment"); gst_event_copy_segment (event, &seg); if (seg.format == GST_FORMAT_TIME) { GST_DEBUG_OBJECT (render, "VIDEO SEGMENT now: %" GST_SEGMENT_FORMAT, &render->video_segment); render->video_segment = seg; GST_DEBUG_OBJECT (render, "VIDEO SEGMENT after: %" GST_SEGMENT_FORMAT, &render->video_segment); ret = gst_pad_push_event (render->srcpad, event); } else { GST_ELEMENT_WARNING (render, STREAM, MUX, (NULL), ("received non-TIME newsegment event on video input")); ret = FALSE; gst_event_unref (event); } break; } case GST_EVENT_FLUSH_STOP: gst_segment_init (&render->video_segment, GST_FORMAT_TIME); default: ret = gst_pad_push_event (render->srcpad, event); break; } return ret; }
static GstStateChangeReturn gst_timecodewait_change_state (GstElement * element, GstStateChange transition) { GstStateChangeReturn ret; GstTimeCodeWait *self = GST_TIMECODEWAIT (element); switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: g_mutex_lock (&self->mutex); self->shutdown_flag = TRUE; g_cond_signal (&self->cond); g_mutex_unlock (&self->mutex); break; case GST_STATE_CHANGE_READY_TO_PAUSED: g_mutex_lock (&self->mutex); self->shutdown_flag = FALSE; self->video_eos_flag = FALSE; self->audio_flush_flag = FALSE; g_mutex_unlock (&self->mutex); default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: g_mutex_lock (&self->mutex); self->running_time_of_timecode = GST_CLOCK_TIME_NONE; gst_segment_init (&self->asegment, GST_FORMAT_UNDEFINED); self->asegment.position = GST_CLOCK_TIME_NONE; gst_segment_init (&self->vsegment, GST_FORMAT_UNDEFINED); self->vsegment.position = GST_CLOCK_TIME_NONE; g_mutex_unlock (&self->mutex); break; default: break; } return ret; }
static GstStateChangeReturn gst_dvdec_change_state (GstElement * element, GstStateChange transition) { GstDVDec *dvdec = GST_DVDEC (element); GstStateChangeReturn ret; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: dvdec->decoder = dv_decoder_new (0, dvdec->clamp_luma, dvdec->clamp_chroma); dvdec->decoder->quality = qualities[dvdec->quality]; dv_set_error_log (dvdec->decoder, NULL); gst_video_info_init (&dvdec->vinfo); gst_segment_init (&dvdec->segment, GST_FORMAT_UNDEFINED); dvdec->src_negotiated = FALSE; dvdec->sink_negotiated = FALSE; dvdec->need_segment = FALSE; /* * Enable this function call when libdv2 0.100 or higher is more * common */ /* dv_set_quality (dvdec->decoder, qualities [dvdec->quality]); */ break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: dv_decoder_free (dvdec->decoder); dvdec->decoder = NULL; if (dvdec->pool) { gst_buffer_pool_set_active (dvdec->pool, FALSE); gst_object_unref (dvdec->pool); dvdec->pool = NULL; } break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static gboolean gst_timecodewait_asink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstTimeCodeWait *self = GST_TIMECODEWAIT (parent); GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEGMENT: g_mutex_lock (&self->mutex); self->running_time_of_timecode = GST_CLOCK_TIME_NONE; gst_event_copy_segment (event, &self->asegment); if (self->asegment.format != GST_FORMAT_TIME) { GST_ERROR_OBJECT (self, "Invalid segment format"); g_mutex_unlock (&self->mutex); return FALSE; } self->asegment.position = GST_CLOCK_TIME_NONE; g_mutex_unlock (&self->mutex); break; case GST_EVENT_FLUSH_START: g_mutex_lock (&self->mutex); self->audio_flush_flag = TRUE; g_cond_signal (&self->cond); g_mutex_unlock (&self->mutex); break; case GST_EVENT_FLUSH_STOP: g_mutex_lock (&self->mutex); self->audio_flush_flag = FALSE; self->running_time_of_timecode = GST_CLOCK_TIME_NONE; gst_segment_init (&self->asegment, GST_FORMAT_UNDEFINED); self->asegment.position = GST_CLOCK_TIME_NONE; g_mutex_unlock (&self->mutex); break; case GST_EVENT_CAPS:{ GstCaps *caps; gst_event_parse_caps (event, &caps); GST_DEBUG_OBJECT (self, "Got caps %" GST_PTR_FORMAT, caps); g_mutex_lock (&self->mutex); if (!gst_audio_info_from_caps (&self->ainfo, caps)) { g_mutex_unlock (&self->mutex); return FALSE; } self->running_time_of_timecode = GST_CLOCK_TIME_NONE; g_mutex_unlock (&self->mutex); break; } default: break; } return gst_pad_event_default (pad, parent, event); }
static gboolean gst_flxdec_sink_event_handler (GstPad * pad, GstObject * parent, GstEvent * event) { GstFlxDec *flxdec; gboolean ret; flxdec = GST_FLXDEC (parent); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEGMENT: { gst_event_copy_segment (event, &flxdec->segment); if (flxdec->segment.format != GST_FORMAT_TIME) { GST_DEBUG_OBJECT (flxdec, "generating TIME segment"); gst_segment_init (&flxdec->segment, GST_FORMAT_TIME); gst_event_unref (event); event = gst_event_new_segment (&flxdec->segment); } if (gst_pad_has_current_caps (flxdec->srcpad)) { ret = gst_pad_event_default (pad, parent, event); } else { flxdec->need_segment = TRUE; gst_event_unref (event); ret = TRUE; } break; } case GST_EVENT_FLUSH_STOP: gst_segment_init (&flxdec->segment, GST_FORMAT_UNDEFINED); ret = gst_pad_event_default (pad, parent, event); break; default: ret = gst_pad_event_default (pad, parent, event); break; } return ret; }
static GstStateChangeReturn gst_real_audio_demux_change_state (GstElement * element, GstStateChange transition) { GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstRealAudioDemux *demux = GST_REAL_AUDIO_DEMUX (element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: demux->state = REAL_AUDIO_DEMUX_STATE_MARKER; demux->segment_running = FALSE; gst_segment_init (&demux->segment, GST_FORMAT_TIME); gst_adapter_clear (demux->adapter); break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY:{ gst_real_audio_demux_reset (demux); gst_segment_init (&demux->segment, GST_FORMAT_UNDEFINED); break; } case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static gboolean gst_rtp_ssrc_demux_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstRtpSsrcDemux *demux; gboolean res = FALSE; demux = GST_RTP_SSRC_DEMUX (parent); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: gst_segment_init (&demux->segment, GST_FORMAT_UNDEFINED); /* fallthrough */ default: { GSList *walk; GSList *pads = NULL; res = TRUE; /* need local snapshot of pads; * should not push downstream while holding lock as that might deadlock * with stuff traveling upstream tyring to get this lock while holding * other (stream)lock */ GST_PAD_LOCK (demux); for (walk = demux->srcpads; walk; walk = g_slist_next (walk)) { GstRtpSsrcDemuxPad *pad = (GstRtpSsrcDemuxPad *) walk->data; pad = g_slice_dup (GstRtpSsrcDemuxPad, pad); gst_object_ref (pad->rtp_pad); pads = g_slist_prepend (pads, pad); } GST_PAD_UNLOCK (demux); for (walk = pads; walk; walk = g_slist_next (walk)) { GstRtpSsrcDemuxPad *dpad = walk->data; GstEvent *newevent; newevent = add_ssrc_and_ref (event, dpad->ssrc); res &= gst_pad_push_event (dpad->rtp_pad, newevent); gst_object_unref (dpad->rtp_pad); g_slice_free (GstRtpSsrcDemuxPad, dpad); } g_slist_free (pads); gst_event_unref (event); break; } } return res; }
static void mpegts_base_reset (MpegTSBase * base) { MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base); mpegts_packetizer_clear (base->packetizer); memset (base->is_pes, 0, 1024); memset (base->known_psi, 0, 1024); /* FIXME : Actually these are not *always* know SI streams * depending on the variant of mpeg-ts being used. */ /* Known PIDs : PAT, TSDT, IPMP CIT */ MPEGTS_BIT_SET (base->known_psi, 0); MPEGTS_BIT_SET (base->known_psi, 2); MPEGTS_BIT_SET (base->known_psi, 3); /* TDT, TOT, ST */ MPEGTS_BIT_SET (base->known_psi, 0x14); /* network synchronization */ MPEGTS_BIT_SET (base->known_psi, 0x15); /* ATSC */ MPEGTS_BIT_SET (base->known_psi, 0x1ffb); /* FIXME : Commenting the Following lines is to be in sync with the following * commit * * 61a885613316ce7657c36a6cd215b43f9dc67b79 * mpegtsparse: don't free PAT structure which may still be needed later */ /* if (base->pat != NULL) */ /* gst_structure_free (base->pat); */ /* base->pat = NULL; */ /* pmt pids will be added and removed dynamically */ gst_segment_init (&base->segment, GST_FORMAT_UNDEFINED); base->last_seek_seqnum = (guint32) - 1; base->mode = BASE_MODE_STREAMING; base->seen_pat = FALSE; base->seek_offset = -1; base->upstream_live = FALSE; base->queried_latency = FALSE; g_hash_table_foreach_remove (base->programs, (GHRFunc) remove_each_program, base); if (klass->reset) klass->reset (base); }
static GstStateChangeReturn gst_overlay_composition_change_state (GstElement * element, GstStateChange transition) { GstOverlayComposition *self = GST_OVERLAY_COMPOSITION (element); GstStateChangeReturn state_ret; switch (transition) { default: break; } state_ret = GST_ELEMENT_CLASS (gst_overlay_composition_parent_class)->change_state (element, transition); if (state_ret == GST_STATE_CHANGE_FAILURE) return state_ret; switch (transition) { case GST_STATE_CHANGE_READY_TO_PAUSED: gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED); break; case GST_STATE_CHANGE_PAUSED_TO_READY: memset (&self->info, 0, sizeof (self->info)); self->window_width = self->window_height = 0; self->attach_compo_to_buffer = FALSE; if (self->sample) { gst_sample_unref (self->sample); self->sample = NULL; } gst_caps_replace (&self->caps, NULL); gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED); break; default: break; } return state_ret; }
static void gst_schro_dec_reset (GstSchroDec *dec) { GST_DEBUG("reset"); dec->granulepos = 0; dec->discont = TRUE; dec->n_frames = 0; dec->timestamp_offset = GST_CLOCK_TIME_NONE; dec->granulepos_offset = -1; gst_segment_init (&dec->segment, GST_FORMAT_TIME); gst_adapter_clear (dec->adapter); }
/*********************************************************************************** * Internal functions ***********************************************************************************/ static void progress_buffer_flush_data(ProgressBuffer *element) { element->last_update = 0.0; element->bandwidth = 0.0; element->subtotal = 0; element->pending_src_event = NULL; gst_segment_init (&element->sink_segment, GST_FORMAT_BYTES); #if ENABLE_PULL_MODE element->range_start = NO_RANGE_REQUEST; element->range_stop = NO_RANGE_REQUEST; #endif }
static void gst_output_selector_reset (GstOutputSelector * osel) { if (osel->pending_srcpad != NULL) { gst_object_unref (osel->pending_srcpad); osel->pending_srcpad = NULL; } if (osel->latest_buffer != NULL) { gst_buffer_unref (osel->latest_buffer); osel->latest_buffer = NULL; } gst_segment_init (&osel->segment, GST_FORMAT_UNDEFINED); }
static void gst_monoscope_reset (GstMonoscope * monoscope) { monoscope->next_ts = GST_CLOCK_TIME_NONE; gst_adapter_clear (monoscope->adapter); gst_segment_init (&monoscope->segment, GST_FORMAT_UNDEFINED); GST_OBJECT_LOCK (monoscope); monoscope->proportion = 1.0; monoscope->earliest_time = -1; GST_OBJECT_UNLOCK (monoscope); }
static void gst_audio_ringbuffer_init (GstAudioRingbuffer * ringbuffer, GstAudioRingbufferClass * g_class) { ringbuffer->sinkpad = gst_pad_new_from_static_template (&sinktemplate, "sink"); gst_pad_set_chain_function (ringbuffer->sinkpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_chain)); gst_pad_set_activatepush_function (ringbuffer->sinkpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_sink_activate_push)); gst_pad_set_event_function (ringbuffer->sinkpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_handle_sink_event)); gst_pad_set_getcaps_function (ringbuffer->sinkpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_getcaps)); gst_pad_set_setcaps_function (ringbuffer->sinkpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_setcaps)); gst_pad_set_bufferalloc_function (ringbuffer->sinkpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_bufferalloc)); gst_element_add_pad (GST_ELEMENT (ringbuffer), ringbuffer->sinkpad); ringbuffer->srcpad = gst_pad_new_from_static_template (&srctemplate, "src"); gst_pad_set_activatepull_function (ringbuffer->srcpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_src_activate_pull)); gst_pad_set_activatepush_function (ringbuffer->srcpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_src_activate_push)); gst_pad_set_getrange_function (ringbuffer->srcpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_get_range)); gst_pad_set_checkgetrange_function (ringbuffer->srcpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_src_checkgetrange_function)); gst_pad_set_getcaps_function (ringbuffer->srcpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_getcaps)); gst_pad_set_event_function (ringbuffer->srcpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_handle_src_event)); gst_pad_set_query_function (ringbuffer->srcpad, GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_handle_src_query)); gst_element_add_pad (GST_ELEMENT (ringbuffer), ringbuffer->srcpad); gst_segment_init (&ringbuffer->sink_segment, GST_FORMAT_TIME); ringbuffer->cond = g_cond_new (); ringbuffer->is_eos = FALSE; ringbuffer->buffer_time = DEFAULT_BUFFER_TIME; ringbuffer->segment_time = DEFAULT_SEGMENT_TIME; GST_DEBUG_OBJECT (ringbuffer, "initialized ringbuffer's not_empty & not_full conditions"); }
static GstStateChangeReturn gst_interleave_change_state (GstElement * element, GstStateChange transition) { GstInterleave *self; GstStateChangeReturn ret; self = GST_INTERLEAVE (element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: self->timestamp = 0; self->offset = 0; self->segment_pending = TRUE; self->segment_position = 0; self->segment_rate = 1.0; gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED); gst_collect_pads_start (self->collect); break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } /* Stop before calling the parent's state change function as * GstCollectPads might take locks and we would deadlock in that * case */ if (transition == GST_STATE_CHANGE_PAUSED_TO_READY) gst_collect_pads_stop (self->collect); ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: gst_pad_set_caps (self->src, NULL); gst_caps_replace (&self->sinkcaps, NULL); break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static gboolean gst_dvdec_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstDVDec *dvdec; gboolean res = TRUE; dvdec = GST_DVDEC (parent); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: gst_segment_init (&dvdec->segment, GST_FORMAT_UNDEFINED); dvdec->need_segment = FALSE; break; case GST_EVENT_SEGMENT:{ const GstSegment *segment; gst_event_parse_segment (event, &segment); GST_DEBUG_OBJECT (dvdec, "Got SEGMENT %" GST_SEGMENT_FORMAT, &segment); gst_segment_copy_into (segment, &dvdec->segment); if (!gst_pad_has_current_caps (dvdec->srcpad)) { dvdec->need_segment = TRUE; gst_event_unref (event); event = NULL; res = TRUE; } else { dvdec->need_segment = FALSE; } break; } case GST_EVENT_CAPS: { GstCaps *caps; gst_event_parse_caps (event, &caps); res = gst_dvdec_sink_setcaps (dvdec, caps); gst_event_unref (event); event = NULL; break; } default: break; } if (event) res = gst_pad_push_event (dvdec->srcpad, event); return res; }
static gboolean gst_type_find_element_activate_sink_mode (GstPad * pad, GstObject * parent, GstPadMode mode, gboolean active) { gboolean res; GstTypeFindElement *typefind; typefind = GST_TYPE_FIND_ELEMENT (parent); switch (mode) { case GST_PAD_MODE_PULL: if (active) { gst_segment_init (&typefind->segment, GST_FORMAT_BYTES); typefind->need_segment = TRUE; typefind->need_stream_start = TRUE; typefind->offset = 0; res = TRUE; } else { res = gst_pad_stop_task (pad); gst_segment_init (&typefind->segment, GST_FORMAT_UNDEFINED); } break; case GST_PAD_MODE_PUSH: if (active) { gst_segment_init (&typefind->segment, GST_FORMAT_UNDEFINED); start_typefinding (typefind); } else { stop_typefinding (typefind); gst_segment_init (&typefind->segment, GST_FORMAT_UNDEFINED); } res = TRUE; break; default: res = FALSE; break; } return res; }
static gboolean gst_rtp_base_payload_sink_event_default (GstRTPBasePayload * rtpbasepayload, GstEvent * event) { GstObject *parent = GST_OBJECT_CAST (rtpbasepayload); gboolean res = FALSE; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_START: res = gst_pad_event_default (rtpbasepayload->sinkpad, parent, event); break; case GST_EVENT_FLUSH_STOP: res = gst_pad_event_default (rtpbasepayload->sinkpad, parent, event); gst_segment_init (&rtpbasepayload->segment, GST_FORMAT_UNDEFINED); break; case GST_EVENT_CAPS: { GstRTPBasePayloadClass *rtpbasepayload_class; GstCaps *caps; gst_event_parse_caps (event, &caps); GST_DEBUG_OBJECT (rtpbasepayload, "setting caps %" GST_PTR_FORMAT, caps); rtpbasepayload_class = GST_RTP_BASE_PAYLOAD_GET_CLASS (rtpbasepayload); if (rtpbasepayload_class->set_caps) res = rtpbasepayload_class->set_caps (rtpbasepayload, caps); gst_event_unref (event); break; } case GST_EVENT_SEGMENT: { GstSegment *segment; segment = &rtpbasepayload->segment; gst_event_copy_segment (event, segment); rtpbasepayload->priv->base_offset = GST_BUFFER_OFFSET_NONE; GST_DEBUG_OBJECT (rtpbasepayload, "configured SEGMENT %" GST_SEGMENT_FORMAT, segment); res = gst_pad_event_default (rtpbasepayload->sinkpad, parent, event); break; } default: res = gst_pad_event_default (rtpbasepayload->sinkpad, parent, event); break; } return res; }
static void rsn_stream_selector_init (RsnStreamSelector * sel) { sel->srcpad = gst_pad_new ("src", GST_PAD_SRC); gst_pad_set_iterate_internal_links_function (sel->srcpad, GST_DEBUG_FUNCPTR (rsn_stream_selector_iterate_linked_pads)); gst_pad_set_getcaps_function (sel->srcpad, GST_DEBUG_FUNCPTR (rsn_stream_selector_getcaps)); gst_element_add_pad (GST_ELEMENT (sel), sel->srcpad); /* sinkpad management */ sel->padcount = 0; sel->active_sinkpad = NULL; gst_segment_init (&sel->segment, GST_FORMAT_UNDEFINED); }