libs/gst/dataprotocol/: It's about time we bump the version number.
[glsdk/gstreamer0-10.git] / libs / gst / dataprotocol / dataprotocol.c
1 /* GStreamer
2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
3  * Copyright (C) <2004> Thomas Vander Stichele <thomas at apestaart dot org>
4  *
5  * dataprotocol.c: Functions implementing the GStreamer Data Protocol
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public
18  * License along with this library; if not, write to the
19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20  * Boston, MA 02111-1307, USA.
21  */
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
27 #include <gst/gst.h>
28 #include <gst/dataprotocol/dataprotocol.h>
29 #include <glib/gprintf.h>       /* g_sprintf */
30 #include <string.h>             /* strlen */
31 #include "dp-private.h"
33 /* debug category */
34 GST_DEBUG_CATEGORY (data_protocol_debug);
35 #define GST_CAT_DEFAULT data_protocol_debug
37 /* calculate a CCITT 16 bit CRC check value for a given byte array */
38 /*
39  * this code snippet is adapted from a web page I found
40  * it is identical except for cleanups, and a final XOR with 0xffff
41  * as outlined in the uecp spec
42  *
43  * XMODEM    x^16 + x^12 + x^5 + 1
44  */
46 #define POLY       0x1021
47 #define CRC_INIT   0xFFFF
49 static guint16
50 gst_dp_crc (const guint8 * buffer, register guint length)
51 {
52   static gboolean initialized = FALSE;
53   static guint16 crc_table[256];
54   guint16 crc_register;
55   unsigned long i, j, k;
57   if (!initialized) {
58     for (i = 0; i < 256; i++) {
59       j = i << 8;
60       for (k = 8; k--;) {
61         j = j & 0x8000 ? (j << 1) ^ POLY : j << 1;
62       }
64       crc_table[i] = (guint16) j;
65     }
66     initialized = TRUE;
67   }
69   crc_register = CRC_INIT;      /* always init register */
71   /* calc CRC */
72   for (; length--;) {
73     crc_register = (guint16) ((crc_register << 8) ^
74         crc_table[((crc_register >> 8) & 0x00ff) ^ *buffer++]);
75   }
76   return (0xffff ^ crc_register);
77 }
79 /* debugging function; dumps byte array values per 8 bytes */
80 /* FIXME: would be nice to merge this with gst_util_dump_mem () */
81 void
82 gst_dp_dump_byte_array (guint8 * array, guint length)
83 {
84   int i;
85   int n = 8;                    /* number of bytes per line */
86   gchar *line = g_malloc (3 * n + 1);
88   GST_LOG ("dumping byte array of length %d", length);
89   for (i = 0; i < length; ++i) {
90     g_sprintf (line + 3 * (i % n), "%02x ", array[i]);
91     if (i % n == (n - 1)) {
92       GST_LOG ("%03d: %s", i - (n - 1), line);
93     }
94   }
95   if (i % n != 0) {
96     GST_LOG ("%03d: %s", (i / n) * n, line);
97   }
98   g_free (line);
99 }
101 /**
102  * gst_dp_init:
103  *
104  * Initialize GStreamer Data Protocol library.
105  *
106  * Should be called before using these functions from source linking
107  * to this source file.
108  */
109 void
110 gst_dp_init (void)
112   static gboolean _gst_dp_initialized = FALSE;
114   if (_gst_dp_initialized)
115     return;
117   _gst_dp_initialized = TRUE;
119   GST_DEBUG_CATEGORY_INIT (data_protocol_debug, "gdp", 0,
120       "GStreamer Data Protocol");
123 /*** PUBLIC FUNCTIONS ***/
125 /**
126  * gst_dp_header_payload_length:
127  * @header: the byte header of the packet array
128  *
129  * Returns: the length of the payload this header describes.
130  */
131 guint32
132 gst_dp_header_payload_length (const guint8 * header)
134   return GST_DP_HEADER_PAYLOAD_LENGTH (header);
137 /**
138  * gst_dp_header_payload_type:
139  * @header: the byte header of the packet array
140  *
141  * Returns: the #GstDPPayloadType the payload this header describes.
142  */
143 GstDPPayloadType
144 gst_dp_header_payload_type (const guint8 * header)
146   return GST_DP_HEADER_PAYLOAD_TYPE (header);
149 /**
150  * gst_dp_header_from_buffer:
151  * @buffer: a #GstBuffer to create a header for
152  * @flags: the #GDPHeaderFlags to create the header with
153  * @length: a guint pointer to store the header length in
154  * @header: a guint8 * pointer to store a newly allocated header byte array in
155  *
156  * Creates a GDP header from the given buffer.
157  *
158  * Returns: %TRUE if the header was successfully created.
159  */
161 gboolean
162 gst_dp_header_from_buffer (const GstBuffer * buffer, GstDPHeaderFlag flags,
163     guint * length, guint8 ** header)
165   guint8 *h;
166   guint16 crc;
167   guint16 flags_mask;
169   g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);
170   g_return_val_if_fail (header, FALSE);
172   *length = GST_DP_HEADER_LENGTH;
173   h = g_malloc (GST_DP_HEADER_LENGTH);
175   /* version, flags, type */
176   h[0] = (guint8) GST_DP_VERSION_MAJOR;
177   h[1] = (guint8) GST_DP_VERSION_MINOR;
178   h[2] = (guint8) flags;
179   h[3] = 0;                     /* padding byte */
180   GST_WRITE_UINT16_BE (h + 4, GST_DP_PAYLOAD_BUFFER);
182   /* buffer properties */
183   GST_WRITE_UINT32_BE (h + 6, GST_BUFFER_SIZE (buffer));
184   GST_WRITE_UINT64_BE (h + 10, GST_BUFFER_TIMESTAMP (buffer));
185   GST_WRITE_UINT64_BE (h + 18, GST_BUFFER_DURATION (buffer));
186   GST_WRITE_UINT64_BE (h + 26, GST_BUFFER_OFFSET (buffer));
187   GST_WRITE_UINT64_BE (h + 34, GST_BUFFER_OFFSET_END (buffer));
189   /* data flags */
190   /* we only copy KEY_UNIT,DELTA_UNIT and IN_CAPS flags */
191   flags_mask = GST_BUFFER_FLAG_PREROLL | GST_BUFFER_FLAG_IN_CAPS |
192       GST_BUFFER_FLAG_DELTA_UNIT;
194   GST_WRITE_UINT16_BE (h + 42, GST_BUFFER_FLAGS (buffer) & flags_mask);
196   /* ABI padding */
197   GST_WRITE_UINT32_BE (h + 44, (guint64) 0);
198   GST_WRITE_UINT64_BE (h + 48, (guint64) 0);
200   /* CRC */
201   crc = 0;
202   if (flags & GST_DP_HEADER_FLAG_CRC_HEADER) {
203     /* we don't crc the last four bytes of the header since they are crc's */
204     crc = gst_dp_crc (h, 58);
205   }
206   GST_WRITE_UINT16_BE (h + 58, crc);
208   crc = 0;
209   if (flags & GST_DP_HEADER_FLAG_CRC_PAYLOAD) {
210     crc = gst_dp_crc (GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer));
211   }
212   GST_WRITE_UINT16_BE (h + 60, crc);
214   GST_LOG ("created header from buffer:");
215   gst_dp_dump_byte_array (h, GST_DP_HEADER_LENGTH);
216   *header = h;
217   return TRUE;
220  /**
221  * gst_dp_packet_from_caps:
222  * @caps: a #GstCaps to create a packet for
223  * @flags: the #GDPHeaderFlags to create the header with
224  * @length: a guint pointer to store the header length in
225  * @header: a guint8 pointer to store a newly allocated header byte array in
226  * @payload: a guint8 pointer to store a newly allocated payload byte array in
227  *
228  * Creates a GDP packet from the given caps.
229  *
230  * Returns: %TRUE if the packet was successfully created.
231  */
232 gboolean
233 gst_dp_packet_from_caps (const GstCaps * caps, GstDPHeaderFlag flags,
234     guint * length, guint8 ** header, guint8 ** payload)
236   guint8 *h;
237   guint16 crc;
238   guchar *string;
240   /* FIXME: GST_IS_CAPS doesn't work
241      g_return_val_if_fail (GST_IS_CAPS (caps), FALSE); */
242   g_return_val_if_fail (caps, FALSE);
243   g_return_val_if_fail (header, FALSE);
244   g_return_val_if_fail (payload, FALSE);
246   *length = GST_DP_HEADER_LENGTH;
247   h = g_malloc (GST_DP_HEADER_LENGTH);
249   string = (guchar *) gst_caps_to_string (caps);
251   /* version, flags, type */
252   h[0] = (guint8) GST_DP_VERSION_MAJOR;
253   h[1] = (guint8) GST_DP_VERSION_MINOR;
254   h[2] = (guint8) flags;
255   h[3] = 0;                     /* padding bytes */
256   GST_WRITE_UINT16_BE (h + 4, GST_DP_PAYLOAD_CAPS);
258   /* buffer properties */
259   GST_WRITE_UINT32_BE (h + 8, strlen ((gchar *) string) + 1);   /* include trailing 0 */
260   GST_WRITE_UINT64_BE (h + 10, (guint64) 0);
261   GST_WRITE_UINT64_BE (h + 18, (guint64) 0);
262   GST_WRITE_UINT64_BE (h + 26, (guint64) 0);
263   GST_WRITE_UINT64_BE (h + 34, (guint64) 0);
265   /* ABI padding */
266   GST_WRITE_UINT64_BE (h + 42, (guint64) 0);
267   GST_WRITE_UINT64_BE (h + 50, (guint64) 0);
269   /* CRC */
270   crc = 0;
271   if (flags & GST_DP_HEADER_FLAG_CRC_HEADER) {
272     crc = gst_dp_crc (h, 58);
273   }
274   GST_WRITE_UINT16_BE (h + 58, crc);
276   crc = 0;
277   if (flags & GST_DP_HEADER_FLAG_CRC_PAYLOAD) {
278     crc = gst_dp_crc (string, strlen ((gchar *) string) + 1);
279   }
280   GST_WRITE_UINT16_BE (h + 60, crc);
282   GST_LOG ("created header from caps:");
283   gst_dp_dump_byte_array (h, GST_DP_HEADER_LENGTH);
284   *header = h;
285   *payload = string;
286   return TRUE;
289 /**
290  * gst_dp_packet_from_event:
291  * @event: a #GstEvent to create a packet for
292  * @flags: the #GDPHeaderFlags to create the header with
293  * @length: a guint pointer to store the header length in
294  * @header: a guint8 pointer to store a newly allocated header byte array in
295  * @payload: a guint8 pointer to store a newly allocated payload byte array in
296  *
297  * Creates a GDP packet from the given event.
298  *
299  * Returns: %TRUE if the packet was successfully created.
300  */
301 gboolean
302 gst_dp_packet_from_event (const GstEvent * event, GstDPHeaderFlag flags,
303     guint * length, guint8 ** header, guint8 ** payload)
305   guint8 *h;
306   guint16 crc;
307   guint pl_length;              /* length of payload */
309   g_return_val_if_fail (event, FALSE);
310   g_return_val_if_fail (GST_IS_EVENT (event), FALSE);
311   g_return_val_if_fail (header, FALSE);
312   g_return_val_if_fail (payload, FALSE);
314   *length = GST_DP_HEADER_LENGTH;
315   h = g_malloc0 (GST_DP_HEADER_LENGTH);
317   /* first construct payload, since we need the length */
318   switch (GST_EVENT_TYPE (event)) {
319     case GST_EVENT_UNKNOWN:
320       g_warning ("Unknown event, ignoring");
321       *length = 0;
322       g_free (h);
323       return FALSE;
324     case GST_EVENT_EOS:
325     case GST_EVENT_FLUSH_START:
326     case GST_EVENT_FLUSH_STOP:
327     case GST_EVENT_NEWSEGMENT:
328       pl_length = 0;
329       *payload = NULL;
330       break;
331     case GST_EVENT_SEEK:
332     {
333       gdouble rate;
334       GstFormat format;
335       GstSeekFlags flags;
336       GstSeekType cur_type, stop_type;
337       gint64 cur, stop;
339       gst_event_parse_seek ((GstEvent *) event, &rate, &format, &flags,
340           &cur_type, &cur, &stop_type, &stop);
342       pl_length = 4 + 4 + 4 + 8 + 4 + 8;
343       *payload = g_malloc0 (pl_length);
344       /* FIXME write rate */
345       GST_WRITE_UINT32_BE (*payload, (guint32) format);
346       GST_WRITE_UINT32_BE (*payload + 4, (guint32) flags);
347       GST_WRITE_UINT32_BE (*payload + 8, (guint32) cur_type);
348       GST_WRITE_UINT64_BE (*payload + 12, (guint64) cur);
349       GST_WRITE_UINT32_BE (*payload + 20, (guint32) stop_type);
350       GST_WRITE_UINT64_BE (*payload + 24, (guint64) stop);
351       break;
352     }
353     case GST_EVENT_QOS:
354     case GST_EVENT_NAVIGATION:
355     case GST_EVENT_TAG:
356       g_warning ("Unhandled event type %d, ignoring", GST_EVENT_TYPE (event));
357       return FALSE;
358     default:
359       g_warning ("Unknown event type %d, ignoring", GST_EVENT_TYPE (event));
360       *length = 0;
361       g_free (h);
362       return FALSE;
363   }
365   /* version, flags, type */
366   h[0] = (guint8) GST_DP_VERSION_MAJOR;
367   h[1] = (guint8) GST_DP_VERSION_MINOR;
368   h[2] = (guint8) flags;
369   h[3] = 0;                     /* padding byte */
370   GST_WRITE_UINT16_BE (h + 4,
371       GST_DP_PAYLOAD_EVENT_NONE + GST_EVENT_TYPE (event));
373   /* length */
374   GST_WRITE_UINT32_BE (h + 6, (guint32) pl_length);
375   /* timestamp */
376   GST_WRITE_UINT64_BE (h + 10, GST_EVENT_TIMESTAMP (event));
378   /* ABI padding */
379   GST_WRITE_UINT64_BE (h + 42, (guint64) 0);
380   GST_WRITE_UINT64_BE (h + 50, (guint64) 0);
382   /* CRC */
383   crc = 0;
384   if (flags & GST_DP_HEADER_FLAG_CRC_HEADER) {
385     crc = gst_dp_crc (h, 58);
386   }
387   GST_WRITE_UINT16_BE (h + 58, crc);
389   crc = 0;
390   /* events can have a NULL payload */
391   if (*payload && flags & GST_DP_HEADER_FLAG_CRC_PAYLOAD) {
392     crc = gst_dp_crc (*payload, strlen ((gchar *) * payload) + 1);
393   }
394   GST_WRITE_UINT16_BE (h + 60, crc);
396   GST_LOG ("created header from event:");
397   gst_dp_dump_byte_array (h, GST_DP_HEADER_LENGTH);
398   *header = h;
399   return TRUE;
403 /**
404  * gst_dp_buffer_from_header:
405  * @header_length: the length of the packet header
406  * @header: the byte array of the packet header
407  *
408  * Creates a newly allocated #GstBuffer from the given header.
409  * The buffer data needs to be copied into it before validating.
410  *
411  * Use this function if you want to pre-allocate a buffer based on the
412  * packet header to read the packet payload in to.
413  *
414  * Returns: %TRUE if the buffer was successfully created.
415  */
416 GstBuffer *
417 gst_dp_buffer_from_header (guint header_length, const guint8 * header)
419   GstBuffer *buffer;
421   g_return_val_if_fail (GST_DP_HEADER_PAYLOAD_TYPE (header) ==
422       GST_DP_PAYLOAD_BUFFER, NULL);
423   buffer =
424       gst_buffer_new_and_alloc ((guint) GST_DP_HEADER_PAYLOAD_LENGTH (header));
425   GST_BUFFER_TIMESTAMP (buffer) = GST_DP_HEADER_TIMESTAMP (header);
426   GST_BUFFER_DURATION (buffer) = GST_DP_HEADER_DURATION (header);
427   GST_BUFFER_OFFSET (buffer) = GST_DP_HEADER_OFFSET (header);
428   GST_BUFFER_OFFSET_END (buffer) = GST_DP_HEADER_OFFSET_END (header);
429   GST_BUFFER_FLAGS (buffer) = GST_DP_HEADER_BUFFER_FLAGS (header);
431   return buffer;
434 /**
435  * gst_dp_caps_from_packet:
436  * @header_length: the length of the packet header
437  * @header: the byte array of the packet header
438  * @payload: the byte array of the packet payload
439  *
440  * Creates a newly allocated #GstCaps from the given packet.
441  *
442  * Returns: %TRUE if the caps was successfully created.
443  */
444 GstCaps *
445 gst_dp_caps_from_packet (guint header_length, const guint8 * header,
446     const guint8 * payload)
448   GstCaps *caps;
449   const gchar *string;
451   g_return_val_if_fail (header, NULL);
452   g_return_val_if_fail (payload, NULL);
453   g_return_val_if_fail (GST_DP_HEADER_PAYLOAD_TYPE (header) ==
454       GST_DP_PAYLOAD_CAPS, NULL);
456   string = (gchar *) payload;
457   caps = gst_caps_from_string (string);
458   return caps;
461 /**
462  * gst_dp_event_from_packet:
463  * @header_length: the length of the packet header
464  * @header: the byte array of the packet header
465  * @payload: the byte array of the packet payload
466  *
467  * Creates a newly allocated #GstEvent from the given packet.
468  *
469  * Returns: %TRUE if the event was successfully created.
470  */
471 GstEvent *
472 gst_dp_event_from_packet (guint header_length, const guint8 * header,
473     const guint8 * payload)
475   GstEvent *event = NULL;
476   GstEventType type;
478   g_return_val_if_fail (header, NULL);
479   /* payload can be NULL, e.g. for an EOS event */
481   type = GST_DP_HEADER_PAYLOAD_TYPE (header) - GST_DP_PAYLOAD_EVENT_NONE;
482   switch (type) {
483     case GST_EVENT_UNKNOWN:
484       g_warning ("Unknown event, ignoring");
485       return FALSE;
486     case GST_EVENT_EOS:
487     case GST_EVENT_FLUSH_START:
488     case GST_EVENT_FLUSH_STOP:
489     case GST_EVENT_NEWSEGMENT:
490       event = gst_event_new_custom (type, NULL);
491       GST_EVENT_TIMESTAMP (event) = GST_DP_HEADER_TIMESTAMP (header);
492       break;
493     case GST_EVENT_SEEK:
494     {
495       gdouble rate;
496       GstFormat format;
497       GstSeekFlags flags;
498       GstSeekType cur_type, stop_type;
499       gint64 cur, stop;
501       /* FIXME, read rate */
502       rate = 1.0;
503       format = (GstFormat) GST_READ_UINT32_BE (payload);
504       flags = (GstSeekFlags) GST_READ_UINT32_BE (payload + 4);
505       cur_type = (GstSeekType) GST_READ_UINT32_BE (payload + 8);
506       cur = (gint64) GST_READ_UINT64_BE (payload + 12);
507       stop_type = (GstSeekType) GST_READ_UINT32_BE (payload + 20);
508       stop = (gint64) GST_READ_UINT64_BE (payload + 24);
510       event = gst_event_new_seek (rate, format, flags, cur_type, cur,
511           stop_type, stop);
512       GST_EVENT_TIMESTAMP (event) = GST_DP_HEADER_TIMESTAMP (header);
513       break;
514     }
515     case GST_EVENT_QOS:
516     case GST_EVENT_NAVIGATION:
517     case GST_EVENT_TAG:
518       g_warning ("Unhandled event type %d, ignoring", GST_EVENT_TYPE (event));
519       return FALSE;
520     default:
521       g_warning ("Unknown event type %d, ignoring", GST_EVENT_TYPE (event));
522       return FALSE;
523   }
525   return event;
528 /**
529  * gst_dp_validate_header:
530  * @header_length: the length of the packet header
531  * @header: the byte array of the packet header
532  *
533  * Validates the given packet header by checking the CRC checksum.
534  *
535  * Returns: %TRUE if the CRC matches, or no CRC checksum is present.
536  */
537 gboolean
538 gst_dp_validate_header (guint header_length, const guint8 * header)
540   guint16 crc_read, crc_calculated;
542   if (!(GST_DP_HEADER_FLAGS (header) & GST_DP_HEADER_FLAG_CRC_HEADER))
543     return TRUE;
544   crc_read = GST_DP_HEADER_CRC_HEADER (header);
545   /* don't included the last two crc fields for the crc check */
546   crc_calculated = gst_dp_crc (header, header_length - 4);
547   if (crc_read != crc_calculated) {
548     GST_WARNING ("header crc mismatch: read %02x, calculated %02x", crc_read,
549         crc_calculated);
550     return FALSE;
551   }
552   GST_LOG ("header crc validation: %02x", crc_read);
553   return TRUE;
556 /**
557  * gst_dp_validate_payload:
558  * @header_length: the length of the packet header
559  * @header: the byte array of the packet header
560  * @payload: the byte array of the packet payload
561  *
562  * Validates the given packet payload using the given packet header
563  * by checking the CRC checksum.
564  *
565  * Returns: %TRUE if the CRC matches, or no CRC checksum is present.
566  */
567 gboolean
568 gst_dp_validate_payload (guint header_length, const guint8 * header,
569     const guint8 * payload)
571   guint16 crc_read, crc_calculated;
573   if (!(GST_DP_HEADER_FLAGS (header) & GST_DP_HEADER_FLAG_CRC_PAYLOAD))
574     return TRUE;
575   crc_read = GST_DP_HEADER_CRC_PAYLOAD (header);
576   crc_calculated = gst_dp_crc (payload, GST_DP_HEADER_PAYLOAD_LENGTH (header));
577   if (crc_read != crc_calculated) {
578     GST_WARNING ("payload crc mismatch: read %02x, calculated %02x", crc_read,
579         crc_calculated);
580     return FALSE;
581   }
582   GST_LOG ("payload crc validation: %02x", crc_read);
583   return TRUE;
586 /**
587  * gst_dp_validate_packet:
588  * @header_length: the length of the packet header
589  * @header: the byte array of the packet header
590  * @payload: the byte array of the packet payload
591  *
592  * Validates the given packet by checking version information and checksums.
593  *
594  * Returns: %TRUE if the packet validates.
595  */
596 gboolean
597 gst_dp_validate_packet (guint header_length, const guint8 * header,
598     const guint8 * payload)
600   if (!gst_dp_validate_header (header_length, header))
601     return FALSE;
602   if (!gst_dp_validate_payload (header_length, header, payload))
603     return FALSE;
605   return TRUE;