mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-27 10:40:34 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/rawparse/gstrawparse.c
Sebastian Dröge 5c11f80c04 rawparse: Small cleanups and implement SEEKING query
2009-08-08 10:27:52 +02:00

1070 lines
29 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 2006 David A. Schleef <ds@schleef.org>
* Copyright (C) 2007 Sebastian Dröge <slomo@circular-chaos.org>
*
* gstrawparse.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/* TODO: - Add locking where appropiate
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <string.h>
#include <gst/gst.h>
#include <gst/base/gstbasetransform.h>
#include <gst/base/gstadapter.h>
#include "gstrawparse.h"
static void gst_raw_parse_dispose (GObject * object);
static gboolean gst_raw_parse_sink_activate (GstPad * sinkpad);
static gboolean gst_raw_parse_sink_activatepull (GstPad * sinkpad,
gboolean active);
static void gst_raw_parse_loop (GstElement * element);
static GstStateChangeReturn gst_raw_parse_change_state (GstElement * element,
GstStateChange transition);
static GstFlowReturn gst_raw_parse_chain (GstPad * pad, GstBuffer * buffer);
static gboolean gst_raw_parse_sink_event (GstPad * pad, GstEvent * event);
static gboolean gst_raw_parse_src_event (GstPad * pad, GstEvent * event);
static const GstQueryType *gst_raw_parse_src_query_type (GstPad * pad);
static gboolean gst_raw_parse_src_query (GstPad * pad, GstQuery * query);
static gboolean gst_raw_parse_convert (GstRawParse * rp,
GstFormat src_format, gint64 src_value,
GstFormat dest_format, gint64 * dest_value);
static gboolean gst_raw_parse_handle_seek_pull (GstRawParse * rp,
GstEvent * event);
static void gst_raw_parse_reset (GstRawParse * rp);
static GstStaticPadTemplate gst_raw_parse_sink_pad_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
GST_DEBUG_CATEGORY_STATIC (gst_raw_parse_debug);
#define GST_CAT_DEFAULT gst_raw_parse_debug
GST_BOILERPLATE (GstRawParse, gst_raw_parse, GstElement, GST_TYPE_ELEMENT);
static void
gst_raw_parse_base_init (gpointer g_class)
{
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
GST_DEBUG_CATEGORY_INIT (gst_raw_parse_debug, "rawparse", 0,
"rawparse element");
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&gst_raw_parse_sink_pad_template));
}
static void
gst_raw_parse_class_init (GstRawParseClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
gobject_class->dispose = gst_raw_parse_dispose;
gstelement_class->change_state =
GST_DEBUG_FUNCPTR (gst_raw_parse_change_state);
}
static void
gst_raw_parse_init (GstRawParse * rp, GstRawParseClass * g_class)
{
GstPadTemplate *src_pad_template;
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
rp->sinkpad =
gst_pad_new_from_static_template (&gst_raw_parse_sink_pad_template,
"sink");
gst_pad_set_chain_function (rp->sinkpad,
GST_DEBUG_FUNCPTR (gst_raw_parse_chain));
gst_pad_set_event_function (rp->sinkpad,
GST_DEBUG_FUNCPTR (gst_raw_parse_sink_event));
gst_pad_set_activate_function (rp->sinkpad,
GST_DEBUG_FUNCPTR (gst_raw_parse_sink_activate));
gst_pad_set_activatepull_function (rp->sinkpad,
GST_DEBUG_FUNCPTR (gst_raw_parse_sink_activatepull));
gst_element_add_pad (GST_ELEMENT (rp), rp->sinkpad);
src_pad_template = gst_element_class_get_pad_template (element_class, "src");
if (src_pad_template) {
rp->srcpad = gst_pad_new_from_template (src_pad_template, "src");
} else {
g_warning ("Subclass didn't specify a src pad template");
g_assert_not_reached ();
}
gst_pad_set_event_function (rp->srcpad,
GST_DEBUG_FUNCPTR (gst_raw_parse_src_event));
gst_pad_set_query_type_function (rp->srcpad,
GST_DEBUG_FUNCPTR (gst_raw_parse_src_query_type));
gst_pad_set_query_function (rp->srcpad,
GST_DEBUG_FUNCPTR (gst_raw_parse_src_query));
gst_element_add_pad (GST_ELEMENT (rp), rp->srcpad);
rp->adapter = gst_adapter_new ();
rp->fps_n = 1;
rp->fps_d = 0;
rp->framesize = 1;
gst_raw_parse_reset (rp);
}
static void
gst_raw_parse_dispose (GObject * object)
{
GstRawParse *rp = GST_RAW_PARSE (object);
if (rp->adapter) {
g_object_unref (rp->adapter);
rp->adapter = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
void
gst_raw_parse_class_set_src_pad_template (GstRawParseClass * klass,
const GstCaps * allowed_caps)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
g_return_if_fail (GST_IS_RAW_PARSE_CLASS (klass));
g_return_if_fail (allowed_caps != NULL);
g_return_if_fail (GST_IS_CAPS (allowed_caps));
gst_element_class_add_pad_template (element_class,
gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
gst_caps_copy (allowed_caps)));
}
void
gst_raw_parse_class_set_multiple_frames_per_buffer (GstRawParseClass * klass,
gboolean multiple_frames)
{
g_return_if_fail (GST_IS_RAW_PARSE_CLASS (klass));
klass->multiple_frames_per_buffer = multiple_frames;
}
static void
gst_raw_parse_reset (GstRawParse * rp)
{
rp->n_frames = 0;
rp->discont = TRUE;
gst_segment_init (&rp->segment, GST_FORMAT_TIME);
gst_adapter_clear (rp->adapter);
}
static gboolean
gst_raw_parse_set_src_caps (GstRawParse * rp)
{
GstRawParseClass *rp_class = GST_RAW_PARSE_GET_CLASS (rp);
GstCaps *caps;
if (rp->negotiated)
return TRUE;
if (rp_class->get_caps) {
caps = rp_class->get_caps (rp);
} else {
GST_WARNING
("Subclass doesn't implement get_caps() method, using ANY caps");
caps = gst_caps_new_any ();
}
rp->negotiated = gst_pad_set_caps (rp->srcpad, caps);
return rp->negotiated;
}
static GstFlowReturn
gst_raw_parse_push_buffer (GstRawParse * rp, GstBuffer * buffer)
{
GstFlowReturn ret;
gint nframes;
GstRawParseClass *rpclass;
rpclass = GST_RAW_PARSE_GET_CLASS (rp);
nframes = GST_BUFFER_SIZE (buffer) / rp->framesize;
if (rp->segment.rate < 0) {
rp->n_frames -= nframes;
rp->discont = TRUE;
}
GST_BUFFER_OFFSET (buffer) = rp->n_frames;
GST_BUFFER_OFFSET_END (buffer) = rp->n_frames + nframes;
if (rp->fps_n) {
GST_BUFFER_TIMESTAMP (buffer) =
gst_util_uint64_scale (rp->n_frames, GST_SECOND * rp->fps_d, rp->fps_n);
GST_BUFFER_DURATION (buffer) =
gst_util_uint64_scale ((rp->n_frames + nframes) * GST_SECOND, rp->fps_d,
rp->fps_n) - GST_BUFFER_TIMESTAMP (buffer);
} else {
GST_BUFFER_TIMESTAMP (buffer) = rp->segment.start;
GST_BUFFER_DURATION (buffer) = GST_CLOCK_TIME_NONE;
}
gst_buffer_set_caps (buffer, GST_PAD_CAPS (rp->srcpad));
if (rpclass->set_buffer_flags) {
rpclass->set_buffer_flags (rp, buffer);
}
if (rp->discont) {
GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
rp->discont = FALSE;
}
if (rp->segment.rate >= 0) {
rp->offset += GST_BUFFER_SIZE (buffer);
rp->n_frames += nframes;
}
rp->segment.last_stop = GST_BUFFER_TIMESTAMP (buffer);
GST_LOG_OBJECT (rp, "Pushing buffer with time %" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)));
ret = gst_pad_push (rp->srcpad, buffer);
return ret;
}
static GstFlowReturn
gst_raw_parse_chain (GstPad * pad, GstBuffer * buffer)
{
GstRawParse *rp = GST_RAW_PARSE (gst_pad_get_parent (pad));
GstFlowReturn ret = GST_FLOW_OK;
GstRawParseClass *rp_class = GST_RAW_PARSE_GET_CLASS (rp);
guint buffersize;
if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))) {
GST_DEBUG_OBJECT (rp, "received DISCONT buffer");
gst_adapter_clear (rp->adapter);
rp->discont = TRUE;
}
if (!gst_raw_parse_set_src_caps (rp))
goto no_caps;
gst_adapter_push (rp->adapter, buffer);
if (rp_class->multiple_frames_per_buffer) {
buffersize = gst_adapter_available (rp->adapter);
buffersize -= buffersize % rp->framesize;
} else {
buffersize = rp->framesize;
}
while (gst_adapter_available (rp->adapter) >= buffersize) {
buffer = gst_adapter_take_buffer (rp->adapter, buffersize);
ret = gst_raw_parse_push_buffer (rp, buffer);
if (ret != GST_FLOW_OK)
break;
}
done:
gst_object_unref (rp);
return ret;
/* ERRORS */
no_caps:
{
GST_ERROR_OBJECT (rp, "could not set caps");
ret = GST_FLOW_NOT_NEGOTIATED;
goto done;
}
}
static void
gst_raw_parse_loop (GstElement * element)
{
GstRawParse *rp = GST_RAW_PARSE (element);
GstRawParseClass *rp_class = GST_RAW_PARSE_GET_CLASS (rp);
GstFlowReturn ret;
GstBuffer *buffer;
gint size;
if (!gst_raw_parse_set_src_caps (rp))
goto no_caps;
if (rp->close_segment) {
GST_DEBUG_OBJECT (rp, "sending close segment");
gst_pad_push_event (rp->srcpad, rp->close_segment);
rp->close_segment = NULL;
}
if (rp->start_segment) {
GST_DEBUG_OBJECT (rp, "sending start segment");
gst_pad_push_event (rp->srcpad, rp->start_segment);
rp->start_segment = NULL;
}
if (rp_class->multiple_frames_per_buffer && rp->framesize < 4096)
size = 4096 - (4096 % rp->framesize);
else
size = rp->framesize;
if (rp->segment.rate >= 0) {
if (rp->offset + size > rp->upstream_length) {
GstFormat fmt = GST_FORMAT_BYTES;
if (!gst_pad_query_peer_duration (rp->sinkpad, &fmt,
&rp->upstream_length)) {
GST_WARNING_OBJECT (rp,
"Could not get upstream duration, trying to pull frame by frame");
size = rp->framesize;
} else if (rp->upstream_length < rp->offset + rp->framesize) {
ret = GST_FLOW_UNEXPECTED;
goto pause;
} else if (rp->offset + size > rp->upstream_length) {
size = rp->upstream_length - rp->offset;
size -= size % rp->framesize;
}
}
} else {
if (rp->offset == 0) {
ret = GST_FLOW_UNEXPECTED;
goto pause;
} else if (rp->offset < size) {
size -= rp->offset;
}
rp->offset -= size;
}
ret = gst_pad_pull_range (rp->sinkpad, rp->offset, size, &buffer);
if (ret != GST_FLOW_OK) {
GST_DEBUG_OBJECT (rp, "pull_range (%" G_GINT64_FORMAT ", %u) "
"failed, flow: %s", rp->offset, size, gst_flow_get_name (ret));
buffer = NULL;
goto pause;
}
if (GST_BUFFER_SIZE (buffer) < size) {
GST_DEBUG_OBJECT (rp, "Short read at offset %" G_GINT64_FORMAT
", got only %u of %u bytes", rp->offset, GST_BUFFER_SIZE (buffer),
size);
if (size > rp->framesize) {
GST_BUFFER_SIZE (buffer) -= GST_BUFFER_SIZE (buffer) % rp->framesize;
} else {
gst_buffer_unref (buffer);
buffer = NULL;
ret = GST_FLOW_UNEXPECTED;
goto pause;
}
}
ret = gst_raw_parse_push_buffer (rp, buffer);
if (ret != GST_FLOW_OK)
goto pause;
return;
/* ERRORS */
no_caps:
{
GST_ERROR_OBJECT (rp, "could not negotiate caps");
ret = GST_FLOW_NOT_NEGOTIATED;
goto pause;
}
pause:
{
const gchar *reason = gst_flow_get_name (ret);
GST_LOG_OBJECT (rp, "pausing task, reason %s", reason);
gst_pad_pause_task (rp->sinkpad);
if (GST_FLOW_IS_FATAL (ret) || ret == GST_FLOW_NOT_LINKED) {
if (ret == GST_FLOW_UNEXPECTED) {
if (rp->segment.flags & GST_SEEK_FLAG_SEGMENT) {
GstClockTime stop;
GST_LOG_OBJECT (rp, "Sending segment done");
if ((stop = rp->segment.stop) == -1)
stop = rp->segment.duration;
gst_element_post_message (GST_ELEMENT_CAST (rp),
gst_message_new_segment_done (GST_OBJECT_CAST (rp),
rp->segment.format, stop));
} else {
GST_LOG_OBJECT (rp, "Sending EOS, at end of stream");
gst_pad_push_event (rp->srcpad, gst_event_new_eos ());
}
} else {
GST_ELEMENT_ERROR (rp, STREAM, FAILED,
("Internal data stream error."),
("stream stopped, reason %s", reason));
gst_pad_push_event (rp->srcpad, gst_event_new_eos ());
}
}
return;
}
}
static gboolean
gst_raw_parse_sink_activate (GstPad * sinkpad)
{
if (gst_pad_check_pull_range (sinkpad)) {
GST_RAW_PARSE (GST_PAD_PARENT (sinkpad))->mode = GST_ACTIVATE_PULL;
return gst_pad_activate_pull (sinkpad, TRUE);
} else {
GST_RAW_PARSE (GST_PAD_PARENT (sinkpad))->mode = GST_ACTIVATE_PUSH;
return gst_pad_activate_push (sinkpad, TRUE);
}
}
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 GstStateChangeReturn
gst_raw_parse_change_state (GstElement * element, GstStateChange transition)
{
GstRawParse *rp = GST_RAW_PARSE (element);
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
gst_segment_init (&rp->segment, GST_FORMAT_TIME);
rp->segment.last_stop = 0;
default:
break;
}
if (GST_ELEMENT_CLASS (parent_class)->change_state)
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
gst_raw_parse_reset (rp);
break;
default:
break;
}
return ret;
}
static gboolean
gst_raw_parse_convert (GstRawParse * rp,
GstFormat src_format, gint64 src_value,
GstFormat dest_format, gint64 * dest_value)
{
gboolean ret = FALSE;
GST_DEBUG ("converting value %" G_GINT64_FORMAT " from %s (%d) to %s (%d)",
src_value, gst_format_get_name (src_format), src_format,
gst_format_get_name (dest_format), dest_format);
if (src_format == dest_format) {
*dest_value = src_value;
ret = TRUE;
goto done;
}
if (src_value == -1) {
*dest_value = -1;
ret = TRUE;
goto done;
}
/* bytes to frames */
if (src_format == GST_FORMAT_BYTES && dest_format == GST_FORMAT_DEFAULT) {
if (rp->framesize != 0) {
*dest_value = gst_util_uint64_scale_int (src_value, 1, rp->framesize);
} else {
GST_ERROR ("framesize is 0");
*dest_value = 0;
}
ret = TRUE;
goto done;
}
/* frames to bytes */
if (src_format == GST_FORMAT_DEFAULT && dest_format == GST_FORMAT_BYTES) {
*dest_value = gst_util_uint64_scale_int (src_value, rp->framesize, 1);
ret = TRUE;
goto done;
}
/* time to frames */
if (src_format == GST_FORMAT_TIME && dest_format == GST_FORMAT_DEFAULT) {
if (rp->fps_d != 0) {
*dest_value = gst_util_uint64_scale (src_value,
rp->fps_n, GST_SECOND * rp->fps_d);
} else {
GST_ERROR ("framerate denominator is 0");
*dest_value = 0;
}
ret = TRUE;
goto done;
}
/* frames to time */
if (src_format == GST_FORMAT_DEFAULT && dest_format == GST_FORMAT_TIME) {
if (rp->fps_n != 0) {
*dest_value = gst_util_uint64_scale (src_value,
GST_SECOND * rp->fps_d, rp->fps_n);
} else {
GST_ERROR ("framerate numerator is 0");
*dest_value = 0;
}
ret = TRUE;
goto done;
}
/* time to bytes */
if (src_format == GST_FORMAT_TIME && dest_format == GST_FORMAT_BYTES) {
if (rp->fps_d != 0) {
*dest_value = gst_util_uint64_scale (src_value,
rp->fps_n * rp->framesize, GST_SECOND * rp->fps_d);
} else {
GST_ERROR ("framerate denominator is 0");
*dest_value = 0;
}
ret = TRUE;
goto done;
}
/* bytes to time */
if (src_format == GST_FORMAT_BYTES && dest_format == GST_FORMAT_TIME) {
if (rp->fps_n != 0 && rp->framesize != 0) {
*dest_value = gst_util_uint64_scale (src_value,
GST_SECOND * rp->fps_d, rp->fps_n * rp->framesize);
} else {
GST_ERROR ("framerate denominator and/or framesize is 0");
*dest_value = 0;
}
ret = TRUE;
}
done:
GST_DEBUG ("ret=%d result %" G_GINT64_FORMAT, ret, *dest_value);
return ret;
}
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;
}
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_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_set_seek (&seeksegment, rate, format, flags,
start_type, start, stop_type, stop, NULL);
}
/* get the desired position */
last_stop = seeksegment.last_stop;
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 ());
gst_pad_push_event (rp->srcpad, gst_event_new_flush_stop ());
} else if (ret && rp->running) {
/* we are running the current segment and doing a non-flushing seek,
* close the segment first based on the last_stop. */
GST_DEBUG_OBJECT (rp, "prepare close segment %" G_GINT64_FORMAT
" to %" G_GINT64_FORMAT, rp->segment.start, rp->segment.last_stop);
/* queue the segment for sending in the stream thread */
if (rp->close_segment)
gst_event_unref (rp->close_segment);
rp->close_segment =
gst_event_new_new_segment_full (TRUE,
rp->segment.rate, rp->segment.applied_rate, rp->segment.format,
rp->segment.start, rp->segment.last_stop, rp->segment.time);
}
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.last_stop));
}
/* 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);
if (rp->segment.rate >= 0.0) {
/* forward, we send data from last_stop to stop */
rp->start_segment =
gst_event_new_new_segment_full (FALSE,
rp->segment.rate, rp->segment.applied_rate, rp->segment.format,
rp->segment.last_stop, stop, rp->segment.time);
} else {
/* reverse, we send data from last_stop to start */
rp->start_segment =
gst_event_new_new_segment_full (FALSE,
rp->segment.rate, rp->segment.applied_rate, rp->segment.format,
rp->segment.start, rp->segment.last_stop, rp->segment.time);
}
}
rp->discont = TRUE;
GST_LOG_OBJECT (rp, "start streaming");
rp->running = TRUE;
gst_pad_start_task (rp->sinkpad, (GstTaskFunction) gst_raw_parse_loop, rp);
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_src_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_SEEK:
if (rp->mode == GST_ACTIVATE_PUSH)
ret = gst_raw_parse_handle_seek_push (rp, event);
else
ret = gst_raw_parse_handle_seek_pull (rp, event);
break;
default:
ret = gst_pad_event_default (rp->srcpad, event);
break;
}
gst_object_unref (rp);
return ret;
}
static const GstQueryType *
gst_raw_parse_src_query_type (GstPad * pad)
{
static const GstQueryType types[] = {
GST_QUERY_POSITION,
GST_QUERY_DURATION,
GST_QUERY_CONVERT,
GST_QUERY_SEEKING,
0
};
return types;
}
static gboolean
gst_raw_parse_src_query (GstPad * pad, GstQuery * query)
{
GstRawParse *rp = GST_RAW_PARSE (gst_pad_get_parent (pad));
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.last_stop;
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_ACTIVATE_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_peer_query (rp->sinkpad, query);
break;
}
done:
gst_object_unref (rp);
return ret;
/* ERRORS */
error:
{
GST_DEBUG_OBJECT (rp, "query failed");
goto done;
}
}
void
gst_raw_parse_set_framesize (GstRawParse * rp, int framesize)
{
g_return_if_fail (GST_IS_RAW_PARSE (rp));
g_return_if_fail (!rp->negotiated);
rp->framesize = framesize;
}
void
gst_raw_parse_set_fps (GstRawParse * rp, int fps_n, int fps_d)
{
g_return_if_fail (GST_IS_RAW_PARSE (rp));
g_return_if_fail (!rp->negotiated);
rp->fps_n = fps_n;
rp->fps_d = fps_d;
}
void
gst_raw_parse_get_fps (GstRawParse * rp, int *fps_n, int *fps_d)
{
g_return_if_fail (GST_IS_RAW_PARSE (rp));
if (fps_n)
*fps_n = rp->fps_n;
if (fps_d)
*fps_d = rp->fps_d;
}
gboolean
gst_raw_parse_is_negotiated (GstRawParse * rp)
{
g_return_val_if_fail (GST_IS_RAW_PARSE (rp), FALSE);
return rp->negotiated;
}
Reference in a new issue View git blame Copy permalink