add parent to pad functions
[platform/upstream/gstreamer.git] / 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, GstObject * parent,
73     GstEvent * event);
74 static gboolean gst_gdp_depay_src_event (GstPad * pad, GstObject * parent,
75     GstEvent * event);
76
77 static GstFlowReturn gst_gdp_depay_chain (GstPad * pad, GstObject * parent,
78     GstBuffer * buffer);
79
80 static GstStateChangeReturn gst_gdp_depay_change_state (GstElement *
81     element, GstStateChange transition);
82
83 static void gst_gdp_depay_finalize (GObject * object);
84
85 static void
86 gst_gdp_depay_class_init (GstGDPDepayClass * klass)
87 {
88   GObjectClass *gobject_class;
89   GstElementClass *gstelement_class;
90
91   gobject_class = (GObjectClass *) klass;
92   gstelement_class = (GstElementClass *) klass;
93
94   gst_element_class_set_details_simple (gstelement_class,
95       "GDP Depayloader", "GDP/Depayloader",
96       "Depayloads GStreamer Data Protocol buffers",
97       "Thomas Vander Stichele <thomas at apestaart dot org>");
98
99   gst_element_class_add_pad_template (gstelement_class,
100       gst_static_pad_template_get (&gdp_depay_sink_template));
101   gst_element_class_add_pad_template (gstelement_class,
102       gst_static_pad_template_get (&gdp_depay_src_template));
103
104   gstelement_class->change_state =
105       GST_DEBUG_FUNCPTR (gst_gdp_depay_change_state);
106   gobject_class->finalize = gst_gdp_depay_finalize;
107 }
108
109 static void
110 gst_gdp_depay_init (GstGDPDepay * gdpdepay)
111 {
112   gdpdepay->sinkpad =
113       gst_pad_new_from_static_template (&gdp_depay_sink_template, "sink");
114   gst_pad_set_chain_function (gdpdepay->sinkpad,
115       GST_DEBUG_FUNCPTR (gst_gdp_depay_chain));
116   gst_pad_set_event_function (gdpdepay->sinkpad,
117       GST_DEBUG_FUNCPTR (gst_gdp_depay_sink_event));
118   gst_element_add_pad (GST_ELEMENT (gdpdepay), gdpdepay->sinkpad);
119
120   gdpdepay->srcpad =
121       gst_pad_new_from_static_template (&gdp_depay_src_template, "src");
122   gst_pad_set_event_function (gdpdepay->srcpad,
123       GST_DEBUG_FUNCPTR (gst_gdp_depay_src_event));
124   /* our caps will always be decided by the incoming GDP caps buffers */
125   gst_pad_use_fixed_caps (gdpdepay->srcpad);
126   gst_element_add_pad (GST_ELEMENT (gdpdepay), gdpdepay->srcpad);
127
128   gdpdepay->adapter = gst_adapter_new ();
129 }
130
131 static void
132 gst_gdp_depay_finalize (GObject * gobject)
133 {
134   GstGDPDepay *this;
135
136   this = GST_GDP_DEPAY (gobject);
137   if (this->caps)
138     gst_caps_unref (this->caps);
139   g_free (this->header);
140   gst_adapter_clear (this->adapter);
141   g_object_unref (this->adapter);
142
143   GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (gobject));
144 }
145
146 static gboolean
147 gst_gdp_depay_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
148 {
149   GstGDPDepay *this;
150   gboolean res = TRUE;
151
152   this = GST_GDP_DEPAY (parent);
153
154   switch (GST_EVENT_TYPE (event)) {
155     case GST_EVENT_FLUSH_START:
156       /* forward flush start */
157       res = gst_pad_push_event (this->srcpad, event);
158       break;
159     case GST_EVENT_FLUSH_STOP:
160       /* clear adapter on flush */
161       gst_adapter_clear (this->adapter);
162       /* forward flush stop */
163       res = gst_pad_push_event (this->srcpad, event);
164       break;
165     case GST_EVENT_EOS:
166       /* after EOS, we don't expect to output anything anymore */
167       res = gst_pad_push_event (this->srcpad, event);
168       break;
169     case GST_EVENT_SEGMENT:
170     case GST_EVENT_TAG:
171     case GST_EVENT_BUFFERSIZE:
172     default:
173       /* we unref most events as we take them from the datastream */
174       gst_event_unref (event);
175       break;
176   }
177
178   return res;
179 }
180
181 static gboolean
182 gst_gdp_depay_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
183 {
184   GstGDPDepay *this;
185   gboolean res = TRUE;
186
187   this = GST_GDP_DEPAY (parent);
188
189   switch (GST_EVENT_TYPE (event)) {
190     case GST_EVENT_SEEK:
191       /* we refuse seek for now. */
192       gst_event_unref (event);
193       res = FALSE;
194       break;
195     case GST_EVENT_QOS:
196     case GST_EVENT_NAVIGATION:
197     default:
198       /* everything else is passed */
199       res = gst_pad_push_event (this->sinkpad, event);
200       break;
201   }
202
203   return res;
204 }
205
206 static GstFlowReturn
207 gst_gdp_depay_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
208 {
209   GstGDPDepay *this;
210   GstFlowReturn ret = GST_FLOW_OK;
211   GstCaps *caps;
212   GstBuffer *buf;
213   GstEvent *event;
214   guint available;
215
216   this = GST_GDP_DEPAY (parent);
217
218   /* On DISCONT, get rid of accumulated data. We assume a buffer after the
219    * DISCONT contains (part of) a new valid header, if not we error because we
220    * lost sync */
221   if (GST_BUFFER_IS_DISCONT (buffer)) {
222     gst_adapter_clear (this->adapter);
223     this->state = GST_GDP_DEPAY_STATE_HEADER;
224   }
225   gst_adapter_push (this->adapter, buffer);
226
227   while (TRUE) {
228     switch (this->state) {
229       case GST_GDP_DEPAY_STATE_HEADER:
230       {
231         guint8 *header;
232
233         /* collect a complete header, validate and store the header. Figure out
234          * the payload length and switch to the PAYLOAD state */
235         available = gst_adapter_available (this->adapter);
236         if (available < GST_DP_HEADER_LENGTH)
237           goto done;
238
239         GST_LOG_OBJECT (this, "reading GDP header from adapter");
240         header = gst_adapter_take (this->adapter, GST_DP_HEADER_LENGTH);
241         if (!gst_dp_validate_header (GST_DP_HEADER_LENGTH, header)) {
242           g_free (header);
243           goto header_validate_error;
244         }
245
246         /* store types and payload length. Also store the header, which we need
247          * to make the payload. */
248         this->payload_length = gst_dp_header_payload_length (header);
249         this->payload_type = gst_dp_header_payload_type (header);
250         /* free previous header and store new one. */
251         g_free (this->header);
252         this->header = header;
253
254         GST_LOG_OBJECT (this,
255             "read GDP header, payload size %d, payload type %d, switching to state PAYLOAD",
256             this->payload_length, this->payload_type);
257         this->state = GST_GDP_DEPAY_STATE_PAYLOAD;
258         break;
259       }
260       case GST_GDP_DEPAY_STATE_PAYLOAD:
261       {
262         /* in this state we wait for all the payload data to be available in the
263          * adapter. Then we switch to the state where we actually process the
264          * payload. */
265         available = gst_adapter_available (this->adapter);
266         if (available < this->payload_length)
267           goto done;
268
269         /* change state based on type */
270         if (this->payload_type == GST_DP_PAYLOAD_BUFFER) {
271           GST_LOG_OBJECT (this, "switching to state BUFFER");
272           this->state = GST_GDP_DEPAY_STATE_BUFFER;
273         } else if (this->payload_type == GST_DP_PAYLOAD_CAPS) {
274           GST_LOG_OBJECT (this, "switching to state CAPS");
275           this->state = GST_GDP_DEPAY_STATE_CAPS;
276         } else if (this->payload_type >= GST_DP_PAYLOAD_EVENT_NONE) {
277           GST_LOG_OBJECT (this, "switching to state EVENT");
278           this->state = GST_GDP_DEPAY_STATE_EVENT;
279         } else {
280           goto wrong_type;
281         }
282
283         if (this->payload_length) {
284           const guint8 *data;
285           gboolean res;
286
287           data = gst_adapter_map (this->adapter, this->payload_length);
288           res = gst_dp_validate_payload (GST_DP_HEADER_LENGTH, this->header,
289               data);
290           gst_adapter_unmap (this->adapter);
291
292           if (!res)
293             goto payload_validate_error;
294         }
295
296         break;
297       }
298       case GST_GDP_DEPAY_STATE_BUFFER:
299       {
300         /* if we receive a buffer without caps first, we error out */
301         if (!this->caps)
302           goto no_caps;
303
304         GST_LOG_OBJECT (this, "reading GDP buffer from adapter");
305         buf = gst_dp_buffer_from_header (GST_DP_HEADER_LENGTH, this->header);
306         if (!buf)
307           goto buffer_failed;
308
309         /* now take the payload if there is any */
310         if (this->payload_length > 0) {
311           guint8 *payload;
312
313           payload = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
314           gst_adapter_copy (this->adapter, payload, 0, this->payload_length);
315           gst_buffer_unmap (buf, payload, this->payload_length);
316
317           gst_adapter_flush (this->adapter, this->payload_length);
318         }
319
320         /* set caps and push */
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 %" G_GSIZE_FORMAT ", 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_get_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   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 }