diff --git a/configure.ac b/configure.ac index 6b760b76ce..f8d71a3ca5 100644 --- a/configure.ac +++ b/configure.ac @@ -302,7 +302,7 @@ GST_PLUGINS_NONPORTED=" adpcmdec adpcmenc aiff asfmux \ mpegpsmux mpegvideoparse mve mxf mythtv nsf nuvdemux \ patchdetect pcapparse pnm rawparse real removesilence rtpmux rtpvp8 scaletempo \ sdi segmentclip siren speed subenc stereo tta videofilters \ - videomaxrate videomeasure videoparsers videosignal vmnc \ + videomaxrate videomeasure videosignal vmnc \ decklink fbdev linsys shm vcd \ voaacenc apexsink bz2 camerabin2 cdaudio celt cog curl dc1394 dirac directfb dts resindvd \ gsettings gsm jp2k ladspa modplug mpeg2enc mplex mimic \ diff --git a/gst/videoparsers/gstdiracparse.c b/gst/videoparsers/gstdiracparse.c index ef99b7ae90..72801ae308 100644 --- a/gst/videoparsers/gstdiracparse.c +++ b/gst/videoparsers/gstdiracparse.c @@ -95,13 +95,20 @@ GST_STATIC_PAD_TEMPLATE ("src", /* class initialization */ -GST_BOILERPLATE (GstDiracParse, gst_dirac_parse, GstBaseParse, - GST_TYPE_BASE_PARSE); +#define parent_class gst_dirac_parse_parent_class +G_DEFINE_TYPE (GstDiracParse, gst_dirac_parse, GST_TYPE_BASE_PARSE); static void -gst_dirac_parse_base_init (gpointer g_class) +gst_dirac_parse_class_init (GstDiracParseClass * klass) { - GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + GstBaseParseClass *base_parse_class = GST_BASE_PARSE_CLASS (klass); + + gobject_class->set_property = gst_dirac_parse_set_property; + gobject_class->get_property = gst_dirac_parse_get_property; + gobject_class->dispose = gst_dirac_parse_dispose; + gobject_class->finalize = gst_dirac_parse_finalize; gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&gst_dirac_parse_src_template)); @@ -111,18 +118,7 @@ gst_dirac_parse_base_init (gpointer g_class) gst_element_class_set_details_simple (element_class, "Dirac parser", "Codec/Parser/Video", "Parses Dirac streams", "David Schleef "); -} -static void -gst_dirac_parse_class_init (GstDiracParseClass * klass) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS (klass); - GstBaseParseClass *base_parse_class = GST_BASE_PARSE_CLASS (klass); - - gobject_class->set_property = gst_dirac_parse_set_property; - gobject_class->get_property = gst_dirac_parse_get_property; - gobject_class->dispose = gst_dirac_parse_dispose; - gobject_class->finalize = gst_dirac_parse_finalize; base_parse_class->start = GST_DEBUG_FUNCPTR (gst_dirac_parse_start); base_parse_class->stop = GST_DEBUG_FUNCPTR (gst_dirac_parse_stop); base_parse_class->set_sink_caps = @@ -140,11 +136,9 @@ gst_dirac_parse_class_init (GstDiracParseClass * klass) } static void -gst_dirac_parse_init (GstDiracParse * diracparse, - GstDiracParseClass * diracparse_class) +gst_dirac_parse_init (GstDiracParse * diracparse) { gst_base_parse_set_min_frame_size (GST_BASE_PARSE (diracparse), 13); - } void @@ -219,37 +213,38 @@ static gboolean gst_dirac_parse_check_valid_frame (GstBaseParse * parse, GstBaseParseFrame * frame, guint * framesize, gint * skipsize) { - GstByteReader reader = GST_BYTE_READER_INIT_FROM_BUFFER (frame->buffer); int off; guint32 next_header; guint8 *data; - int size; + gsize size; gboolean have_picture = FALSE; int offset; - data = GST_BUFFER_DATA (frame->buffer); - size = GST_BUFFER_SIZE (frame->buffer); + data = gst_buffer_map (frame->buffer, &size, NULL, GST_MAP_READ); if (G_UNLIKELY (size < 13)) - return FALSE; + goto out; GST_DEBUG ("%d: %02x %02x %02x %02x", size, data[0], data[1], data[2], data[3]); if (GST_READ_UINT32_BE (data) != 0x42424344) { + GstByteReader reader; + + gst_byte_reader_init (&reader, data, size); off = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff, - 0x42424344, 0, GST_BUFFER_SIZE (frame->buffer)); + 0x42424344, 0, size); if (off < 0) { - *skipsize = GST_BUFFER_SIZE (frame->buffer) - 3; - return FALSE; + *skipsize = size - 3; + goto out; } GST_LOG_OBJECT (parse, "possible sync at buffer offset %d", off); GST_DEBUG ("skipping %d", off); *skipsize = off; - return FALSE; + goto out; } /* have sync, parse chunks */ @@ -260,7 +255,7 @@ gst_dirac_parse_check_valid_frame (GstBaseParse * parse, if (offset + 13 >= size) { *framesize = offset + 13; - return FALSE; + goto out; } GST_DEBUG ("chunk type %02x", data[offset + 4]); @@ -268,7 +263,7 @@ gst_dirac_parse_check_valid_frame (GstBaseParse * parse, if (GST_READ_UINT32_BE (data + offset) != 0x42424344) { GST_DEBUG ("bad header"); *skipsize = 3; - return FALSE; + goto out; } next_header = GST_READ_UINT32_BE (data + offset + 5); @@ -283,14 +278,20 @@ gst_dirac_parse_check_valid_frame (GstBaseParse * parse, offset += next_header; if (offset >= size) { *framesize = offset; - return FALSE; + goto out; } } + gst_buffer_unmap (frame->buffer, data, size); + *framesize = offset; GST_DEBUG ("framesize %d", *framesize); return TRUE; + +out: + gst_buffer_unmap (frame->buffer, data, size); + return FALSE; } static GstFlowReturn @@ -298,14 +299,13 @@ gst_dirac_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame) { GstDiracParse *diracparse = GST_DIRAC_PARSE (parse); guint8 *data; - int size; + gsize size; /* Called when processing incoming buffers. Function should parse a checked frame. */ /* MUST implement */ - data = GST_BUFFER_DATA (frame->buffer); - size = GST_BUFFER_SIZE (frame->buffer); + data = gst_buffer_map (frame->buffer, &size, NULL, GST_MAP_READ); //GST_ERROR("got here %d", size); @@ -339,8 +339,7 @@ gst_dirac_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame) } } - gst_buffer_set_caps (frame->buffer, - GST_PAD_CAPS (GST_BASE_PARSE_SRC_PAD (parse))); + gst_buffer_unmap (frame->buffer, data, size); gst_base_parse_set_min_frame_size (parse, 13); diff --git a/gst/videoparsers/gsth263parse.c b/gst/videoparsers/gsth263parse.c index 4a5633f3bc..14e8ef6880 100644 --- a/gst/videoparsers/gsth263parse.c +++ b/gst/videoparsers/gsth263parse.c @@ -48,7 +48,7 @@ GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_STATIC_CAPS ("video/x-h263, variant = (string) itu") ); -GST_BOILERPLATE (GstH263Parse, gst_h263_parse, GstElement, GST_TYPE_BASE_PARSE); +G_DEFINE_TYPE (GstH263Parse, gst_h263_parse, GST_TYPE_BASE_PARSE); static gboolean gst_h263_parse_start (GstBaseParse * parse); static gboolean gst_h263_parse_stop (GstBaseParse * parse); @@ -60,9 +60,12 @@ static GstFlowReturn gst_h263_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame); static void -gst_h263_parse_base_init (gpointer g_class) +gst_h263_parse_class_init (GstH263ParseClass * klass) { - GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class); + GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass); + GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass); + + GST_DEBUG_CATEGORY_INIT (h263_parse_debug, "h263parse", 0, "h263 parser"); gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&srctemplate)); @@ -74,14 +77,6 @@ gst_h263_parse_base_init (gpointer g_class) "Arun Raghavan ," "Edward Hervey "); - GST_DEBUG_CATEGORY_INIT (h263_parse_debug, "h263parse", 0, "h263 parser"); -} - -static void -gst_h263_parse_class_init (GstH263ParseClass * klass) -{ - GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass); - /* Override BaseParse vfuncs */ parse_class->start = GST_DEBUG_FUNCPTR (gst_h263_parse_start); parse_class->stop = GST_DEBUG_FUNCPTR (gst_h263_parse_stop); @@ -92,7 +87,7 @@ gst_h263_parse_class_init (GstH263ParseClass * klass) } static void -gst_h263_parse_init (GstH263Parse * h263parse, GstH263ParseClass * g_class) +gst_h263_parse_init (GstH263Parse * h263parse) { } @@ -153,10 +148,13 @@ gst_h263_parse_sink_event (GstBaseParse * parse, GstEvent * event) static guint find_psc (GstBuffer * buffer, guint skip) { + guint8 *buf_data; + gsize buf_size; GstByteReader br; guint psc_pos = -1, psc; - gst_byte_reader_init_from_buffer (&br, buffer); + buf_data = gst_buffer_map (buffer, &buf_size, NULL, GST_MAP_READ); + gst_byte_reader_init (&br, buf_data, buf_size); if (!gst_byte_reader_set_pos (&br, skip)) goto out; @@ -174,6 +172,7 @@ find_psc (GstBuffer * buffer, guint skip) } out: + gst_buffer_unmap (buffer, buf_data, buf_size); return psc_pos; } @@ -187,16 +186,16 @@ gst_h263_parse_set_src_caps (GstH263Parse * h263parse, g_assert (h263parse->state == PASSTHROUGH || h263parse->state == GOT_HEADER); - caps = GST_PAD_CAPS (GST_BASE_PARSE_SINK_PAD (h263parse)); + caps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (h263parse)); if (caps) { - caps = gst_caps_copy (caps); + caps = gst_caps_make_writable (caps); } else { caps = gst_caps_new_simple ("video/x-h263", "variant", G_TYPE_STRING, "itu", NULL); } gst_caps_set_simple (caps, "parsed", G_TYPE_BOOLEAN, TRUE, NULL); - sink_caps = GST_PAD_CAPS (GST_BASE_PARSE_SINK_PAD (h263parse)); + sink_caps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (h263parse)); if (sink_caps && (st = gst_caps_get_structure (sink_caps, 0)) && gst_structure_get_fraction (st, "framerate", &fr_num, &fr_denom)) { /* Got it in caps - nothing more to do */ @@ -253,19 +252,21 @@ gst_h263_parse_check_valid_frame (GstBaseParse * parse, GstH263Parse *h263parse; GstBuffer *buffer; guint psc_pos, next_psc_pos; + gsize size; h263parse = GST_H263_PARSE (parse); buffer = frame->buffer; + size = gst_buffer_get_size (buffer); - if (GST_BUFFER_SIZE (buffer) < 3) + if (size < 3) return FALSE; psc_pos = find_psc (buffer, 0); if (psc_pos == -1) { /* PSC not found, need more data */ - if (GST_BUFFER_SIZE (buffer) > 3) - psc_pos = GST_BUFFER_SIZE (buffer) - 3; + if (size > 3) + psc_pos = size - 3; else psc_pos = 0; goto more; @@ -278,7 +279,7 @@ gst_h263_parse_check_valid_frame (GstBaseParse * parse, if (next_psc_pos == -1) { if (GST_BASE_PARSE_DRAINING (parse)) /* FLUSH/EOS, it's okay if we can't find the next frame */ - next_psc_pos = GST_BUFFER_SIZE (buffer); + next_psc_pos = size; else goto more; } @@ -347,9 +348,6 @@ gst_h263_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame) /* h263parse->state is now GOT_HEADER */ - gst_buffer_set_caps (buffer, - GST_PAD_CAPS (GST_BASE_PARSE_SRC_PAD (GST_BASE_PARSE (h263parse)))); - if (gst_h263_parse_is_delta_unit (¶ms)) GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DELTA_UNIT); else diff --git a/gst/videoparsers/gsth264parse.c b/gst/videoparsers/gsth264parse.c index 241b92da36..6dc02d1eec 100644 --- a/gst/videoparsers/gsth264parse.c +++ b/gst/videoparsers/gsth264parse.c @@ -71,8 +71,8 @@ static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src", "stream-format=(string) { avc, byte-stream }, " "alignment=(string) { au, nal }")); -GST_BOILERPLATE (GstH264Parse, gst_h264_parse, GstBaseParse, - GST_TYPE_BASE_PARSE); +#define parent_class gst_h264_parse_parent_class +G_DEFINE_TYPE (GstH264Parse, gst_h264_parse, GST_TYPE_BASE_PARSE); static void gst_h264_parse_finalize (GObject * object); @@ -91,32 +91,19 @@ static void gst_h264_parse_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static gboolean gst_h264_parse_set_caps (GstBaseParse * parse, GstCaps * caps); -static GstCaps *gst_h264_parse_get_caps (GstBaseParse * parse); -static GstFlowReturn gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer); - -static void -gst_h264_parse_base_init (gpointer g_class) -{ - GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class); - - gst_element_class_add_pad_template (gstelement_class, - gst_static_pad_template_get (&srctemplate)); - gst_element_class_add_pad_template (gstelement_class, - gst_static_pad_template_get (&sinktemplate)); - - gst_element_class_set_details_simple (gstelement_class, "H.264 parser", - "Codec/Parser/Converter/Video", - "Parses H.264 streams", - "Mark Nauwelaerts "); - - GST_DEBUG_CATEGORY_INIT (h264_parse_debug, "h264parse", 0, "h264 parser"); -} +static GstCaps *gst_h264_parse_get_caps (GstBaseParse * parse, + GstCaps * filter); +static GstFlowReturn gst_h264_parse_chain (GstPad * pad, GstObject * parent, + GstBuffer * buffer); static void gst_h264_parse_class_init (GstH264ParseClass * klass) { GObjectClass *gobject_class = (GObjectClass *) klass; GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass); + GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass); + + GST_DEBUG_CATEGORY_INIT (h264_parse_debug, "h264parse", 0, "h264 parser"); gobject_class->finalize = gst_h264_parse_finalize; gobject_class->set_property = gst_h264_parse_set_property; @@ -140,10 +127,20 @@ gst_h264_parse_class_init (GstH264ParseClass * klass) GST_DEBUG_FUNCPTR (gst_h264_parse_pre_push_frame); parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_h264_parse_set_caps); parse_class->get_sink_caps = GST_DEBUG_FUNCPTR (gst_h264_parse_get_caps); + + gst_element_class_add_pad_template (gstelement_class, + gst_static_pad_template_get (&srctemplate)); + gst_element_class_add_pad_template (gstelement_class, + gst_static_pad_template_get (&sinktemplate)); + + gst_element_class_set_details_simple (gstelement_class, "H.264 parser", + "Codec/Parser/Converter/Video", + "Parses H.264 streams", + "Mark Nauwelaerts "); } static void -gst_h264_parse_init (GstH264Parse * h264parse, GstH264ParseClass * g_class) +gst_h264_parse_init (GstH264Parse * h264parse) { h264parse->frame_out = gst_adapter_new (); @@ -340,22 +337,23 @@ gst_h264_parse_wrap_nal (GstH264Parse * h264parse, guint format, guint8 * data, { GstBuffer *buf; guint nl = h264parse->nal_length_size; + guint32 tmp; GST_DEBUG_OBJECT (h264parse, "nal length %d", size); - buf = gst_buffer_new_and_alloc (size + nl + 4); + buf = gst_buffer_new_allocate (NULL, nl + size, 0); if (format == GST_H264_PARSE_FORMAT_AVC) { - GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf), size << (32 - 8 * nl)); + tmp = GUINT32_TO_BE (size << (32 - 8 * nl)); } else { /* HACK: nl should always be 4 here, otherwise this won't work. * There are legit cases where nl in avc stream is 2, but byte-stream * SC is still always 4 bytes. */ nl = 4; - GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf), 1); + tmp = GUINT32_TO_BE (1); } - GST_BUFFER_SIZE (buf) = size + nl; - memcpy (GST_BUFFER_DATA (buf) + nl, data, size); + gst_buffer_fill (buf, 0, &tmp, sizeof (guint32)); + gst_buffer_fill (buf, nl, data, size); return buf; } @@ -383,8 +381,8 @@ gst_h264_parser_store_nal (GstH264Parse * h264parse, guint id, return; } - buf = gst_buffer_new_and_alloc (size); - memcpy (GST_BUFFER_DATA (buf), nalu->data + nalu->offset, size); + buf = gst_buffer_new_allocate (NULL, size, 0); + gst_buffer_fill (buf, 0, nalu->data + nalu->offset, size); if (store[id]) gst_buffer_unref (store[id]); @@ -592,14 +590,19 @@ gst_h264_parse_check_valid_frame (GstBaseParse * parse, GstH264Parse *h264parse = GST_H264_PARSE (parse); GstBuffer *buffer = frame->buffer; guint8 *data; - guint size, current_off = 0; + gsize size; + guint current_off = 0; gboolean drain; GstH264NalParser *nalparser = h264parse->nalparser; GstH264NalUnit nalu = h264parse->nalu; + data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ); + /* expect at least 3 bytes startcode == sc, and 2 bytes NALU payload */ - if (G_UNLIKELY (GST_BUFFER_SIZE (buffer) < 5)) + if (G_UNLIKELY (size < 5)) { + gst_buffer_unmap (buffer, data, size); return FALSE; + } /* need to configure aggregation */ if (G_UNLIKELY (h264parse->format == GST_H264_PARSE_FORMAT_NONE)) @@ -614,9 +617,6 @@ gst_h264_parse_check_valid_frame (GstBaseParse * parse, GST_LOG_OBJECT (h264parse, "resuming frame parsing"); } - data = GST_BUFFER_DATA (buffer); - size = GST_BUFFER_SIZE (buffer); - drain = FALSE; current_off = h264parse->current_off; @@ -645,7 +645,7 @@ gst_h264_parse_check_valid_frame (GstBaseParse * parse, } break; case GST_H264_PARSER_BROKEN_LINK: - return FALSE; + goto out; case GST_H264_PARSER_ERROR: current_off = size - 3; goto parsing_error; @@ -711,6 +711,7 @@ end: *framesize = nalu.offset + nalu.size - h264parse->nalu.sc_offset; h264parse->current_off = current_off; + gst_buffer_unmap (buffer, data, size); return TRUE; parsing_error: @@ -733,11 +734,14 @@ more: /* Restart parsing from here next time */ h264parse->current_off = current_off; + /* Fall-through. */ +out: + gst_buffer_unmap (buffer, data, size); return FALSE; invalid: gst_h264_parse_reset_frame (h264parse); - return FALSE; + goto out; } /* byte together avc codec data based on collected pps and sps so far */ @@ -748,20 +752,23 @@ gst_h264_parse_make_codec_data (GstH264Parse * h264parse) gint i, sps_size = 0, pps_size = 0, num_sps = 0, num_pps = 0; guint8 profile_idc = 0, profile_comp = 0, level_idc = 0; gboolean found = FALSE; - guint8 *data; + guint8 *buf_data, *data; /* only nal payload in stored nals */ for (i = 0; i < GST_H264_MAX_SPS_COUNT; i++) { if ((nal = h264parse->sps_nals[i])) { + gsize size = gst_buffer_get_size (nal); num_sps++; /* size bytes also count */ - sps_size += GST_BUFFER_SIZE (nal) + 2; - if (GST_BUFFER_SIZE (nal) >= 4) { + sps_size += size + 2; + if (size >= 4) { + guint8 tmp[3]; found = TRUE; - profile_idc = (GST_BUFFER_DATA (nal))[1]; - profile_comp = (GST_BUFFER_DATA (nal))[2]; - level_idc = (GST_BUFFER_DATA (nal))[3]; + gst_buffer_extract (nal, 1, tmp, 3); + profile_idc = tmp[0]; + profile_comp = tmp[1]; + level_idc = tmp[2]; } } } @@ -769,7 +776,7 @@ gst_h264_parse_make_codec_data (GstH264Parse * h264parse) if ((nal = h264parse->pps_nals[i])) { num_pps++; /* size bytes also count */ - pps_size += GST_BUFFER_SIZE (nal) + 2; + pps_size += gst_buffer_get_size (nal) + 2; } } @@ -779,8 +786,9 @@ gst_h264_parse_make_codec_data (GstH264Parse * h264parse) if (!found || !num_pps) return NULL; - buf = gst_buffer_new_and_alloc (5 + 1 + sps_size + 1 + pps_size); - data = GST_BUFFER_DATA (buf); + buf = gst_buffer_new_allocate (NULL, 5 + 1 + sps_size + 1 + pps_size, 0); + buf_data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE); + data = buf_data; data[0] = 1; /* AVC Decoder Configuration Record ver. 1 */ data[1] = profile_idc; /* profile_idc */ @@ -792,9 +800,10 @@ gst_h264_parse_make_codec_data (GstH264Parse * h264parse) data += 6; for (i = 0; i < GST_H264_MAX_SPS_COUNT; i++) { if ((nal = h264parse->sps_nals[i])) { - GST_WRITE_UINT16_BE (data, GST_BUFFER_SIZE (nal)); - memcpy (data + 2, GST_BUFFER_DATA (nal), GST_BUFFER_SIZE (nal)); - data += 2 + GST_BUFFER_SIZE (nal); + gsize nal_size = gst_buffer_get_size (nal); + GST_WRITE_UINT16_BE (data, nal_size); + gst_buffer_extract (nal, 0, data + 2, nal_size); + data += 2 + nal_size; } } @@ -802,12 +811,15 @@ gst_h264_parse_make_codec_data (GstH264Parse * h264parse) data++; for (i = 0; i < GST_H264_MAX_PPS_COUNT; i++) { if ((nal = h264parse->pps_nals[i])) { - GST_WRITE_UINT16_BE (data, GST_BUFFER_SIZE (nal)); - memcpy (data + 2, GST_BUFFER_DATA (nal), GST_BUFFER_SIZE (nal)); - data += 2 + GST_BUFFER_SIZE (nal); + gsize nal_size = gst_buffer_get_size (nal); + GST_WRITE_UINT16_BE (data, nal_size); + gst_buffer_extract (nal, 0, data + 2, nal_size); + data += 2 + nal_size; } } + gst_buffer_unmap (buf, buf_data, -1); + return buf; } @@ -819,7 +831,8 @@ gst_h264_parse_update_src_caps (GstH264Parse * h264parse, GstCaps * caps) gboolean modified = FALSE; GstBuffer *buf = NULL; - if (G_UNLIKELY (!GST_PAD_CAPS (GST_BASE_PARSE_SRC_PAD (h264parse)))) + if (G_UNLIKELY (!gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD + (h264parse)))) modified = TRUE; else if (G_UNLIKELY (!h264parse->update_caps)) return; @@ -829,13 +842,11 @@ gst_h264_parse_update_src_caps (GstH264Parse * h264parse, GstCaps * caps) if (caps) sink_caps = caps; else - sink_caps = GST_PAD_CAPS (GST_BASE_PARSE_SINK_PAD (h264parse)); + sink_caps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (h264parse)); /* carry over input caps as much as possible; override with our own stuff */ - if (sink_caps) - gst_caps_ref (sink_caps); - else - sink_caps = gst_caps_new_simple ("video/x-h264", NULL); + if (!sink_caps) + sink_caps = gst_caps_new_empty_simple ("video/x-h264"); sps = h264parse->nalparser->last_sps; GST_DEBUG_OBJECT (h264parse, "sps: %p", sps); @@ -845,10 +856,15 @@ gst_h264_parse_update_src_caps (GstH264Parse * h264parse, GstCaps * caps) h264parse->align == GST_H264_PARSE_ALIGN_AU) { buf = gst_h264_parse_make_codec_data (h264parse); if (buf && h264parse->codec_data) { - if (GST_BUFFER_SIZE (buf) != GST_BUFFER_SIZE (h264parse->codec_data) || - memcmp (GST_BUFFER_DATA (buf), - GST_BUFFER_DATA (h264parse->codec_data), GST_BUFFER_SIZE (buf))) + gsize size; + gpointer data; + + data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ); + if (size != gst_buffer_get_size (h264parse->codec_data) || + gst_buffer_memcmp (h264parse->codec_data, 0, data, size)) modified = TRUE; + + gst_buffer_unmap (buf, data, size); } else { if (h264parse->codec_data) buf = gst_buffer_ref (h264parse->codec_data); @@ -1061,7 +1077,7 @@ gst_h264_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame) GstBuffer *buf; buf = gst_adapter_take_buffer (h264parse->frame_out, av); - gst_buffer_copy_metadata (buf, buffer, GST_BUFFER_COPY_ALL); + gst_buffer_copy_into (buf, buffer, GST_BUFFER_COPY_METADATA, 0, -1); gst_buffer_replace (&frame->buffer, buf); gst_buffer_unref (buf); } @@ -1075,14 +1091,16 @@ static GstFlowReturn gst_h264_parse_push_codec_buffer (GstH264Parse * h264parse, GstBuffer * nal, GstClockTime ts) { - nal = gst_h264_parse_wrap_nal (h264parse, h264parse->format, - GST_BUFFER_DATA (nal), GST_BUFFER_SIZE (nal)); + gpointer data; + gsize size; + + data = gst_buffer_map (nal, &size, NULL, GST_MAP_READ); + nal = gst_h264_parse_wrap_nal (h264parse, h264parse->format, data, size); + gst_buffer_unmap (nal, data, size); GST_BUFFER_TIMESTAMP (nal) = ts; GST_BUFFER_DURATION (nal) = 0; - gst_buffer_set_caps (nal, GST_PAD_CAPS (GST_BASE_PARSE_SRC_PAD (h264parse))); - return gst_pad_push (GST_BASE_PARSE_SRC_PAD (h264parse), nal); } @@ -1156,36 +1174,33 @@ gst_h264_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame) GstBuffer *new_buf; const gboolean bs = h264parse->format == GST_H264_PARSE_FORMAT_BYTE; - gst_byte_writer_init_with_size (&bw, GST_BUFFER_SIZE (buffer), FALSE); - gst_byte_writer_put_data (&bw, GST_BUFFER_DATA (buffer), - h264parse->idr_pos); + gst_byte_writer_init_with_size (&bw, gst_buffer_get_size (buffer), + FALSE); + gst_byte_writer_put_buffer (&bw, buffer, 0, h264parse->idr_pos); GST_DEBUG_OBJECT (h264parse, "- inserting SPS/PPS"); for (i = 0; i < GST_H264_MAX_SPS_COUNT; i++) { if ((codec_nal = h264parse->sps_nals[i])) { + gsize nal_size = gst_buffer_get_size (codec_nal); GST_DEBUG_OBJECT (h264parse, "inserting SPS nal"); - gst_byte_writer_put_uint32_be (&bw, - bs ? 1 : GST_BUFFER_SIZE (codec_nal)); - gst_byte_writer_put_data (&bw, GST_BUFFER_DATA (codec_nal), - GST_BUFFER_SIZE (codec_nal)); + gst_byte_writer_put_uint32_be (&bw, bs ? 1 : nal_size); + gst_byte_writer_put_buffer (&bw, codec_nal, 0, nal_size); h264parse->last_report = new_ts; } } for (i = 0; i < GST_H264_MAX_PPS_COUNT; i++) { if ((codec_nal = h264parse->pps_nals[i])) { + gsize nal_size = gst_buffer_get_size (codec_nal); GST_DEBUG_OBJECT (h264parse, "inserting PPS nal"); - gst_byte_writer_put_uint32_be (&bw, - bs ? 1 : GST_BUFFER_SIZE (codec_nal)); - gst_byte_writer_put_data (&bw, GST_BUFFER_DATA (codec_nal), - GST_BUFFER_SIZE (codec_nal)); + gst_byte_writer_put_uint32_be (&bw, bs ? 1 : nal_size); + gst_byte_writer_put_buffer (&bw, codec_nal, 0, nal_size); h264parse->last_report = new_ts; } } - gst_byte_writer_put_data (&bw, - GST_BUFFER_DATA (buffer) + h264parse->idr_pos, - GST_BUFFER_SIZE (buffer) - h264parse->idr_pos); + gst_byte_writer_put_buffer (&bw, buffer, h264parse->idr_pos, -1); /* collect result and push */ new_buf = gst_byte_writer_reset_and_get_buffer (&bw); - gst_buffer_copy_metadata (new_buf, buffer, GST_BUFFER_COPY_ALL); + gst_buffer_copy_into (new_buf, buffer, GST_BUFFER_COPY_METADATA, 0, + -1); gst_buffer_replace (&frame->buffer, new_buf); gst_buffer_unref (new_buf); } @@ -1207,7 +1222,8 @@ gst_h264_parse_set_caps (GstBaseParse * parse, GstCaps * caps) GstStructure *str; const GValue *value; GstBuffer *codec_data = NULL; - guint size, format, align, off; + gsize size; + guint format, align, off; GstH264NalUnit nalu; GstH264ParserResult parseres; @@ -1241,15 +1257,18 @@ gst_h264_parse_set_caps (GstBaseParse * parse, GstCaps * caps) codec_data = gst_value_get_buffer (value); if (!codec_data) goto wrong_type; - data = GST_BUFFER_DATA (codec_data); - size = GST_BUFFER_SIZE (codec_data); + data = gst_buffer_map (codec_data, &size, NULL, GST_MAP_READ); /* parse the avcC data */ - if (size < 8) + if (size < 8) { + gst_buffer_unmap (codec_data, data, size); goto avcc_too_small; + } /* parse the version, this must be 1 */ - if (data[0] != 1) + if (data[0] != 1) { + gst_buffer_unmap (codec_data, data, size); goto wrong_version; + } /* AVCProfileIndication */ /* profile_compat */ @@ -1269,8 +1288,10 @@ gst_h264_parse_set_caps (GstBaseParse * parse, GstCaps * caps) for (i = 0; i < num_sps; i++) { parseres = gst_h264_parser_identify_nalu_avc (h264parse->nalparser, data, off, size, 2, &nalu); - if (parseres != GST_H264_PARSER_OK) + if (parseres != GST_H264_PARSER_OK) { + gst_buffer_unmap (codec_data, data, size); goto avcc_too_small; + } gst_h264_parse_process_nal (h264parse, &nalu); off = nalu.offset + nalu.size; @@ -1283,6 +1304,7 @@ gst_h264_parse_set_caps (GstBaseParse * parse, GstCaps * caps) parseres = gst_h264_parser_identify_nalu_avc (h264parse->nalparser, data, off, size, 2, &nalu); if (parseres != GST_H264_PARSER_OK) { + gst_buffer_unmap (codec_data, data, size); goto avcc_too_small; } @@ -1290,6 +1312,8 @@ gst_h264_parse_set_caps (GstBaseParse * parse, GstCaps * caps) off = nalu.offset + nalu.size; } + gst_buffer_unmap (codec_data, data, size); + h264parse->codec_data = gst_buffer_ref (codec_data); /* if upstream sets codec_data without setting stream-format and alignment, we @@ -1354,11 +1378,13 @@ refuse_caps: } static GstCaps * -gst_h264_parse_get_caps (GstBaseParse * parse) +gst_h264_parse_get_caps (GstBaseParse * parse, GstCaps * filter) { - GstCaps *peercaps; + GstCaps *peercaps, *template_caps; GstCaps *res; + template_caps = + gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse)); peercaps = gst_pad_get_allowed_caps (GST_BASE_PARSE_SRC_PAD (parse)); if (peercaps) { guint i, n; @@ -1372,24 +1398,28 @@ gst_h264_parse_get_caps (GstBaseParse * parse) gst_structure_remove_field (s, "parsed"); } - res = - gst_caps_intersect_full (peercaps, - gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse)), + res = gst_caps_intersect_full (peercaps, template_caps, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (peercaps); + gst_caps_unref (template_caps); } else { - res = - gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD - (parse))); + res = template_caps; + } + + if (filter) { + GstCaps *tmp = gst_caps_intersect_full (res, filter, + GST_CAPS_INTERSECT_FIRST); + gst_caps_unref (res); + res = tmp; } return res; } static GstFlowReturn -gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) +gst_h264_parse_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer) { - GstH264Parse *h264parse = GST_H264_PARSE (GST_PAD_PARENT (pad)); + GstH264Parse *h264parse = GST_H264_PARSE (parent); if (h264parse->packetized && buffer) { GstBuffer *sub; @@ -1397,6 +1427,8 @@ gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) GstH264ParserResult parse_res; GstH264NalUnit nalu; const guint nl = h264parse->nal_length_size; + gpointer data; + gsize size; if (nl < 1 || nl > 4) { GST_DEBUG_OBJECT (h264parse, "insufficient data to split input"); @@ -1405,11 +1437,13 @@ gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) return GST_FLOW_NOT_NEGOTIATED; } - GST_LOG_OBJECT (h264parse, "processing packet buffer of size %d", - GST_BUFFER_SIZE (buffer)); + data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ); + + GST_LOG_OBJECT (h264parse, + "processing packet buffer of size %" G_GSIZE_FORMAT, size); parse_res = gst_h264_parser_identify_nalu_avc (h264parse->nalparser, - GST_BUFFER_DATA (buffer), 0, GST_BUFFER_SIZE (buffer), nl, &nalu); + data, 0, size, nl, &nalu); while (parse_res == GST_H264_PARSER_OK) { GST_DEBUG_OBJECT (h264parse, "AVC nal offset %d", @@ -1422,7 +1456,7 @@ gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) /* at least this should make sense */ GST_BUFFER_TIMESTAMP (sub) = GST_BUFFER_TIMESTAMP (buffer); GST_LOG_OBJECT (h264parse, "pushing NAL of size %d", nalu.size); - ret = h264parse->parse_chain (pad, sub); + ret = h264parse->parse_chain (pad, parent, sub); } else { /* pass-through: no looking for frames (and nal processing), * so need to parse to collect data here */ @@ -1434,10 +1468,11 @@ gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) } parse_res = gst_h264_parser_identify_nalu_avc (h264parse->nalparser, - GST_BUFFER_DATA (buffer), nalu.offset + nalu.size, - GST_BUFFER_SIZE (buffer), nl, &nalu); + data, nalu.offset + nalu.size, size, nl, &nalu); } + gst_buffer_unmap (buffer, data, size); + if (h264parse->split_packetized) { gst_buffer_unref (buffer); return ret; @@ -1463,7 +1498,7 @@ gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) } } - return h264parse->parse_chain (pad, buffer); + return h264parse->parse_chain (pad, parent, buffer); } static void diff --git a/gst/videoparsers/gstmpegvideoparse.c b/gst/videoparsers/gstmpegvideoparse.c index 66a8929f77..6c1c9834ce 100644 --- a/gst/videoparsers/gstmpegvideoparse.c +++ b/gst/videoparsers/gstmpegvideoparse.c @@ -61,8 +61,8 @@ enum PROP_LAST }; -GST_BOILERPLATE (GstMpegvParse, gst_mpegv_parse, GstBaseParse, - GST_TYPE_BASE_PARSE); +#define parent_class gst_mpegv_parse_parent_class +G_DEFINE_TYPE (GstMpegvParse, gst_mpegv_parse, GST_TYPE_BASE_PARSE); static gboolean gst_mpegv_parse_start (GstBaseParse * parse); static gboolean gst_mpegv_parse_stop (GstBaseParse * parse); @@ -79,28 +79,6 @@ static void gst_mpegv_parse_set_property (GObject * object, guint prop_id, static void gst_mpegv_parse_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); -static void -gst_mpegv_parse_base_init (gpointer klass) -{ - GstElementClass *element_class = GST_ELEMENT_CLASS (klass); - - gst_element_class_add_pad_template (element_class, - gst_static_pad_template_get (&src_template)); - gst_element_class_add_pad_template (element_class, - gst_static_pad_template_get (&sink_template)); - - gst_element_class_set_details_simple (element_class, - "MPEG video elementary stream parser", - "Codec/Parser/Video", - "Parses and frames MPEG-1 and MPEG-2 elementary video streams", - "Wim Taymans , " - "Jan Schmidt , " - "Mark Nauwelaerts "); - - GST_DEBUG_CATEGORY_INIT (mpegv_parse_debug, "mpegvideoparse", 0, - "MPEG-1/2 video parser"); -} - static void gst_mpegv_parse_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) @@ -141,8 +119,12 @@ static void gst_mpegv_parse_class_init (GstMpegvParseClass * klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass); + GST_DEBUG_CATEGORY_INIT (mpegv_parse_debug, "mpegvideoparse", 0, + "MPEG-1/2 video parser"); + parent_class = g_type_class_peek_parent (klass); gobject_class->set_property = gst_mpegv_parse_set_property; @@ -159,6 +141,19 @@ gst_mpegv_parse_class_init (GstMpegvParseClass * klass) "Split frame when encountering GOP", DEFAULT_PROP_GOP_SPLIT, G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&src_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&sink_template)); + + gst_element_class_set_details_simple (element_class, + "MPEG video elementary stream parser", + "Codec/Parser/Video", + "Parses and frames MPEG-1 and MPEG-2 elementary video streams", + "Wim Taymans , " + "Jan Schmidt , " + "Mark Nauwelaerts "); + /* Override BaseParse vfuncs */ parse_class->start = GST_DEBUG_FUNCPTR (gst_mpegv_parse_start); parse_class->stop = GST_DEBUG_FUNCPTR (gst_mpegv_parse_stop); @@ -171,7 +166,7 @@ gst_mpegv_parse_class_init (GstMpegvParseClass * klass) } static void -gst_mpegv_parse_init (GstMpegvParse * parse, GstMpegvParseClass * g_class) +gst_mpegv_parse_init (GstMpegvParse * parse) { parse->mpeg_version = 0; } @@ -231,16 +226,21 @@ gst_mpegv_parse_process_config (GstMpegvParse * mpvparse, GstBuffer * buf, guint size) { GList *tmp; - guint8 *data = GST_BUFFER_DATA (buf); - data = data + mpvparse->seq_offset; + guint8 *buf_data, *data; + gsize buf_size; + + buf_data = gst_buffer_map (buf, &buf_size, NULL, GST_MAP_READ); + data = buf_data + mpvparse->seq_offset; /* only do stuff if something new */ - if (mpvparse->config && size == GST_BUFFER_SIZE (mpvparse->config) && - memcmp (GST_BUFFER_DATA (mpvparse->config), data, size) == 0) + if (mpvparse->config && size == gst_buffer_get_size (mpvparse->config) && + gst_buffer_memcmp (mpvparse->config, 0, data, size) == 0) { + gst_buffer_unmap (buf, buf_data, buf_size); return TRUE; + } if (gst_mpeg_video_parse_sequence_header (&mpvparse->sequencehdr, data, - GST_BUFFER_SIZE (buf) - mpvparse->seq_offset, 0)) { + buf_size - mpvparse->seq_offset, 0)) { if (mpvparse->fps_num == 0 || mpvparse->fps_den == 0) { mpvparse->fps_num = mpvparse->sequencehdr.fps_n; mpvparse->fps_den = mpvparse->sequencehdr.fps_d; @@ -249,6 +249,7 @@ gst_mpegv_parse_process_config (GstMpegvParse * mpvparse, GstBuffer * buf, GST_DEBUG_OBJECT (mpvparse, "failed to parse config data (size %d) at offset %d", size, mpvparse->seq_offset); + gst_buffer_unmap (buf, buf_data, buf_size); return FALSE; } @@ -266,8 +267,7 @@ gst_mpegv_parse_process_config (GstMpegvParse * mpvparse, GstBuffer * buf, mpvparse->mpeg_version = 2; if (gst_mpeg_video_parse_sequence_extension (&mpvparse->sequenceext, - GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf), - tpoffsz->offset)) { + buf_data, buf_size, tpoffsz->offset)) { mpvparse->fps_num = mpvparse->sequencehdr.fps_n * (mpvparse->sequenceext.fps_n_ext + 1) * 2; @@ -284,11 +284,13 @@ gst_mpegv_parse_process_config (GstMpegvParse * mpvparse, GstBuffer * buf, gst_buffer_unref (mpvparse->config); mpvparse->config = gst_buffer_new_and_alloc (size); - memcpy (GST_BUFFER_DATA (mpvparse->config), data, size); + gst_buffer_fill (mpvparse->config, 0, data, size); /* trigger src caps update */ mpvparse->update_caps = TRUE; + gst_buffer_unmap (buf, buf_data, buf_size); + return TRUE; } @@ -354,8 +356,12 @@ static void parse_picture_extension (GstMpegvParse * mpvparse, GstBuffer * buf, guint off) { GstMpegVideoPictureExt ext; - if (gst_mpeg_video_parse_picture_extension (&ext, GST_BUFFER_DATA (buf), - GST_BUFFER_SIZE (buf), off)) { + gpointer data; + gsize size; + + data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ); + + if (gst_mpeg_video_parse_picture_extension (&ext, data, size, off)) { mpvparse->frame_repeat_count = 1; if (ext.repeat_first_field) { @@ -369,6 +375,8 @@ parse_picture_extension (GstMpegvParse * mpvparse, GstBuffer * buf, guint off) } } } + + gst_buffer_unmap (buf, data, size); } /* caller guarantees at least start code in @buf at @off */ @@ -380,7 +388,7 @@ gst_mpegv_parse_process_sc (GstMpegvParse * mpvparse, { gboolean ret = FALSE, packet = TRUE; - g_return_val_if_fail (buf && GST_BUFFER_SIZE (buf) >= 4, FALSE); + g_return_val_if_fail (buf && gst_buffer_get_size (buf) >= 4, FALSE); GST_LOG_OBJECT (mpvparse, "process startcode %x (%s)", code, picture_start_code_name (code)); @@ -427,14 +435,19 @@ gst_mpegv_parse_process_sc (GstMpegvParse * mpvparse, /* extract some picture info if there is any in the frame being terminated */ if (ret && mpvparse->pic_offset >= 0 && mpvparse->pic_offset < off) { + gsize size; + gpointer data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ); + if (gst_mpeg_video_parse_picture_header (&mpvparse->pichdr, - GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf), mpvparse->pic_offset)) + data, size, mpvparse->pic_offset)) GST_LOG_OBJECT (mpvparse, "picture_coding_type %d (%s), ending" "frame of size %d", mpvparse->pichdr.pic_type, picture_type_name (mpvparse->pichdr.pic_type), off - 4); else GST_LOG_OBJECT (mpvparse, "Couldn't parse picture at offset %d", mpvparse->pic_offset); + + gst_buffer_unmap (buf, data, size); } return ret; @@ -487,14 +500,17 @@ gst_mpegv_parse_check_valid_frame (GstBaseParse * parse, gboolean ret = FALSE; GList *tmp; gint off = 0, fsize = -1; + gpointer buf_data; + gsize buf_size; update_frame_parsing_status (mpvparse, frame); if (mpvparse->last_sc >= 0) off = mpvparse->last_sc; - mpvparse->typeoffsize = - gst_mpeg_video_parse (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf), off); + buf_data = gst_buffer_map (buf, &buf_size, NULL, GST_MAP_READ); + mpvparse->typeoffsize = gst_mpeg_video_parse (buf_data, buf_size, off); + gst_buffer_unmap (buf, buf_data, buf_size); /* No sc found */ if (mpvparse->typeoffsize == NULL) @@ -531,15 +547,15 @@ end: *framesize = fsize; ret = TRUE; } else if (GST_BASE_PARSE_DRAINING (parse)) { - *framesize = GST_BUFFER_SIZE (buf); + *framesize = buf_size; ret = TRUE; } else { /* resume scan where we left it */ if (!mpvparse->last_sc) - *skipsize = mpvparse->last_sc = GST_BUFFER_SIZE (buf) - 3; + *skipsize = mpvparse->last_sc = buf_size - 3; else if (mpvparse->typeoffsize) - mpvparse->last_sc = GST_BUFFER_SIZE (buf) - 3; + mpvparse->last_sc = buf_size - 3; else *skipsize = 0; @@ -561,16 +577,16 @@ gst_mpegv_parse_update_src_caps (GstMpegvParse * mpvparse) GstCaps *caps = NULL; /* only update if no src caps yet or explicitly triggered */ - if (G_LIKELY (GST_PAD_CAPS (GST_BASE_PARSE_SRC_PAD (mpvparse)) && + if (G_LIKELY (gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (mpvparse)) && !mpvparse->update_caps)) return; /* carry over input caps as much as possible; override with our own stuff */ - caps = GST_PAD_CAPS (GST_BASE_PARSE_SINK_PAD (mpvparse)); + caps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (mpvparse)); if (caps) { - caps = gst_caps_copy (caps); + caps = gst_caps_make_writable (caps); } else { - caps = gst_caps_new_simple ("video/mpeg", NULL); + caps = gst_caps_new_empty_simple ("video/mpeg"); } /* typically we don't output buffers until we have properly parsed some @@ -722,13 +738,11 @@ gst_mpegv_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame) /* codec tag */ codec = g_strdup_printf ("MPEG %d Video", mpvparse->mpeg_version); - taglist = gst_tag_list_new (); - gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, - GST_TAG_VIDEO_CODEC, codec, NULL); + taglist = gst_tag_list_new (GST_TAG_VIDEO_CODEC, codec, NULL); g_free (codec); - gst_element_found_tags_for_pad (GST_ELEMENT (mpvparse), - GST_BASE_PARSE_SRC_PAD (mpvparse), taglist); + gst_pad_push_event (GST_BASE_PARSE_SRC_PAD (mpvparse), + gst_event_new_tag (taglist)); mpvparse->send_codec_tag = FALSE; } @@ -756,7 +770,7 @@ gst_mpegv_parse_set_caps (GstBaseParse * parse, GstCaps * caps) /* best possible parse attempt, * src caps are based on sink caps so it will end up in there * whether sucessful or not */ - gst_mpegv_parse_process_config (mpvparse, buf, GST_BUFFER_SIZE (buf)); + gst_mpegv_parse_process_config (mpvparse, buf, gst_buffer_get_size (buf)); } /* let's not interfere and accept regardless of config parsing success */ diff --git a/gst/videoparsers/h263parse.c b/gst/videoparsers/h263parse.c index 14911e79f0..71f3661c92 100644 --- a/gst/videoparsers/h263parse.c +++ b/gst/videoparsers/h263parse.c @@ -73,14 +73,18 @@ gst_h263_parse_get_params (H263Params * params, GstBuffer * buffer, }; GstBitReader br; + guint8 *buf_data; + gsize buf_size; guint8 tr; guint32 psc = 0, temp32; guint8 temp8, pquant; gboolean hasplusptype; + buf_data = gst_buffer_map (buffer, &buf_size, NULL, GST_MAP_READ); + /* FIXME: we can optimise a little by checking the value of available * instead of calling using the bit reader's get_bits_* functions. */ - gst_bit_reader_init_from_buffer (&br, buffer); + gst_bit_reader_init (&br, buf_data, buf_size); /* Default PCF is CIF PCF = 30000/1001 */ params->pcfnum = 30000; @@ -445,10 +449,12 @@ gst_h263_parse_get_params (H263Params * params, GstBuffer * buffer, done: *state = GOT_HEADER; more: + gst_buffer_unmap (buffer, buf_data, buf_size); return GST_FLOW_OK; beach: *state = PASSTHROUGH; + gst_buffer_unmap (buffer, buf_data, buf_size); return GST_FLOW_OK; }