X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Frtp%2Fgstrtph263ppay.c;h=6bb9e4a3d49859d843d9b0a10a693cbe7b6a7f65;hb=775ccdf9775bd7051929b257444b3be915e88ec6;hp=52a3fb314d5859b411886b3de3289bd099f0c014;hpb=e9df54819c85da821f62eb34f4af4b6781f0c559;p=platform%2Fupstream%2Fgst-plugins-good.git diff --git a/gst/rtp/gstrtph263ppay.c b/gst/rtp/gstrtph263ppay.c index 52a3fb3..6bb9e4a 100644 --- a/gst/rtp/gstrtph263ppay.c +++ b/gst/rtp/gstrtph263ppay.c @@ -13,8 +13,8 @@ * * 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. + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. */ #ifdef HAVE_CONFIG_H @@ -22,10 +22,14 @@ #endif #include +#include +#include #include +#include #include "gstrtph263ppay.h" +#include "gstrtputils.h" #define DEFAULT_FRAGMENTATION_MODE GST_FRAGMENTATION_MODE_NORMAL @@ -61,9 +65,23 @@ static GstStaticPadTemplate gst_rtp_h263p_pay_sink_template = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, - GST_STATIC_CAPS ("video/x-h263, " "variant = (string) \"itu\" ") + GST_STATIC_CAPS ("video/x-h263, variant = (string) itu") ); +/* + * We also return these in getcaps() as required by the SDP caps + * + * width = (int) [16, 4096] + * height = (int) [16, 4096] + * "annex-f = (boolean) {true, false}," + * "annex-i = (boolean) {true, false}," + * "annex-j = (boolean) {true, false}," + * "annex-l = (boolean) {true, false}," + * "annex-t = (boolean) {true, false}," + * "annex-v = (boolean) {true, false}") + */ + + static GstStaticPadTemplate gst_rtp_h263p_pay_src_template = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, @@ -85,31 +103,34 @@ static void gst_rtp_h263p_pay_set_property (GObject * object, guint prop_id, static void gst_rtp_h263p_pay_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); -static gboolean gst_rtp_h263p_pay_setcaps (GstBaseRTPPayload * payload, +static gboolean gst_rtp_h263p_pay_setcaps (GstRTPBasePayload * payload, GstCaps * caps); -static GstFlowReturn gst_rtp_h263p_pay_handle_buffer (GstBaseRTPPayload * +static GstCaps *gst_rtp_h263p_pay_sink_getcaps (GstRTPBasePayload * payload, + GstPad * pad, GstCaps * filter); +static GstFlowReturn gst_rtp_h263p_pay_handle_buffer (GstRTPBasePayload * payload, GstBuffer * buffer); #define gst_rtp_h263p_pay_parent_class parent_class -G_DEFINE_TYPE (GstRtpH263PPay, gst_rtp_h263p_pay, GST_TYPE_BASE_RTP_PAYLOAD); +G_DEFINE_TYPE (GstRtpH263PPay, gst_rtp_h263p_pay, GST_TYPE_RTP_BASE_PAYLOAD); static void gst_rtp_h263p_pay_class_init (GstRtpH263PPayClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; - GstBaseRTPPayloadClass *gstbasertppayload_class; + GstRTPBasePayloadClass *gstrtpbasepayload_class; gobject_class = (GObjectClass *) klass; gstelement_class = (GstElementClass *) klass; - gstbasertppayload_class = (GstBaseRTPPayloadClass *) klass; + gstrtpbasepayload_class = (GstRTPBasePayloadClass *) klass; gobject_class->finalize = gst_rtp_h263p_pay_finalize; gobject_class->set_property = gst_rtp_h263p_pay_set_property; gobject_class->get_property = gst_rtp_h263p_pay_get_property; - gstbasertppayload_class->set_caps = gst_rtp_h263p_pay_setcaps; - gstbasertppayload_class->handle_buffer = gst_rtp_h263p_pay_handle_buffer; + gstrtpbasepayload_class->set_caps = gst_rtp_h263p_pay_setcaps; + gstrtpbasepayload_class->get_caps = gst_rtp_h263p_pay_sink_getcaps; + gstrtpbasepayload_class->handle_buffer = gst_rtp_h263p_pay_handle_buffer; g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_FRAGMENTATION_MODE, g_param_spec_enum ("fragmentation-mode", @@ -118,18 +139,22 @@ gst_rtp_h263p_pay_class_init (GstRtpH263PPayClass * klass) DEFAULT_FRAGMENTATION_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); - gst_element_class_add_pad_template (gstelement_class, - gst_static_pad_template_get (&gst_rtp_h263p_pay_src_template)); - gst_element_class_add_pad_template (gstelement_class, - gst_static_pad_template_get (&gst_rtp_h263p_pay_sink_template)); + gst_element_class_add_static_pad_template (gstelement_class, + &gst_rtp_h263p_pay_src_template); + gst_element_class_add_static_pad_template (gstelement_class, + &gst_rtp_h263p_pay_sink_template); - gst_element_class_set_details_simple (gstelement_class, "RTP H263 payloader", + gst_element_class_set_static_metadata (gstelement_class, "RTP H263 payloader", "Codec/Payloader/Network/RTP", "Payload-encodes H263/+/++ video in RTP packets (RFC 4629)", "Wim Taymans "); GST_DEBUG_CATEGORY_INIT (rtph263ppay_debug, "rtph263ppay", 0, "rtph263ppay (RFC 4629)"); + +#ifndef TIZEN_FEATURE_GST_UPSTREAM_AVOID_BUILD_BREAK + gst_type_mark_as_plugin_api (GST_TYPE_FRAGMENTATION_MODE, 0); +#endif } static void @@ -154,16 +179,452 @@ gst_rtp_h263p_pay_finalize (GObject * object) } static gboolean -gst_rtp_h263p_pay_setcaps (GstBaseRTPPayload * payload, GstCaps * caps) +gst_rtp_h263p_pay_setcaps (GstRTPBasePayload * payload, GstCaps * caps) { gboolean res; + GstCaps *peercaps; + gchar *encoding_name = NULL; + + g_return_val_if_fail (gst_caps_is_fixed (caps), FALSE); + + peercaps = + gst_pad_peer_query_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload), NULL); + if (peercaps) { + GstCaps *tcaps = + gst_pad_get_pad_template_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload)); + GstCaps *intersect = gst_caps_intersect (peercaps, tcaps); + gst_caps_unref (tcaps); + + gst_caps_unref (peercaps); + if (!gst_caps_is_empty (intersect)) { + GstStructure *s = gst_caps_get_structure (intersect, 0); + encoding_name = g_strdup (gst_structure_get_string (s, "encoding-name")); + } + gst_caps_unref (intersect); + } + + if (!encoding_name) + encoding_name = g_strdup ("H263-1998"); - gst_basertppayload_set_options (payload, "video", TRUE, "H263-1998", 90000); - res = gst_basertppayload_set_outcaps (payload, NULL); + gst_rtp_base_payload_set_options (payload, "video", TRUE, + (gchar *) encoding_name, 90000); + res = gst_rtp_base_payload_set_outcaps (payload, NULL); + g_free (encoding_name); return res; } +static GstCaps * +caps_append (GstCaps * caps, GstStructure * in_s, guint x, guint y, guint mpi) +{ + GstStructure *s; + + if (!in_s) + return caps; + + if (mpi < 1 || mpi > 32) + return caps; + + s = gst_structure_copy (in_s); + + gst_structure_set (s, + "width", GST_TYPE_INT_RANGE, 1, x, + "height", GST_TYPE_INT_RANGE, 1, y, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 30000, 1001 * mpi, NULL); + + caps = gst_caps_merge_structure (caps, s); + + return caps; +} + + +static GstCaps * +gst_rtp_h263p_pay_sink_getcaps (GstRTPBasePayload * payload, GstPad * pad, + GstCaps * filter) +{ + GstRtpH263PPay *rtph263ppay; + GstCaps *caps = NULL, *templ; + GstCaps *peercaps = NULL; + GstCaps *intersect = NULL; + guint i; + + rtph263ppay = GST_RTP_H263P_PAY (payload); + + peercaps = + gst_pad_peer_query_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload), NULL); + + /* if we're just outputting to udpsink or fakesink or so, we should also + * accept any input compatible with our sink template caps */ + if (!peercaps || gst_caps_is_any (peercaps)) { + if (peercaps) + gst_caps_unref (peercaps); + caps = + gst_pad_get_pad_template_caps (GST_RTP_BASE_PAYLOAD_SINKPAD (payload)); + goto done; + } + + /* We basically need to differentiate two use-cases here: One where there's + * a capsfilter after the payloader with caps created from an SDP; in this + * case the filter caps are fixed and we want to signal to an encoder what + * we want it to produce. The second case is simply payloader ! depayloader + * where we are dealing with the depayloader's template caps. In this case + * we should accept any input compatible with our sink template caps. */ + if (!gst_caps_is_fixed (peercaps)) { + gst_caps_unref (peercaps); + caps = + gst_pad_get_pad_template_caps (GST_RTP_BASE_PAYLOAD_SINKPAD (payload)); + goto done; + } + + templ = gst_pad_get_pad_template_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload)); + intersect = gst_caps_intersect (peercaps, templ); + gst_caps_unref (peercaps); + gst_caps_unref (templ); + + if (gst_caps_is_empty (intersect)) + return intersect; + + caps = gst_caps_new_empty (); + for (i = 0; i < gst_caps_get_size (intersect); i++) { + GstStructure *s = gst_caps_get_structure (intersect, i); + const gchar *encoding_name = gst_structure_get_string (s, "encoding-name"); + + if (!strcmp (encoding_name, "H263-2000")) { + const gchar *profile_str = gst_structure_get_string (s, "profile"); + const gchar *level_str = gst_structure_get_string (s, "level"); + int profile = 0; + int level = 0; + + if (profile_str && level_str) { + gboolean i = FALSE, j = FALSE, l = FALSE, t = FALSE, f = FALSE, + v = FALSE; + GstStructure *new_s = gst_structure_new ("video/x-h263", + "variant", G_TYPE_STRING, "itu", + NULL); + + profile = atoi (profile_str); + level = atoi (level_str); + + /* These profiles are defined in the H.263 Annex X */ + switch (profile) { + case 0: + /* The Baseline Profile (Profile 0) */ + break; + case 1: + /* H.320 Coding Efficiency Version 2 Backward-Compatibility Profile + * (Profile 1) + * Baseline + Annexes I, J, L.4 and T + */ + i = j = l = t = TRUE; + break; + case 2: + /* Version 1 Backward-Compatibility Profile (Profile 2) + * Baseline + Annex F + */ + i = j = l = t = f = TRUE; + break; + case 3: + /* Version 2 Interactive and Streaming Wireless Profile + * Baseline + Annexes I, J, T + */ + i = j = t = TRUE; + break; + case 4: + /* Version 3 Interactive and Streaming Wireless Profile (Profile 4) + * Baseline + Annexes I, J, T, V, W.6.3.8, + */ + /* Missing W.6.3.8 */ + i = j = t = v = TRUE; + break; + case 5: + /* Conversational High Compression Profile (Profile 5) + * Baseline + Annexes F, I, J, L.4, T, D, U + */ + /* Missing D, U */ + f = i = j = l = t = TRUE; + break; + case 6: + /* Conversational Internet Profile (Profile 6) + * Baseline + Annexes F, I, J, L.4, T, D, U and + * K with arbitratry slice ordering + */ + /* Missing D, U, K with arbitratry slice ordering */ + f = i = j = l = t = TRUE; + break; + case 7: + /* Conversational Interlace Profile (Profile 7) + * Baseline + Annexes F, I, J, L.4, T, D, U, W.6.3.11 + */ + /* Missing D, U, W.6.3.11 */ + f = i = j = l = t = TRUE; + break; + case 8: + /* High Latency Profile (Profile 8) + * Baseline + Annexes F, I, J, L.4, T, D, U, P.5, O.1.1 and + * K with arbitratry slice ordering + */ + /* Missing D, U, P.5, O.1.1 */ + f = i = j = l = t = TRUE; + break; + } + + + if (f || i || j || t || l || v) { + GValue list = { 0 }; + GValue vstr = { 0 }; + + g_value_init (&list, GST_TYPE_LIST); + g_value_init (&vstr, G_TYPE_STRING); + + g_value_set_static_string (&vstr, "h263"); + gst_value_list_append_value (&list, &vstr); + g_value_set_static_string (&vstr, "h263p"); + gst_value_list_append_value (&list, &vstr); + + if (l || v) { + g_value_set_static_string (&vstr, "h263pp"); + gst_value_list_append_value (&list, &vstr); + } + g_value_unset (&vstr); + + gst_structure_set_value (new_s, "h263version", &list); + g_value_unset (&list); + } else { + gst_structure_set (new_s, "h263version", G_TYPE_STRING, "h263", NULL); + } + + + if (!f) + gst_structure_set (new_s, "annex-f", G_TYPE_BOOLEAN, FALSE, NULL); + if (!i) + gst_structure_set (new_s, "annex-i", G_TYPE_BOOLEAN, FALSE, NULL); + if (!j) + gst_structure_set (new_s, "annex-j", G_TYPE_BOOLEAN, FALSE, NULL); + if (!t) + gst_structure_set (new_s, "annex-t", G_TYPE_BOOLEAN, FALSE, NULL); + if (!l) + gst_structure_set (new_s, "annex-l", G_TYPE_BOOLEAN, FALSE, NULL); + if (!v) + gst_structure_set (new_s, "annex-v", G_TYPE_BOOLEAN, FALSE, NULL); + + + if (level <= 10 || level == 45) { + gst_structure_set (new_s, + "width", GST_TYPE_INT_RANGE, 1, 176, + "height", GST_TYPE_INT_RANGE, 1, 144, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 30000, 2002, NULL); + caps = gst_caps_merge_structure (caps, new_s); + } else if (level <= 20) { + GstStructure *s_copy = gst_structure_copy (new_s); + + gst_structure_set (new_s, + "width", GST_TYPE_INT_RANGE, 1, 352, + "height", GST_TYPE_INT_RANGE, 1, 288, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 30000, 2002, NULL); + caps = gst_caps_merge_structure (caps, new_s); + + gst_structure_set (s_copy, + "width", GST_TYPE_INT_RANGE, 1, 176, + "height", GST_TYPE_INT_RANGE, 1, 144, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 30000, 1001, NULL); + caps = gst_caps_merge_structure (caps, s_copy); + } else if (level <= 40) { + + gst_structure_set (new_s, + "width", GST_TYPE_INT_RANGE, 1, 352, + "height", GST_TYPE_INT_RANGE, 1, 288, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 30000, 1001, NULL); + caps = gst_caps_merge_structure (caps, new_s); + } else if (level <= 50) { + GstStructure *s_copy = gst_structure_copy (new_s); + + gst_structure_set (new_s, + "width", GST_TYPE_INT_RANGE, 1, 352, + "height", GST_TYPE_INT_RANGE, 1, 288, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 50, 1, NULL); + caps = gst_caps_merge_structure (caps, new_s); + + gst_structure_set (s_copy, + "width", GST_TYPE_INT_RANGE, 1, 352, + "height", GST_TYPE_INT_RANGE, 1, 240, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 60000, 1001, NULL); + caps = gst_caps_merge_structure (caps, s_copy); + } else if (level <= 60) { + GstStructure *s_copy = gst_structure_copy (new_s); + + gst_structure_set (new_s, + "width", GST_TYPE_INT_RANGE, 1, 720, + "height", GST_TYPE_INT_RANGE, 1, 288, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 50, 1, NULL); + caps = gst_caps_merge_structure (caps, new_s); + + gst_structure_set (s_copy, + "width", GST_TYPE_INT_RANGE, 1, 720, + "height", GST_TYPE_INT_RANGE, 1, 240, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 60000, 1001, NULL); + caps = gst_caps_merge_structure (caps, s_copy); + } else if (level <= 70) { + GstStructure *s_copy = gst_structure_copy (new_s); + + gst_structure_set (new_s, + "width", GST_TYPE_INT_RANGE, 1, 720, + "height", GST_TYPE_INT_RANGE, 1, 576, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 50, 1, NULL); + caps = gst_caps_merge_structure (caps, new_s); + + gst_structure_set (s_copy, + "width", GST_TYPE_INT_RANGE, 1, 720, + "height", GST_TYPE_INT_RANGE, 1, 480, + "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 60000, 1001, NULL); + caps = gst_caps_merge_structure (caps, s_copy); + } else { + caps = gst_caps_merge_structure (caps, new_s); + } + + } else { + GstStructure *new_s = gst_structure_new ("video/x-h263", + "variant", G_TYPE_STRING, "itu", + "h263version", G_TYPE_STRING, "h263", + NULL); + + GST_DEBUG_OBJECT (rtph263ppay, "No profile or level specified" + " for H263-2000, defaulting to baseline H263"); + + caps = gst_caps_merge_structure (caps, new_s); + } + } else { + gboolean f = FALSE, i = FALSE, j = FALSE, t = FALSE; + /* FIXME: ffmpeg support the Appendix K too, how do we express it ? + * guint k; + */ + const gchar *str; + GstStructure *new_s = gst_structure_new ("video/x-h263", + "variant", G_TYPE_STRING, "itu", + NULL); + gboolean added = FALSE; + + str = gst_structure_get_string (s, "f"); + if (str && !strcmp (str, "1")) + f = TRUE; + + str = gst_structure_get_string (s, "i"); + if (str && !strcmp (str, "1")) + i = TRUE; + + str = gst_structure_get_string (s, "j"); + if (str && !strcmp (str, "1")) + j = TRUE; + + str = gst_structure_get_string (s, "t"); + if (str && !strcmp (str, "1")) + t = TRUE; + + if (f || i || j || t) { + GValue list = { 0 }; + GValue vstr = { 0 }; + + g_value_init (&list, GST_TYPE_LIST); + g_value_init (&vstr, G_TYPE_STRING); + + g_value_set_static_string (&vstr, "h263"); + gst_value_list_append_value (&list, &vstr); + g_value_set_static_string (&vstr, "h263p"); + gst_value_list_append_value (&list, &vstr); + g_value_unset (&vstr); + + gst_structure_set_value (new_s, "h263version", &list); + g_value_unset (&list); + } else { + gst_structure_set (new_s, "h263version", G_TYPE_STRING, "h263", NULL); + } + + if (!f) + gst_structure_set (new_s, "annex-f", G_TYPE_BOOLEAN, FALSE, NULL); + if (!i) + gst_structure_set (new_s, "annex-i", G_TYPE_BOOLEAN, FALSE, NULL); + if (!j) + gst_structure_set (new_s, "annex-j", G_TYPE_BOOLEAN, FALSE, NULL); + if (!t) + gst_structure_set (new_s, "annex-t", G_TYPE_BOOLEAN, FALSE, NULL); + + + str = gst_structure_get_string (s, "custom"); + if (str) { + unsigned int xmax, ymax, mpi; + if (sscanf (str, "%u,%u,%u", &xmax, &ymax, &mpi) == 3) { + if (xmax % 4 && ymax % 4 && mpi >= 1 && mpi <= 32) { + caps = caps_append (caps, new_s, xmax, ymax, mpi); + added = TRUE; + } else { + GST_WARNING_OBJECT (rtph263ppay, "Invalid custom framesize/MPI" + " %u x %u at %u, ignoring", xmax, ymax, mpi); + } + } else { + GST_WARNING_OBJECT (rtph263ppay, "Invalid custom framesize/MPI: %s," + " ignoring", str); + } + } + + str = gst_structure_get_string (s, "16cif"); + if (str) { + int mpi = atoi (str); + caps = caps_append (caps, new_s, 1408, 1152, mpi); + added = TRUE; + } + + str = gst_structure_get_string (s, "4cif"); + if (str) { + int mpi = atoi (str); + caps = caps_append (caps, new_s, 704, 576, mpi); + added = TRUE; + } + + str = gst_structure_get_string (s, "cif"); + if (str) { + int mpi = atoi (str); + caps = caps_append (caps, new_s, 352, 288, mpi); + added = TRUE; + } + + str = gst_structure_get_string (s, "qcif"); + if (str) { + int mpi = atoi (str); + caps = caps_append (caps, new_s, 176, 144, mpi); + added = TRUE; + } + + str = gst_structure_get_string (s, "sqcif"); + if (str) { + int mpi = atoi (str); + caps = caps_append (caps, new_s, 128, 96, mpi); + added = TRUE; + } + + if (added) + gst_structure_free (new_s); + else + caps = gst_caps_merge_structure (caps, new_s); + } + } + + gst_caps_unref (intersect); + +done: + + if (filter) { + GstCaps *tmp; + + GST_DEBUG_OBJECT (payload, "Intersect %" GST_PTR_FORMAT " and filter %" + GST_PTR_FORMAT, caps, filter); + tmp = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST); + gst_caps_unref (caps); + caps = tmp; + } + + return caps; +} + + static void gst_rtp_h263p_pay_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) @@ -204,9 +665,10 @@ static GstFlowReturn gst_rtp_h263p_pay_flush (GstRtpH263PPay * rtph263ppay) { guint avail; - GstBuffer *outbuf; + GstBufferList *list = NULL; + GstBuffer *outbuf = NULL; GstFlowReturn ret; - gboolean fragmented; + gboolean fragmented = FALSE; avail = gst_adapter_available (rtph263ppay->adapter); if (avail == 0) @@ -222,60 +684,57 @@ gst_rtp_h263p_pay_flush (GstRtpH263PPay * rtph263ppay) * This algorithm separates large frames at synchronisation points (Segments) * (See RFC 4629 section 6). It would be interesting to have a property such as network * quality to select between both packetization methods */ - /* TODO Add VRC supprt (See RFC 4629 section 5.2) */ + /* TODO Add VRC support (See RFC 4629 section 5.2) */ while (avail > 0) { guint towrite; guint8 *payload; - guint payload_len; gint header_len; guint next_gop = 0; gboolean found_gob = FALSE; GstRTPBuffer rtp = { NULL }; + GstBuffer *payload_buf; if (rtph263ppay->fragmentation_mode == GST_FRAGMENTATION_MODE_SYNC) { /* start after 1st gop possible */ - guint parsed_len = 3; - const guint8 *parse_data = NULL; - - parse_data = gst_adapter_map (rtph263ppay->adapter, avail); /* Check if we have a gob or eos , eossbs */ /* FIXME EOS and EOSSBS packets should never contain any gobs and vice-versa */ - if (avail >= 3 && *parse_data == 0 && *(parse_data + 1) == 0 - && *(parse_data + 2) >= 0x80) { + next_gop = + gst_adapter_masked_scan_uint32 (rtph263ppay->adapter, 0xffff8000, + 0x00008000, 0, avail); + if (next_gop == 0) { GST_DEBUG_OBJECT (rtph263ppay, " Found GOB header"); found_gob = TRUE; } + /* Find next and cut the packet accordingly */ /* TODO we should get as many gobs as possible until MTU is reached, this * code seems to just get one GOB per packet */ - while (parsed_len + 2 < avail) { - if (parse_data[parsed_len] == 0 && parse_data[parsed_len + 1] == 0 - && parse_data[parsed_len + 2] >= 0x80) { - next_gop = parsed_len; - GST_DEBUG_OBJECT (rtph263ppay, " Next GOB Detected at : %d", - next_gop); - break; - } - parsed_len++; - } - gst_adapter_unmap (rtph263ppay->adapter, 0); + if (next_gop == 0 && avail > 3) + next_gop = + gst_adapter_masked_scan_uint32 (rtph263ppay->adapter, 0xffff8000, + 0x00008000, 3, avail - 3); + GST_DEBUG_OBJECT (rtph263ppay, " Next GOB Detected at : %d", next_gop); + if (next_gop == -1) + next_gop = 0; } /* for picture start frames (non-fragmented), we need to remove the first * two 0x00 bytes and set P=1 */ - header_len = (fragmented && !found_gob) ? 2 : 0; + if (!fragmented || found_gob) { + gst_adapter_flush (rtph263ppay->adapter, 2); + avail -= 2; + } + header_len = 2; towrite = MIN (avail, gst_rtp_buffer_calc_payload_len - (GST_BASE_RTP_PAYLOAD_MTU (rtph263ppay) - header_len, 0, 0)); + (GST_RTP_BASE_PAYLOAD_MTU (rtph263ppay) - header_len, 0, 0)); if (next_gop > 0) towrite = MIN (next_gop, towrite); - payload_len = header_len + towrite; - - outbuf = gst_rtp_buffer_new_allocate (payload_len, 0, 0); + outbuf = gst_rtp_buffer_new_allocate (header_len, 0, 0); gst_rtp_buffer_map (outbuf, GST_MAP_WRITE, &rtp); /* last fragment gets the marker bit set */ @@ -283,8 +742,6 @@ gst_rtp_h263p_pay_flush (GstRtpH263PPay * rtph263ppay) payload = gst_rtp_buffer_get_payload (&rtp); - gst_adapter_copy (rtph263ppay->adapter, &payload[header_len], 0, towrite); - /* 0 1 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ @@ -295,23 +752,47 @@ gst_rtp_h263p_pay_flush (GstRtpH263PPay * rtph263ppay) payload[0] = (fragmented && !found_gob) ? 0x00 : 0x04; payload[1] = 0; - GST_BUFFER_TIMESTAMP (outbuf) = rtph263ppay->first_timestamp; + GST_BUFFER_PTS (outbuf) = rtph263ppay->first_timestamp; GST_BUFFER_DURATION (outbuf) = rtph263ppay->first_duration; gst_rtp_buffer_unmap (&rtp); - gst_adapter_flush (rtph263ppay->adapter, towrite); + payload_buf = gst_adapter_take_buffer_fast (rtph263ppay->adapter, towrite); + gst_rtp_copy_video_meta (rtph263ppay, outbuf, payload_buf); + outbuf = gst_buffer_append (outbuf, payload_buf); + avail -= towrite; - ret = gst_basertppayload_push (GST_BASE_RTP_PAYLOAD (rtph263ppay), outbuf); + /* If more data is available and this is our first iteration, + * we create a buffer list and remember that we're fragmented. + * + * If we're fragmented already, add buffers to the previously + * created buffer list. + * + * Otherwise fragmented will be FALSE and we just push the single output + * buffer, and no list is allocated. + */ + if (avail && !fragmented) { + fragmented = TRUE; + list = gst_buffer_list_new (); + gst_buffer_list_add (list, outbuf); + } else if (fragmented) { + gst_buffer_list_add (list, outbuf); + } + } - avail -= towrite; - fragmented = TRUE; + if (fragmented) { + ret = + gst_rtp_base_payload_push_list (GST_RTP_BASE_PAYLOAD (rtph263ppay), + list); + } else { + ret = + gst_rtp_base_payload_push (GST_RTP_BASE_PAYLOAD (rtph263ppay), outbuf); } return ret; } static GstFlowReturn -gst_rtp_h263p_pay_handle_buffer (GstBaseRTPPayload * payload, +gst_rtp_h263p_pay_handle_buffer (GstRTPBasePayload * payload, GstBuffer * buffer) { GstRtpH263PPay *rtph263ppay; @@ -319,7 +800,7 @@ gst_rtp_h263p_pay_handle_buffer (GstBaseRTPPayload * payload, rtph263ppay = GST_RTP_H263P_PAY (payload); - rtph263ppay->first_timestamp = GST_BUFFER_TIMESTAMP (buffer); + rtph263ppay->first_timestamp = GST_BUFFER_PTS (buffer); rtph263ppay->first_duration = GST_BUFFER_DURATION (buffer); /* we always encode and flush a full picture */