gst/gstevent.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wim.taymans@chello.be>
   4  *
   5  * gstevent.h: Header for GstEvent subsystem
   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  */
  22
  23 #include <string.h>             /* memcpy */
  24
  25 #include "gst_private.h"
  26 #include "gstdata_private.h"
  27
  28 #include "gstinfo.h"
  29 #include "gstmemchunk.h"
  30 #include "gstevent.h"
  31 #include "gstlog.h"
  32 #include "gsttag.h"
  33
  34 #ifndef GST_DISABLE_TRACE
  35 /* #define GST_WITH_ALLOC_TRACE */
  36 #include "gsttrace.h"
  37 static GstAllocTrace *_event_trace;
  38 #endif
  39
  40 static GstMemChunk *chunk;
  41
  42 /* #define MEMPROF */
  43
  44 GType _gst_event_type;
  45
  46 void
  47 _gst_event_initialize (void)
  48 {
  49   /* register the type */
  50   _gst_event_type = g_boxed_type_register_static ("GstEvent",
  51                                                (GBoxedCopyFunc) gst_data_ref,
  52                                                (GBoxedFreeFunc) gst_data_unref);
  53
  54 #ifndef GST_DISABLE_TRACE
  55   _event_trace = gst_alloc_trace_register (GST_EVENT_TRACE_NAME);
  56 #endif
  57
  58   chunk = gst_mem_chunk_new ("GstEventChunk", sizeof (GstEvent),
  59                                  sizeof (GstEvent) * 50, 0);
  60 }
  61
  62 static GstEvent*
  63 _gst_event_copy (GstEvent *event)
  64 {
  65   GstEvent *copy;
  66
  67   copy = gst_mem_chunk_alloc (chunk);
  68 #ifndef GST_DISABLE_TRACE
  69   gst_alloc_trace_new (_event_trace, copy);
  70 #endif
  71
  72   memcpy (copy, event, sizeof (GstEvent));
  73
  74   /* FIXME copy/ref additional fields */
  75   switch (GST_EVENT_TYPE (event)) {
  76     case GST_EVENT_TAG:
  77       copy->event_data.structure.structure = gst_structure_copy (event->event_data.structure.structure);
  78     default:
  79       break;
  80   }
  81
  82   return copy;
  83 }
  84
  85 static void
  86 _gst_event_free (GstEvent* event)
  87 {
  88   GST_CAT_INFO (GST_CAT_EVENT, "freeing event %p", event);
  89
  90   if (GST_EVENT_SRC (event)) {
  91     gst_object_unref (GST_EVENT_SRC (event));
  92   }
  93   switch (GST_EVENT_TYPE (event)) {
  94     case GST_EVENT_TAG:
  95       gst_tag_list_free (event->event_data.structure.structure);
  96     default:
  97       break;
  98   }
  99   _GST_DATA_DISPOSE (GST_DATA (event));
 100 #ifndef GST_DISABLE_TRACE
 101   gst_alloc_trace_free (_event_trace, event);
 102 #endif
 103   gst_mem_chunk_free (chunk, event);
 104 }
 105
 106 /**
 107  * gst_event_masks_contains:
 108  * @masks: The eventmask array to search
 109  * @mask: the event mask to find
 110  *
 111  * See if the given eventmask is inside the eventmask array.
 112  *
 113  * Returns: TRUE if the eventmask is found inside the array
 114  */
 115 gboolean
 116 gst_event_masks_contains (const GstEventMask *masks, GstEventMask *mask)
 117 {
 118   g_return_val_if_fail (mask != NULL, FALSE);
 119
 120   if (!masks)
 121     return FALSE;
 122
 123   while (masks->type) {
 124     if (masks->type == mask->type &&
 125         (masks->flags & mask->flags) == mask->flags)
 126       return TRUE;
 127
 128     masks++;
 129   }
 130
 131   return FALSE;
 132 }
 133
 134 GType
 135 gst_event_get_type (void)
 136 {
 137   return _gst_event_type;
 138 }
 139
 140 /**
 141  * gst_event_new:
 142  * @type: The type of the new event
 143  *
 144  * Allocate a new event of the given type.
 145  *
 146  * Returns: A new event.
 147  */
 148 GstEvent*
 149 gst_event_new (GstEventType type)
 150 {
 151   GstEvent *event;
 152
 153   event = gst_mem_chunk_alloc0 (chunk);
 154 #ifndef GST_DISABLE_TRACE
 155   gst_alloc_trace_new (_event_trace, event);
 156 #endif
 157
 158   GST_CAT_INFO (GST_CAT_EVENT, "creating new event %p %d", event, type);
 159
 160   _GST_DATA_INIT (GST_DATA (event),
 161                   _gst_event_type,
 162                   0,
 163                   (GstDataFreeFunction) _gst_event_free,
 164                   (GstDataCopyFunction) _gst_event_copy);
 165
 166   GST_EVENT_TYPE (event) = type;
 167   GST_EVENT_TIMESTAMP (event) = G_GINT64_CONSTANT (0);
 168   GST_EVENT_SRC (event) = NULL;
 169
 170   return event;
 171 }
 172
 173 /**
 174  * gst_event_new_seek:
 175  * @type: The type of the seek event
 176  * @offset: The offset of the seek
 177  *
 178  * Allocate a new seek event with the given parameters.
 179  *
 180  * Returns: A new seek event.
 181  */
 182 GstEvent*
 183 gst_event_new_seek (GstSeekType type, gint64 offset)
 184 {
 185   GstEvent *event;
 186
 187   event = gst_event_new (GST_EVENT_SEEK);
 188
 189   GST_EVENT_SEEK_TYPE (event) = type;
 190   GST_EVENT_SEEK_OFFSET (event) = offset;
 191   GST_EVENT_SEEK_ENDOFFSET (event) = -1;
 192
 193   return event;
 194 }
 195
 196 /**
 197  * gst_event_new_discontinuous_valist:
 198  * @new_media: A flag indicating a new media type starts
 199  * @format1: The format of the discont value
 200  * @var_args: more discont values and formats
 201  *
 202  * Allocate a new discontinuous event with the given format/value pairs. Note
 203  * that the values are of type gint64 - you may not use simple integers such
 204  * as "0" when calling this function, always cast them like "(gint64) 0".
 205  * Terminate the list with #GST_FORMAT_UNDEFINED.
 206  *
 207  * Returns: A new discontinuous event.
 208  */
 209 GstEvent*
 210 gst_event_new_discontinuous_valist (gboolean new_media, GstFormat format1, va_list var_args)
 211 {
 212   GstEvent *event;
 213   gint count = 0;
 214
 215   event = gst_event_new (GST_EVENT_DISCONTINUOUS);
 216   GST_EVENT_DISCONT_NEW_MEDIA (event) = new_media;
 217
 218   while (format1 != GST_FORMAT_UNDEFINED && count < 8) {
 219
 220     GST_EVENT_DISCONT_OFFSET (event, count).format = format1 & GST_SEEK_FORMAT_MASK;
 221     GST_EVENT_DISCONT_OFFSET (event, count).value = va_arg (var_args, gint64);
 222
 223     format1 = va_arg (var_args, GstFormat);
 224
 225     count++;
 226   }
 227
 228   GST_EVENT_DISCONT_OFFSET_LEN (event) = count;
 229
 230   return event;
 231 }
 232
 233 /**
 234  * gst_event_new_discontinuous:
 235  * @new_media: A flag indicating a new media type starts
 236  * @format1: The format of the discont value
 237  * @...: more discont values and formats
 238  *
 239  * Allocate a new discontinuous event with the given format/value pairs. Note
 240  * that the values are of type gint64 - you may not use simple integers such
 241  * as "0" when calling this function, always cast them like "(gint64) 0".
 242  * Terminate the list with #GST_FORMAT_UNDEFINED.
 243  *
 244  * Returns: A new discontinuous event.
 245  */
 246 GstEvent*
 247 gst_event_new_discontinuous (gboolean new_media, GstFormat format1, ...)
 248 {
 249   va_list var_args;
 250   GstEvent *event;
 251
 252   va_start (var_args, format1);
 253
 254   event = gst_event_new_discontinuous_valist (new_media, format1, var_args);
 255
 256   va_end (var_args);
 257
 258   return event;
 259 }
 260
 261 /**
 262  * gst_event_discont_get_value:
 263  * @event: The event to query
 264  * @format: The format of the discont value
 265  * @value: A pointer to the value
 266  *
 267  * Get the value for the given format in the dicont event.
 268  *
 269  * Returns: TRUE if the discont event caries the specified format/value pair.
 270  */
 271 gboolean
 272 gst_event_discont_get_value (GstEvent *event, GstFormat format, gint64 *value)
 273 {
 274   gint i, n;
 275
 276   g_return_val_if_fail (event != NULL, FALSE);
 277   g_return_val_if_fail (value != NULL, FALSE);
 278
 279   n = GST_EVENT_DISCONT_OFFSET_LEN (event);
 280
 281   for (i = 0; i < n; i++) {
 282     if (GST_EVENT_DISCONT_OFFSET(event,i).format == format) {
 283       *value = GST_EVENT_DISCONT_OFFSET(event,i).value;
 284       return TRUE;
 285     }
 286   }
 287
 288   return FALSE;
 289 }
 290
 291
 292 /**
 293  * gst_event_new_size:
 294  * @format: The format of the size value
 295  * @value: The value of the size event
 296  *
 297  * Create a new size event with the given values.
 298  *
 299  * Returns: The new size event.
 300  */
 301 GstEvent*
 302 gst_event_new_size (GstFormat format, gint64 value)
 303 {
 304   GstEvent *event;
 305
 306   event = gst_event_new (GST_EVENT_SIZE);
 307
 308   GST_EVENT_SIZE_FORMAT (event) = format;
 309   GST_EVENT_SIZE_VALUE (event) = value;
 310
 311   return event;
 312 }
 313
 314
 315 /**
 316  * gst_event_new_segment_seek:
 317  * @type: The type of the seek event
 318  * @start: The start offset of the seek
 319  * @stop: The stop offset of the seek
 320  *
 321  * Allocate a new segment seek event with the given parameters.
 322  *
 323  * Returns: A new segment seek event.
 324  */
 325 GstEvent*
 326 gst_event_new_segment_seek (GstSeekType type, gint64 start, gint64 stop)
 327 {
 328   GstEvent *event;
 329
 330   g_return_val_if_fail (start < stop, NULL);
 331
 332   event = gst_event_new (GST_EVENT_SEEK_SEGMENT);
 333
 334   GST_EVENT_SEEK_TYPE (event) = type;
 335   GST_EVENT_SEEK_OFFSET (event) = start;
 336   GST_EVENT_SEEK_ENDOFFSET (event) = stop;
 337
 338   return event;
 339 }