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; }
/* 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; }
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; }
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; }
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; }
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); }
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; }
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); }
/* * @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; }
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); }
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); }
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)); }
/** * 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; }
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; }
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; }
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); }
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; }
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; }
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); }
// 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; }
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; }
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); }
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; }
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); }