diff options
Diffstat (limited to 'gst')
| -rw-r--r-- | gst/h264parse/gsth264parse.c | 717 | ||||
| -rw-r--r-- | gst/h264parse/gsth264parse.h | 19 |
2 files changed, 684 insertions, 52 deletions
diff --git a/gst/h264parse/gsth264parse.c b/gst/h264parse/gsth264parse.c index fef7ddfc..05e1b7f4 100644 --- a/gst/h264parse/gsth264parse.c +++ b/gst/h264parse/gsth264parse.c @@ -1,5 +1,6 @@ /* GStreamer h264 parser * Copyright (C) 2005 Michal Benes <michal.benes@itonis.tv> + * (C) 2008 Wim Taymans <wim.taymans@gmail.com> * * gsth264parse.c: * @@ -46,13 +47,184 @@ static const GstElementDetails gst_h264_parse_details = GST_ELEMENT_DETAILS ("H264Parse", "Codec/Parser", "Parses raw h264 stream", - "Michal Benes <michal.benes@itonis.tv>"); + "Michal Benes <michal.benes@itonis.tv>," + "Wim Taymans <wim.taymans@gmail.com"); + +#define DEFAULT_SPLIT_PACKETIZED FALSE + +enum +{ + PROP_0, + PROP_SPLIT_PACKETIZED +}; + +typedef enum +{ + NAL_UNKNOWN = 0, + NAL_SLICE = 1, + NAL_SLICE_DPA = 2, + NAL_SLICE_DPB = 3, + NAL_SLICE_DPC = 4, + NAL_SLICE_IDR = 5, + NAL_SEI = 6, + NAL_SPS = 7, + NAL_PPS = 8, + NAL_AU_DELIMITER = 9, + NAL_SEQ_END = 10, + NAL_STREAM_END = 11, + NAL_FILTER_DATA = 12 +} GstNalUnitType; + +/* small linked list implementation to allocate the list entry and the data in + * one go */ +struct _GstNalList +{ + GstNalList *next; + + gint nal_type; + gint nal_ref_idc; + gint first_mb_in_slice; + gint slice_type; + gboolean slice; + gboolean i_frame; + + GstBuffer *buffer; +}; + +static GstNalList * +gst_nal_list_new (GstBuffer * buffer) +{ + GstNalList *new_list; + + new_list = g_slice_new0 (GstNalList); + new_list->buffer = buffer; + + return new_list; +} + +static GstNalList * +gst_nal_list_prepend_link (GstNalList * list, GstNalList * link) +{ + link->next = list; + + return link; +} + +static GstNalList * +gst_nal_list_delete_head (GstNalList * list) +{ + if (list) { + GstNalList *old = list; + + list = list->next; + + g_slice_free (GstNalList, old); + } + return list; +} + +/* simple bitstream parser, automatically skips over + * emulation_prevention_three_bytes. */ +typedef struct +{ + guint8 *data; + guint8 *end; + gint head; /* bitpos in the cache of next bit */ + guint64 cache; /* cached bytes */ +} GstNalBs; + +static void +gst_nal_bs_init (GstNalBs * bs, guint8 * data, guint size) +{ + bs->data = data; + bs->end = data + size; + bs->head = 0; + /* fill with something other than 0 to detect emulation prevention bytes */ + bs->cache = 0xffffffff; +} + +static guint32 +gst_nal_bs_read (GstNalBs * bs, guint n) +{ + guint32 res = 0; + gint shift; + + if (n == 0) + return res; + + /* fill up the cache if we need to */ + while (bs->head < n) { + guint8 byte; + gboolean check_three_byte; + + check_three_byte = TRUE; + next_byte: + if (bs->data >= bs->end) { + /* we're at the end, can't produce more than head number of bits */ + n = bs->head; + break; + } + /* get the byte, this can be an emulation_prevention_three_byte that we need + * to ignore. */ + byte = *bs->data++; + if (check_three_byte && byte == 0x03 && ((bs->cache & 0xffff) == 0)) { + /* next byte goes unconditionally to the cache, even if it's 0x03 */ + check_three_byte = FALSE; + goto next_byte; + } + /* shift bytes in cache, moving the head bits of the cache left */ + bs->cache = (bs->cache << 8) | byte; + bs->head += 8; + } + + /* bring the required bits down and truncate */ + if ((shift = bs->head - n) > 0) + res = bs->cache >> shift; + else + res = bs->cache; + + /* mask out required bits */ + if (n < 32) + res &= (1 << n) - 1; + + bs->head = shift; + + return res; +} + +static gboolean +gst_nal_bs_eos (GstNalBs * bs) +{ + return (bs->data >= bs->end) && (bs->head == 0); +} + +/* read unsigned Exp-Golomb code */ +static gint +gst_nal_bs_read_ue (GstNalBs * bs) +{ + gint i = 0; + + while (gst_nal_bs_read (bs, 1) == 0 && !gst_nal_bs_eos (bs) && i < 32) + i++; + + return ((1 << i) - 1 + gst_nal_bs_read (bs, i)); +} + GST_BOILERPLATE (GstH264Parse, gst_h264_parse, GstElement, GST_TYPE_ELEMENT); static void gst_h264_parse_finalize (GObject * object); +static void gst_h264_parse_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_h264_parse_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + static GstFlowReturn gst_h264_parse_chain (GstPad * pad, GstBuffer * buf); -static gboolean gst_h264_parse_handle_event (GstPad * pad, GstEvent * event); +static gboolean gst_h264_parse_sink_event (GstPad * pad, GstEvent * event); +static gboolean gst_h264_parse_sink_setcaps (GstPad * pad, GstCaps * caps); + +static GstStateChangeReturn gst_h264_parse_change_state (GstElement * element, + GstStateChange transition); static void gst_h264_parse_base_init (gpointer g_class) @@ -69,6 +241,46 @@ gst_h264_parse_base_init (gpointer g_class) } static void +gst_h264_parse_class_init (GstH264ParseClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *gstelement_class; + + gobject_class = G_OBJECT_CLASS (klass); + gstelement_class = (GstElementClass *) klass; + + gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_h264_parse_finalize); + gobject_class->set_property = gst_h264_parse_set_property; + gobject_class->get_property = gst_h264_parse_get_property; + + g_object_class_install_property (gobject_class, PROP_SPLIT_PACKETIZED, + g_param_spec_boolean ("split-packetized", "Split packetized", + "Split NAL units of packetized streams", DEFAULT_SPLIT_PACKETIZED, + G_PARAM_READWRITE)); + + gstelement_class->change_state = gst_h264_parse_change_state; +} + +static void +gst_h264_parse_init (GstH264Parse * h264parse, GstH264ParseClass * g_class) +{ + h264parse->sinkpad = gst_pad_new_from_static_template (&sinktemplate, "sink"); + gst_pad_set_chain_function (h264parse->sinkpad, + GST_DEBUG_FUNCPTR (gst_h264_parse_chain)); + gst_pad_set_event_function (h264parse->sinkpad, + GST_DEBUG_FUNCPTR (gst_h264_parse_sink_event)); + gst_pad_set_setcaps_function (h264parse->sinkpad, + GST_DEBUG_FUNCPTR (gst_h264_parse_sink_setcaps)); + gst_element_add_pad (GST_ELEMENT (h264parse), h264parse->sinkpad); + + h264parse->srcpad = gst_pad_new_from_static_template (&srctemplate, "src"); + gst_element_add_pad (GST_ELEMENT (h264parse), h264parse->srcpad); + + h264parse->split_packetized = DEFAULT_SPLIT_PACKETIZED; + h264parse->adapter = gst_adapter_new (); +} + +static void gst_h264_parse_finalize (GObject * object) { GstH264Parse *h264parse; @@ -81,59 +293,94 @@ gst_h264_parse_finalize (GObject * object) } static void -gst_h264_parse_class_init (GstH264ParseClass * klass) +gst_h264_parse_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) { - GObjectClass *gobject_class; + GstH264Parse *parse; - gobject_class = G_OBJECT_CLASS (klass); + parse = GST_H264PARSE (object); - gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_h264_parse_finalize); + switch (prop_id) { + case PROP_SPLIT_PACKETIZED: + parse->split_packetized = g_value_get_boolean (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } } static void -gst_h264_parse_init (GstH264Parse * h264parse, GstH264ParseClass * g_class) +gst_h264_parse_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) { - h264parse->sink = gst_pad_new_from_static_template (&sinktemplate, "sink"); - gst_pad_set_chain_function (h264parse->sink, - GST_DEBUG_FUNCPTR (gst_h264_parse_chain)); - gst_pad_set_event_function (h264parse->sink, - GST_DEBUG_FUNCPTR (gst_h264_parse_handle_event)); - gst_element_add_pad (GST_ELEMENT (h264parse), h264parse->sink); + GstH264Parse *parse; - h264parse->src = gst_pad_new_from_static_template (&srctemplate, "src"); - gst_element_add_pad (GST_ELEMENT (h264parse), h264parse->src); + parse = GST_H264PARSE (object); - h264parse->adapter = gst_adapter_new (); + switch (prop_id) { + case PROP_SPLIT_PACKETIZED: + g_value_set_boolean (value, parse->split_packetized); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } } -static GstFlowReturn -gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) +static gboolean +gst_h264_parse_sink_setcaps (GstPad * pad, GstCaps * caps) { - GstFlowReturn res = GST_FLOW_OK; + gboolean res; GstH264Parse *h264parse; + GstStructure *str; + const GValue *value; h264parse = GST_H264PARSE (GST_PAD_PARENT (pad)); - if (!GST_PAD_CAPS (h264parse->src)) { - GstCaps *caps; + str = gst_caps_get_structure (caps, 0); + + /* packetized video has a codec_data */ + if ((value = gst_structure_get_value (str, "codec_data"))) { + GST_DEBUG_OBJECT (h264parse, "have packetized h264"); + h264parse->packetized = TRUE; + /* FIXME, PPS, SPS have vital info for detecting new I-frames */ + } else { + GST_DEBUG_OBJECT (h264parse, "have bytestream h264"); + h264parse->packetized = FALSE; + } - /* Forward sink caps if possible */ - caps = GST_PAD_CAPS (h264parse->sink); - if (caps) - gst_caps_ref (caps); + /* forward the caps */ + res = gst_pad_set_caps (h264parse->srcpad, caps); - /* Set default caps if the sink caps were not negotiated */ - if (!caps) - caps = gst_caps_new_simple ("video/x-h264", NULL); + return res; +} - /* Set source caps */ - if (!gst_pad_set_caps (h264parse->src, caps)) { - GST_ELEMENT_ERROR (GST_ELEMENT (h264parse), - CORE, NEGOTIATION, (NULL), ("failed to set caps")); - gst_caps_unref (caps); - return GST_FLOW_ERROR; - } - gst_caps_unref (caps); +static void +gst_h264_parse_clear_queues (GstH264Parse * h264parse) +{ + g_list_foreach (h264parse->gather, (GFunc) gst_mini_object_unref, NULL); + g_list_free (h264parse->gather); + h264parse->gather = NULL; + while (h264parse->decode) { + gst_buffer_unref (h264parse->decode->buffer); + h264parse->decode = gst_nal_list_delete_head (h264parse->decode); + } + h264parse->decode = NULL; + gst_adapter_clear (h264parse->adapter); + h264parse->have_i_frame = FALSE; +} + +static GstFlowReturn +gst_h264_parse_chain_forward (GstH264Parse * h264parse, gboolean discont, + GstBuffer * buffer) +{ + GstFlowReturn res = GST_FLOW_OK; + const guint8 *data; + + if (discont) { + gst_adapter_clear (h264parse->adapter); + h264parse->discont = TRUE; } gst_adapter_push (h264parse->adapter, buffer); @@ -143,7 +390,6 @@ gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) gint next_nalu_pos = -1; guint32 nalu_size; gint avail; - const guint8 *data; avail = gst_adapter_available (h264parse->adapter); if (avail < 5) @@ -164,45 +410,416 @@ gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) } } } else { - /* Packetized format */ - if (nalu_size + 4 <= avail) - next_nalu_pos = nalu_size + 4; + /* Packetized format, see if we have to split it, usually splitting is not + * a good idea as decoders have no way of handling it. */ + if (h264parse->split_packetized) { + if (nalu_size + 4 <= avail) + next_nalu_pos = nalu_size + 4; + } else { + next_nalu_pos = avail; + } } - - /* Send packet */ + /* we have a packet */ if (next_nalu_pos > 0) { GstBuffer *outbuf; - outbuf = gst_buffer_new_and_alloc (next_nalu_pos); - memcpy (GST_BUFFER_DATA (outbuf), data, next_nalu_pos); - gst_adapter_flush (h264parse->adapter, next_nalu_pos); + outbuf = gst_adapter_take_buffer (h264parse->adapter, next_nalu_pos); + + GST_DEBUG_OBJECT (h264parse, + "pushing buffer %p, size %u, ts %" GST_TIME_FORMAT, outbuf, + next_nalu_pos, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf))); - gst_buffer_set_caps (outbuf, GST_PAD_CAPS (h264parse->src)); + if (h264parse->discont) { + GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT); + h264parse->discont = FALSE; + } + + gst_buffer_set_caps (outbuf, GST_PAD_CAPS (h264parse->srcpad)); GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buffer); - res = gst_pad_push (h264parse->src, outbuf); + res = gst_pad_push (h264parse->srcpad, outbuf); + } else { + /* NALU can not be parsed yet, we wait for more data in the adapter. */ + break; + } + } + return res; +} + +static GstFlowReturn +gst_h264_parse_flush_decode (GstH264Parse * h264parse) +{ + GstFlowReturn res = GST_FLOW_OK; + gboolean first = TRUE; + + while (h264parse->decode) { + GstNalList *link; + GstBuffer *buf; + + link = h264parse->decode; + buf = link->buffer; + + GST_DEBUG_OBJECT (h264parse, "have type: %d, I frame: %d", link->nal_type, + link->i_frame); + + if (first) { + /* first buffer has discont */ + GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT); + first = FALSE; } else { - break; /* NALU can not be parsed yet */ + /* next buffers are not discont */ + GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT); } + + GST_DEBUG_OBJECT (h264parse, "pushing buffer %p, ts %" GST_TIME_FORMAT, + buf, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf))); + + res = gst_pad_push (h264parse->srcpad, buf); + + h264parse->decode = gst_nal_list_delete_head (h264parse->decode); } + /* the i frame is gone now */ + h264parse->have_i_frame = FALSE; + + return res; +} + +/* check that the decode queue contains a valid sync code that should be pushed + * out before adding @buffer to the decode queue */ +static GstFlowReturn +gst_h264_parse_queue_buffer (GstH264Parse * parse, GstBuffer * buffer) +{ + guint8 *data; + guint size; + guint32 nalu_size; + GstNalBs bs; + GstNalList *link; + GstFlowReturn res = GST_FLOW_OK; + + /* create new NALU link */ + link = gst_nal_list_new (buffer); + + /* first parse the buffer */ + data = GST_BUFFER_DATA (buffer); + size = GST_BUFFER_SIZE (buffer); + + link->slice = FALSE; + link->i_frame = FALSE; + + GST_DEBUG_OBJECT (parse, "analyse buffer of size %u", size); + + /* now parse all the NAL units in this buffer, for bytestream we only have one + * NAL unit but for packetized streams we can have multiple ones */ + while (size >= 5) { + nalu_size = (data[0] << 24) + + (data[1] << 16) + (data[2] << 8) + data[3]; + + link->nal_ref_idc = (data[4] & 0x60) >> 5; + link->nal_type = (data[4] & 0x1f); + + GST_DEBUG_OBJECT (parse, "size: %u, NAL type: %d, ref_idc: %d", + nalu_size, link->nal_type, link->nal_ref_idc); + + /* first parse some things needed to get to the frame type */ + if (link->nal_type >= NAL_SLICE && link->nal_type <= NAL_SLICE_IDR) { + gst_nal_bs_init (&bs, data + 5, size - 5); + + link->first_mb_in_slice = gst_nal_bs_read_ue (&bs); + link->slice_type = gst_nal_bs_read_ue (&bs); + link->slice = TRUE; + + GST_DEBUG_OBJECT (parse, "first MB: %d, slice type: %d", + link->first_mb_in_slice, link->slice_type); + + switch (link->slice_type) { + case 0: + case 5: + case 3: + case 8: /* SP */ + /* P frames */ + GST_DEBUG_OBJECT (parse, "we have a P slice"); + break; + case 1: + case 6: + /* B frames */ + GST_DEBUG_OBJECT (parse, "we have a B slice"); + break; + case 2: + case 7: + case 4: + case 9: + /* I frames */ + GST_DEBUG_OBJECT (parse, "we have an I slice"); + link->i_frame = TRUE; + break; + } + } + /* bytestream, we can exit now */ + if (nalu_size == 1) + break; + + /* packetized format, continue parsing all packets, skip size */ + nalu_size += 4; + data += nalu_size; + size -= nalu_size; + } + + /* we have an I frame in the queue, this new NAL unit is a slice but not + * an I frame, output the decode queue */ + GST_DEBUG_OBJECT (parse, "have_I_frame: %d, I_frame: %d, slice: %d", + parse->have_i_frame, link->i_frame, link->slice); + if (parse->have_i_frame && !link->i_frame && link->slice) { + GST_DEBUG_OBJECT (parse, "flushing decode queue"); + res = gst_h264_parse_flush_decode (parse); + } + if (link->i_frame) + /* we're going to add a new I-frame in the queue */ + parse->have_i_frame = TRUE; + + GST_DEBUG_OBJECT (parse, "copy %d bytes of NAL to decode queue", size); + parse->decode = gst_nal_list_prepend_link (parse->decode, link); + + return res; +} + +static guint +gst_h264_parse_find_start_reverse (GstH264Parse * parse, guint8 * data, + guint size, guint32 * code) +{ + guint32 search = *code; + + while (size > 0) { + /* the sync code is kept in reverse */ + search = (search << 8) | (data[size - 1]); + GST_DEBUG_OBJECT (parse, "start code 0x%08x", search); + if (search == 0x01000000) + break; + + size--; + } + *code = search; + + return size - 1; +} + +static GstFlowReturn +gst_h264_parse_chain_reverse (GstH264Parse * h264parse, gboolean discont, + GstBuffer * buffer) +{ + GstFlowReturn res = GST_FLOW_OK; + + /* if we have a discont, move buffers to the decode list */ + if (G_UNLIKELY (discont)) { + guint start, stop, last; + guint32 code; + GstBuffer *prev; + + GST_DEBUG_OBJECT (h264parse, + "received discont, copy gathered buffers for decoding"); + + /* init start code accumulator */ + stop = -1; + prev = NULL; + + while (h264parse->gather) { + GstBuffer *gbuf; + guint8 *data; + + /* get new buffer and init the start code search to the end position */ + gbuf = GST_BUFFER_CAST (h264parse->gather->data); + + /* remove from the gather list, they are in reverse order */ + h264parse->gather = + g_list_delete_link (h264parse->gather, h264parse->gather); + + if (h264parse->packetized) { + /* packetized the packets are already split, we can just parse and + * store them */ + GST_DEBUG_OBJECT (h264parse, "copied packetized buffer"); + res = gst_h264_parse_queue_buffer (h264parse, gbuf); + } else { + /* bytestream, we have to split the NALUs on the sync markers */ + code = 0xffffffff; + if (prev) { + /* if we have a previous buffer or a leftover, merge them together + * now */ + gbuf = gst_buffer_join (gbuf, prev); + prev = NULL; + } + last = GST_BUFFER_SIZE (gbuf); + data = GST_BUFFER_DATA (gbuf); + + while (last > 0) { + /* find a start code searching backwards in this buffer */ + start = + gst_h264_parse_find_start_reverse (h264parse, data, last, &code); + GST_DEBUG_OBJECT (h264parse, "found start %d", start); + + if (start != -1) { + GstBuffer *decode; + + /* we found a start code, copy everything starting from it to the + * decode queue. */ + if (start != 0) + decode = gst_buffer_create_sub (gbuf, start, last - start); + else + decode = gbuf; + + /* see what we have here */ + res = gst_h264_parse_queue_buffer (h264parse, decode); + } else { + /* no start code found, keep the buffer and merge with potential next + * buffer. */ + GST_DEBUG_OBJECT (h264parse, "keeping buffer"); + prev = gst_buffer_create_sub (gbuf, 0, last); + gst_buffer_unref (gbuf); + } + last = start; + } + } + } + } + if (buffer) { + /* add buffer to gather queue */ + GST_DEBUG_OBJECT (h264parse, "gathering buffer %p, size %u", buffer, + GST_BUFFER_SIZE (buffer)); + h264parse->gather = g_list_prepend (h264parse->gather, buffer); + } return res; } +static GstFlowReturn +gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) +{ + GstFlowReturn res; + GstH264Parse *h264parse; + gboolean discont; + GstCaps *caps; + + h264parse = GST_H264PARSE (GST_PAD_PARENT (pad)); + + if (!GST_PAD_CAPS (h264parse->srcpad)) { + /* Set default caps if the sink caps were not negotiated, this is when we + * are reading from a file or so */ + caps = gst_caps_new_simple ("video/x-h264", NULL); + + /* Set source caps */ + if (!gst_pad_set_caps (h264parse->srcpad, caps)) + goto caps_failed; + + /* we assume the bytestream format but won't really fail otherwise if the + * data turns out to be a nicely aligned packetized format (except we don't + * do the codec_data caps with the PPS and SPS). */ + h264parse->packetized = FALSE; + + gst_caps_unref (caps); + } + + discont = GST_BUFFER_IS_DISCONT (buffer); + + GST_DEBUG_OBJECT (h264parse, "received buffer"); + + if (h264parse->segment.rate > 0.0) + res = gst_h264_parse_chain_forward (h264parse, discont, buffer); + else + res = gst_h264_parse_chain_reverse (h264parse, discont, buffer); + + return res; + + /* ERRORS */ +caps_failed: + { + GST_ELEMENT_ERROR (GST_ELEMENT (h264parse), + CORE, NEGOTIATION, (NULL), ("failed to set caps")); + gst_caps_unref (caps); + return GST_FLOW_ERROR; + } +} static gboolean -gst_h264_parse_handle_event (GstPad * pad, GstEvent * event) +gst_h264_parse_sink_event (GstPad * pad, GstEvent * event) { GstH264Parse *h264parse; gboolean res; h264parse = GST_H264PARSE (gst_pad_get_parent (pad)); - res = gst_pad_event_default (pad, event); + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_FLUSH_STOP: + GST_DEBUG_OBJECT (h264parse, "received FLUSH stop"); + gst_segment_init (&h264parse->segment, GST_FORMAT_UNDEFINED); + gst_h264_parse_clear_queues (h264parse); + res = gst_pad_push_event (h264parse->srcpad, event); + break; + case GST_EVENT_EOS: + GST_DEBUG_OBJECT (h264parse, "received EOS"); + if (h264parse->segment.rate < 0.0) { + gst_h264_parse_chain_reverse (h264parse, TRUE, NULL); + gst_h264_parse_flush_decode (h264parse); + } + res = gst_pad_push_event (h264parse->srcpad, event); + break; + case GST_EVENT_NEWSEGMENT: + { + gdouble rate, applied_rate; + GstFormat format; + gint64 start, stop, pos; + gboolean update; + + gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, + &format, &start, &stop, &pos); + + /* now configure the values */ + gst_segment_set_newsegment_full (&h264parse->segment, update, + rate, applied_rate, format, start, stop, pos); + + GST_DEBUG_OBJECT (h264parse, + "Pushing newseg rate %g, applied rate %g, format %d, start %" + G_GINT64_FORMAT ", stop %" G_GINT64_FORMAT ", pos %" G_GINT64_FORMAT, + rate, applied_rate, format, start, stop, pos); + + res = gst_pad_push_event (h264parse->srcpad, event); + break; + } + default: + res = gst_pad_push_event (h264parse->srcpad, event); + break; + } gst_object_unref (h264parse); + return res; } +static GstStateChangeReturn +gst_h264_parse_change_state (GstElement * element, GstStateChange transition) +{ + GstH264Parse *h264parse; + GstStateChangeReturn ret; + + h264parse = GST_H264PARSE (element); + + switch (transition) { + case GST_STATE_CHANGE_READY_TO_PAUSED: + gst_segment_init (&h264parse->segment, GST_FORMAT_UNDEFINED); + break; + default: + break; + } + + ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + gst_h264_parse_clear_queues (h264parse); + break; + default: + break; + } + + return ret; +} + static gboolean plugin_init (GstPlugin * plugin) diff --git a/gst/h264parse/gsth264parse.h b/gst/h264parse/gsth264parse.h index 8f283be9..8aed514c 100644 --- a/gst/h264parse/gsth264parse.h +++ b/gst/h264parse/gsth264parse.h @@ -42,12 +42,27 @@ G_BEGIN_DECLS typedef struct _GstH264Parse GstH264Parse; typedef struct _GstH264ParseClass GstH264ParseClass; +typedef struct _GstNalList GstNalList; + struct _GstH264Parse { GstElement element; - GstPad *sink; - GstPad *src; + GstPad *sinkpad; + GstPad *srcpad; + + gboolean split_packetized; + + GstSegment segment; + gboolean packetized; + gboolean discont; + + /* gather/decode queues for reverse playback */ + GList *gather; + GstNalList *decode; + gboolean have_sps; + gboolean have_pps; + gboolean have_i_frame; GstAdapter *adapter; }; |