static gboolean gst_raw_parse_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstRawParse *rp = GST_RAW_PARSE (parent); 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_SEGMENT: { GstSegment segment; /* Only happens in push mode */ gst_event_copy_segment (event, &segment); if (segment.format != GST_FORMAT_TIME) { gst_event_unref (event); ret = gst_raw_parse_convert (rp, segment.format, segment.start, GST_FORMAT_TIME, (gint64 *) & segment.start); ret &= gst_raw_parse_convert (rp, segment.format, segment.time, GST_FORMAT_TIME, (gint64 *) & segment.time); ret &= gst_raw_parse_convert (rp, segment.format, segment.stop, GST_FORMAT_TIME, (gint64 *) & segment.stop); if (!ret) { GST_ERROR_OBJECT (rp, "Failed converting to GST_FORMAT_TIME format (%d)", segment.format); break; } segment.format = GST_FORMAT_TIME; event = gst_event_new_segment (&segment); } gst_segment_copy_into (&segment, &rp->segment); if (rp->start_segment) gst_event_unref (rp->start_segment); rp->start_segment = event; ret = TRUE; break; } default: ret = gst_pad_event_default (pad, parent, event); break; } return ret; }
static gboolean gst_raw_parse_handle_seek_push (GstRawParse * rp, GstEvent * event) { GstFormat format; gdouble rate; GstSeekFlags flags; GstSeekType start_type, stop_type; gint64 start, stop; gboolean ret = FALSE; gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start, &stop_type, &stop); /* can't seek backwards yet */ if (rate <= 0.0) goto wrong_rate; /* First try if upstream handles the seek */ ret = gst_pad_push_event (rp->sinkpad, event); if (ret) return ret; /* Otherwise convert to bytes and push upstream */ if (format == GST_FORMAT_TIME || format == GST_FORMAT_DEFAULT) { ret = gst_raw_parse_convert (rp, format, start, GST_FORMAT_BYTES, &start); ret &= gst_raw_parse_convert (rp, format, stop, GST_FORMAT_BYTES, &stop); if (ret) { /* Seek on a frame boundary */ start -= start % rp->framesize; if (stop != -1) stop += rp->framesize - stop % rp->framesize; event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags, start_type, start, stop_type, stop); ret = gst_pad_push_event (rp->sinkpad, event); } else { GST_DEBUG_OBJECT (rp, "Seek failed: couldn't convert to byte positions"); } } else { GST_DEBUG_OBJECT (rp, "seeking is only supported in TIME or DEFAULT format"); } return ret; /* ERRORS */ wrong_rate: { GST_DEBUG_OBJECT (rp, "Seek failed: negative rates not supported yet"); return FALSE; } }
static gboolean gst_raw_parse_sink_activatepull (GstPad * sinkpad, gboolean active) { GstRawParse *rp = GST_RAW_PARSE (gst_pad_get_parent (sinkpad)); gboolean result; if (active) { GstFormat format; gint64 duration; /* get the duration in bytes */ format = GST_FORMAT_BYTES; result = gst_pad_query_peer_duration (sinkpad, &format, &duration); if (result) { GST_DEBUG_OBJECT (rp, "got duration %" GST_TIME_FORMAT, GST_TIME_ARGS (duration)); rp->upstream_length = duration; /* convert to time */ gst_raw_parse_convert (rp, format, duration, GST_FORMAT_TIME, &duration); } else { rp->upstream_length = -1; duration = -1; } gst_segment_set_duration (&rp->segment, GST_FORMAT_TIME, duration); result = gst_raw_parse_handle_seek_pull (rp, NULL); } else { result = gst_pad_stop_task (sinkpad); } gst_object_unref (rp); return result; }
static gboolean gst_raw_parse_sink_activatemode (GstPad * sinkpad, GstObject * parent, GstPadMode mode, gboolean active) { GstRawParse *rp = GST_RAW_PARSE (parent); gboolean result; switch (mode) { case GST_PAD_MODE_PULL: if (active) { GstFormat format; gint64 duration; /* get the duration in bytes */ format = GST_FORMAT_BYTES; result = gst_pad_peer_query_duration (sinkpad, format, &duration); if (result) { GST_DEBUG_OBJECT (rp, "got duration %" GST_TIME_FORMAT, GST_TIME_ARGS (duration)); rp->upstream_length = duration; /* convert to time */ gst_raw_parse_convert (rp, format, duration, GST_FORMAT_TIME, &duration); } else { rp->upstream_length = -1; duration = -1; } rp->segment.duration = duration; rp->push_stream_start = TRUE; result = gst_raw_parse_handle_seek_pull (rp, NULL); rp->mode = mode; } else { result = gst_pad_stop_task (sinkpad); } return result; case GST_PAD_MODE_PUSH: rp->mode = mode; return TRUE; default: return FALSE; } }
static gboolean gst_raw_parse_src_query (GstPad * pad, GstObject * parent, GstQuery * query) { GstRawParse *rp = GST_RAW_PARSE (parent); gboolean ret = FALSE; GST_DEBUG ("src_query %s", gst_query_type_get_name (GST_QUERY_TYPE (query))); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; gint64 time, value; GST_LOG ("query position"); gst_query_parse_position (query, &format, NULL); time = rp->segment.position; ret = gst_raw_parse_convert (rp, GST_FORMAT_TIME, time, format, &value); gst_query_set_position (query, format, value); break; } case GST_QUERY_DURATION:{ gint64 duration; GstFormat format; GstQuery *bquery; GST_LOG ("query duration"); ret = gst_pad_peer_query (rp->sinkpad, query); if (ret) goto done; gst_query_parse_duration (query, &format, NULL); /* We only handle TIME and DEFAULT format */ if (format != GST_FORMAT_TIME && format != GST_FORMAT_DEFAULT) goto error; bquery = gst_query_new_duration (GST_FORMAT_BYTES); ret = gst_pad_peer_query (rp->sinkpad, bquery); if (!ret) { gst_query_unref (bquery); goto error; } gst_query_parse_duration (bquery, NULL, &duration); gst_query_unref (bquery); ret = gst_raw_parse_convert (rp, GST_FORMAT_BYTES, duration, format, &duration); if (ret) gst_query_set_duration (query, format, duration); break; } case GST_QUERY_CONVERT: { GstFormat src_fmt, dest_fmt; gint64 src_val, dest_val; GST_LOG ("query convert"); gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val); ret = gst_raw_parse_convert (rp, src_fmt, src_val, dest_fmt, &dest_val); if (!ret) goto error; gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); break; } case GST_QUERY_SEEKING:{ GstFormat fmt; ret = TRUE; gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL); if (fmt != GST_FORMAT_TIME && fmt != GST_FORMAT_DEFAULT && fmt != GST_FORMAT_BYTES) { gst_query_set_seeking (query, fmt, FALSE, -1, -1); } else if (rp->mode == GST_PAD_MODE_PUSH) { GstQuery *peerquery = gst_query_new_seeking (GST_FORMAT_BYTES); gboolean seekable; seekable = gst_pad_peer_query (rp->sinkpad, peerquery); if (seekable) gst_query_parse_seeking (peerquery, NULL, &seekable, NULL, NULL); gst_query_unref (peerquery); gst_query_set_seeking (query, fmt, seekable, seekable ? 0 : -1, -1); } else { gst_query_set_seeking (query, fmt, TRUE, 0, -1); } break; } default: /* else forward upstream */ ret = gst_pad_query_default (rp->sinkpad, parent, query); break; } done: return ret; /* ERRORS */ error: { GST_DEBUG_OBJECT (rp, "query failed"); goto done; } }
static gboolean gst_raw_parse_handle_seek_pull (GstRawParse * rp, GstEvent * event) { gdouble rate; GstFormat format; GstSeekFlags flags; GstSeekType start_type, stop_type; gint64 start, stop; gint64 last_stop; gboolean ret = FALSE; gboolean flush; GstSegment seeksegment; if (event) { gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start, &stop_type, &stop); /* convert input offsets to time */ ret = gst_raw_parse_convert (rp, format, start, GST_FORMAT_TIME, &start); ret &= gst_raw_parse_convert (rp, format, stop, GST_FORMAT_TIME, &stop); if (!ret) goto convert_failed; GST_DEBUG_OBJECT (rp, "converted start - stop to time"); format = GST_FORMAT_TIME; gst_event_unref (event); } else { format = GST_FORMAT_TIME; flags = 0; } flush = ((flags & GST_SEEK_FLAG_FLUSH) != 0); /* start flushing up and downstream so that the loop function pauses and we * can acquire the STREAM_LOCK. */ if (flush) { GST_LOG_OBJECT (rp, "flushing"); gst_pad_push_event (rp->sinkpad, gst_event_new_flush_start ()); gst_pad_push_event (rp->srcpad, gst_event_new_flush_start ()); } else { GST_LOG_OBJECT (rp, "pause task"); gst_pad_pause_task (rp->sinkpad); } GST_PAD_STREAM_LOCK (rp->sinkpad); memcpy (&seeksegment, &rp->segment, sizeof (GstSegment)); if (event) { /* configure the seek values */ gst_segment_do_seek (&seeksegment, rate, format, flags, start_type, start, stop_type, stop, NULL); } /* get the desired position */ last_stop = seeksegment.position; GST_LOG_OBJECT (rp, "seeking to %" GST_TIME_FORMAT, GST_TIME_ARGS (last_stop)); /* convert the desired position to bytes */ ret = gst_raw_parse_convert (rp, format, last_stop, GST_FORMAT_BYTES, &last_stop); /* prepare for streaming */ if (flush) { GST_LOG_OBJECT (rp, "stop flush"); gst_pad_push_event (rp->sinkpad, gst_event_new_flush_stop (TRUE)); gst_pad_push_event (rp->srcpad, gst_event_new_flush_stop (TRUE)); } if (ret) { /* seek done */ /* Seek on a frame boundary */ last_stop -= last_stop % rp->framesize; rp->offset = last_stop; rp->n_frames = last_stop / rp->framesize; GST_LOG_OBJECT (rp, "seeking to bytes %" G_GINT64_FORMAT, last_stop); memcpy (&rp->segment, &seeksegment, sizeof (GstSegment)); if (rp->segment.flags & GST_SEEK_FLAG_SEGMENT) { gst_element_post_message (GST_ELEMENT_CAST (rp), gst_message_new_segment_start (GST_OBJECT_CAST (rp), rp->segment.format, rp->segment.position)); } /* for deriving a stop position for the playback segment from the seek * segment, we must take the duration when the stop is not set */ if ((stop = rp->segment.stop) == -1) stop = rp->segment.duration; GST_DEBUG_OBJECT (rp, "preparing newsegment from %" G_GINT64_FORMAT " to %" G_GINT64_FORMAT, rp->segment.start, stop); /* now replace the old segment so that we send it in the stream thread the * next time it is scheduled. */ if (rp->start_segment) gst_event_unref (rp->start_segment); rp->start_segment = gst_event_new_segment (&rp->segment); } rp->discont = TRUE; GST_LOG_OBJECT (rp, "start streaming"); gst_pad_start_task (rp->sinkpad, (GstTaskFunction) gst_raw_parse_loop, rp, NULL); GST_PAD_STREAM_UNLOCK (rp->sinkpad); return ret; /* ERRORS */ convert_failed: { GST_DEBUG_OBJECT (rp, "Seek failed: couldn't convert to byte positions"); return FALSE; } }
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; }