static gboolean
gst_real_audio_demux_sink_activate_mode (GstPad * sinkpad, GstObject * parent,
GstPadMode mode, gboolean active)
{
gboolean res;
GstRealAudioDemux *demux;
demux = GST_REAL_AUDIO_DEMUX (parent);
switch (mode) {
case GST_PAD_MODE_PUSH:
demux->seekable = FALSE;
res = TRUE;
break;
case GST_PAD_MODE_PULL:
if (active) {
demux->seekable = TRUE;
res = gst_pad_start_task (sinkpad,
(GstTaskFunction) gst_real_audio_demux_loop, demux, NULL);
} else {
demux->seekable = FALSE;
res = gst_pad_stop_task (sinkpad);
}
break;
default:
res = FALSE;
break;
}
return res;
}
/**
* hls_progress_buffer_activatepush_src()
*
* Set the source pad's push mode.
*/
static gboolean hls_progress_buffer_activatepush_src(GstPad *pad, gboolean active)
{
HLSProgressBuffer *element = HLS_PROGRESS_BUFFER(GST_PAD_PARENT(pad));
if (active)
{
g_mutex_lock(element->lock);
element->srcresult = GST_FLOW_OK;
g_mutex_unlock(element->lock);
if (gst_pad_is_linked(pad))
return gst_pad_start_task(pad, hls_progress_buffer_loop, element);
else
return TRUE;
}
else
{
g_mutex_lock(element->lock);
element->srcresult = GST_FLOW_WRONG_STATE;
g_cond_signal(element->add_cond);
g_cond_signal(element->del_cond);
g_mutex_unlock(element->lock);
return gst_pad_stop_task(pad);
}
}
/**
* progress_buffer_activatepush_src()
*
* Set the source pad's push mode.
*/
static gboolean progress_buffer_activatepush_src(GstPad *pad, GstObject *parent, gboolean active)
{
ProgressBuffer *element = PROGRESS_BUFFER(parent);
if (active)
{
g_mutex_lock(&element->lock);
element->srcresult = GST_FLOW_OK;
// Do not clear pending events, since we might get events before pad is activated.
reset_eos(element, FALSE);
element->unexpected = FALSE;
g_mutex_unlock(&element->lock);
if (gst_pad_is_linked(pad))
return gst_pad_start_task(pad, progress_buffer_loop, element, NULL);
else
return TRUE;
}
else
{
g_mutex_lock(&element->lock);
element->srcresult = GST_FLOW_FLUSHING;
g_cond_signal(&element->add_cond);
g_mutex_unlock(&element->lock);
return gst_pad_stop_task(pad);
}
}
static void
gst_omx_audio_enc_flush (GstAudioEncoder * encoder)
{
GstOMXAudioEnc *self;
self = GST_OMX_AUDIO_ENC (encoder);
GST_DEBUG_OBJECT (self, "Resetting encoder");
gst_omx_audio_enc_drain (self);
gst_omx_port_set_flushing (self->enc_in_port, 5 * GST_SECOND, TRUE);
gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, TRUE);
/* Wait until the srcpad loop is finished */
GST_AUDIO_ENCODER_STREAM_UNLOCK (self);
GST_PAD_STREAM_LOCK (GST_AUDIO_ENCODER_SRC_PAD (self));
GST_PAD_STREAM_UNLOCK (GST_AUDIO_ENCODER_SRC_PAD (self));
GST_AUDIO_ENCODER_STREAM_LOCK (self);
gst_omx_port_set_flushing (self->enc_in_port, 5 * GST_SECOND, FALSE);
gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, FALSE);
gst_omx_port_populate (self->enc_out_port);
/* Start the srcpad loop again */
self->last_upstream_ts = 0;
self->downstream_flow_ret = GST_FLOW_OK;
self->eos = FALSE;
gst_pad_start_task (GST_AUDIO_ENCODER_SRC_PAD (self),
(GstTaskFunction) gst_omx_audio_enc_loop, encoder, NULL);
}
static gboolean
gst_type_find_element_activate_sink (GstPad * pad, GstObject * parent)
{
GstQuery *query;
gboolean pull_mode;
query = gst_query_new_scheduling ();
if (!gst_pad_peer_query (pad, query)) {
gst_query_unref (query);
goto typefind_push;
}
pull_mode = gst_query_has_scheduling_mode_with_flags (query,
GST_PAD_MODE_PULL, GST_SCHEDULING_FLAG_SEEKABLE);
gst_query_unref (query);
if (!pull_mode)
goto typefind_push;
if (!gst_pad_activate_mode (pad, GST_PAD_MODE_PULL, TRUE))
goto typefind_push;
/* only start our task if we ourselves decide to start in pull mode */
return gst_pad_start_task (pad, (GstTaskFunction) gst_type_find_element_loop,
pad, NULL);
typefind_push:
{
return gst_pad_activate_mode (pad, GST_PAD_MODE_PUSH, TRUE);
}
}
static GstPadLinkReturn
gst_frame_store_link_src (GstPad *pad, GstPad *peer)
{
GstPadLinkReturn result = GST_PAD_LINK_OK;
GstFrameStore *fs;
fs = GST_FRAME_STORE(gst_pad_get_parent(pad));
if (GST_PAD_LINKFUNC (peer)) {
result = GST_PAD_LINKFUNC(peer) (peer, pad);
}
if (GST_PAD_LINK_SUCCESSFUL (result)) {
g_mutex_lock (fs->lock);
fs->srcresult = GST_FLOW_OK;
if (fs->srcresult == GST_FLOW_OK) {
gst_pad_start_task (pad, (GstTaskFunction) gst_frame_store_task,
pad);
} else {
GST_DEBUG("not starting task");
/* not starting task */
}
g_mutex_unlock (fs->lock);
}
gst_object_unref (fs);
return result;
}
static gboolean
gst_cdxa_parse_do_seek (GstCDXAParse * cdxa, GstEvent * event)
{
GstSeekFlags flags;
GstSeekType start_type;
GstFormat format;
gint64 start, off, upstream_size;
gst_event_parse_seek (event, NULL, &format, &flags, &start_type, &start,
NULL, NULL);
if (format != GST_FORMAT_BYTES) {
GST_DEBUG_OBJECT (cdxa, "Can only handle seek in BYTES format");
return FALSE;
}
if (start_type != GST_SEEK_TYPE_SET) {
GST_DEBUG_OBJECT (cdxa, "Can only handle seek from start (SEEK_TYPE_SET)");
return FALSE;
}
GST_OBJECT_LOCK (cdxa);
off = gst_cdxa_parse_convert_src_to_sink_offset (cdxa, start);
upstream_size = cdxa->datasize;
GST_OBJECT_UNLOCK (cdxa);
if (off >= upstream_size) {
GST_DEBUG_OBJECT (cdxa, "Invalid target offset %" G_GINT64_FORMAT ", file "
"is only %" G_GINT64_FORMAT " bytes in size", off, upstream_size);
return FALSE;
}
/* unlock upstream pull_range */
gst_pad_push_event (cdxa->sinkpad, gst_event_new_flush_start ());
/* make sure our loop function exits */
gst_pad_push_event (cdxa->srcpad, gst_event_new_flush_start ());
/* wait for streaming to finish */
GST_PAD_STREAM_LOCK (cdxa->sinkpad);
/* prepare for streaming again */
gst_pad_push_event (cdxa->sinkpad, gst_event_new_flush_stop ());
gst_pad_push_event (cdxa->srcpad, gst_event_new_flush_stop ());
gst_pad_push_event (cdxa->srcpad,
gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,
start, GST_CLOCK_TIME_NONE, 0));
GST_OBJECT_LOCK (cdxa);
cdxa->offset = off;
GST_OBJECT_UNLOCK (cdxa);
/* and restart */
gst_pad_start_task (cdxa->sinkpad,
(GstTaskFunction) gst_cdxa_parse_loop, cdxa->sinkpad, NULL);
GST_PAD_STREAM_UNLOCK (cdxa->sinkpad);
return TRUE;
}
static gboolean
gst_rtp_jitter_buffer_src_activate_push (GstPad * pad, gboolean active)
{
gboolean result = TRUE;
GstRtpJitterBuffer *jitterbuffer = NULL;
jitterbuffer = GST_RTP_JITTER_BUFFER (gst_pad_get_parent (pad));
if (active) {
/* allow data processing */
gst_rtp_jitter_buffer_flush_stop (jitterbuffer);
/* start pushing out buffers */
GST_DEBUG_OBJECT (jitterbuffer, "Starting task on srcpad");
gst_pad_start_task (jitterbuffer->priv->srcpad,
(GstTaskFunction) gst_rtp_jitter_buffer_loop, jitterbuffer);
} else {
/* make sure all data processing stops ASAP */
gst_rtp_jitter_buffer_flush_start (jitterbuffer);
/* NOTE this will hardlock if the state change is called from the src pad
* task thread because we will _join() the thread. */
GST_DEBUG_OBJECT (jitterbuffer, "Stopping task on srcpad");
result = gst_pad_stop_task (pad);
}
gst_object_unref (jitterbuffer);
return result;
}
static gboolean
gst_sctp_enc_src_activate_mode (GstPad * pad, GstObject * parent,
GstPadMode mode, gboolean active)
{
GstSctpEnc *self = GST_SCTP_ENC(parent);
gboolean ret = FALSE;
switch (mode) {
case GST_PAD_MODE_PUSH:
if (active) {
self->need_segment = self->need_stream_start_caps = TRUE;
gst_data_queue_set_flushing(self->outbound_sctp_packet_queue, FALSE);
gst_pad_start_task(self->src_pad,
(GstTaskFunction)gst_sctp_enc_srcpad_loop, self->src_pad, NULL);
ret = configure_association(self);
} else {
sctpenc_cleanup(self);
ret = TRUE;
}
GST_DEBUG_OBJECT (self, "activate_mode: active %d, ret %d", active, ret);
break;
default:
break;
}
return ret;
}
/* src operating in push mode, we start a task on the source pad that pushes out
* buffers from the cache */
static inline gboolean
gst_ts_shifter_src_activate (GstPad * pad, GstObject * parent, gboolean active)
{
GstTSShifter *ts = GST_TS_SHIFTER (parent);
gboolean ret = FALSE;
if (active) {
FLOW_MUTEX_LOCK (ts);
GST_DEBUG_OBJECT (ts, "activating push mode");
ts->srcresult = GST_FLOW_OK;
ts->sinkresult = GST_FLOW_OK;
ts->is_eos = FALSE;
ts->unexpected = FALSE;
ret =
gst_pad_start_task (pad, (GstTaskFunction) gst_ts_shifter_loop, pad,
NULL);
FLOW_MUTEX_UNLOCK (ts);
} else {
/* unblock loop function */
FLOW_MUTEX_LOCK (ts);
GST_DEBUG_OBJECT (ts, "deactivating push mode");
ts->srcresult = GST_FLOW_FLUSHING;
ts->sinkresult = GST_FLOW_FLUSHING;
/* the item add signal will unblock */
FLOW_SIGNAL_ADD (ts);
FLOW_MUTEX_UNLOCK (ts);
/* step 2, make sure streaming finishes */
ret = gst_pad_stop_task (pad);
}
return ret;
}
static gboolean
mpegts_base_sink_activate_mode (GstPad * pad, GstObject * parent,
GstPadMode mode, gboolean active)
{
gboolean res;
MpegTSBase *base = GST_MPEGTS_BASE (parent);
switch (mode) {
case GST_PAD_MODE_PUSH:
base->mode = BASE_MODE_PUSHING;
res = TRUE;
break;
case GST_PAD_MODE_PULL:
if (active) {
base->mode = BASE_MODE_SCANNING;
/* When working pull-based, we always use offsets for estimation */
base->packetizer->calculate_offset = TRUE;
base->packetizer->calculate_skew = FALSE;
gst_segment_init (&base->segment, GST_FORMAT_BYTES);
res =
gst_pad_start_task (pad, (GstTaskFunction) mpegts_base_loop, base,
NULL);
} else
res = gst_pad_stop_task (pad);
break;
default:
res = FALSE;
break;
}
return res;
}
static gboolean
gst_rnd_buffer_size_activate_mode (GstPad * pad, GstObject * parent,
GstPadMode mode, gboolean active)
{
gboolean res;
GstRndBufferSize *self = GST_RND_BUFFER_SIZE (parent);
switch (mode) {
case GST_PAD_MODE_PULL:
if (active) {
GST_INFO_OBJECT (self, "starting pull");
res =
gst_pad_start_task (pad, (GstTaskFunction) gst_rnd_buffer_size_loop,
self, NULL);
self->need_newsegment = TRUE;
} else {
GST_INFO_OBJECT (self, "stopping pull");
res = gst_pad_stop_task (pad);
}
break;
case GST_PAD_MODE_PUSH:
GST_INFO_OBJECT (self, "%sactivating in push mode", (active) ? "" : "de");
res = TRUE;
break;
default:
res = FALSE;
break;
}
return res;
}
static gboolean
gst_midi_parse_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
gboolean res;
GstMidiParse *midiparse = GST_MIDI_PARSE (parent);
GST_DEBUG_OBJECT (pad, "%s event received", GST_EVENT_TYPE_NAME (event));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
midiparse->state = GST_MIDI_PARSE_STATE_PARSE;
/* now start the parsing task */
res = gst_pad_start_task (midiparse->sinkpad,
(GstTaskFunction) gst_midi_parse_loop, midiparse->sinkpad, NULL);
/* don't forward the event */
gst_event_unref (event);
break;
case GST_EVENT_CAPS:
case GST_EVENT_STREAM_START:
case GST_EVENT_SEGMENT:
res = TRUE;
gst_event_unref (event);
break;
default:
res = gst_pad_event_default (pad, parent, event);
break;
}
return res;
}
static gboolean
gst_live_adder_src_activate_push (GstPad * pad, gboolean active)
{
gboolean result = TRUE;
GstLiveAdder *adder = NULL;
adder = GST_LIVE_ADDER (gst_pad_get_parent (pad));
if (active) {
/* Mark as non flushing */
GST_OBJECT_LOCK (adder);
adder->srcresult = GST_FLOW_OK;
GST_OBJECT_UNLOCK (adder);
/* start pushing out buffers */
GST_DEBUG_OBJECT (adder, "Starting task on srcpad");
gst_pad_start_task (adder->srcpad,
(GstTaskFunction) gst_live_adder_loop, adder);
} else {
/* make sure all data processing stops ASAP */
gst_live_adder_flush_start (adder);
/* NOTE this will hardlock if the state change is called from the src pad
* task thread because we will _join() the thread. */
GST_DEBUG_OBJECT (adder, "Stopping task on srcpad");
result = gst_pad_stop_task (pad);
}
gst_object_unref (adder);
return result;
}
static gboolean src_activate_mode(GstPad *pad, GstErDtlsEnc *self, GstPadMode mode, gboolean active)
{
gboolean success = TRUE;
g_return_val_if_fail(mode == GST_PAD_MODE_PUSH, FALSE);
if (active) {
GST_DEBUG_OBJECT(self, "src pad activating in push mode");
self->send_initial_events = TRUE;
success = gst_pad_start_task(pad, (GstTaskFunction) src_task_loop, self->src, NULL);
if (!success) {
GST_WARNING_OBJECT(self, "failed to activate pad task");
}
} else {
GST_DEBUG_OBJECT(self, "deactivating src pad");
g_cond_signal(&self->queue_cond_add);
success = gst_pad_stop_task(pad);
if (!success) {
GST_WARNING_OBJECT(self, "failed to deactivate pad task");
}
}
return success;
}
static gboolean gst_sctp_dec_src_event(GstPad *pad, GstSctpDec *self, GstEvent *event)
{
switch (GST_EVENT_TYPE(event)) {
case GST_EVENT_RECONFIGURE:
case GST_EVENT_FLUSH_STOP: {
GstSctpDecPad *sctpdec_pad = GST_SCTP_DEC_PAD(pad);
/* Unflush and start task again */
gst_data_queue_set_flushing(sctpdec_pad->packet_queue, FALSE);
gst_pad_start_task(pad, (GstTaskFunction)gst_sctp_data_srcpad_loop, pad, NULL);
return gst_pad_event_default(pad, GST_OBJECT(self), event);
}
case GST_EVENT_FLUSH_START: {
GstSctpDecPad *sctpdec_pad = GST_SCTP_DEC_PAD(pad);
gst_data_queue_set_flushing(sctpdec_pad->packet_queue, TRUE);
gst_data_queue_flush(sctpdec_pad->packet_queue);
return gst_pad_event_default(pad, GST_OBJECT(self), event);
}
default:
return gst_pad_event_default(pad, GST_OBJECT(self), event);
}
}
static void
gst_amc_audio_dec_flush (GstAudioDecoder * decoder, gboolean hard)
{
GstAmcAudioDec *self;
self = GST_AMC_AUDIO_DEC (decoder);
GST_DEBUG_OBJECT (self, "Resetting decoder");
if (!self->started) {
GST_DEBUG_OBJECT (self, "Codec not started yet");
return;
}
self->flushing = TRUE;
/* Wait until the srcpad loop is finished,
* unlock GST_AUDIO_DECODER_STREAM_LOCK to prevent deadlocks
* caused by using this lock from inside the loop function */
GST_AUDIO_DECODER_STREAM_UNLOCK (self);
GST_PAD_STREAM_LOCK (GST_AUDIO_DECODER_SRC_PAD (self));
GST_PAD_STREAM_UNLOCK (GST_AUDIO_DECODER_SRC_PAD (self));
GST_AUDIO_DECODER_STREAM_LOCK (self);
gst_amc_codec_flush (self->codec);
self->flushing = FALSE;
/* Start the srcpad loop again */
self->last_upstream_ts = 0;
self->eos = FALSE;
self->downstream_flow_ret = GST_FLOW_OK;
gst_pad_start_task (GST_AUDIO_DECODER_SRC_PAD (self),
(GstTaskFunction) gst_amc_audio_dec_loop, decoder, NULL);
GST_DEBUG_OBJECT (self, "Reset decoder");
}
static gboolean
gst_asf_parse_sink_activate_mode (GstPad * pad, GstObject * parent,
GstPadMode mode, gboolean active)
{
gboolean res;
switch (mode) {
case GST_PAD_MODE_PULL:
if (active) {
res =
gst_pad_start_task (pad, (GstTaskFunction) gst_asf_parse_loop, pad,
NULL);
} else {
res = gst_pad_stop_task (pad);
}
case GST_PAD_MODE_PUSH:
res = TRUE;
break;
default:
res = FALSE;
break;
}
return res;
}
static void
_start_srcpad_task (GstAggregator * self)
{
GST_INFO_OBJECT (self, "Starting srcpad task");
self->priv->running = TRUE;
gst_pad_start_task (GST_PAD (self->srcpad),
(GstTaskFunction) iterate_main_context_func, self, NULL);
}
static gboolean
gst_rdt_manager_src_activate_mode (GstPad * pad, GstObject * parent,
GstPadMode mode, gboolean active)
{
gboolean result;
GstRDTManager *rdtmanager;
GstRDTManagerSession *session;
session = gst_pad_get_element_private (pad);
rdtmanager = session->dec;
switch (mode) {
case GST_PAD_MODE_PUSH:
if (active) {
/* allow data processing */
JBUF_LOCK (session);
GST_DEBUG_OBJECT (rdtmanager, "Enabling pop on queue");
/* Mark as non flushing */
session->srcresult = GST_FLOW_OK;
gst_segment_init (&session->segment, GST_FORMAT_TIME);
session->last_popped_seqnum = -1;
session->last_out_time = -1;
session->next_seqnum = -1;
session->eos = FALSE;
JBUF_UNLOCK (session);
/* start pushing out buffers */
GST_DEBUG_OBJECT (rdtmanager, "Starting task on srcpad");
result =
gst_pad_start_task (pad, (GstTaskFunction) gst_rdt_manager_loop,
pad, NULL);
} else {
/* make sure all data processing stops ASAP */
JBUF_LOCK (session);
/* mark ourselves as flushing */
session->srcresult = GST_FLOW_FLUSHING;
GST_DEBUG_OBJECT (rdtmanager, "Disabling pop on queue");
/* this unblocks any waiting pops on the src pad task */
JBUF_SIGNAL (session);
/* unlock clock, we just unschedule, the entry will be released by
* the locking streaming thread. */
if (session->clock_id)
gst_clock_id_unschedule (session->clock_id);
JBUF_UNLOCK (session);
/* NOTE this will hardlock if the state change is called from the src pad
* task thread because we will _join() the thread. */
GST_DEBUG_OBJECT (rdtmanager, "Stopping task on srcpad");
result = gst_pad_stop_task (pad);
}
break;
default:
result = FALSE;
break;
}
return result;
}
static gboolean
gst_timidity_activatepull (GstPad * pad, gboolean active)
{
if (active) {
return gst_pad_start_task (pad, (GstTaskFunction) gst_timidity_loop, pad);
} else {
return gst_pad_stop_task (pad);
}
}
static gboolean
activate_push (GstPad *pad,
gboolean active)
{
gboolean result = TRUE;
GstOmxBaseFilter *self;
self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
if (active)
{
GST_DEBUG_OBJECT (self, "activate");
/* task may carry on */
g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_OK);
/* we do not start the task yet if the pad is not connected */
if (gst_pad_is_linked (pad))
{
if (self->ready)
{
/** @todo link callback function also needed */
g_omx_port_resume (self->in_port);
g_omx_port_resume (self->out_port);
result = gst_pad_start_task (pad, output_loop, pad);
}
}
}
else
{
GST_DEBUG_OBJECT (self, "deactivate");
/* persuade task to bail out */
g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_WRONG_STATE);
if (self->ready)
{
/** @todo disable this until we properly reinitialize the buffers. */
#if 0
/* flush all buffers */
OMX_SendCommand (self->gomx->omx_handle, OMX_CommandFlush, OMX_ALL, NULL);
#endif
/* unlock loops */
g_omx_port_pause (self->in_port);
g_omx_port_pause (self->out_port);
}
/* make sure streaming finishes */
result = gst_pad_stop_task (pad);
}
gst_object_unref (self);
return result;
}
/* this function gets called when we activate ourselves in pull mode.
* We can perform random access to the resource and we start a task
* to start reading */
static gboolean
gst_pngdec_sink_activate_pull (GstPad * sinkpad, gboolean active)
{
if (active) {
return gst_pad_start_task (sinkpad, (GstTaskFunction) gst_pngdec_task,
sinkpad);
} else {
return gst_pad_stop_task (sinkpad);
}
}
static gboolean
gst_vaapiencode_set_format (GstVideoEncoder * venc, GstVideoCodecState * state)
{
GstVaapiEncode *const encode = GST_VAAPIENCODE_CAST (venc);
gboolean ret;
g_return_val_if_fail (state->caps != NULL, FALSE);
if (!set_codec_state (encode, state))
return FALSE;
if (!gst_vaapi_plugin_base_set_caps (GST_VAAPI_PLUGIN_BASE (encode),
state->caps, NULL))
return FALSE;
if (encode->input_state)
gst_video_codec_state_unref (encode->input_state);
encode->input_state = gst_video_codec_state_ref (state);
encode->input_state_changed = TRUE;
ret = gst_pad_start_task (GST_VAAPI_PLUGIN_BASE_SRC_PAD (encode),
(GstTaskFunction) gst_vaapiencode_buffer_loop, encode, NULL);
if (!ret)
return FALSE;
/* Store some tags */
{
GstTagList *tags = gst_tag_list_new_empty ();
const gchar *encoder, *codec;
guint bitrate = 0;
g_object_get (encode, "bitrate", &bitrate, NULL);
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_NOMINAL_BITRATE,
bitrate, NULL);
if ((encoder =
gst_element_class_get_metadata (GST_ELEMENT_GET_CLASS (encode),
GST_ELEMENT_METADATA_LONGNAME)))
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_ENCODER, encoder,
NULL);
if ((codec =
gst_vaapi_codec_get_name (gst_vaapi_profile_get_codec
(gst_vaapi_profile_from_caps (state->caps)))))
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_CODEC, codec,
NULL);
gst_video_encoder_merge_tags (venc, tags, GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (tags);
}
return TRUE;
}
static gboolean
gst_tcp_mix_src_pad_start (GstTCPMixSrcPad * pad)
{
gboolean res = FALSE;
if (GST_PAD_TASK (pad) == NULL) {
GstTaskFunction func = (GstTaskFunction) gst_tcp_mix_src_loop;
res = gst_pad_start_task (GST_PAD (pad), func, GST_PAD (pad), NULL);
}
return res;
}
static gboolean
gst_rnd_buffer_size_src_event (GstPad * pad, GstObject * parent,
GstEvent * event)
{
GstRndBufferSize *self;
GstSeekType start_type;
GstSeekFlags flags;
GstFormat format;
gint64 start;
if (GST_EVENT_TYPE (event) != GST_EVENT_SEEK) {
GST_WARNING_OBJECT (pad, "dropping %s event", GST_EVENT_TYPE_NAME (event));
return FALSE;
}
self = GST_RND_BUFFER_SIZE (parent);
gst_event_parse_seek (event, NULL, &format, &flags, &start_type, &start,
NULL, NULL);
if (format != GST_FORMAT_BYTES) {
GST_WARNING_OBJECT (pad, "only BYTE format supported");
return FALSE;
}
if (start_type != GST_SEEK_TYPE_SET) {
GST_WARNING_OBJECT (pad, "only SEEK_TYPE_SET supported");
return FALSE;
}
if ((flags & GST_SEEK_FLAG_FLUSH)) {
gst_pad_push_event (self->srcpad, gst_event_new_flush_start ());
gst_pad_push_event (self->sinkpad, gst_event_new_flush_start ());
} else {
gst_pad_pause_task (self->sinkpad);
}
GST_PAD_STREAM_LOCK (self->sinkpad);
if ((flags & GST_SEEK_FLAG_FLUSH)) {
gst_pad_push_event (self->srcpad, gst_event_new_flush_stop (TRUE));
gst_pad_push_event (self->sinkpad, gst_event_new_flush_stop (TRUE));
}
GST_INFO_OBJECT (pad, "seeking to offset %" G_GINT64_FORMAT, start);
self->offset = start;
self->need_newsegment = TRUE;
gst_pad_start_task (self->sinkpad, (GstTaskFunction) gst_rnd_buffer_size_loop,
self);
GST_PAD_STREAM_UNLOCK (self->sinkpad);
return TRUE;
}
static void flush_srcpad(const GValue *item, gpointer user_data)
{
GstSctpDecPad *sctpdec_pad = g_value_get_object(item);
gboolean flush = GPOINTER_TO_INT(user_data);
if (flush) {
gst_data_queue_set_flushing(sctpdec_pad->packet_queue, TRUE);
gst_data_queue_flush(sctpdec_pad->packet_queue);
} else {
gst_data_queue_set_flushing(sctpdec_pad->packet_queue, FALSE);
gst_pad_start_task(GST_PAD(sctpdec_pad), (GstTaskFunction)gst_sctp_data_srcpad_loop, sctpdec_pad, NULL);
}
}
static gboolean
gst_cdxa_parse_sink_activate_pull (GstPad * sinkpad, gboolean active)
{
if (active) {
/* if we have a scheduler we can start the task */
gst_pad_start_task (sinkpad, (GstTaskFunction) gst_cdxa_parse_loop,
sinkpad, NULL);
} else {
gst_pad_stop_task (sinkpad);
}
return TRUE;
}
static gboolean
gst_aiff_parse_sink_activate_pull (GstPad * sinkpad, gboolean active)
{
GstAiffParse *aiff = GST_AIFF_PARSE (GST_OBJECT_PARENT (sinkpad));
if (active) {
aiff->segment_running = TRUE;
return gst_pad_start_task (sinkpad, (GstTaskFunction) gst_aiff_parse_loop,
sinkpad);
} else {
aiff->segment_running = FALSE;
return gst_pad_stop_task (sinkpad);
}
};
static gboolean
gst_musepackdec_sink_activate_pull (GstPad * sinkpad, gboolean active)
{
gboolean result;
if (active) {
result = gst_pad_start_task (sinkpad,
(GstTaskFunction) gst_musepackdec_loop, sinkpad);
} else {
result = gst_pad_stop_task (sinkpad);
}
return result;
}
