Пример #1
0
static void
gst_object_init (GstObject * object)
{
  g_mutex_init (&object->lock);
  object->parent = NULL;
  object->name = NULL;
  GST_CAT_TRACE_OBJECT (GST_CAT_REFCOUNTING, object, "%p new", object);

#ifndef GST_DISABLE_TRACE
  _gst_alloc_trace_new (_gst_object_trace, object);
#endif

  object->flags = 0;

  object->control_rate = 100 * GST_MSECOND;
  object->last_sync = GST_CLOCK_TIME_NONE;
}
Пример #2
0
/* initialize the new element
 * instantiate pads and add them to element
 * set functions
 * initialize structure
 */
static void
gst_directsound_src_init (GstDirectSoundSrc * src)
{
  GST_DEBUG_OBJECT (src, "initializing directsoundsrc");
  g_mutex_init (&src->dsound_lock);
  src->system_clock = gst_system_clock_obtain ();
  src->read_wait_clock_id = NULL;
  src->reset_while_sleeping = FALSE;
  src->device_guid = NULL;
  src->device_id = NULL;
  src->device_name = NULL;
  src->mixer = NULL;
  src->control_id_mute = -1;
  src->control_id_volume = -1;
  src->volume = 100;
  src->mute = FALSE;
}
Пример #3
0
static void
xmr_downloader_init(XmrDownloader *downloader)
{
	XmrDownloaderPrivate *priv;

	downloader->priv = G_TYPE_INSTANCE_GET_PRIVATE(downloader, XMR_TYPE_DOWNLOADER, XmrDownloaderPrivate);
	priv = downloader->priv;

#if GLIB_CHECK_VERSION(2, 32, 0)
	priv->mutex = g_malloc(sizeof(GMutex));
	g_mutex_init(priv->mutex);
#else
	priv->mutex = g_mutex_new();
#endif

	priv->tasks = NULL;
}
Пример #4
0
static GObject * soy_textures_bumpmap_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
	GObject * obj;
	GObjectClass * parent_class;
	soytexturesBumpmap * self;
	GeeHashMap* _tmp0_;
	parent_class = G_OBJECT_CLASS (soy_textures_bumpmap_parent_class);
	obj = parent_class->constructor (type, n_construct_properties, construct_properties);
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SOY_TEXTURES_TYPE_BUMPMAP, soytexturesBumpmap);
	_tmp0_ = gee_hash_map_new (G_TYPE_INT, NULL, NULL, SOY_ATOMS_TYPE_VECTOR, NULL, NULL, NULL, NULL, NULL);
	_g_object_unref0 (self->priv->_texel_objs);
	self->priv->_texel_objs = _tmp0_;
	_vala_clear_GMutex (&self->priv->_mutex);
	g_mutex_init (&self->priv->_mutex);
	soy_textures_texture_set_channels ((soytexturesTexture*) self, 3);
	((soytexturesTexture*) self)->translucent = FALSE;
	return obj;
}
Пример #5
0
static void webkit_video_sink_init(WebKitVideoSink* sink)
{
    sink->priv = G_TYPE_INSTANCE_GET_PRIVATE(sink, WEBKIT_TYPE_VIDEO_SINK, WebKitVideoSinkPrivate);
#if GLIB_CHECK_VERSION(2, 31, 0)
    sink->priv->dataCondition = new GCond;
    g_cond_init(sink->priv->dataCondition);
    sink->priv->bufferMutex = new GMutex;
    g_mutex_init(sink->priv->bufferMutex);
#else
    sink->priv->dataCondition = g_cond_new();
    sink->priv->bufferMutex = g_mutex_new();
#endif

#ifdef GST_API_VERSION_1
    gst_video_info_init(&sink->priv->info);
#endif
}
GstOmxBufQueue *
gst_omx_buf_queue_new ()
{
  GstOmxBufQueue *bufqueue = NULL;
  bufqueue = g_malloc0 (sizeof (GstOmxBufQueue));
  if (!bufqueue)
    goto exit;

  g_mutex_init (&bufqueue->queuemutex);
  g_cond_init (&bufqueue->queuecond);
  bufqueue->queue = g_queue_new ();
  g_queue_init (bufqueue->queue);
  bufqueue->release = FALSE;

exit:
  return bufqueue;
}
Пример #7
0
static void
gst_decklink_audio_src_init (GstDecklinkAudioSrc * self)
{
  self->device_number = 0;
  self->alignment_threshold = DEFAULT_ALIGNMENT_THRESHOLD;
  self->discont_wait = DEFAULT_DISCONT_WAIT;
  self->buffer_size = DEFAULT_BUFFER_SIZE;
  self->channels = DEFAULT_CHANNELS;

  gst_base_src_set_live (GST_BASE_SRC (self), TRUE);
  gst_base_src_set_format (GST_BASE_SRC (self), GST_FORMAT_TIME);

  g_mutex_init (&self->lock);
  g_cond_init (&self->cond);

  g_queue_init (&self->current_packets);
}
Пример #8
0
static void
gst_app_sink_init (GstAppSink * appsink)
{
  GstAppSinkPrivate *priv;

  priv = appsink->priv =
      G_TYPE_INSTANCE_GET_PRIVATE (appsink, GST_TYPE_APP_SINK,
      GstAppSinkPrivate);

  g_mutex_init (&priv->mutex);
  g_cond_init (&priv->cond);
  priv->queue = g_queue_new ();

  priv->emit_signals = DEFAULT_PROP_EMIT_SIGNALS;
  priv->max_buffers = DEFAULT_PROP_MAX_BUFFERS;
  priv->drop = DEFAULT_PROP_DROP;
}
Пример #9
0
CamelImapxAcl*
camel_imapx_acl_new (gboolean locked)
{
	CamelImapxAcl *acl = g_new0 (CamelImapxAcl, 1);
	g_mutex_init (&(acl->lock));

	if (locked)
		g_mutex_lock (&(acl->lock));

	/* foldername:myrights */
	acl->myrights = imapx_acl_myrights_table_new ();

	/* foldername:access_id:rights */
	acl->mboxes = imapx_acl_mboxes_table_new ();

	return acl;
}
void
_priv_gst_alloc_trace_initialize (void)
{
  const gchar *trace;

  trace = g_getenv ("GST_TRACE");
  if (trace != NULL) {
    const GDebugKey keys[] = {
      {"live", GST_ALLOC_TRACE_LIVE},
      {"mem-live", GST_ALLOC_TRACE_MEM_LIVE},
    };
    _gst_trace_flags = g_parse_debug_string (trace, keys, G_N_ELEMENTS (keys));
    atexit (_at_exit);
  }

  g_mutex_init (&_gst_trace_mutex);
}
Пример #11
0
/*
 * @final_callback: (transfer full):
 * @list_item_destroy: (allow none): used to free the list items after calling @final_callback
 *
 * Returns a closure which should be called with a single GList argument.
 * When the refcount of the closure reaches 0, final_callback is called
 * with a concatenation of all the lists that were sent to the closure.
 */
GClosure *_owr_utils_list_closure_merger_new(GClosure *final_callback, GDestroyNotify list_item_destroy)
{
    CallbackMergeContext *context;
    GClosure *merger;

    context = g_new0(CallbackMergeContext, 1);

    context->callback = final_callback;
    context->item_destroy = list_item_destroy;
    context->list = NULL;
    g_mutex_init(&context->mutex);

    merger = g_cclosure_new(G_CALLBACK(callback_merger), context, (GClosureNotify) callback_merger_on_destroy_data);
    g_closure_set_marshal(merger, g_cclosure_marshal_generic);

    return merger;
}
Пример #12
0
static void
gst_audio_fx_base_fir_filter_init (GstAudioFXBaseFIRFilter * self)
{
  self->kernel = NULL;
  self->buffer = NULL;
  self->buffer_length = 0;

  self->start_ts = GST_CLOCK_TIME_NONE;
  self->start_off = GST_BUFFER_OFFSET_NONE;
  self->nsamples_out = 0;
  self->nsamples_in = 0;

  self->low_latency = DEFAULT_LOW_LATENCY;
  self->drain_on_changes = DEFAULT_DRAIN_ON_CHANGES;

  g_mutex_init (&self->lock);
}
static void
gst_decklink_video_src_init (GstDecklinkVideoSrc * self)
{
  self->mode = DEFAULT_MODE;
  self->caps_mode = GST_DECKLINK_MODE_AUTO;
  self->connection = DEFAULT_CONNECTION;
  self->device_number = 0;
  self->buffer_size = DEFAULT_BUFFER_SIZE;

  gst_base_src_set_live (GST_BASE_SRC (self), TRUE);
  gst_base_src_set_format (GST_BASE_SRC (self), GST_FORMAT_TIME);

  g_mutex_init (&self->lock);
  g_cond_init (&self->cond);

  g_queue_init (&self->current_frames);
}
Пример #14
0
GError *
meta2_backend_init(struct meta2_backend_s **result,
		struct sqlx_repository_s *repo, const gchar *ns,
		struct grid_lbpool_s *glp, struct hc_resolver_s *resolver)
{
	GError *err = NULL;
	struct meta2_backend_s *m2 = NULL;
	gsize s;

	EXTRA_ASSERT(result != NULL);
	EXTRA_ASSERT(glp != NULL);
	EXTRA_ASSERT(repo != NULL);
	EXTRA_ASSERT(resolver != NULL);

	m2 = g_malloc0(sizeof(struct meta2_backend_s));
	s = metautils_strlcpy_physical_ns(m2->backend.ns_name, ns,
			sizeof(m2->backend.ns_name));
	if (sizeof(m2->backend.ns_name) <= s) {
		g_free(m2);
		return NEWERROR(CODE_BAD_REQUEST, "Namespace too long");
	}

	m2->backend.type = NAME_SRVTYPE_META2;
	m2->backend.repo = repo;
	m2->backend.lb = glp;
	m2->policies = service_update_policies_create();
	g_mutex_init(&m2->nsinfo_lock);

	m2->flag_precheck_on_generate = TRUE;

	err = sqlx_repository_configure_type(m2->backend.repo,
			NAME_SRVTYPE_META2, schema);
	if (NULL != err) {
		meta2_backend_clean(m2);
		g_prefix_error(&err, "Backend init error: ");
		return err;
	}

	m2->resolver = resolver;

	GRID_DEBUG("M2V2 backend created for NS[%s] and repo[%p]",
			m2->backend.ns_name, m2->backend.repo);

	*result = m2;
	return NULL;
}
static void
gst_audio_iir_filter_init (GstAudioIIRFilter * self)
{
  GValue v = { 0, };
  GValueArray *a;

  a = g_value_array_new (1);

  g_value_init (&v, G_TYPE_DOUBLE);
  g_value_set_double (&v, 1.0);
  g_value_array_append (a, &v);
  g_value_unset (&v);

  gst_audio_iir_filter_update_coefficients (self, a, g_value_array_copy (a));

  g_mutex_init (&self->lock);
}
Пример #16
0
static void 
gw_installprogresswindow_constructed (GObject *object)
{
    //Declarations
    GwInstallProgressWindow *window;
    GwInstallProgressWindowPrivate *priv;
    GtkAccelGroup *accelgroup;

    //Chain the parent class
    {
      G_OBJECT_CLASS (gw_installprogresswindow_parent_class)->constructed (object);
    }

    window = GW_INSTALLPROGRESSWINDOW (object);
    priv = window->priv;
    accelgroup = gw_window_get_accel_group (GW_WINDOW (window));

    g_mutex_init (&priv->mutex);
    priv->label = GTK_LABEL (gw_window_get_object (GW_WINDOW (window), "progress_label"));
    priv->sublabel = GTK_LABEL (gw_window_get_object (GW_WINDOW (window), "sub_progress_label"));
    priv->progressbar = GTK_PROGRESS_BAR (gw_window_get_object (GW_WINDOW (window), "progress_progressbar"));
    priv->cancel_button = GTK_BUTTON (gw_window_get_object (GW_WINDOW (window), "cancel_button"));
    priv->cancellable = g_cancellable_new ();

    gtk_window_set_title (GTK_WINDOW (window), gettext("Installing Dictionaries..."));
    gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
    gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
    gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), TRUE);
    gtk_window_set_skip_pager_hint (GTK_WINDOW (window), TRUE);
    gtk_window_set_destroy_with_parent (GTK_WINDOW (window), TRUE);
    gtk_window_set_icon_name (GTK_WINDOW (window), "gwaei");
    gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER_ON_PARENT);
    gtk_window_set_modal (GTK_WINDOW (window), TRUE);
    gtk_window_set_default_size (GTK_WINDOW (window), 500, -1);
    gtk_window_set_has_resize_grip (GTK_WINDOW (window), FALSE);
    gtk_container_set_border_width (GTK_CONTAINER (window), 4);


    gtk_widget_add_accelerator (GTK_WIDGET (priv->cancel_button), "activate", 
      accelgroup, (GDK_KEY_W), GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator (GTK_WIDGET (priv->cancel_button), "activate", 
      accelgroup, (GDK_KEY_Escape), 0, GTK_ACCEL_VISIBLE);

    gw_window_unload_xml (GW_WINDOW (window));
}
Пример #17
0
/**
 * cra_context_new:
 */
CraContext *
cra_context_new (void)
{
	CraContext *ctx;
	ctx = g_new0 (CraContext, 1);
	ctx->blacklisted_pkgs = cra_glob_value_array_new ();
	ctx->plugins = cra_plugin_loader_new ();
	ctx->packages = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
	ctx->extra_pkgs = cra_glob_value_array_new ();
	g_mutex_init (&ctx->apps_mutex);
	ctx->old_md_cache = as_store_new ();

	/* add extra data */
	cra_context_add_extra_pkg (ctx, "alliance-libs", "alliance");
	cra_context_add_extra_pkg (ctx, "beneath-a-steel-sky*", "scummvm");
	cra_context_add_extra_pkg (ctx, "coq-coqide", "coq");
	cra_context_add_extra_pkg (ctx, "drascula*", "scummvm");
	cra_context_add_extra_pkg (ctx, "efte-*", "efte-common");
	cra_context_add_extra_pkg (ctx, "fcitx-*", "fcitx-data");
	cra_context_add_extra_pkg (ctx, "flight-of-the-amazon-queen", "scummvm");
	cra_context_add_extra_pkg (ctx, "gcin", "gcin-data");
	cra_context_add_extra_pkg (ctx, "hotot-gtk", "hotot-common");
	cra_context_add_extra_pkg (ctx, "hotot-qt", "hotot-common");
	cra_context_add_extra_pkg (ctx, "java-1.7.0-openjdk-devel", "java-1.7.0-openjdk");
	cra_context_add_extra_pkg (ctx, "kchmviewer-qt", "kchmviewer");
	cra_context_add_extra_pkg (ctx, "libreoffice-*", "libreoffice-core");
	cra_context_add_extra_pkg (ctx, "lure", "scummvm");
	cra_context_add_extra_pkg (ctx, "nntpgrab-gui", "nntpgrab-core");
	cra_context_add_extra_pkg (ctx, "projectM-*", "libprojectM-qt");
	cra_context_add_extra_pkg (ctx, "scummvm-tools", "scummvm");
	cra_context_add_extra_pkg (ctx, "speed-dreams", "speed-dreams-robots-base");
	cra_context_add_extra_pkg (ctx, "switchdesk-gui", "switchdesk");
	cra_context_add_extra_pkg (ctx, "transmission-*", "transmission-common");
	cra_context_add_extra_pkg (ctx, "calligra-krita", "calligra-core");

	/* add blacklisted packages */
	cra_context_add_blacklist_pkg (ctx, "beneath-a-steel-sky-cd");
	cra_context_add_blacklist_pkg (ctx, "anaconda");
	cra_context_add_blacklist_pkg (ctx, "mate-control-center");
	cra_context_add_blacklist_pkg (ctx, "lxde-common");
	cra_context_add_blacklist_pkg (ctx, "xscreensaver-*");
	cra_context_add_blacklist_pkg (ctx, "bmpanel2-cfg");

	return ctx;
}
Пример #18
0
GstImxEglVivSinkEGLPlatform* gst_imx_egl_viv_sink_egl_platform_create(gchar const *native_display_name, GstImxEglVivSinkWindowResizedEventCallback window_resized_event_cb, gpointer user_context)
{
	EGLint ver_major, ver_minor;
	GstImxEglVivSinkEGLPlatform* platform;
	Display *x11_display;

	init_debug_category();

	platform = (GstImxEglVivSinkEGLPlatform *)g_new0(GstImxEglVivSinkEGLPlatform, 1);
	platform->window_resized_event_cb = window_resized_event_cb;
	platform->user_context = user_context;

	g_mutex_init(&(platform->mutex));

	x11_display = XOpenDisplay(native_display_name);
	if (x11_display == NULL)
	{
		GST_ERROR("could not open X display");
		g_free(platform);
		return NULL;
	}

	platform->native_display = (EGLNativeDisplayType)x11_display;

	platform->egl_display = eglGetDisplay(platform->native_display);
	if (platform->egl_display == EGL_NO_DISPLAY)
	{
		GST_ERROR("eglGetDisplay failed: %s", gst_imx_egl_viv_sink_egl_platform_get_last_error_string());
		XCloseDisplay(x11_display);
		g_free(platform);
		return NULL;
	}

	if (!eglInitialize(platform->egl_display, &ver_major, &ver_minor))
	{
		GST_ERROR("eglInitialize failed: %s", gst_imx_egl_viv_sink_egl_platform_get_last_error_string());
		XCloseDisplay(x11_display);
		g_free(platform);
		return NULL;
	}

	GST_INFO("X11 EGL platform initialized, using EGL %d.%d", ver_major, ver_minor);

	return platform;
}
Пример #19
0
static GFileMonitorSource *
g_file_monitor_source_new (gpointer           instance,
                           const gchar       *filename,
                           gboolean           is_directory,
                           GFileMonitorFlags  flags)
{
  static GSourceFuncs source_funcs = {
    NULL, NULL,
    g_file_monitor_source_dispatch,
    g_file_monitor_source_finalize
  };
  GFileMonitorSource *fms;
  GSource *source;

  source = g_source_new (&source_funcs, sizeof (GFileMonitorSource));
  fms = (GFileMonitorSource *) source;

  g_mutex_init (&fms->lock);
  fms->instance = instance;
  fms->pending_changes = g_sequence_new (pending_change_free);
  fms->pending_changes_table = g_hash_table_new (str_hash0, str_equal0);
  fms->rate_limit = DEFAULT_RATE_LIMIT;
  fms->flags = flags;

  if (is_directory)
    {
      fms->dirname = g_strdup (filename);
      fms->basename = NULL;
      fms->filename = NULL;
    }
  else if (flags & G_FILE_MONITOR_WATCH_HARD_LINKS)
    {
      fms->dirname = NULL;
      fms->basename = NULL;
      fms->filename = g_strdup (filename);
    }
  else
    {
      fms->dirname = g_path_get_dirname (filename);
      fms->basename = g_path_get_basename (filename);
      fms->filename = NULL;
    }

  return fms;
}
Пример #20
0
static void
gst_multiudpsink_init (GstMultiUDPSink * sink)
{
  g_mutex_init (&sink->client_lock);
  sink->socket = DEFAULT_SOCKET;
  sink->used_socket = DEFAULT_USED_SOCKET;
  sink->close_socket = DEFAULT_CLOSE_SOCKET;
  sink->external_socket = (sink->socket != NULL);
  sink->auto_multicast = DEFAULT_AUTO_MULTICAST;
  sink->ttl = DEFAULT_TTL;
  sink->ttl_mc = DEFAULT_TTL_MC;
  sink->loop = DEFAULT_LOOP;
  sink->qos_dscp = DEFAULT_QOS_DSCP;
  sink->family = DEFAULT_FAMILY;
  sink->send_duplicates = DEFAULT_SEND_DUPLICATES;

  sink->cancellable = g_cancellable_new ();
}
static void
gst_glimage_sink_init (GstGLImageSink * glimage_sink)
{
  glimage_sink->display_name = NULL;
  glimage_sink->window_id = 0;
  glimage_sink->new_window_id = 0;
  glimage_sink->display = NULL;
  glimage_sink->clientReshapeCallback = NULL;
  glimage_sink->clientDrawCallback = NULL;
  glimage_sink->client_data = NULL;
  glimage_sink->keep_aspect_ratio = FALSE;
  glimage_sink->par_n = 0;
  glimage_sink->par_d = 1;
  glimage_sink->pool = NULL;
  glimage_sink->redisplay_texture = 0;

  g_mutex_init (&glimage_sink->drawing_lock);
}
Пример #22
0
static CoglGstSource *
cogl_gst_source_new (CoglGstVideoSink *sink)
{
  GSource *source;
  CoglGstSource *gst_source;

  source = g_source_new (&gst_source_funcs, sizeof (CoglGstSource));
  gst_source = (CoglGstSource *) source;

  g_source_set_can_recurse (source, TRUE);
  g_source_set_priority (source, COGL_GST_DEFAULT_PRIORITY);

  gst_source->sink = sink;
  g_mutex_init (&gst_source->buffer_lock);
  gst_source->buffer = NULL;

  return gst_source;
}
Пример #23
0
Packet* packet_new(gconstpointer payload, gsize payloadLength) {
	Packet* packet = g_new0(Packet, 1);
	MAGIC_INIT(packet);

	g_mutex_init(&(packet->lock));
	packet->referenceCount = 1;

	packet->payloadLength = payloadLength;
	if(payloadLength > 0) {
		/* if length is 0, this returns NULL */
		packet->payload = g_memdup(payload, payloadLength);

		/* application data needs a priority ordering for FIFO onto the wire */
		packet->priority = node_getNextPacketPriority(worker_getPrivate()->cached_node);
	}

	return packet;
}
Пример #24
0
static void
gst_task_pool_init (GstTaskPool * pool)
{
  pool->priv = GST_TASK_POOL_GET_PRIVATE (pool);

  pool->priv->max_threads = -1;
  pool->priv->exclusive = FALSE;

  pool->priv->need_schedule_thread = 0;
  pool->priv->schedule_context = NULL;
  pool->priv->schedule_loop = NULL;
  pool->priv->schedule_thread = NULL;
  g_mutex_init (&pool->priv->schedule_lock);
  g_cond_init (&pool->priv->schedule_cond);

  /* clear floating flag */
  gst_object_ref_sink (pool);
}
Пример #25
0
// It turns out that ncurses isn't thread-safe
gint wsh_client_init(GError **err) {
	int ret = -1;

	if (initialized)
		return 0;

	if ((ret = wsh_client_init_fds(err)))
		return ret;

#if ! GLIB_CHECK_VERSION( 2, 32, 0 )
	g_thread_init(NULL);
#endif

	g_mutex_init(&client_mtx);

	initialized = 1;
	return ret;
}
Пример #26
0
static void
lbmss_stream_class_init(LibBalsaMimeStreamSharedClass * klass)
{
    GMimeStreamClass *stream_class = GMIME_STREAM_CLASS(klass);
    GObjectClass *object_class = G_OBJECT_CLASS(klass);

    parent_class = g_type_class_ref(GMIME_TYPE_STREAM_FS);
    g_mutex_init(&lbmss_mutex);
    g_cond_init(&lbmss_cond);

    object_class->finalize  = lbmss_finalize;

    stream_class->read      = lbmss_stream_read;
    stream_class->write     = lbmss_stream_write;
    stream_class->reset     = lbmss_stream_reset;
    stream_class->seek      = lbmss_stream_seek;
    stream_class->substream = lbmss_stream_substream;
}
Пример #27
0
static void
gst_base_camera_src_init (GstBaseCameraSrc * self)
{
  self->width = DEFAULT_WIDTH;
  self->height = DEFAULT_HEIGHT;
  self->zoom = DEFAULT_ZOOM;
  self->max_zoom = MAX_ZOOM;
  self->mode = MODE_IMAGE;

  self->capturing = FALSE;
  g_mutex_init (&self->capturing_mutex);

  self->post_preview = DEFAULT_POST_PREVIEW;
  self->preview_caps = gst_caps_new_any ();

  self->preview_pipeline =
      gst_camerabin_create_preview_pipeline (GST_ELEMENT_CAST (self), NULL);
}
Пример #28
0
int
main (int argc, char *argv[])
{
  GThread *thread1, *thread2, *thread3;
  Example *data = g_new (Example, 1);;

  data->counter = 0;
  g_mutex_init (&data->mutex);

  thread1 = g_thread_new ("1", sensitive_function, data);
  thread2 = g_thread_new ("2", sensitive_function, data);
  thread3 = g_thread_new ("3", concurrent_function, NULL);

  g_thread_join (thread1);
  g_thread_join (thread2);

  return 0;
}
static HostStealThreadData* _hoststealthreaddata_new() {
    HostStealThreadData* tdata = g_new0(HostStealThreadData, 1);

    tdata->unprocessedHosts = g_queue_new();
    tdata->processedHosts = g_queue_new();

    /* Create new timers to track thread idle times. The timers start in a 'started' state,
     * so we want to stop them immediately so we can continue/stop later around blocking code
     * to collect total elapsed idle time in the scheduling process throughout the entire
     * runtime of the program. */
    tdata->pushIdleTime = g_timer_new();
    g_timer_stop(tdata->pushIdleTime);
    tdata->popIdleTime = g_timer_new();
    g_timer_stop(tdata->popIdleTime);
    g_mutex_init(&(tdata->lock));
    tdata->runningHost = NULL;
    return tdata;
}
Пример #30
0
static void
tracker_extract_init (TrackerExtract *object)
{
	TrackerExtractPrivate *priv;

#ifdef HAVE_LIBSTREAMANALYZER
	tracker_topanalyzer_init ();
#endif /* HAVE_STREAMANALYZER */

	priv = TRACKER_EXTRACT_GET_PRIVATE (object);
	priv->statistics_data = g_hash_table_new_full (NULL, NULL, NULL,
	                                               (GDestroyNotify) statistics_data_free);
	priv->single_thread_extractors = g_hash_table_new (NULL, NULL);
	priv->thread_pool = g_thread_pool_new ((GFunc) get_metadata,
	                                       NULL, 10, TRUE, NULL);

	g_mutex_init (&priv->task_mutex);
}