static gboolean gst_rsvg_dec_sink_event (GstPad * pad, GstEvent * event) { GstRsvgDec *rsvg = GST_RSVG_DEC (gst_pad_get_parent (pad)); gboolean res = FALSE; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT:{ gdouble rate, arate; gboolean update; gint64 start, stop, position; GstFormat fmt; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &fmt, &start, &stop, &position); gst_segment_set_newsegment_full (&rsvg->segment, update, rate, arate, fmt, start, stop, position); if (fmt == GST_FORMAT_TIME) { rsvg->need_newsegment = FALSE; res = gst_pad_push_event (rsvg->srcpad, event); } else { gst_event_unref (event); res = TRUE; } break; } case GST_EVENT_EOS: case GST_EVENT_FLUSH_STOP: gst_adapter_clear (rsvg->adapter); /* fall through */ case GST_EVENT_FLUSH_START: res = gst_pad_push_event (rsvg->srcpad, event); break; default: if (GST_PAD_CAPS (rsvg->srcpad)) { res = gst_pad_push_event (rsvg->srcpad, event); } else { res = TRUE; rsvg->pending_events = g_list_append (rsvg->pending_events, event); } break; } gst_object_unref (rsvg); return res; }
static VALUE newsegment_parse(VALUE self) { gboolean update; gdouble rate, applied_rate; GstFormat format; gint64 start, stop, position; gst_event_parse_new_segment_full(RGST_EVENT(self), &update, &rate, &applied_rate, &format, &start, &stop, &position); return rb_ary_new3(7, CBOOL2RVAL(update), DBL2NUM(update), DBL2NUM(rate), GST_FORMAT2RVAL(format), LL2NUM(start), LL2NUM(stop), LL2NUM(position)); }
static gboolean dvdlpcmdec_sink_event (GstPad * pad, GstEvent * event) { GstDvdLpcmDec *dvdlpcmdec; gboolean res; dvdlpcmdec = GST_DVDLPCMDEC (GST_PAD_PARENT (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT: { gdouble rate, arate; GstFormat format; gboolean update; gint64 start, stop, pos; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &pos); GST_DEBUG_OBJECT (dvdlpcmdec, "new segment, format=%d, start = %" G_GINT64_FORMAT ", stop = %" G_GINT64_FORMAT ", position %" G_GINT64_FORMAT, format, start, stop, pos); gst_segment_set_newsegment_full (&dvdlpcmdec->segment, update, rate, arate, format, start, stop, pos); if (format == GST_FORMAT_TIME) { dvdlpcmdec->timestamp = GST_CLOCK_TIME_NONE; } else { dvdlpcmdec->timestamp = 0; } res = gst_pad_push_event (dvdlpcmdec->srcpad, event); break; } case GST_EVENT_FLUSH_STOP: gst_segment_init (&dvdlpcmdec->segment, GST_FORMAT_UNDEFINED); res = gst_pad_push_event (dvdlpcmdec->srcpad, event); break; default: res = gst_pad_push_event (dvdlpcmdec->srcpad, event); break; } return res; }
static gboolean gst_visual_sink_event (GstPad * pad, GstEvent * event) { GstVisual *visual; gboolean res; visual = GST_VISUAL (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_START: res = gst_pad_push_event (visual->srcpad, event); break; case GST_EVENT_FLUSH_STOP: /* reset QoS and adapter. */ gst_visual_reset (visual); res = gst_pad_push_event (visual->srcpad, event); break; case GST_EVENT_NEWSEGMENT: { GstFormat format; gdouble rate, arate; gint64 start, stop, time; gboolean update; /* the newsegment values are used to clip the input samples * and to convert the incomming timestamps to running time so * we can do QoS */ gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); /* now configure the values */ gst_segment_set_newsegment_full (&visual->segment, update, rate, arate, format, start, stop, time); /* and forward */ res = gst_pad_push_event (visual->srcpad, event); break; } default: res = gst_pad_push_event (visual->srcpad, event); break; } gst_object_unref (visual); return res; }
static gboolean gst_monoscope_sink_event (GstPad * pad, GstEvent * event) { GstMonoscope *monoscope; gboolean res; monoscope = GST_MONOSCOPE (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_START: res = gst_pad_push_event (monoscope->srcpad, event); break; case GST_EVENT_FLUSH_STOP: gst_monoscope_reset (monoscope); res = gst_pad_push_event (monoscope->srcpad, event); break; case GST_EVENT_NEWSEGMENT: { GstFormat format; gdouble rate, arate; gint64 start, stop, time; gboolean update; /* the newsegment values are used to clip the input samples * and to convert the incomming timestamps to running time so * we can do QoS */ gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); /* now configure the values */ gst_segment_set_newsegment_full (&monoscope->segment, update, rate, arate, format, start, stop, time); res = gst_pad_push_event (monoscope->srcpad, event); break; } default: res = gst_pad_push_event (monoscope->srcpad, event); break; } gst_object_unref (monoscope); return res; }
static gboolean gst_gsmdec_sink_event (GstPad * pad, GstEvent * event) { gboolean res; GstGSMDec *gsmdec; gsmdec = GST_GSMDEC (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_START: res = gst_pad_push_event (gsmdec->srcpad, event); break; case GST_EVENT_FLUSH_STOP: gst_segment_init (&gsmdec->segment, GST_FORMAT_UNDEFINED); res = gst_pad_push_event (gsmdec->srcpad, event); break; case GST_EVENT_NEWSEGMENT: { gboolean update; GstFormat format; gdouble rate, arate; gint64 start, stop, time; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); /* now configure the values */ gst_segment_set_newsegment_full (&gsmdec->segment, update, rate, arate, format, start, stop, time); /* and forward */ res = gst_pad_push_event (gsmdec->srcpad, event); break; } case GST_EVENT_EOS: default: res = gst_pad_push_event (gsmdec->srcpad, event); break; } gst_object_unref (gsmdec); return res; }
static gboolean gst_vdp_vpp_sink_event (GstPad * pad, GstEvent * event) { GstVdpVideoPostProcess *vpp = GST_VDP_VIDEO_POST_PROCESS (gst_pad_get_parent (pad)); gboolean res; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: { GST_DEBUG_OBJECT (vpp, "flush stop"); gst_vdp_vpp_flush (vpp); res = gst_pad_event_default (pad, event); break; } case GST_EVENT_NEWSEGMENT: { gboolean update; gdouble rate, applied_rate; GstFormat format; gint64 start, stop, time; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &time); GST_OBJECT_LOCK (vpp); gst_segment_set_newsegment_full (&vpp->segment, update, rate, applied_rate, format, start, stop, time); GST_OBJECT_UNLOCK (vpp); res = gst_pad_event_default (pad, event); break; } default: res = gst_pad_event_default (pad, event); } gst_object_unref (vpp); return res; }
static gboolean gst_pgmdec_sink_event (GstPad * pad, GstEvent * event) { gboolean ret = TRUE; Gstpgmdec *filter = GST_PGMDEC (GST_OBJECT_PARENT (pad)); GST_DEBUG_OBJECT (filter, "event : %s", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP:{ GST_DEBUG_OBJECT (filter, "Aborting decompress"); //jpeg_abort_decompress (&dec->cinfo); gst_segment_init (&filter->segment, GST_FORMAT_UNDEFINED); //gst_jpeg_dec_reset_qos (dec); break; } case GST_EVENT_NEWSEGMENT:{ gboolean update; gdouble rate, applied_rate; GstFormat format; gint64 start, stop, position; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); GST_DEBUG_OBJECT (filter, "Got NEWSEGMENT [%" GST_TIME_FORMAT " - %" GST_TIME_FORMAT " / %" GST_TIME_FORMAT "]", GST_TIME_ARGS (start), GST_TIME_ARGS (stop), GST_TIME_ARGS (position)); gst_segment_set_newsegment_full (&filter->segment, update, rate, applied_rate, format, start, stop, position); break; } default: break; } ret = gst_pad_push_event (filter->srcpad, event); return ret; }
static gboolean gst_mse_sink_event (GstPad * pad, GstEvent * event) { GstMSE *fs; fs = GST_MSE (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT: { gboolean update; double rate; double applied_rate; GstFormat format; gint64 start, stop, position; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); GST_DEBUG ("new_segment %d %g %g %d %" G_GINT64_FORMAT " %" G_GINT64_FORMAT " %" G_GINT64_FORMAT, update, rate, applied_rate, format, start, stop, position); } break; case GST_EVENT_FLUSH_START: GST_DEBUG ("flush start"); fs->cancel = TRUE; break; case GST_EVENT_FLUSH_STOP: GST_DEBUG ("flush stop"); fs->cancel = FALSE; break; default: break; } gst_pad_push_event (fs->srcpad, event); gst_object_unref (fs); return TRUE; }
/*********************************************************************************** * Sink event handler ***********************************************************************************/ static gboolean videodecoder_sink_event(GstPad *pad, GstEvent *event) { VideoDecoder *decoder = VIDEODECODER(GST_PAD_PARENT(pad)); switch (GST_EVENT_TYPE(event)) { case GST_EVENT_FLUSH_START: // Start flushing buffers. // Set flag so chain function refuses new buffers. BASEDECODER(decoder)->is_flushing = TRUE; break; case GST_EVENT_FLUSH_STOP: // Stop flushing buffers. videodecoder_state_reset(decoder); // Unset flag so chain function accepts buffers. BASEDECODER(decoder)->is_flushing = FALSE; break; #ifdef DEBUG_OUTPUT case GST_EVENT_NEWSEGMENT: { GstFormat format; gboolean update; gdouble rate, applied_rate; gint64 start, stop, time; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &time); g_print("videodecoder_sink_event: NEW_SEGMENT update=%s, rate=%.1f, format=%d, start=%.3f, stop=%.3f, time=%.3f\n", update ? "TRUE" : "FALSE", rate, format, (double)start/GST_SECOND, (double)stop/GST_SECOND, (double)time/GST_SECOND); break; } #endif // DEBUG_OUTPUT default: break; } return gst_pad_push_event(BASEDECODER(decoder)->srcpad, event); }
static gboolean gst_frame_store_sink_event (GstPad *pad, GstEvent *event) { GstFrameStore *fs; //fs = GST_FRAME_STORE(gst_pad_get_parent(pad)); fs = (GstFrameStore *)(gst_pad_get_parent(pad)); switch(GST_EVENT_TYPE(event)) { case GST_EVENT_NEWSEGMENT: { gboolean update; double rate; double applied_rate; GstFormat format; gint64 start, stop, position; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); GST_ERROR("new_segment %d %g %g %d %lld %lld %lld", update, rate, applied_rate, format, start, stop, position); gst_frame_store_clear (fs); } break; case GST_EVENT_FLUSH_START: fs->flushing = TRUE; GST_DEBUG("flush start"); break; case GST_EVENT_FLUSH_STOP: fs->flushing = FALSE; GST_DEBUG("flush stop"); break; default: break; } gst_pad_push_event (fs->srcpad, event); return TRUE; }
static gboolean gst_play_sink_video_convert_sink_event (GstPad * pad, GstEvent * event) { GstPlaySinkVideoConvert *self = GST_PLAY_SINK_VIDEO_CONVERT (gst_pad_get_parent (pad)); gboolean ret; ret = gst_proxy_pad_event_default (pad, gst_event_ref (event)); if (GST_EVENT_TYPE (event) == GST_EVENT_NEWSEGMENT) { gboolean update; gdouble rate, applied_rate; GstFormat format; gint64 start, stop, position; GST_PLAY_SINK_VIDEO_CONVERT_LOCK (self); gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); GST_DEBUG_OBJECT (self, "Segment before %" GST_SEGMENT_FORMAT, &self->segment); gst_segment_set_newsegment_full (&self->segment, update, rate, applied_rate, format, start, stop, position); GST_DEBUG_OBJECT (self, "Segment after %" GST_SEGMENT_FORMAT, &self->segment); GST_PLAY_SINK_VIDEO_CONVERT_UNLOCK (self); } else if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) { GST_PLAY_SINK_VIDEO_CONVERT_LOCK (self); GST_DEBUG_OBJECT (self, "Resetting segment"); gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED); GST_PLAY_SINK_VIDEO_CONVERT_UNLOCK (self); } gst_event_unref (event); gst_object_unref (self); return ret; }
static gboolean gst_vcd_parse_sink_event (GstPad * pad, GstEvent * event) { GstVcdParse *vcd = GST_VCD_PARSE (gst_pad_get_parent (pad)); gboolean res; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT:{ GstFormat format; gboolean update; gdouble rate, applied_rate; gint64 start, stop, position; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); if (format == GST_FORMAT_BYTES) { gst_event_unref (event); event = gst_event_new_new_segment_full (update, rate, applied_rate, GST_FORMAT_BYTES, gst_vcd_parse_get_out_offset (start), gst_vcd_parse_get_out_offset (stop), position); } else { GST_WARNING_OBJECT (vcd, "newsegment event in non-byte format"); } res = gst_pad_event_default (pad, event); break; } case GST_EVENT_FLUSH_START: gst_adapter_clear (vcd->adapter); /* fall through */ default: res = gst_pad_event_default (pad, event); break; } gst_object_unref (vcd); return res; }
static gboolean gst_dvdec_sink_event (GstPad * pad, GstEvent * event) { GstDVDec *dvdec; gboolean res = TRUE; dvdec = GST_DVDEC (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: gst_segment_init (dvdec->segment, GST_FORMAT_UNDEFINED); break; case GST_EVENT_NEWSEGMENT:{ gboolean update; gdouble rate, applied_rate; GstFormat format; gint64 start, stop, position; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); GST_DEBUG_OBJECT (dvdec, "Got NEWSEGMENT [%" GST_TIME_FORMAT " - %" GST_TIME_FORMAT " / %" GST_TIME_FORMAT "]", GST_TIME_ARGS (start), GST_TIME_ARGS (stop), GST_TIME_ARGS (position)); gst_segment_set_newsegment_full (dvdec->segment, update, rate, applied_rate, format, start, stop, position); break; } default: break; } res = gst_pad_push_event (dvdec->srcpad, event); return res; }
static gboolean theora_enc_sink_event (GstPad * pad, GstEvent * event) { GstTheoraEnc *enc; ogg_packet op; gboolean res; enc = GST_THEORA_ENC (GST_PAD_PARENT (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT: { gboolean update; gdouble rate, applied_rate; GstFormat format; gint64 start, stop, time; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &time); gst_segment_set_newsegment_full (&enc->segment, update, rate, applied_rate, format, start, stop, time); res = gst_pad_push_event (enc->srcpad, event); break; } case GST_EVENT_EOS: if (enc->initialised) { /* push last packet with eos flag, should not be called */ while (theora_encode_packetout (&enc->state, 1, &op)) { GstClockTime next_time = theora_enc_get_ogg_packet_end_time (enc, &op); theora_push_packet (enc, &op, GST_CLOCK_TIME_NONE, enc->next_ts, next_time - enc->next_ts); enc->next_ts = next_time; } } res = gst_pad_push_event (enc->srcpad, event); break; case GST_EVENT_FLUSH_STOP: gst_segment_init (&enc->segment, GST_FORMAT_UNDEFINED); res = gst_pad_push_event (enc->srcpad, event); break; case GST_EVENT_CUSTOM_DOWNSTREAM: { const GstStructure *s; s = gst_event_get_structure (event); if (gst_structure_has_name (s, "GstForceKeyUnit")) { GstClockTime next_ts; /* make sure timestamps increment after resetting the decoder */ next_ts = enc->next_ts + enc->timestamp_offset; theora_enc_reset (enc); enc->granulepos_offset = gst_util_uint64_scale (next_ts, enc->fps_n, GST_SECOND * enc->fps_d); enc->timestamp_offset = next_ts; enc->next_ts = 0; } res = gst_pad_push_event (enc->srcpad, event); break; } default: res = gst_pad_push_event (enc->srcpad, event); break; } return res; }
static gboolean gst_base_video_decoder_sink_event (GstPad * pad, GstEvent * event) { GstBaseVideoDecoder *base_video_decoder; GstBaseVideoDecoderClass *base_video_decoder_class; gboolean ret = FALSE; base_video_decoder = GST_BASE_VIDEO_DECODER (gst_pad_get_parent (pad)); base_video_decoder_class = GST_BASE_VIDEO_DECODER_GET_CLASS (base_video_decoder); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: { GstVideoFrame *frame; frame = g_malloc0 (sizeof (GstVideoFrame)); frame->presentation_frame_number = base_video_decoder->presentation_frame_number; frame->presentation_duration = 0; base_video_decoder->presentation_frame_number++; base_video_decoder->frames = g_list_append (base_video_decoder->frames, frame); if (base_video_decoder_class->finish) { base_video_decoder_class->finish (base_video_decoder, frame); } ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_decoder), event); } break; case GST_EVENT_NEWSEGMENT: { gboolean update; double rate; double applied_rate; GstFormat format; gint64 start; gint64 stop; gint64 position; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); if (format != GST_FORMAT_TIME) goto newseg_wrong_format; gst_segment_set_newsegment_full (&base_video_decoder->state.segment, update, rate, applied_rate, format, start, stop, position); GST_DEBUG ("new segment %" GST_SEGMENT_FORMAT, &base_video_decoder->state.segment); ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_decoder), event); } break; default: /* FIXME this changes the order of events */ ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_decoder), event); break; } done: gst_object_unref (base_video_decoder); return ret; newseg_wrong_format: { GST_DEBUG_OBJECT (base_video_decoder, "received non TIME newsegment"); gst_event_unref (event); goto done; } }
static gboolean gst_base_video_decoder_sink_event (GstPad * pad, GstEvent * event) { GstBaseVideoDecoder *base_video_decoder; GstBaseVideoDecoderClass *base_video_decoder_class; gboolean ret = FALSE; base_video_decoder = GST_BASE_VIDEO_DECODER (gst_pad_get_parent (pad)); base_video_decoder_class = GST_BASE_VIDEO_DECODER_GET_CLASS (base_video_decoder); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: { if (!base_video_decoder->packetized) gst_base_video_decoder_drain (base_video_decoder, TRUE); ret = gst_pad_push_event (GST_BASE_VIDEO_DECODER_SRC_PAD (base_video_decoder), event); } break; case GST_EVENT_NEWSEGMENT: { gboolean update; double rate; double applied_rate; GstFormat format; gint64 start; gint64 stop; gint64 position; GstSegment *segment = &base_video_decoder->segment; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); if (format != GST_FORMAT_TIME) goto newseg_wrong_format; if (!update) { gst_base_video_decoder_flush (base_video_decoder); } base_video_decoder->timestamp_offset = start; gst_segment_set_newsegment_full (segment, update, rate, applied_rate, format, start, stop, position); base_video_decoder->have_segment = TRUE; GST_WARNING ("new segment: format %d rate %g start %" GST_TIME_FORMAT " stop %" GST_TIME_FORMAT " position %" GST_TIME_FORMAT " update %d", format, rate, GST_TIME_ARGS (segment->start), GST_TIME_ARGS (segment->stop), GST_TIME_ARGS (segment->time), update); ret = gst_pad_push_event (GST_BASE_VIDEO_DECODER_SRC_PAD (base_video_decoder), event); } break; case GST_EVENT_FLUSH_STOP: gst_base_video_decoder_flush (base_video_decoder); gst_segment_init (&base_video_decoder->segment, GST_FORMAT_TIME); ret = gst_pad_push_event (GST_BASE_VIDEO_DECODER_SRC_PAD (base_video_decoder), event); break; default: /* FIXME this changes the order of events */ ret = gst_pad_push_event (GST_BASE_VIDEO_DECODER_SRC_PAD (base_video_decoder), event); break; } done: gst_object_unref (base_video_decoder); return ret; newseg_wrong_format: { GST_DEBUG_OBJECT (base_video_decoder, "received non TIME newsegment"); gst_event_unref (event); goto done; } }
static gboolean gst_base_video_encoder_sink_event (GstPad * pad, GstEvent * event) { GstBaseVideoEncoder *base_video_encoder; GstBaseVideoEncoderClass *base_video_encoder_class; gboolean ret = FALSE; base_video_encoder = GST_BASE_VIDEO_ENCODER (gst_pad_get_parent (pad)); base_video_encoder_class = GST_BASE_VIDEO_ENCODER_GET_CLASS (base_video_encoder); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: { if (base_video_encoder_class->finish) { base_video_encoder_class->finish (base_video_encoder); } ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), event); } break; case GST_EVENT_NEWSEGMENT: { gboolean update; double rate; double applied_rate; GstFormat format; gint64 start; gint64 stop; gint64 position; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); if (format != GST_FORMAT_TIME) goto newseg_wrong_format; GST_DEBUG ("new segment %" GST_TIME_FORMAT " %" GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (position)); gst_segment_set_newsegment_full (&GST_BASE_VIDEO_CODEC (base_video_encoder)->segment, update, rate, applied_rate, format, start, stop, position); ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), event); } break; case GST_EVENT_CUSTOM_DOWNSTREAM: { const GstStructure *s; s = gst_event_get_structure (event); if (gst_structure_has_name (s, "GstForceKeyUnit")) { GST_OBJECT_LOCK (base_video_encoder); base_video_encoder->force_keyframe = TRUE; GST_OBJECT_UNLOCK (base_video_encoder); gst_event_unref (event); ret = GST_FLOW_OK; } else { ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), event); } break; } default: /* FIXME this changes the order of events */ ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), event); break; } done: gst_object_unref (base_video_encoder); return ret; newseg_wrong_format: { GST_DEBUG_OBJECT (base_video_encoder, "received non TIME newsegment"); gst_event_unref (event); goto done; } }
static gboolean theora_dec_sink_event (GstPad * pad, GstEvent * event) { gboolean ret = FALSE; GstTheoraDec *dec; dec = GST_THEORA_DEC (gst_pad_get_parent (pad)); GST_LOG_OBJECT (dec, "handling event"); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_START: ret = gst_pad_push_event (dec->srcpad, event); break; case GST_EVENT_FLUSH_STOP: gst_theora_dec_reset (dec); ret = gst_pad_push_event (dec->srcpad, event); break; case GST_EVENT_EOS: ret = gst_pad_push_event (dec->srcpad, event); break; case GST_EVENT_NEWSEGMENT: { gboolean update; GstFormat format; gdouble rate, arate; gint64 start, stop, time; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); /* we need TIME format */ if (format != GST_FORMAT_TIME) goto newseg_wrong_format; /* now configure the values */ gst_segment_set_newsegment_full (&dec->segment, update, rate, arate, format, start, stop, time); /* We don't forward this unless/until the decoder is initialised */ if (dec->have_header) { ret = gst_pad_push_event (dec->srcpad, event); dec->sent_newsegment = TRUE; } else { gst_event_unref (event); ret = TRUE; } break; } default: ret = gst_pad_push_event (dec->srcpad, event); break; } done: gst_object_unref (dec); return ret; /* ERRORS */ newseg_wrong_format: { GST_DEBUG_OBJECT (dec, "received non TIME newsegment"); gst_event_unref (event); goto done; } }
static gboolean gst_rtp_jitter_buffer_sink_event (GstPad * pad, GstEvent * event) { gboolean ret = TRUE; GstRtpJitterBuffer *jitterbuffer; GstRtpJitterBufferPrivate *priv; jitterbuffer = GST_RTP_JITTER_BUFFER (gst_pad_get_parent (pad)); priv = jitterbuffer->priv; GST_DEBUG_OBJECT (jitterbuffer, "received %s", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT: { GstFormat format; gdouble rate, arate; gint64 start, stop, time; gboolean update; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); /* we need time for now */ if (format != GST_FORMAT_TIME) goto newseg_wrong_format; GST_DEBUG_OBJECT (jitterbuffer, "newsegment: update %d, rate %g, arate %g, start %" GST_TIME_FORMAT ", stop %" GST_TIME_FORMAT ", time %" GST_TIME_FORMAT, update, rate, arate, GST_TIME_ARGS (start), GST_TIME_ARGS (stop), GST_TIME_ARGS (time)); /* now configure the values, we need these to time the release of the * buffers on the srcpad. */ gst_segment_set_newsegment_full (&priv->segment, update, rate, arate, format, start, stop, time); /* FIXME, push SEGMENT in the queue. Sorting order might be difficult. */ ret = gst_pad_push_event (priv->srcpad, event); break; } case GST_EVENT_FLUSH_START: gst_rtp_jitter_buffer_flush_start (jitterbuffer); ret = gst_pad_push_event (priv->srcpad, event); break; case GST_EVENT_FLUSH_STOP: ret = gst_pad_push_event (priv->srcpad, event); ret = gst_rtp_jitter_buffer_src_activate_push (priv->srcpad, TRUE); break; case GST_EVENT_EOS: { /* push EOS in queue. We always push it at the head */ JBUF_LOCK (priv); /* check for flushing, we need to discard the event and return FALSE when * we are flushing */ ret = priv->srcresult == GST_FLOW_OK; if (ret && !priv->eos) { GST_DEBUG_OBJECT (jitterbuffer, "queuing EOS"); priv->eos = TRUE; JBUF_SIGNAL (priv); } else if (priv->eos) { GST_DEBUG_OBJECT (jitterbuffer, "dropping EOS, we are already EOS"); } else { GST_DEBUG_OBJECT (jitterbuffer, "dropping EOS, reason %s", gst_flow_get_name (priv->srcresult)); } JBUF_UNLOCK (priv); gst_event_unref (event); break; } default: ret = gst_pad_push_event (priv->srcpad, event); break; } done: gst_object_unref (jitterbuffer); return ret; /* ERRORS */ newseg_wrong_format: { GST_DEBUG_OBJECT (jitterbuffer, "received non TIME newsegment"); ret = FALSE; goto done; } }
static gboolean gst_jasper_dec_sink_event (GstPad * pad, GstEvent * event) { GstJasperDec *dec; gboolean res = FALSE; dec = GST_JASPER_DEC (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: gst_jasper_dec_reset_qos (dec); gst_segment_init (&dec->segment, GST_FORMAT_TIME); dec->discont = TRUE; break; case GST_EVENT_NEWSEGMENT:{ gboolean update; GstFormat fmt; gint64 start, stop, time; gdouble rate, arate; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &fmt, &start, &stop, &time); switch (fmt) { case GST_FORMAT_TIME: /* great, our native segment format */ break; case GST_FORMAT_BYTES: /* hmm .. */ if (start != 0 || time != 0) goto invalid_bytes_segment; /* create bogus segment in TIME format, starting from 0 */ gst_event_unref (event); fmt = GST_FORMAT_TIME; start = 0; stop = -1; time = 0; event = gst_event_new_new_segment (update, rate, fmt, start, stop, time); break; default: /* invalid format */ goto invalid_format; } gst_segment_set_newsegment_full (&dec->segment, update, rate, arate, fmt, start, stop, time); GST_DEBUG_OBJECT (dec, "NEWSEGMENT %" GST_SEGMENT_FORMAT, &dec->segment); break; } default: break; } res = gst_pad_push_event (dec->srcpad, event); done: gst_object_unref (dec); return res; /* ERRORS */ invalid_format: { GST_WARNING_OBJECT (dec, "unknown format received in NEWSEGMENT event"); gst_event_unref (event); goto done; } invalid_bytes_segment: { GST_WARNING_OBJECT (dec, "can't handle NEWSEGMENT event in BYTES format " "with a non-0 start or non-0 time value"); gst_event_unref (event); goto done; } }
static gboolean vorbis_dec_sink_event (GstPad * pad, GstEvent * event) { gboolean ret = FALSE; GstVorbisDec *dec; dec = GST_VORBIS_DEC (gst_pad_get_parent (pad)); GST_LOG_OBJECT (dec, "handling event"); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: if (dec->segment.rate < 0.0) vorbis_dec_chain_reverse (dec, TRUE, NULL); ret = gst_pad_push_event (dec->srcpad, event); break; case GST_EVENT_FLUSH_START: ret = gst_pad_push_event (dec->srcpad, event); break; case GST_EVENT_FLUSH_STOP: /* here we must clean any state in the decoder */ #ifdef HAVE_VORBIS_SYNTHESIS_RESTART vorbis_synthesis_restart (&dec->vd); #endif gst_vorbis_dec_reset (dec); ret = gst_pad_push_event (dec->srcpad, event); break; case GST_EVENT_NEWSEGMENT: { GstFormat format; gdouble rate, arate; gint64 start, stop, time; gboolean update; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); /* we need time for now */ if (format != GST_FORMAT_TIME) goto newseg_wrong_format; GST_DEBUG_OBJECT (dec, "newsegment: update %d, rate %g, arate %g, start %" GST_TIME_FORMAT ", stop %" GST_TIME_FORMAT ", time %" GST_TIME_FORMAT, update, rate, arate, GST_TIME_ARGS (start), GST_TIME_ARGS (stop), GST_TIME_ARGS (time)); /* now configure the values */ gst_segment_set_newsegment_full (&dec->segment, update, rate, arate, format, start, stop, time); dec->seqnum = gst_event_get_seqnum (event); if (dec->initialized) /* and forward */ ret = gst_pad_push_event (dec->srcpad, event); else { /* store it to send once we're initialized */ dec->pendingevents = g_list_append (dec->pendingevents, event); ret = TRUE; } break; } case GST_EVENT_TAG: { if (dec->initialized) /* and forward */ ret = gst_pad_push_event (dec->srcpad, event); else { /* store it to send once we're initialized */ dec->pendingevents = g_list_append (dec->pendingevents, event); ret = TRUE; } break; } default: ret = gst_pad_push_event (dec->srcpad, event); break; } done: gst_object_unref (dec); return ret; /* ERRORS */ newseg_wrong_format: { GST_DEBUG_OBJECT (dec, "received non TIME newsegment"); goto done; } }
static gboolean gst_au_parse_sink_event (GstPad * pad, GstEvent * event) { GstAuParse *auparse; gboolean ret = TRUE; auparse = GST_AU_PARSE (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT: { GstFormat format; gdouble rate, arate; gint64 start, stop, time, offset = 0; gboolean update; GstSegment segment; GstEvent *new_event = NULL; gst_segment_init (&segment, GST_FORMAT_UNDEFINED); gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); gst_segment_set_newsegment_full (&segment, update, rate, arate, format, start, stop, time); if (auparse->sample_size > 0) { if (start > 0) { offset = start; start -= auparse->offset; start = MAX (start, 0); } if (stop > 0) { stop -= auparse->offset; stop = MAX (stop, 0); } gst_au_parse_src_convert (auparse, GST_FORMAT_BYTES, start, GST_FORMAT_TIME, &start); gst_au_parse_src_convert (auparse, GST_FORMAT_BYTES, stop, GST_FORMAT_TIME, &stop); } if (auparse->srcpad) { GST_INFO_OBJECT (auparse, "new segment: %" GST_TIME_FORMAT " ... %" GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (stop)); new_event = gst_event_new_new_segment_full (update, rate, arate, GST_FORMAT_TIME, start, stop, start); ret = gst_pad_push_event (auparse->srcpad, new_event); } auparse->buffer_offset = offset; gst_event_unref (event); break; } case GST_EVENT_EOS: if (!auparse->srcpad) { GST_ELEMENT_ERROR (auparse, STREAM, WRONG_TYPE, ("No valid input found before end of stream"), (NULL)); } /* fall-through */ default: ret = gst_pad_event_default (pad, event); break; } gst_object_unref (auparse); return ret; }
static gboolean gst_audio_rate_sink_event (GstPad * pad, GstEvent * event) { gboolean res; GstAudioRate *audiorate; audiorate = GST_AUDIO_RATE (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: GST_DEBUG_OBJECT (audiorate, "handling FLUSH_STOP"); gst_audio_rate_reset (audiorate); res = gst_pad_push_event (audiorate->srcpad, event); break; case GST_EVENT_NEWSEGMENT: { GstFormat format; gdouble rate, arate; gint64 start, stop, time; gboolean update; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); GST_DEBUG_OBJECT (audiorate, "handle NEWSEGMENT"); /* FIXME: * - sparse stream support. For this, the update flag is TRUE and the * start/time positions are updated, meaning that time progressed by * time - old_time amount and we need to fill that gap with empty * samples. * - fill the current segment if it has a valid stop position. This * happens when the update flag is FALSE. With the segment helper we can * calculate the accumulated time and compare this to the next_offset. */ if (!update) { /* a new segment starts. We need to figure out what will be the next * sample offset. We mark the offsets as invalid so that the _chain * function will perform this calculation. */ audiorate->next_offset = -1; audiorate->next_ts = -1; } /* we accept all formats */ gst_segment_set_newsegment_full (&audiorate->sink_segment, update, rate, arate, format, start, stop, time); GST_DEBUG_OBJECT (audiorate, "updated segment: %" GST_SEGMENT_FORMAT, &audiorate->sink_segment); if (format == GST_FORMAT_TIME) { /* TIME formats can be copied to src and forwarded */ res = gst_pad_push_event (audiorate->srcpad, event); memcpy (&audiorate->src_segment, &audiorate->sink_segment, sizeof (GstSegment)); } else { /* other formats will be handled in the _chain function */ gst_event_unref (event); res = TRUE; } break; } case GST_EVENT_EOS: /* FIXME, fill last segment */ res = gst_pad_push_event (audiorate->srcpad, event); break; default: res = gst_pad_push_event (audiorate->srcpad, event); break; } gst_object_unref (audiorate); return res; }
static gboolean gst_selector_pad_event (GstPad * pad, GstEvent * event) { gboolean res = TRUE; gboolean forward = TRUE; RsnStreamSelector *sel; RsnSelectorPad *selpad; GstPad *active_sinkpad; sel = RSN_STREAM_SELECTOR (gst_pad_get_parent (pad)); selpad = GST_SELECTOR_PAD_CAST (pad); /* only forward if we are dealing with the active sinkpad */ active_sinkpad = rsn_stream_selector_get_active (sel, pad); forward = (active_sinkpad == pad); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: gst_selector_pad_reset (selpad); break; case GST_EVENT_NEWSEGMENT: { gboolean update; GstFormat format; gdouble rate, arate; gint64 start, stop, time; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); GST_DEBUG_OBJECT (selpad, "configured NEWSEGMENT update %d, rate %lf, applied rate %lf, " "format %d, " "%" G_GINT64_FORMAT " -- %" G_GINT64_FORMAT ", time %" G_GINT64_FORMAT, update, rate, arate, format, start, stop, time); gst_segment_set_newsegment_full (&selpad->segment, update, rate, arate, format, start, stop, time); /* if we are not going to forward the segment, mark the segment as * pending */ if (!forward) selpad->segment_pending = TRUE; break; } case GST_EVENT_TAG: { GstTagList *tags; GST_OBJECT_LOCK (selpad); if (selpad->tags) gst_tag_list_free (selpad->tags); gst_event_parse_tag (event, &tags); if (tags) tags = gst_tag_list_copy (tags); selpad->tags = tags; GST_DEBUG_OBJECT (sel, "received tags %" GST_PTR_FORMAT, selpad->tags); GST_OBJECT_UNLOCK (selpad); break; } case GST_EVENT_CUSTOM_DOWNSTREAM: { const GstStructure *structure = gst_event_get_structure (event); if (structure != NULL && gst_structure_has_name (structure, "application/x-gst-dvd")) { const char *type = gst_structure_get_string (structure, "event"); if (strcmp (type, "select-pad") == 0) { rsn_stream_selector_set_active (sel, pad); forward = FALSE; } } } case GST_EVENT_EOS: selpad->eos = TRUE; break; default: break; } if (forward) res = gst_pad_push_event (sel->srcpad, event); else gst_event_unref (event); gst_object_unref (sel); return res; }
static gboolean rsn_audiomunge_sink_event (GstPad * pad, GstEvent * event) { gboolean ret = FALSE; RsnAudioMunge *munge = RSN_AUDIOMUNGE (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: rsn_audiomunge_reset (munge); ret = gst_pad_push_event (munge->srcpad, event); break; case GST_EVENT_NEWSEGMENT: { GstSegment *segment; gboolean update; GstFormat format; gdouble rate, arate; gint64 start, stop, time; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); /* we need TIME format */ if (format != GST_FORMAT_TIME) goto newseg_wrong_format; /* now configure the values */ segment = &munge->sink_segment; gst_segment_set_newsegment_full (segment, update, rate, arate, format, start, stop, time); if (munge->have_audio) { ret = gst_pad_push_event (munge->srcpad, event); break; } /* * FIXME: * If the accum >= threshold or we're in a still frame and there's been * no audio received, then we need to generate some audio data. * If caused by a segment start update (time advancing in a gap) adjust * the new-segment and send the buffer. * * Otherwise, send the buffer before the newsegment, so that it appears * in the closing segment. */ if (!update) { GST_DEBUG_OBJECT (munge, "Sending newsegment: start %" GST_TIME_FORMAT " stop %" GST_TIME_FORMAT " accum now %" GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (stop), GST_TIME_ARGS (segment->accum)); ret = gst_pad_push_event (munge->srcpad, event); } if (segment->accum >= AUDIO_FILL_THRESHOLD || munge->in_still) { g_print ("*********** Sending audio fill: accum = %" GST_TIME_FORMAT " still-state=%d\n", GST_TIME_ARGS (segment->accum), munge->in_still); /* Just generate a 100ms silence buffer for now. FIXME: Fill the gap */ if (rsn_audiomunge_make_audio (munge, segment->start, GST_SECOND / 10) == GST_FLOW_OK) munge->have_audio = TRUE; } else { GST_LOG_OBJECT (munge, "Not sending audio fill buffer: " "segment accum below thresh: accum = %" GST_TIME_FORMAT, GST_TIME_ARGS (segment->accum)); } if (update) { GST_DEBUG_OBJECT (munge, "Sending newsegment: start %" GST_TIME_FORMAT " stop %" GST_TIME_FORMAT " accum now %" GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (stop), GST_TIME_ARGS (segment->accum)); ret = gst_pad_push_event (munge->srcpad, event); } break; } case GST_EVENT_CUSTOM_DOWNSTREAM: { const GstStructure *s = gst_event_get_structure (event); if (s && gst_structure_has_name (s, "application/x-gst-dvd")) rsn_audiomunge_handle_dvd_event (munge, event); ret = gst_pad_push_event (munge->srcpad, event); break; } default: ret = gst_pad_push_event (munge->srcpad, event); break; } return ret; newseg_wrong_format: GST_DEBUG_OBJECT (munge, "received non TIME newsegment"); gst_event_unref (event); gst_object_unref (munge); return FALSE; }
static gboolean speex_dec_sink_event (GstPad * pad, GstEvent * event) { GstSpeexDec *dec; gboolean ret = FALSE; dec = GST_SPEEX_DEC (gst_pad_get_parent (pad)); GST_LOG_OBJECT (dec, "handling %s event", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT:{ GstFormat format; gdouble rate, arate; gint64 start, stop, time; gboolean update; gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); if (format != GST_FORMAT_TIME) goto newseg_wrong_format; if (rate <= 0.0) goto newseg_wrong_rate; if (update) { /* time progressed without data, see if we can fill the gap with * some concealment data */ if (dec->segment.last_stop < start) { GstClockTime duration; duration = start - dec->segment.last_stop; speex_dec_chain_parse_data (dec, NULL, dec->segment.last_stop, duration); } } /* now configure the values */ gst_segment_set_newsegment_full (&dec->segment, update, rate, arate, GST_FORMAT_TIME, start, stop, time); GST_DEBUG_OBJECT (dec, "segment now: cur = %" GST_TIME_FORMAT " [%" GST_TIME_FORMAT " - %" GST_TIME_FORMAT "]", GST_TIME_ARGS (dec->segment.last_stop), GST_TIME_ARGS (dec->segment.start), GST_TIME_ARGS (dec->segment.stop)); ret = gst_pad_push_event (dec->srcpad, event); break; } default: ret = gst_pad_event_default (pad, event); break; } gst_object_unref (dec); return ret; /* ERRORS */ newseg_wrong_format: { GST_DEBUG_OBJECT (dec, "received non TIME newsegment"); gst_object_unref (dec); return FALSE; } newseg_wrong_rate: { GST_DEBUG_OBJECT (dec, "negative rates not supported yet"); gst_object_unref (dec); return FALSE; } }
static gboolean gst_base_video_encoder_sink_event (GstPad * pad, GstEvent * event) { GstBaseVideoEncoder *base_video_encoder; GstBaseVideoEncoderClass *base_video_encoder_class; gboolean ret = FALSE; base_video_encoder = GST_BASE_VIDEO_ENCODER (gst_pad_get_parent (pad)); base_video_encoder_class = GST_BASE_VIDEO_ENCODER_GET_CLASS (base_video_encoder); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: { if (base_video_encoder_class->finish) { base_video_encoder_class->finish (base_video_encoder); } ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), event); } break; case GST_EVENT_NEWSEGMENT: { gboolean update; double rate; double applied_rate; GstFormat format; gint64 start; gint64 stop; gint64 position; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &position); if (format != GST_FORMAT_TIME) goto newseg_wrong_format; GST_DEBUG ("new segment %lld %lld", start, position); gst_segment_set_newsegment_full (&base_video_encoder->segment, update, rate, applied_rate, format, start, stop, position); ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), event); } break; default: /* FIXME this changes the order of events */ ret = gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), event); break; } done: gst_object_unref (base_video_encoder); return ret; newseg_wrong_format: { GST_DEBUG_OBJECT (base_video_encoder, "received non TIME newsegment"); gst_event_unref (event); goto done; } }
static gboolean theora_enc_sink_event (GstPad * pad, GstEvent * event) { GstTheoraEnc *enc; ogg_packet op; gboolean res; enc = GST_THEORA_ENC (GST_PAD_PARENT (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT: { gboolean update; gdouble rate, applied_rate; GstFormat format; gint64 start, stop, time; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &format, &start, &stop, &time); gst_segment_set_newsegment_full (&enc->segment, update, rate, applied_rate, format, start, stop, time); res = gst_pad_push_event (enc->srcpad, event); break; } case GST_EVENT_EOS: if (enc->initialised) { /* push last packet with eos flag, should not be called */ while (th_encode_packetout (enc->encoder, 1, &op)) { GstClockTime next_time = th_granule_time (enc->encoder, op.granulepos) * GST_SECOND; theora_push_packet (enc, &op, GST_CLOCK_TIME_NONE, enc->next_ts, next_time - enc->next_ts); enc->next_ts = next_time; } } if (enc->initialised && enc->multipass_cache_fd && enc->multipass_mode == MULTIPASS_MODE_FIRST_PASS) theora_enc_write_multipass_cache (enc, TRUE, TRUE); theora_enc_clear_multipass_cache (enc); res = gst_pad_push_event (enc->srcpad, event); break; case GST_EVENT_FLUSH_STOP: gst_segment_init (&enc->segment, GST_FORMAT_UNDEFINED); res = gst_pad_push_event (enc->srcpad, event); break; case GST_EVENT_CUSTOM_DOWNSTREAM: { const GstStructure *s; s = gst_event_get_structure (event); if (gst_structure_has_name (s, "GstForceKeyUnit")) theora_enc_force_keyframe (enc); res = gst_pad_push_event (enc->srcpad, event); break; } default: res = gst_pad_push_event (enc->srcpad, event); break; } return res; }
static gboolean gst_raw_parse_sink_event (GstPad * pad, GstEvent * event) { GstRawParse *rp = GST_RAW_PARSE (gst_pad_get_parent (pad)); gboolean ret; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: case GST_EVENT_FLUSH_STOP: /* Only happens in push mode */ gst_raw_parse_reset (rp); ret = gst_pad_push_event (rp->srcpad, event); break; case GST_EVENT_NEWSEGMENT: { GstClockTimeDiff start, stop, time; gdouble rate, arate; gboolean update; GstFormat format; /* Only happens in push mode */ gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); if (format == GST_FORMAT_TIME) { gst_segment_set_newsegment_full (&rp->segment, update, rate, arate, GST_FORMAT_TIME, start, stop, time); ret = gst_pad_push_event (rp->srcpad, event); } else { gst_event_unref (event); ret = gst_raw_parse_convert (rp, format, start, GST_FORMAT_TIME, &start); ret &= gst_raw_parse_convert (rp, format, time, GST_FORMAT_TIME, &time); ret &= gst_raw_parse_convert (rp, format, stop, GST_FORMAT_TIME, &stop); if (!ret) { GST_ERROR_OBJECT (rp, "Failed converting to GST_FORMAT_TIME format (%d)", format); break; } gst_segment_set_newsegment_full (&rp->segment, update, rate, arate, GST_FORMAT_TIME, start, stop, time); /* create new segment with the fields converted to time */ event = gst_event_new_new_segment_full (update, rate, arate, GST_FORMAT_TIME, start, stop, time); ret = gst_pad_push_event (rp->srcpad, event); } break; } default: ret = gst_pad_event_default (rp->sinkpad, event); break; } gst_object_unref (rp); return ret; }