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