gst/gdp/gstgdppay.c

   1 /* GStreamer
   2  * Copyright (C) 2006 Thomas Vander Stichele <thomas at apestaart dot org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /**
  21  * SECTION:element-gdppay
  22  * @see_also: gdpdepay
  23  *
  24  * <refsect2>
  25  * <para>
  26  * This element payloads GStreamer buffers and events using the
  27  * GStreamer Data Protocol.
  28  * </para>
  29  * <para>
  30  * <programlisting>
  31  * gst-launch -v -m videotestsrc num-buffers=50 ! gdppay ! filesink location=test.gdp
  32  * </programlisting>
  33  * This pipeline creates a serialized video stream that can be played back
  34  * with the example shown in gdpdepay.
  35  * </para>
  36  * </refsect2>
  37  */
  38
  39 #ifdef HAVE_CONFIG_H
  40 #include "config.h"
  41 #endif
  42
  43 #include <gst/dataprotocol/dataprotocol.h>
  44
  45 #include "gstgdppay.h"
  46
  47 /* elementfactory information */
  48 static const GstElementDetails gdp_pay_details =
  49 GST_ELEMENT_DETAILS ("GDP Payloader",
  50     "GDP/Payloader",
  51     "Payloads GStreamer Data Protocol buffers",
  52     "Thomas Vander Stichele <thomas at apestaart dot org>");
  53
  54 static GstStaticPadTemplate gdp_pay_sink_template =
  55 GST_STATIC_PAD_TEMPLATE ("sink",
  56     GST_PAD_SINK,
  57     GST_PAD_ALWAYS,
  58     GST_STATIC_CAPS_ANY);
  59
  60 static GstStaticPadTemplate gdp_pay_src_template =
  61 GST_STATIC_PAD_TEMPLATE ("src",
  62     GST_PAD_SRC,
  63     GST_PAD_ALWAYS,
  64     GST_STATIC_CAPS ("application/x-gdp"));
  65
  66 GST_DEBUG_CATEGORY_STATIC (gst_gdp_pay_debug);
  67 #define GST_CAT_DEFAULT gst_gdp_pay_debug
  68
  69 #define DEFAULT_CRC_HEADER TRUE
  70 #define DEFAULT_CRC_PAYLOAD FALSE
  71 #define DEFAULT_VERSION GST_DP_VERSION_1_0
  72
  73 enum
  74 {
  75   PROP_0,
  76   PROP_CRC_HEADER,
  77   PROP_CRC_PAYLOAD,
  78   PROP_VERSION,
  79 };
  80
  81 #define _do_init(x) \
  82     GST_DEBUG_CATEGORY_INIT (gst_gdp_pay_debug, "gdppay", 0, \
  83     "GDP payloader");
  84
  85 GST_BOILERPLATE_FULL (GstGDPPay, gst_gdp_pay, GstElement,
  86     GST_TYPE_ELEMENT, _do_init);
  87
  88 static GstFlowReturn gst_gdp_pay_chain (GstPad * pad, GstBuffer * buffer);
  89 static gboolean gst_gdp_pay_sink_event (GstPad * pad, GstEvent * event);
  90 static GstStateChangeReturn gst_gdp_pay_change_state (GstElement *
  91     element, GstStateChange transition);
  92
  93 static void gst_gdp_pay_set_property (GObject * object, guint prop_id,
  94     const GValue * value, GParamSpec * pspec);
  95 static void gst_gdp_pay_get_property (GObject * object, guint prop_id,
  96     GValue * value, GParamSpec * pspec);
  97
  98 static void gst_gdp_pay_dispose (GObject * gobject);
  99
 100 static void
 101 gst_gdp_pay_base_init (gpointer g_class)
 102 {
 103   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 104
 105   gst_element_class_set_details (element_class, &gdp_pay_details);
 106
 107   gst_element_class_add_pad_template (element_class,
 108       gst_static_pad_template_get (&gdp_pay_sink_template));
 109   gst_element_class_add_pad_template (element_class,
 110       gst_static_pad_template_get (&gdp_pay_src_template));
 111 }
 112
 113 static void
 114 gst_gdp_pay_class_init (GstGDPPayClass * klass)
 115 {
 116   GObjectClass *gobject_class;
 117   GstElementClass *gstelement_class;
 118
 119   gobject_class = (GObjectClass *) klass;
 120   gstelement_class = (GstElementClass *) klass;
 121
 122   gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_gdp_pay_set_property);
 123   gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_gdp_pay_get_property);
 124   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_gdp_pay_dispose);
 125   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_gdp_pay_change_state);
 126
 127   g_object_class_install_property (gobject_class, PROP_CRC_HEADER,
 128       g_param_spec_boolean ("crc-header", "CRC Header",
 129           "Calculate and store a CRC checksum on the header",
 130           DEFAULT_CRC_HEADER, G_PARAM_READWRITE));
 131   g_object_class_install_property (gobject_class, PROP_CRC_PAYLOAD,
 132       g_param_spec_boolean ("crc-payload", "CRC Payload",
 133           "Calculate and store a CRC checksum on the payload",
 134           DEFAULT_CRC_PAYLOAD, G_PARAM_READWRITE));
 135   g_object_class_install_property (gobject_class, PROP_VERSION,
 136       g_param_spec_enum ("version", "Version",
 137           "Version of the GStreamer Data Protocol",
 138           GST_TYPE_DP_VERSION, DEFAULT_VERSION, G_PARAM_READWRITE));
 139 }
 140
 141 static void
 142 gst_gdp_pay_init (GstGDPPay * gdppay, GstGDPPayClass * g_class)
 143 {
 144   gdppay->sinkpad =
 145       gst_pad_new_from_static_template (&gdp_pay_sink_template, "sink");
 146   gst_pad_set_chain_function (gdppay->sinkpad,
 147       GST_DEBUG_FUNCPTR (gst_gdp_pay_chain));
 148   gst_pad_set_event_function (gdppay->sinkpad,
 149       GST_DEBUG_FUNCPTR (gst_gdp_pay_sink_event));
 150   gst_element_add_pad (GST_ELEMENT (gdppay), gdppay->sinkpad);
 151
 152   gdppay->srcpad =
 153       gst_pad_new_from_static_template (&gdp_pay_src_template, "src");
 154   gst_element_add_pad (GST_ELEMENT (gdppay), gdppay->srcpad);
 155
 156   gdppay->offset = 0;
 157
 158   gdppay->crc_header = DEFAULT_CRC_HEADER;
 159   gdppay->crc_payload = DEFAULT_CRC_PAYLOAD;
 160   gdppay->header_flag = gdppay->crc_header | gdppay->crc_payload;
 161   gdppay->version = DEFAULT_VERSION;
 162 }
 163
 164 static void
 165 gst_gdp_pay_dispose (GObject * gobject)
 166 {
 167   GstGDPPay *this = GST_GDP_PAY (gobject);
 168
 169   if (this->caps_buf) {
 170     gst_buffer_unref (this->caps_buf);
 171     this->caps_buf = NULL;
 172   }
 173   if (this->new_segment_buf) {
 174     gst_buffer_unref (this->new_segment_buf);
 175     this->new_segment_buf = NULL;
 176   }
 177   GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (gobject));
 178 }
 179
 180 /* set OFFSET and OFFSET_END with running count */
 181 static void
 182 gst_gdp_stamp_buffer (GstGDPPay * this, GstBuffer * buffer)
 183 {
 184   GST_BUFFER_OFFSET (buffer) = this->offset;
 185   GST_BUFFER_OFFSET_END (buffer) = this->offset + GST_BUFFER_SIZE (buffer);
 186   this->offset = GST_BUFFER_OFFSET_END (buffer);
 187 }
 188
 189 static GstBuffer *
 190 gst_gdp_buffer_from_caps (GstGDPPay * this, GstCaps * caps)
 191 {
 192   GstBuffer *headerbuf;
 193   GstBuffer *payloadbuf;
 194   guint8 *header, *payload;
 195   guint len;
 196
 197   if (!this->packetizer->packet_from_caps (caps, this->header_flag, &len,
 198           &header, &payload)) {
 199     GST_WARNING_OBJECT (this, "could not create GDP header from caps");
 200     return NULL;
 201   }
 202
 203   GST_LOG_OBJECT (this, "creating GDP header and payload buffer from caps");
 204   headerbuf = gst_buffer_new ();
 205   gst_buffer_set_data (headerbuf, header, len);
 206   GST_BUFFER_MALLOCDATA (headerbuf) = header;
 207
 208   payloadbuf = gst_buffer_new ();
 209   gst_buffer_set_data (payloadbuf, payload,
 210       gst_dp_header_payload_length (header));
 211   GST_BUFFER_MALLOCDATA (payloadbuf) = payload;
 212
 213   return gst_buffer_join (headerbuf, payloadbuf);
 214 }
 215
 216 static GstBuffer *
 217 gst_gdp_pay_buffer_from_buffer (GstGDPPay * this, GstBuffer * buffer)
 218 {
 219   GstBuffer *headerbuf;
 220   guint8 *header;
 221   guint len;
 222
 223   if (!this->packetizer->header_from_buffer (buffer, this->header_flag, &len,
 224           &header)) {
 225     GST_WARNING_OBJECT (this, "could not create GDP header from buffer");
 226     return NULL;
 227   }
 228
 229   GST_LOG_OBJECT (this, "creating GDP header and payload buffer from buffer");
 230   headerbuf = gst_buffer_new ();
 231   gst_buffer_set_data (headerbuf, header, len);
 232   GST_BUFFER_MALLOCDATA (headerbuf) = header;
 233
 234   /* we do not want to lose the ref on the incoming buffer */
 235   gst_buffer_ref (buffer);
 236   return gst_buffer_join (headerbuf, buffer);
 237 }
 238
 239 static GstBuffer *
 240 gst_gdp_buffer_from_event (GstGDPPay * this, GstEvent * event)
 241 {
 242   GstBuffer *headerbuf;
 243   GstBuffer *payloadbuf;
 244   guint8 *header, *payload;
 245   guint len;
 246   gboolean ret;
 247
 248   ret =
 249       this->packetizer->packet_from_event (event, this->header_flag, &len,
 250       &header, &payload);
 251
 252   if (!ret) {
 253     GST_WARNING_OBJECT (this, "could not create GDP header from event %s (%d)",
 254         gst_event_type_get_name (event->type), event->type);
 255     return NULL;
 256   }
 257
 258   GST_LOG_OBJECT (this, "creating GDP header and payload buffer from event");
 259   headerbuf = gst_buffer_new ();
 260   gst_buffer_set_data (headerbuf, header, len);
 261   GST_BUFFER_MALLOCDATA (headerbuf) = header;
 262
 263   payloadbuf = gst_buffer_new ();
 264   gst_buffer_set_data (payloadbuf, payload,
 265       gst_dp_header_payload_length (header));
 266   GST_BUFFER_MALLOCDATA (payloadbuf) = payload;
 267
 268   return gst_buffer_join (headerbuf, payloadbuf);
 269 }
 270
 271
 272 /* set our caps with streamheader, based on the latest newsegment and caps,
 273  * and (possibly) GDP-serialized buffers of the streamheaders on the src pad */
 274 static GstFlowReturn
 275 gst_gdp_pay_reset_streamheader (GstGDPPay * this)
 276 {
 277   GstCaps *caps;
 278   GstStructure *structure;
 279   GstBuffer *new_segment_buf = NULL, *caps_buf, *tag_buf = NULL;
 280   GstFlowReturn r = GST_FLOW_OK;
 281   gboolean version_one_zero = TRUE;
 282
 283   GValue array = { 0 };
 284   GValue value = { 0 };
 285
 286   /* In version 0.2, we didn't need or send new segment or tags */
 287   if (this->version == GST_DP_VERSION_0_2)
 288     version_one_zero = FALSE;
 289
 290   if (version_one_zero) {
 291     if (!this->new_segment_buf || !this->caps_buf)
 292       return GST_FLOW_OK;
 293   } else {
 294     if (!this->caps_buf)
 295       return GST_FLOW_OK;
 296   }
 297
 298   /* put copies of the buffers in a fixed list */
 299   g_value_init (&array, GST_TYPE_ARRAY);
 300
 301   if (version_one_zero) {
 302     new_segment_buf = gst_buffer_copy (this->new_segment_buf);
 303     g_value_init (&value, GST_TYPE_BUFFER);
 304     gst_value_set_buffer (&value, new_segment_buf);
 305     gst_value_array_append_value (&array, &value);
 306     g_value_unset (&value);
 307
 308     if (this->tag_buf) {
 309       tag_buf = gst_buffer_copy (this->tag_buf);
 310       g_value_init (&value, GST_TYPE_BUFFER);
 311       gst_value_set_buffer (&value, tag_buf);
 312       gst_value_array_append_value (&array, &value);
 313       g_value_unset (&value);
 314     }
 315   }
 316
 317   caps_buf = gst_buffer_copy (this->caps_buf);
 318   g_value_init (&value, GST_TYPE_BUFFER);
 319   gst_value_set_buffer (&value, caps_buf);
 320   gst_value_array_append_value (&array, &value);
 321   g_value_unset (&value);
 322
 323   /* we also need to add GDP serializations of the streamheaders of the
 324    * incoming caps */
 325   structure = gst_caps_get_structure (this->caps, 0);
 326   if (gst_structure_has_field (structure, "streamheader")) {
 327     const GValue *sh;
 328     GArray *buffers;
 329     GstBuffer *buffer;
 330     int i;
 331
 332     sh = gst_structure_get_value (structure, "streamheader");
 333     buffers = g_value_peek_pointer (sh);
 334     GST_DEBUG_OBJECT (this,
 335         "Need to serialize %d incoming streamheader buffers on ours",
 336         buffers->len);
 337     for (i = 0; i < buffers->len; ++i) {
 338       GValue *bufval;
 339       GstBuffer *outbuffer;
 340
 341       bufval = &g_array_index (buffers, GValue, i);
 342       buffer = g_value_peek_pointer (bufval);
 343       outbuffer = gst_gdp_pay_buffer_from_buffer (this, buffer);
 344       if (outbuffer) {
 345         g_value_init (&value, GST_TYPE_BUFFER);
 346         gst_value_set_buffer (&value, outbuffer);
 347         gst_value_array_append_value (&array, &value);
 348         g_value_unset (&value);
 349       }
 350       /* FIXME: if one or more in this loop fail to produce an outbuffer,
 351        * should we error out ? Once ? Every time ? */
 352     }
 353   }
 354
 355   caps = gst_caps_from_string ("application/x-gdp");
 356   structure = gst_caps_get_structure (caps, 0);
 357
 358   gst_structure_set_value (structure, "streamheader", &array);
 359   g_value_unset (&array);
 360
 361   /* Unref our copies */
 362   if (new_segment_buf)
 363     gst_buffer_unref (new_segment_buf);
 364   gst_buffer_unref (caps_buf);
 365
 366   GST_DEBUG_OBJECT (this, "Setting caps on src pad %" GST_PTR_FORMAT, caps);
 367   gst_pad_set_caps (this->srcpad, caps);
 368   gst_buffer_set_caps (this->caps_buf, caps);
 369   gst_buffer_set_caps (this->new_segment_buf, caps);
 370
 371   /* if these are our first ever buffers, send out new_segment first */
 372   if (!this->sent_streamheader) {
 373     GstEvent *event =
 374         gst_event_new_new_segment (TRUE, 1.0, GST_FORMAT_BYTES, 0, -1, 0);
 375     GST_DEBUG_OBJECT (this, "Sending out new_segment event %p", event);
 376     if (!gst_pad_push_event (this->srcpad, event)) {
 377       GST_WARNING_OBJECT (this, "pushing new segment failed");
 378       return GST_FLOW_ERROR;
 379     }
 380   }
 381
 382   /* push out these streamheader buffers, then flush our internal queue */
 383   GST_DEBUG_OBJECT (this, "Pushing GDP new_segment buffer %p",
 384       this->new_segment_buf);
 385   /* we stored these bufs with refcount 1, so make sure we keep a ref */
 386   r = gst_pad_push (this->srcpad, gst_buffer_ref (this->new_segment_buf));
 387   if (r != GST_FLOW_OK) {
 388     GST_WARNING_OBJECT (this, "pushing GDP newsegment buffer returned %d", r);
 389     return r;
 390   }
 391   if (this->tag_buf) {
 392     GST_DEBUG_OBJECT (this, "Pushing GDP tag buffer %p", this->tag_buf);
 393     /* we stored these bufs with refcount 1, so make sure we keep a ref */
 394     r = gst_pad_push (this->srcpad, gst_buffer_ref (this->tag_buf));
 395     if (r != GST_FLOW_OK) {
 396       GST_WARNING_OBJECT (this, "pushing GDP tag buffer returned %d", r);
 397       return r;
 398     }
 399   }
 400   GST_DEBUG_OBJECT (this, "Pushing GDP caps buffer %p", this->new_segment_buf);
 401   r = gst_pad_push (this->srcpad, gst_buffer_ref (this->caps_buf));
 402   if (r != GST_FLOW_OK) {
 403     GST_WARNING_OBJECT (this, "pushing GDP caps buffer returned %d", r);
 404     return r;
 405   }
 406   this->sent_streamheader = TRUE;
 407   GST_DEBUG_OBJECT (this, "need to push %d queued buffers",
 408       g_list_length (this->queue));
 409   if (this->queue) {
 410     GList *l;
 411
 412     for (l = this->queue; l; l = g_list_next (l)) {
 413       GST_DEBUG_OBJECT (this, "Pushing queued GDP buffer %p", l->data);
 414       gst_buffer_set_caps (l->data, caps);
 415       r = gst_pad_push (this->srcpad, l->data);
 416       if (r != GST_FLOW_OK) {
 417         GST_WARNING_OBJECT (this, "pushing queued GDP buffer returned %d", r);
 418         return r;
 419       }
 420     }
 421   }
 422
 423   return r;
 424 }
 425
 426 /* queue a buffer internally if we haven't sent streamheader buffers yet;
 427  * otherwise, just push on */
 428 static GstFlowReturn
 429 gst_gdp_queue_buffer (GstGDPPay * this, GstBuffer * buffer)
 430 {
 431   if (this->sent_streamheader) {
 432     GST_LOG_OBJECT (this, "Pushing GDP buffer %p", buffer);
 433     GST_LOG_OBJECT (this, "set caps %" GST_PTR_FORMAT, this->caps);
 434     return gst_pad_push (this->srcpad, buffer);
 435   }
 436
 437   /* store it on an internal queue */
 438   this->queue = g_list_append (this->queue, buffer);
 439   GST_DEBUG_OBJECT (this, "queued buffer %p, now %d buffers queued",
 440       buffer, g_list_length (this->queue));
 441   return GST_FLOW_OK;
 442 }
 443
 444 static GstFlowReturn
 445 gst_gdp_pay_chain (GstPad * pad, GstBuffer * buffer)
 446 {
 447   GstGDPPay *this;
 448   GstCaps *caps;
 449   GstBuffer *outbuffer;
 450   GstFlowReturn ret;
 451
 452   this = GST_GDP_PAY (gst_pad_get_parent (pad));
 453
 454   /* we should have received a new_segment before, otherwise it's a bug.
 455    * fake one in that case */
 456   if (!this->new_segment_buf) {
 457     GstEvent *event;
 458
 459     GST_WARNING_OBJECT (this,
 460         "did not receive new-segment before first buffer");
 461     event = gst_event_new_new_segment (TRUE, 1.0, GST_FORMAT_BYTES, 0, -1, 0);
 462     outbuffer = gst_gdp_buffer_from_event (this, event);
 463     gst_event_unref (event);
 464
 465     /* GDP 0.2 doesn't know about new-segment, so this is not fatal */
 466     if (!outbuffer) {
 467       GST_ELEMENT_WARNING (this, STREAM, ENCODE, (NULL),
 468           ("Could not create GDP buffer from new segment event"));
 469 /*
 470       ret = GST_FLOW_ERROR;
 471       goto done;
 472 */
 473     } else {
 474
 475       gst_gdp_stamp_buffer (this, outbuffer);
 476       GST_BUFFER_TIMESTAMP (outbuffer) = GST_BUFFER_TIMESTAMP (buffer);
 477       GST_BUFFER_DURATION (outbuffer) = 0;
 478       GST_DEBUG_OBJECT (this, "Storing buffer %p as new_segment_buf",
 479           outbuffer);
 480       this->new_segment_buf = outbuffer;
 481     }
 482   }
 483
 484   /* make sure we've received caps before */
 485   caps = gst_buffer_get_caps (buffer);
 486   if (!this->caps && !caps) {
 487     GST_WARNING_OBJECT (this, "first received buffer does not have caps set");
 488     if (caps)
 489       gst_caps_unref (caps);
 490     ret = GST_FLOW_NOT_NEGOTIATED;
 491     goto done;
 492   }
 493
 494   /* if the caps have changed, process caps first */
 495   if (caps && !gst_caps_is_equal (this->caps, caps)) {
 496     GST_LOG_OBJECT (this, "caps changed to %p, %" GST_PTR_FORMAT, caps, caps);
 497     gst_caps_replace (&(this->caps), caps);
 498     outbuffer = gst_gdp_buffer_from_caps (this, caps);
 499     if (!outbuffer) {
 500       GST_ELEMENT_ERROR (this, STREAM, ENCODE, (NULL),
 501           ("Could not create GDP buffer from caps %" GST_PTR_FORMAT, caps));
 502       gst_caps_unref (caps);
 503       ret = GST_FLOW_ERROR;
 504       goto done;
 505     }
 506
 507     gst_gdp_stamp_buffer (this, outbuffer);
 508     GST_BUFFER_TIMESTAMP (outbuffer) = GST_BUFFER_TIMESTAMP (buffer);
 509     GST_BUFFER_DURATION (outbuffer) = 0;
 510     GST_BUFFER_FLAG_SET (outbuffer, GST_BUFFER_FLAG_IN_CAPS);
 511     this->caps_buf = outbuffer;
 512     gst_gdp_pay_reset_streamheader (this);
 513   }
 514
 515   /* create a GDP header packet,
 516    * then create a GST buffer of the header packet and the buffer contents */
 517   outbuffer = gst_gdp_pay_buffer_from_buffer (this, buffer);
 518   if (!outbuffer) {
 519     GST_ELEMENT_ERROR (this, STREAM, ENCODE, (NULL),
 520         ("Could not create GDP buffer from buffer"));
 521     ret = GST_FLOW_ERROR;
 522     goto done;
 523   }
 524
 525   gst_gdp_stamp_buffer (this, outbuffer);
 526   GST_BUFFER_TIMESTAMP (outbuffer) = GST_BUFFER_TIMESTAMP (buffer);
 527   GST_BUFFER_DURATION (outbuffer) = GST_BUFFER_DURATION (buffer);
 528
 529   ret = gst_gdp_queue_buffer (this, outbuffer);
 530
 531 done:
 532   gst_buffer_unref (buffer);
 533   gst_object_unref (this);
 534   return ret;
 535 }
 536
 537 static gboolean
 538 gst_gdp_pay_sink_event (GstPad * pad, GstEvent * event)
 539 {
 540   GstBuffer *outbuffer;
 541   GstGDPPay *this = GST_GDP_PAY (gst_pad_get_parent (pad));
 542   GstFlowReturn flowret;
 543   gboolean ret = TRUE;
 544
 545   GST_DEBUG_OBJECT (this, "received event %p of type %s (%d)",
 546       event, gst_event_type_get_name (event->type), event->type);
 547
 548   /* now turn the event into a buffer */
 549   outbuffer = gst_gdp_buffer_from_event (this, event);
 550   if (!outbuffer) {
 551     GST_ELEMENT_WARNING (this, STREAM, ENCODE, (NULL),
 552         ("Could not create GDP buffer from received event (type %s)",
 553             gst_event_type_get_name (event->type)));
 554     ret = FALSE;
 555     goto done;
 556   }
 557   gst_gdp_stamp_buffer (this, outbuffer);
 558   GST_BUFFER_TIMESTAMP (outbuffer) = GST_EVENT_TIMESTAMP (event);
 559   GST_BUFFER_DURATION (outbuffer) = 0;
 560
 561   /* if we got a new segment, we should put it on our streamheader,
 562    * and not send it on */
 563   switch (GST_EVENT_TYPE (event)) {
 564     case GST_EVENT_NEWSEGMENT:
 565       GST_DEBUG_OBJECT (this, "received new_segment event");
 566       if (this->new_segment_buf) {
 567         gst_buffer_unref (this->new_segment_buf);
 568       }
 569       GST_DEBUG_OBJECT (this, "Storing buffer %p as new_segment_buf",
 570           outbuffer);
 571       this->new_segment_buf = outbuffer;
 572       gst_gdp_pay_reset_streamheader (this);
 573       break;
 574     case GST_EVENT_TAG:
 575       GST_DEBUG_OBJECT (this, "received tag event");
 576       if (this->tag_buf) {
 577         gst_buffer_unref (this->tag_buf);
 578       }
 579       GST_DEBUG_OBJECT (this, "Storing buffer %p as tag_buf", outbuffer);
 580       this->tag_buf = outbuffer;
 581       gst_gdp_pay_reset_streamheader (this);
 582       break;
 583     default:
 584       GST_DEBUG_OBJECT (this, "queuing GDP buffer %p of event %p", outbuffer,
 585           event);
 586       flowret = gst_gdp_queue_buffer (this, outbuffer);
 587       if (flowret != GST_FLOW_OK) {
 588         GST_WARNING_OBJECT (this, "queueing GDP event buffer returned %d",
 589             flowret);
 590         ret = FALSE;
 591         goto done;
 592       }
 593       break;
 594   }
 595
 596   /* if we have EOS, we should send on EOS ourselves */
 597   if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
 598     GST_DEBUG_OBJECT (this, "Sending on EOS event %p", event);
 599     return gst_pad_push_event (this->srcpad, event);
 600   };
 601
 602 done:
 603   gst_object_unref (this);
 604   gst_event_unref (event);
 605   return ret;
 606 }
 607
 608 static void
 609 gst_gdp_pay_set_property (GObject * object, guint prop_id,
 610     const GValue * value, GParamSpec * pspec)
 611 {
 612   GstGDPPay *this;
 613
 614   g_return_if_fail (GST_IS_GDP_PAY (object));
 615   this = GST_GDP_PAY (object);
 616
 617   switch (prop_id) {
 618     case PROP_CRC_HEADER:
 619       this->crc_header =
 620           g_value_get_boolean (value) ? GST_DP_HEADER_FLAG_CRC_HEADER : 0;
 621       this->header_flag = this->crc_header | this->crc_payload;
 622       break;
 623     case PROP_CRC_PAYLOAD:
 624       this->crc_payload =
 625           g_value_get_boolean (value) ? GST_DP_HEADER_FLAG_CRC_PAYLOAD : 0;
 626       this->header_flag = this->crc_header | this->crc_payload;
 627       break;
 628     case PROP_VERSION:
 629       this->version = g_value_get_enum (value);
 630       break;
 631     default:
 632       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 633       break;
 634   }
 635 }
 636
 637 static void
 638 gst_gdp_pay_get_property (GObject * object, guint prop_id,
 639     GValue * value, GParamSpec * pspec)
 640 {
 641   GstGDPPay *this;
 642
 643   g_return_if_fail (GST_IS_GDP_PAY (object));
 644   this = GST_GDP_PAY (object);
 645
 646   switch (prop_id) {
 647     case PROP_CRC_HEADER:
 648       g_value_set_boolean (value, this->crc_header);
 649       break;
 650     case PROP_CRC_PAYLOAD:
 651       g_value_set_boolean (value, this->crc_payload);
 652       break;
 653     case PROP_VERSION:
 654       g_value_set_enum (value, this->version);
 655       break;
 656     default:
 657       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 658       break;
 659   }
 660 }
 661
 662 static GstStateChangeReturn
 663 gst_gdp_pay_change_state (GstElement * element, GstStateChange transition)
 664 {
 665   GstStateChangeReturn ret;
 666   GstGDPPay *this = GST_GDP_PAY (element);
 667
 668   switch (transition) {
 669     case GST_STATE_CHANGE_READY_TO_PAUSED:
 670       this->packetizer = gst_dp_packetizer_new (this->version);
 671       break;
 672     default:
 673       break;
 674   }
 675
 676   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 677
 678   switch (transition) {
 679     case GST_STATE_CHANGE_PAUSED_TO_READY:
 680       if (this->packetizer) {
 681         gst_dp_packetizer_free (this->packetizer);
 682         this->packetizer = NULL;
 683       }
 684       break;
 685     case GST_STATE_CHANGE_READY_TO_NULL:
 686       if (this->caps) {
 687         gst_caps_unref (this->caps);
 688         this->caps = NULL;
 689       }
 690       break;
 691     default:
 692       break;
 693   }
 694
 695   return ret;
 696 }
 697
 698 gboolean
 699 gst_gdp_pay_plugin_init (GstPlugin * plugin)
 700 {
 701   if (!gst_element_register (plugin, "gdppay", GST_RANK_NONE, GST_TYPE_GDP_PAY))
 702     return FALSE;
 703
 704   return TRUE;
 705 }