gst/gdp/gstgdpdepay.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-gdpdepay
  22  * @see_also: gdppay
  23  *
  24  * This element depayloads GStreamer Data Protocol buffers back to deserialized
  25  * buffers and events.
  26  *
  27  * <refsect2>
  28  * |[
  29  * gst-launch -v -m filesrc location=test.gdp ! gdpdepay ! xvimagesink
  30  * ]| This pipeline plays back a serialized video stream as created in the
  31  * example for gdppay.
  32  * </refsect2>
  33  */
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include "config.h"
  37 #endif
  38
  39 #include <string.h>
  40
  41 #include <gst/dataprotocol/dataprotocol.h>
  42
  43 #include "gstgdpdepay.h"
  44
  45 enum
  46 {
  47   PROP_0,
  48 };
  49
  50 static GstStaticPadTemplate gdp_depay_sink_template =
  51 GST_STATIC_PAD_TEMPLATE ("sink",
  52     GST_PAD_SINK,
  53     GST_PAD_ALWAYS,
  54     GST_STATIC_CAPS ("application/x-gdp"));
  55
  56 static GstStaticPadTemplate gdp_depay_src_template =
  57 GST_STATIC_PAD_TEMPLATE ("src",
  58     GST_PAD_SRC,
  59     GST_PAD_ALWAYS,
  60     GST_STATIC_CAPS_ANY);
  61
  62 GST_DEBUG_CATEGORY_STATIC (gst_gdp_depay_debug);
  63 #define GST_CAT_DEFAULT gst_gdp_depay_debug
  64
  65 #define _do_init \
  66     GST_DEBUG_CATEGORY_INIT (gst_gdp_depay_debug, "gdpdepay", 0, \
  67     "GDP depayloader");
  68 #define gst_gdp_depay_parent_class parent_class
  69 G_DEFINE_TYPE_WITH_CODE (GstGDPDepay, gst_gdp_depay,
  70     GST_TYPE_ELEMENT, _do_init);
  71
  72 static gboolean gst_gdp_depay_sink_event (GstPad * pad, GstEvent * event);
  73 static gboolean gst_gdp_depay_src_event (GstPad * pad, GstEvent * event);
  74
  75 static GstFlowReturn gst_gdp_depay_chain (GstPad * pad, GstBuffer * buffer);
  76
  77 static GstStateChangeReturn gst_gdp_depay_change_state (GstElement *
  78     element, GstStateChange transition);
  79
  80 static void gst_gdp_depay_finalize (GObject * object);
  81
  82 static void
  83 gst_gdp_depay_class_init (GstGDPDepayClass * klass)
  84 {
  85   GObjectClass *gobject_class;
  86   GstElementClass *gstelement_class;
  87
  88   gobject_class = (GObjectClass *) klass;
  89   gstelement_class = (GstElementClass *) klass;
  90
  91   gst_element_class_set_details_simple (gstelement_class,
  92       "GDP Depayloader", "GDP/Depayloader",
  93       "Depayloads GStreamer Data Protocol buffers",
  94       "Thomas Vander Stichele <thomas at apestaart dot org>");
  95
  96   gst_element_class_add_pad_template (gstelement_class,
  97       gst_static_pad_template_get (&gdp_depay_sink_template));
  98   gst_element_class_add_pad_template (gstelement_class,
  99       gst_static_pad_template_get (&gdp_depay_src_template));
 100
 101   gstelement_class->change_state =
 102       GST_DEBUG_FUNCPTR (gst_gdp_depay_change_state);
 103   gobject_class->finalize = gst_gdp_depay_finalize;
 104 }
 105
 106 static void
 107 gst_gdp_depay_init (GstGDPDepay * gdpdepay)
 108 {
 109   gdpdepay->sinkpad =
 110       gst_pad_new_from_static_template (&gdp_depay_sink_template, "sink");
 111   gst_pad_set_chain_function (gdpdepay->sinkpad,
 112       GST_DEBUG_FUNCPTR (gst_gdp_depay_chain));
 113   gst_pad_set_event_function (gdpdepay->sinkpad,
 114       GST_DEBUG_FUNCPTR (gst_gdp_depay_sink_event));
 115   gst_element_add_pad (GST_ELEMENT (gdpdepay), gdpdepay->sinkpad);
 116
 117   gdpdepay->srcpad =
 118       gst_pad_new_from_static_template (&gdp_depay_src_template, "src");
 119   gst_pad_set_event_function (gdpdepay->srcpad,
 120       GST_DEBUG_FUNCPTR (gst_gdp_depay_src_event));
 121   /* our caps will always be decided by the incoming GDP caps buffers */
 122   gst_pad_use_fixed_caps (gdpdepay->srcpad);
 123   gst_element_add_pad (GST_ELEMENT (gdpdepay), gdpdepay->srcpad);
 124
 125   gdpdepay->adapter = gst_adapter_new ();
 126 }
 127
 128 static void
 129 gst_gdp_depay_finalize (GObject * gobject)
 130 {
 131   GstGDPDepay *this;
 132
 133   this = GST_GDP_DEPAY (gobject);
 134   if (this->caps)
 135     gst_caps_unref (this->caps);
 136   g_free (this->header);
 137   gst_adapter_clear (this->adapter);
 138   g_object_unref (this->adapter);
 139
 140   GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (gobject));
 141 }
 142
 143 static gboolean
 144 gst_gdp_depay_sink_event (GstPad * pad, GstEvent * event)
 145 {
 146   GstGDPDepay *this;
 147   gboolean res = TRUE;
 148
 149   this = GST_GDP_DEPAY (gst_pad_get_parent (pad));
 150
 151   switch (GST_EVENT_TYPE (event)) {
 152     case GST_EVENT_FLUSH_START:
 153       /* forward flush start */
 154       res = gst_pad_push_event (this->srcpad, event);
 155       break;
 156     case GST_EVENT_FLUSH_STOP:
 157       /* clear adapter on flush */
 158       gst_adapter_clear (this->adapter);
 159       /* forward flush stop */
 160       res = gst_pad_push_event (this->srcpad, event);
 161       break;
 162     case GST_EVENT_EOS:
 163       /* after EOS, we don't expect to output anything anymore */
 164       res = gst_pad_push_event (this->srcpad, event);
 165       break;
 166     case GST_EVENT_SEGMENT:
 167     case GST_EVENT_TAG:
 168     case GST_EVENT_BUFFERSIZE:
 169     default:
 170       /* we unref most events as we take them from the datastream */
 171       gst_event_unref (event);
 172       break;
 173   }
 174   gst_object_unref (this);
 175
 176   return res;
 177 }
 178
 179 static gboolean
 180 gst_gdp_depay_src_event (GstPad * pad, GstEvent * event)
 181 {
 182   GstGDPDepay *this;
 183   gboolean res = TRUE;
 184
 185   this = GST_GDP_DEPAY (gst_pad_get_parent (pad));
 186
 187   switch (GST_EVENT_TYPE (event)) {
 188     case GST_EVENT_SEEK:
 189       /* we refuse seek for now. */
 190       gst_event_unref (event);
 191       res = FALSE;
 192       break;
 193     case GST_EVENT_QOS:
 194     case GST_EVENT_NAVIGATION:
 195     default:
 196       /* everything else is passed */
 197       res = gst_pad_push_event (this->sinkpad, event);
 198       break;
 199   }
 200   gst_object_unref (this);
 201
 202   return res;
 203 }
 204
 205 static GstFlowReturn
 206 gst_gdp_depay_chain (GstPad * pad, GstBuffer * buffer)
 207 {
 208   GstGDPDepay *this;
 209   GstFlowReturn ret = GST_FLOW_OK;
 210   GstCaps *caps;
 211   GstBuffer *buf;
 212   GstEvent *event;
 213   guint available;
 214
 215   this = GST_GDP_DEPAY (gst_pad_get_parent (pad));
 216
 217   /* On DISCONT, get rid of accumulated data. We assume a buffer after the
 218    * DISCONT contains (part of) a new valid header, if not we error because we
 219    * lost sync */
 220   if (GST_BUFFER_IS_DISCONT (buffer)) {
 221     gst_adapter_clear (this->adapter);
 222     this->state = GST_GDP_DEPAY_STATE_HEADER;
 223   }
 224   gst_adapter_push (this->adapter, buffer);
 225
 226   while (TRUE) {
 227     switch (this->state) {
 228       case GST_GDP_DEPAY_STATE_HEADER:
 229       {
 230         guint8 *header;
 231
 232         /* collect a complete header, validate and store the header. Figure out
 233          * the payload length and switch to the PAYLOAD state */
 234         available = gst_adapter_available (this->adapter);
 235         if (available < GST_DP_HEADER_LENGTH)
 236           goto done;
 237
 238         GST_LOG_OBJECT (this, "reading GDP header from adapter");
 239         header = gst_adapter_take (this->adapter, GST_DP_HEADER_LENGTH);
 240         if (!gst_dp_validate_header (GST_DP_HEADER_LENGTH, header)) {
 241           g_free (header);
 242           goto header_validate_error;
 243         }
 244
 245         /* store types and payload length. Also store the header, which we need
 246          * to make the payload. */
 247         this->payload_length = gst_dp_header_payload_length (header);
 248         this->payload_type = gst_dp_header_payload_type (header);
 249         /* free previous header and store new one. */
 250         g_free (this->header);
 251         this->header = header;
 252
 253         GST_LOG_OBJECT (this,
 254             "read GDP header, payload size %d, payload type %d, switching to state PAYLOAD",
 255             this->payload_length, this->payload_type);
 256         this->state = GST_GDP_DEPAY_STATE_PAYLOAD;
 257         break;
 258       }
 259       case GST_GDP_DEPAY_STATE_PAYLOAD:
 260       {
 261         /* in this state we wait for all the payload data to be available in the
 262          * adapter. Then we switch to the state where we actually process the
 263          * payload. */
 264         available = gst_adapter_available (this->adapter);
 265         if (available < this->payload_length)
 266           goto done;
 267
 268         /* change state based on type */
 269         if (this->payload_type == GST_DP_PAYLOAD_BUFFER) {
 270           GST_LOG_OBJECT (this, "switching to state BUFFER");
 271           this->state = GST_GDP_DEPAY_STATE_BUFFER;
 272         } else if (this->payload_type == GST_DP_PAYLOAD_CAPS) {
 273           GST_LOG_OBJECT (this, "switching to state CAPS");
 274           this->state = GST_GDP_DEPAY_STATE_CAPS;
 275         } else if (this->payload_type >= GST_DP_PAYLOAD_EVENT_NONE) {
 276           GST_LOG_OBJECT (this, "switching to state EVENT");
 277           this->state = GST_GDP_DEPAY_STATE_EVENT;
 278         } else {
 279           goto wrong_type;
 280         }
 281
 282         if (this->payload_length) {
 283           const guint8 *data;
 284           gboolean res;
 285
 286           data = gst_adapter_map (this->adapter, this->payload_length);
 287           res = gst_dp_validate_payload (GST_DP_HEADER_LENGTH, this->header,
 288               data);
 289           gst_adapter_unmap (this->adapter, 0);
 290
 291           if (!res)
 292             goto payload_validate_error;
 293         }
 294
 295         break;
 296       }
 297       case GST_GDP_DEPAY_STATE_BUFFER:
 298       {
 299         /* if we receive a buffer without caps first, we error out */
 300         if (!this->caps)
 301           goto no_caps;
 302
 303         GST_LOG_OBJECT (this, "reading GDP buffer from adapter");
 304         buf = gst_dp_buffer_from_header (GST_DP_HEADER_LENGTH, this->header);
 305         if (!buf)
 306           goto buffer_failed;
 307
 308         /* now take the payload if there is any */
 309         if (this->payload_length > 0) {
 310           guint8 *payload;
 311
 312           payload = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
 313           gst_adapter_copy (this->adapter, payload, 0, this->payload_length);
 314           gst_buffer_unmap (buf, payload, this->payload_length);
 315
 316           gst_adapter_flush (this->adapter, this->payload_length);
 317         }
 318
 319         /* set caps and push */
 320         GST_LOG_OBJECT (this, "deserialized buffer %p, pushing, timestamp %"
 321             GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT
 322             ", offset %" G_GINT64_FORMAT ", offset_end %" G_GINT64_FORMAT
 323             ", size %" G_GSIZE_FORMAT ", flags 0x%x",
 324             buf,
 325             GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
 326             GST_TIME_ARGS (GST_BUFFER_DURATION (buf)),
 327             GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET_END (buf),
 328             gst_buffer_get_size (buf), GST_BUFFER_FLAGS (buf));
 329         ret = gst_pad_push (this->srcpad, buf);
 330         if (ret != GST_FLOW_OK)
 331           goto push_error;
 332
 333         GST_LOG_OBJECT (this, "switching to state HEADER");
 334         this->state = GST_GDP_DEPAY_STATE_HEADER;
 335         break;
 336       }
 337       case GST_GDP_DEPAY_STATE_CAPS:
 338       {
 339         guint8 *payload;
 340
 341         /* take the payload of the caps */
 342         GST_LOG_OBJECT (this, "reading GDP caps from adapter");
 343         payload = gst_adapter_take (this->adapter, this->payload_length);
 344         caps = gst_dp_caps_from_packet (GST_DP_HEADER_LENGTH, this->header,
 345             payload);
 346         g_free (payload);
 347         if (!caps)
 348           goto caps_failed;
 349
 350         GST_DEBUG_OBJECT (this, "deserialized caps %" GST_PTR_FORMAT, caps);
 351         gst_caps_replace (&(this->caps), caps);
 352         gst_pad_set_caps (this->srcpad, caps);
 353         /* drop the creation ref we still have */
 354         gst_caps_unref (caps);
 355
 356         GST_LOG_OBJECT (this, "switching to state HEADER");
 357         this->state = GST_GDP_DEPAY_STATE_HEADER;
 358         break;
 359       }
 360       case GST_GDP_DEPAY_STATE_EVENT:
 361       {
 362         guint8 *payload;
 363
 364         GST_LOG_OBJECT (this, "reading GDP event from adapter");
 365
 366         /* adapter doesn't like 0 length payload */
 367         if (this->payload_length > 0)
 368           payload = gst_adapter_take (this->adapter, this->payload_length);
 369         else
 370           payload = NULL;
 371         event = gst_dp_event_from_packet (GST_DP_HEADER_LENGTH, this->header,
 372             payload);
 373         g_free (payload);
 374         if (!event)
 375           goto event_failed;
 376
 377         GST_DEBUG_OBJECT (this, "deserialized event %p of type %s, pushing",
 378             event, gst_event_type_get_name (event->type));
 379         gst_pad_push_event (this->srcpad, event);
 380
 381         GST_LOG_OBJECT (this, "switching to state HEADER");
 382         this->state = GST_GDP_DEPAY_STATE_HEADER;
 383         break;
 384       }
 385     }
 386   }
 387
 388 done:
 389   gst_object_unref (this);
 390   return ret;
 391
 392   /* ERRORS */
 393 header_validate_error:
 394   {
 395     GST_ELEMENT_ERROR (this, STREAM, DECODE, (NULL),
 396         ("GDP packet header does not validate"));
 397     ret = GST_FLOW_ERROR;
 398     goto done;
 399   }
 400 payload_validate_error:
 401   {
 402     GST_ELEMENT_ERROR (this, STREAM, DECODE, (NULL),
 403         ("GDP packet payload does not validate"));
 404     ret = GST_FLOW_ERROR;
 405     goto done;
 406   }
 407 wrong_type:
 408   {
 409     GST_ELEMENT_ERROR (this, STREAM, DECODE, (NULL),
 410         ("GDP packet header is of wrong type"));
 411     ret = GST_FLOW_ERROR;
 412     goto done;
 413   }
 414 no_caps:
 415   {
 416     GST_ELEMENT_ERROR (this, STREAM, DECODE, (NULL),
 417         ("Received a buffer without first receiving caps"));
 418     ret = GST_FLOW_NOT_NEGOTIATED;
 419     goto done;
 420   }
 421 buffer_failed:
 422   {
 423     GST_ELEMENT_ERROR (this, STREAM, DECODE, (NULL),
 424         ("could not create buffer from GDP packet"));
 425     ret = GST_FLOW_ERROR;
 426     goto done;
 427   }
 428 push_error:
 429   {
 430     GST_WARNING_OBJECT (this, "pushing depayloaded buffer returned %d", ret);
 431     goto done;
 432   }
 433 caps_failed:
 434   {
 435     GST_ELEMENT_ERROR (this, STREAM, DECODE, (NULL),
 436         ("could not create caps from GDP packet"));
 437     ret = GST_FLOW_ERROR;
 438     goto done;
 439   }
 440 event_failed:
 441   {
 442     GST_ELEMENT_ERROR (this, STREAM, DECODE, (NULL),
 443         ("could not create event from GDP packet"));
 444     ret = GST_FLOW_ERROR;
 445     goto done;
 446   }
 447 }
 448
 449 static GstStateChangeReturn
 450 gst_gdp_depay_change_state (GstElement * element, GstStateChange transition)
 451 {
 452   GstStateChangeReturn ret;
 453   GstGDPDepay *this = GST_GDP_DEPAY (element);
 454
 455   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 456
 457   switch (transition) {
 458     case GST_STATE_CHANGE_PAUSED_TO_READY:
 459       if (this->caps) {
 460         gst_caps_unref (this->caps);
 461         this->caps = NULL;
 462       }
 463       gst_adapter_clear (this->adapter);
 464       break;
 465     default:
 466       break;
 467   }
 468   return ret;
 469 }
 470
 471 gboolean
 472 gst_gdp_depay_plugin_init (GstPlugin * plugin)
 473 {
 474   if (!gst_element_register (plugin, "gdpdepay", GST_RANK_NONE,
 475           GST_TYPE_GDP_DEPAY))
 476     return FALSE;
 477
 478   return TRUE;
 479 }