gstevent.c 4.78 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
/* GStreamer
 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
 *                    2000 Wim Taymans <wim.taymans@chello.be>
 *
 * gstevent.h: Header for GstEvent subsystem
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */


#include "gst/gstinfo.h"
#include "gst/gstevent.h"
Benjamin Otte's avatar
Benjamin Otte committed
26
#include <string.h>		/* memcpy */
27

28 29
/* #define MEMPROF */

30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
GType _gst_event_type;

static GMemChunk *_gst_event_chunk;
static GMutex *_gst_event_chunk_lock;

void
_gst_event_initialize (void)
{
  gint eventsize = sizeof(GstEvent);
  static const GTypeInfo event_info = {
    0,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    0, 
    0,
    NULL,
49
    NULL,
50 51
  };

52
  /* round up to the nearest 32 bytes for cache-line and other efficiencies */
53 54 55 56 57 58
  eventsize = (((eventsize-1) / 32) + 1) * 32;

  _gst_event_chunk = g_mem_chunk_new ("GstEvent", eventsize,
  				      eventsize * 32, G_ALLOC_AND_FREE);
  _gst_event_chunk_lock = g_mutex_new ();

59
  /* register the type */
60 61 62
  _gst_event_type = g_type_register_static (G_TYPE_INT, "GstEvent", &event_info, 0);
}

63 64 65 66 67 68 69 70
/**
 * gst_event_new:
 * @type: The type of the new event
 *
 * Allocate a new event of the given type.
 *
 * Returns: A new event.
 */
71 72 73 74 75
GstEvent*
gst_event_new (GstEventType type)
{
  GstEvent *event;

76
#ifndef MEMPROF
77 78 79
  g_mutex_lock (_gst_event_chunk_lock);
  event = g_mem_chunk_alloc (_gst_event_chunk);
  g_mutex_unlock (_gst_event_chunk_lock);
80 81 82
#else
  event = g_new0(GstEvent, 1);
#endif
83 84 85 86
  GST_INFO (GST_CAT_EVENT, "creating new event %p", event);

  GST_DATA_TYPE (event) = _gst_event_type;
  GST_EVENT_TYPE (event) = type;
87 88
  GST_EVENT_TIMESTAMP (event) = 0LL;
  GST_EVENT_SRC (event) = NULL;
89 90 91 92

  return event;
}

Wim Taymans's avatar
Wim Taymans committed
93 94 95 96 97 98 99 100 101 102 103 104 105
/**
 * gst_event_copy:
 * @event: The event to copy
 *
 * Copy the event
 *
 * Returns: A copy of the event.
 */
GstEvent*
gst_event_copy (GstEvent *event)
{
  GstEvent *copy;

106
#ifndef MEMPROF
Wim Taymans's avatar
Wim Taymans committed
107 108 109
  g_mutex_lock (_gst_event_chunk_lock);
  copy = g_mem_chunk_alloc (_gst_event_chunk);
  g_mutex_unlock (_gst_event_chunk_lock);
110 111 112
#else
  copy = g_new0(GstEvent, 1);
#endif
Wim Taymans's avatar
Wim Taymans committed
113 114 115 116 117 118 119 120

  memcpy (copy, event, sizeof (GstEvent));
  
  /* FIXME copy/ref additional fields */

  return copy;
}

121 122 123 124 125 126
/**
 * gst_event_free:
 * @event: The event to free
 *
 * Free the given element.
 */
127 128 129
void
gst_event_free (GstEvent* event)
{
Wim Taymans's avatar
Wim Taymans committed
130 131
  GST_INFO (GST_CAT_EVENT, "freeing event %p", event);

132
  g_mutex_lock (_gst_event_chunk_lock);
133 134 135 136 137 138 139
  if (GST_EVENT_SRC (event)) {
    gst_object_unref (GST_EVENT_SRC (event));
  }
  switch (GST_EVENT_TYPE (event)) {
    default:
      break;
  }
140
#ifndef MEMPROF
141
  g_mem_chunk_free (_gst_event_chunk, event);
142 143 144
#else
  g_free (event);
#endif
145 146 147
  g_mutex_unlock (_gst_event_chunk_lock);
}

148 149 150 151 152 153 154 155 156 157
/**
 * gst_event_new_seek:
 * @type: The type of the seek event
 * @offset: The offset of the seek
 * @flush: A boolean indicating a flush has to be performed as well
 *
 * Allocate a new seek event with the given parameters.
 *
 * Returns: A new seek event.
 */
158
GstEvent*       
159
gst_event_new_seek (GstSeekType type, gint64 offset)
160 161 162 163 164 165 166 167 168
{
  GstEvent *event;

  event = gst_event_new (GST_EVENT_SEEK);
  GST_EVENT_SEEK_TYPE (event) = type;
  GST_EVENT_SEEK_OFFSET (event) = offset;

  return event;
}
169

170
GstEvent*
171
gst_event_new_discontinuous (gboolean flush, GstSeekType format1, ...)
172 173 174 175 176 177
{
  va_list var_args;
  GstEvent *event;
  gint count = 0;

  event = gst_event_new (GST_EVENT_DISCONTINUOUS);
178
  GST_EVENT_DISCONT_FLUSH (event) = flush;
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219

  va_start (var_args, format1);
	        
  while (format1) {

    GST_EVENT_DISCONT_OFFSET (event, count).format = format1 & GST_SEEK_FORMAT_MASK;
    GST_EVENT_DISCONT_OFFSET (event, count).value = va_arg (var_args, gint64);

    format1 = va_arg (var_args, GstSeekType);

    count++;
  }
  va_end (var_args);

  GST_EVENT_DISCONT_OFFSET_LEN (event) = count;
		    
  return event;
}

gboolean
gst_event_discont_get_value (GstEvent *event, GstSeekType type, gint64 *value)
{
  gint i, n;

  g_return_val_if_fail (event, FALSE);
  g_return_val_if_fail (value, FALSE);

  n = GST_EVENT_DISCONT_OFFSET_LEN (event);

  for (i = 0; i < n; i++) {
    if (GST_EVENT_DISCONT_OFFSET(event,i).format == type) {
      *value = GST_EVENT_DISCONT_OFFSET(event,i).value;
      return TRUE;
    }
  }
  
  return FALSE;
}



220