void gst_gl_async_debug_init (GstGLAsyncDebug * ad) { _init_debug (); memset (ad, 0, sizeof (*ad)); }
gchar * _gst_glsl_mangle_shader (const gchar * str, guint shader_type, GstGLTextureTarget from, GstGLTextureTarget to, GstGLContext * context, GstGLSLVersion * version, GstGLSLProfile * profile) { gchar *tmp, *tmp2; _init_debug (); g_return_val_if_fail (GST_IS_GL_CONTEXT (context), NULL); _mangle_version_profile_from_gl_api (context, from, to, version, profile); tmp2 = _mangle_external_image_extension (str, context, from, to, *version, *profile); tmp = _mangle_texture_access (tmp2, context, from, to, *version, *profile); g_free (tmp2); tmp2 = _mangle_sampler_type (tmp, from, to); g_free (tmp); tmp = _mangle_varying_attribute (tmp2, shader_type, *version, *profile); g_free (tmp2); if (shader_type == GL_FRAGMENT_SHADER) { if ((*profile == GST_GLSL_PROFILE_ES && *version >= GST_GLSL_VERSION_300) || (*profile == GST_GLSL_PROFILE_CORE && *version >= GST_GLSL_VERSION_150)) { tmp2 = _mangle_frag_color_data (tmp); g_free (tmp); tmp = tmp2; } } return tmp; }
void GSTGLAPI _gst_gl_debug_callback (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const gchar * message, gpointer user_data) { GstGLContext *context = user_data; const gchar *severity_str = _debug_severity_to_string (severity); const gchar *source_str = _debug_source_to_string (source); const gchar *type_str = _debug_type_to_string (type); _init_debug (); switch (type) { case GL_DEBUG_TYPE_ERROR: case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOUR: GST_ERROR_OBJECT (context, "%s: GL %s from %s id:%u, %s", severity_str, type_str, source_str, id, message); break; case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOUR: case GL_DEBUG_TYPE_PORTABILITY: GST_FIXME_OBJECT (context, "%s: GL %s from %s id:%u, %s", severity_str, type_str, source_str, id, message); break; case GL_DEBUG_TYPE_PERFORMANCE: GST_CAT_DEBUG_OBJECT (gst_performance, context, "%s: GL %s from %s id:%u," " %s", severity_str, type_str, source_str, id, message); break; default: GST_DEBUG_OBJECT (context, "%s: GL %s from %s id:%u, %s", severity_str, type_str, source_str, id, message); break; } }
/** * gst_gl_context_new_wrapped: * @display: a #GstGLDisplay * @handle: the OpenGL context to wrap * @context_type: a #GstGLPlatform specifying the type of context in @handle * @available_apis: a #GstGLAPI containing the available OpenGL apis in @handle * * Wraps an existing OpenGL context into a #GstGLContext. * * Returns: a #GstGLContext wrapping @handle */ GstGLContext * gst_gl_context_new_wrapped (GstGLDisplay * display, guintptr handle, GstGLPlatform context_type, GstGLAPI available_apis) { GstGLContext *context; GstGLWrappedContext *context_wrap = NULL; _init_debug (); context_wrap = g_object_new (GST_GL_TYPE_WRAPPED_CONTEXT, NULL); if (!context_wrap) { /* subclass returned a NULL context */ GST_ERROR ("Could not wrap existing context"); return NULL; } context = (GstGLContext *) context_wrap; context->priv->display = gst_object_ref (display); context_wrap->handle = handle; context_wrap->platform = context_type; context_wrap->available_apis = available_apis; return context; }
void gst_gl_query_init (GstGLQuery * query, GstGLContext * context, GstGLQueryType query_type) { const GstGLFuncs *gl; g_return_if_fail (query != NULL); g_return_if_fail (GST_IS_GL_CONTEXT (context)); gl = context->gl_vtable; memset (query, 0, sizeof (*query)); _init_debug (); query->context = gst_object_ref (context); query->query_type = _gst_gl_query_type_to_gl (query_type); query->supported = _context_supports_query_type (context, query->query_type); if (query->supported) gl->GenQueries (1, &query->query_id); gst_gl_async_debug_init (&query->debug); query->debug.callback = _log_time; query->debug.user_data = query; }
/** * gst_gl_context_get_current_gl_context: * @context_type: a #GstGLPlatform specifying the type of context to retrieve * * Returns: The OpenGL context handle current in the calling thread or %NULL * * Since: 1.6 */ guintptr gst_gl_context_get_current_gl_context (GstGLPlatform context_type) { guintptr handle = 0; _init_debug (); #if GST_GL_HAVE_PLATFORM_GLX if (!handle && (context_type & GST_GL_PLATFORM_GLX) != 0) handle = gst_gl_context_glx_get_current_context (); #endif #if GST_GL_HAVE_PLATFORM_EGL if (!handle && (context_type & GST_GL_PLATFORM_EGL) != 0) handle = gst_gl_context_egl_get_current_context (); #endif #if GST_GL_HAVE_PLATFORM_CGL if (!handle && (context_type & GST_GL_PLATFORM_CGL) != 0) handle = gst_gl_context_cocoa_get_current_context (); #endif #if GST_GL_HAVE_PLATFORM_WGL if (!handle && (context_type & GST_GL_PLATFORM_WGL) != 0) handle = gst_gl_context_wgl_get_current_context (); #endif #if GST_GL_HAVE_PLATFORM_EAGL if (!handle && (context_type & GST_GL_PLATFORM_EAGL) != 0) handle = gst_gl_context_eagl_get_current_context (); #endif if (!handle) GST_WARNING ("Could not retrieve current context"); return handle; }
static void gst_gl_context_class_init (GstGLContextClass * klass) { g_type_class_add_private (klass, sizeof (GstGLContextPrivate)); klass->get_proc_address = GST_DEBUG_FUNCPTR (gst_gl_context_default_get_proc_address); G_OBJECT_CLASS (klass)->finalize = gst_gl_context_finalize; _init_debug (); }
/** * gst_gl_window_new: * @display: a #GstGLDisplay * * Returns: (transfer full): a new #GstGLWindow using @display's connection * * Since: 1.4 */ GstGLWindow * gst_gl_window_new (GstGLDisplay * display) { GstGLWindow *window = NULL; const gchar *user_choice; g_return_val_if_fail (display != NULL, NULL); _init_debug (); user_choice = g_getenv ("GST_GL_WINDOW"); GST_INFO ("creating a window, user choice:%s", user_choice); #if GST_GL_HAVE_WINDOW_COCOA if (!window && (!user_choice || g_strstr_len (user_choice, 5, "cocoa"))) window = GST_GL_WINDOW (gst_gl_window_cocoa_new (display)); #endif #if GST_GL_HAVE_WINDOW_X11 if (!window && (!user_choice || g_strstr_len (user_choice, 3, "x11"))) window = GST_GL_WINDOW (gst_gl_window_x11_new (display)); #endif #if GST_GL_HAVE_WINDOW_WIN32 if (!window && (!user_choice || g_strstr_len (user_choice, 5, "win32"))) window = GST_GL_WINDOW (gst_gl_window_win32_new (display)); #endif #if GST_GL_HAVE_WINDOW_WAYLAND if (!window && (!user_choice || g_strstr_len (user_choice, 7, "wayland"))) window = GST_GL_WINDOW (gst_gl_window_wayland_egl_new (display)); #endif #if GST_GL_HAVE_WINDOW_DISPMANX if (!window && (!user_choice || g_strstr_len (user_choice, 8, "dispmanx"))) window = GST_GL_WINDOW (gst_gl_window_dispmanx_egl_new (display)); #endif #if GST_GL_HAVE_WINDOW_ANDROID if (!window && (!user_choice || g_strstr_len (user_choice, 7, "android"))) window = GST_GL_WINDOW (gst_gl_window_android_egl_new (display)); #endif #if GST_GL_HAVE_WINDOW_EAGL if (!window && (!user_choice || g_strstr_len (user_choice, 4, "eagl"))) window = GST_GL_WINDOW (gst_gl_window_eagl_new (display)); #endif if (!window) { /* subclass returned a NULL window */ GST_WARNING ("Could not create window. user specified %s, creating dummy" " window", user_choice ? user_choice : "(null)"); window = GST_GL_WINDOW (gst_gl_dummy_window_new ()); } window->display = gst_object_ref (display); return window; }
static void gst_gl_window_class_init (GstGLWindowClass * klass) { g_type_class_add_private (klass, sizeof (GstGLWindowPrivate)); klass->open = GST_DEBUG_FUNCPTR (gst_gl_window_default_open); klass->close = GST_DEBUG_FUNCPTR (gst_gl_window_default_close); klass->run = GST_DEBUG_FUNCPTR (gst_gl_window_default_run); klass->quit = GST_DEBUG_FUNCPTR (gst_gl_window_default_quit); klass->draw = GST_DEBUG_FUNCPTR (gst_gl_window_default_draw); klass->send_message = GST_DEBUG_FUNCPTR (gst_gl_window_default_send_message); klass->send_message_async = GST_DEBUG_FUNCPTR (gst_gl_window_default_send_message_async); G_OBJECT_CLASS (klass)->finalize = gst_gl_window_finalize; /** * GstGLWindow::mouse-event: * @object: the #GstGLWindow * @id: the name of the event * @button: the id of the button * @x: the x coordinate of the mouse event * @y: the y coordinate of the mouse event * * Will be emitted when a mouse event is received by the GstGLwindow. * * Since: 1.6 */ gst_gl_window_signals[EVENT_MOUSE_SIGNAL] = g_signal_new ("mouse-event", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_DOUBLE); /** * GstGLWindow::key-event: * @object: the #GstGLWindow * @id: the name of the event * @key: the id of the key pressed * * Will be emitted when a key event is received by the GstGLwindow. * * Since: 1.6 */ gst_gl_window_signals[EVENT_KEY_SIGNAL] = g_signal_new ("key-event", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING); _init_debug (); }
/** * gst_gl_context_new: * @display: a #GstGLDisplay * * Create a new #GstGLContext with the specified @display * * Returns: a new #GstGLContext * * Since: 1.4 */ GstGLContext * gst_gl_context_new (GstGLDisplay * display) { GstGLContext *context = NULL; const gchar *user_choice; _init_debug (); user_choice = g_getenv ("GST_GL_PLATFORM"); GST_INFO ("creating a context for display %" GST_PTR_FORMAT ", user choice:%s", display, user_choice); #if GST_GL_HAVE_PLATFORM_CGL if (!context && (!user_choice || g_strstr_len (user_choice, 5, "cgl"))) context = GST_GL_CONTEXT (gst_gl_context_cocoa_new ()); #endif #if GST_GL_HAVE_PLATFORM_GLX if (!context && (!user_choice || g_strstr_len (user_choice, 3, "glx"))) context = GST_GL_CONTEXT (gst_gl_context_glx_new ()); #endif #if GST_GL_HAVE_PLATFORM_EGL if (!context && (!user_choice || g_strstr_len (user_choice, 7, "egl"))) context = GST_GL_CONTEXT (gst_gl_context_egl_new ()); #endif #if GST_GL_HAVE_PLATFORM_WGL if (!context && (!user_choice || g_strstr_len (user_choice, 3, "wgl"))) { context = GST_GL_CONTEXT (gst_gl_context_wgl_new ()); } #endif #if GST_GL_HAVE_PLATFORM_EAGL if (!context && (!user_choice || g_strstr_len (user_choice, 5, "eagl"))) context = GST_GL_CONTEXT (gst_gl_context_eagl_new ()); #endif if (!context) { /* subclass returned a NULL context */ GST_WARNING ("Could not create context. user specified %s", user_choice ? user_choice : "(null)"); return NULL; } context->priv->display = gst_object_ref (display); GST_DEBUG_OBJECT (context, "Done creating context for display %" GST_PTR_FORMAT " (user_choice:%s)", display, user_choice); return context; }
SPDConnection* spd_open(const char* client_name, const char* connection_name, const char* user_name, SPDConnectionMode mode) { char *error; int autospawn = 1; SPDConnection *conn; conn = spd_open2(client_name, connection_name, user_name, mode, NULL, autospawn, &error); if (!conn){ _init_debug(); assert(error); SPD_DBG("Could not connect to Speech Dispatcher: %s", error); xfree(error); } return conn; }
GstGLSLVersion gst_gl_version_to_glsl_version (GstGLAPI gl_api, gint maj, gint min) { g_return_val_if_fail (gl_api != GST_GL_API_NONE, 0); _init_debug (); if (gl_api & GST_GL_API_GLES2) { if (maj == 2 && min == 0) return 100; if (maj == 3 && min >= 0 && min <= 2) return maj * 100 + min * 10; GST_WARNING ("unknown GLES version"); return 0; } /* versions match for >= 3.3 */ if (gl_api & (GST_GL_API_OPENGL3 | GST_GL_API_OPENGL)) { if (maj > 3 || (maj == 3 && min >= 3)) return maj * 100 + min * 10; if (maj == 3 && min == 2) return 150; if (maj == 3 && min == 1) return 140; if (maj == 3 && min == 0) return 130; if (maj == 2 && min == 1) return 120; if (maj == 2 && min == 0) return 110; GST_WARNING ("unknown GL version"); return 0; } GST_WARNING ("unknown GL API"); return 0; }
GstVulkanTrash * gst_vulkan_trash_new (GstVulkanFence * fence, GstVulkanTrashNotify notify, gpointer user_data) { GstVulkanTrash *ret = NULL; g_return_val_if_fail (fence != NULL, NULL); g_return_val_if_fail (GST_IS_VULKAN_DEVICE (fence->device), NULL); g_return_val_if_fail (notify != NULL, NULL); _init_debug (); ret = g_new0 (GstVulkanTrash, 1); GST_TRACE ("Creating new trash object %p with fence %" GST_PTR_FORMAT " on device %" GST_PTR_FORMAT, ret, fence, fence->device); ret->fence = fence; ret->notify = notify; ret->user_data = user_data; return ret; }
gboolean gst_glsl_version_profile_from_string (const gchar * string, GstGLSLVersion * version_ret, GstGLSLProfile * profile_ret) { gchar *str, *version_s, *profile_s; GstGLSLVersion version = GST_GLSL_VERSION_NONE; GstGLSLProfile profile = GST_GLSL_PROFILE_NONE; gint i; _init_debug (); if (!string) goto error; str = g_strdup (string); version_s = g_strstrip (str); /* skip possible #version prefix */ if (str[0] == '#') { if (!(version_s = (gchar *) _check_valid_version_preprocessor_string (version_s))) { GST_WARNING ("Invalid preprocesser directive detected: %s", version_s); g_free (str); goto error; } } version_s = g_strstrip (version_s); i = 0; while (version_s && version_s[i] != '\0' && g_ascii_isdigit (version_s[i])) i++; /* wrong version length */ if (i != 3) { GST_WARNING ("version number has the wrong number of digits: %s", version_s); g_free (str); goto error; } if (version_s[i] != 0) { version_s[i] = '\0'; i++; profile_s = &version_s[i]; profile_s = g_strstrip (profile_s); profile = gst_glsl_profile_from_string (profile_s); } version = gst_glsl_version_from_string (version_s); g_free (str); /* check whether the parsed data is valid */ if (!version) { GST_WARNING ("Could not map the version number to a valid GLSL version:"); goto error; } if (!_is_valid_version_profile (version, profile)) { GST_WARNING ("Invalid version/profile combination specified: %s %s", gst_glsl_version_to_string (version), gst_glsl_profile_to_string (profile)); goto error; } /* got a profile when none was expected */ if (version <= GST_GLSL_VERSION_140 && profile != GST_GLSL_PROFILE_NONE) { GST_WARNING ("Found a profile (%s) with a version (%s) that does not support " "profiles", gst_glsl_version_to_string (version), gst_glsl_profile_to_string (profile)); goto error; } _fixup_version_profile (&version, &profile); if (profile_ret) *profile_ret = profile; if (version_ret) *version_ret = version; return TRUE; error: { if (profile_ret) *profile_ret = GST_GLSL_PROFILE_NONE; if (version_ret) *version_ret = GST_GLSL_VERSION_NONE; return FALSE; } }
/* returns the pointer in @str to the #version declaration */ const gchar * _gst_glsl_shader_string_find_version (const gchar * str) { gboolean sl_comment = FALSE; gboolean ml_comment = FALSE; gboolean newline = TRUE; gint i = 0; _init_debug (); /* search for #version while allowing for preceeding comments/whitespace as * permitted by the GLSL specification */ while (str && str[i] != '\0' && i < 1024) { if (str[i] == '\n' || str[i] == '\r') { newline = TRUE; sl_comment = FALSE; i++; continue; } if (g_ascii_isspace (str[i])) goto next; if (sl_comment) goto next; if (ml_comment) { if (g_strstr_len (&str[i], 2, "*/")) { ml_comment = FALSE; i++; } goto next; } if (g_strstr_len (&str[i], 2, "//")) { sl_comment = TRUE; i++; goto next; } if (g_strstr_len (&str[i], 2, "/*")) { ml_comment = TRUE; i++; goto next; } if (str[i] == '#') { if (newline && _check_valid_version_preprocessor_string (&str[i])) { GST_DEBUG ("found #version declaration at index %i", i); return &str[i]; } break; } next: newline = FALSE; i++; } GST_DEBUG ("no #version declaration found in the first 1K"); return NULL; }
/** * gst_gl_context_new_wrapped: * @display: a #GstGLDisplay * @handle: the OpenGL context to wrap * @context_type: a #GstGLPlatform specifying the type of context in @handle * @available_apis: a #GstGLAPI containing the available OpenGL apis in @handle * * Wraps an existing OpenGL context into a #GstGLContext. * * Returns: a #GstGLContext wrapping @handle * * Since: 1.4 */ GstGLContext * gst_gl_context_new_wrapped (GstGLDisplay * display, guintptr handle, GstGLPlatform context_type, GstGLAPI available_apis) { GstGLContext *context; GstGLWrappedContext *context_wrap = NULL; GstGLContextClass *context_class; GstGLAPI display_api; _init_debug (); display_api = gst_gl_display_get_gl_api (display); g_return_val_if_fail ((display_api & available_apis) != GST_GL_API_NONE, NULL); context_wrap = g_object_new (GST_GL_TYPE_WRAPPED_CONTEXT, NULL); if (!context_wrap) { /* subclass returned a NULL context */ GST_ERROR ("Could not wrap existing context"); return NULL; } context = (GstGLContext *) context_wrap; context->display = gst_object_ref (display); context->priv->sharegroup_id = _new_sharegroup_id (); context_wrap->handle = handle; context_wrap->platform = context_type; context_wrap->available_apis = available_apis; context_class = GST_GL_CONTEXT_GET_CLASS (context); #if GST_GL_HAVE_PLATFORM_GLX if (context_type == GST_GL_PLATFORM_GLX) { context_class->get_current_context = gst_gl_context_glx_get_current_context; context_class->get_proc_address = gst_gl_context_glx_get_proc_address; } #endif #if GST_GL_HAVE_PLATFORM_EGL if (context_type == GST_GL_PLATFORM_EGL) { context_class->get_current_context = gst_gl_context_egl_get_current_context; context_class->get_proc_address = gst_gl_context_egl_get_proc_address; } #endif #if GST_GL_HAVE_PLATFORM_CGL if (context_type == GST_GL_PLATFORM_CGL) { context_class->get_current_context = gst_gl_context_cocoa_get_current_context; context_class->get_proc_address = gst_gl_context_default_get_proc_address; } #endif #if GST_GL_HAVE_PLATFORM_WGL if (context_type == GST_GL_PLATFORM_WGL) { context_class->get_current_context = gst_gl_context_wgl_get_current_context; context_class->get_proc_address = gst_gl_context_wgl_get_proc_address; } #endif #if GST_GL_HAVE_PLATFORM_EAGL if (context_type == GST_GL_PLATFORM_EAGL) { context_class->get_current_context = gst_gl_context_eagl_get_current_context; context_class->get_proc_address = gst_gl_context_default_get_proc_address; } #endif if (!context_class->get_current_context) { /* we don't have API support */ gst_object_unref (context); return NULL; } return context; }
SPDConnection* spd_open2(const char* client_name, const char* connection_name, const char* user_name, SPDConnectionMode mode, SPDConnectionAddress *address, int autospawn, char **error_result) { SPDConnection *connection; char *set_client_name; char* conn_name; char* usr_name; int ret; char tcp_no_delay = 1; /* Autospawn related */ int spawn_err; gchar *spawn_report; char *host_ip; int is_localhost = 1; struct sockaddr_in address_inet; struct sockaddr_un address_unix; struct sockaddr *sock_address; size_t sock_address_len; gchar *resolve_error; _init_debug(); if (client_name == NULL){ *error_result = strdup("ERROR: Client name not specified"); SPD_DBG(*error_result); return NULL; } if (user_name == NULL) { usr_name = strdup((char*) g_get_user_name()); } else usr_name = strdup(user_name); if(connection_name == NULL) conn_name = strdup("main"); else conn_name = strdup(connection_name); if (address == NULL){ char *err = NULL; address = spd_get_default_address(&err); if (!address){ assert(err); *error_result = err; SPD_DBG(*error_result); return NULL; } } /* Connect to server using the selected method */ connection = xmalloc(sizeof(SPDConnection)); if (address->method==SPD_METHOD_INET_SOCKET){ host_ip = resolve_host(address->inet_socket_host, &is_localhost, &resolve_error); if (host_ip == NULL){ *error_result = strdup(resolve_error); g_free(resolve_error); return NULL; } address_inet.sin_addr.s_addr = inet_addr(host_ip); address_inet.sin_port = htons(address->inet_socket_port); address_inet.sin_family = AF_INET; connection->socket = socket(AF_INET, SOCK_STREAM, 0); sock_address = (struct sockaddr*) &address_inet; sock_address_len = sizeof(address_inet); }else if (address->method==SPD_METHOD_UNIX_SOCKET){ /* Create the unix socket */ address_unix.sun_family = AF_UNIX; strncpy (address_unix.sun_path, address->unix_socket_name, sizeof (address_unix.sun_path)); address_unix.sun_path[sizeof (address_unix.sun_path) - 1] = '\0'; connection->socket = socket(AF_UNIX, SOCK_STREAM, 0); sock_address = (struct sockaddr*) &address_unix; sock_address_len = SUN_LEN(&address_unix); }else SPD_FATAL("Unsupported connection method for spd_open2()"); ret = connect(connection->socket, sock_address, sock_address_len); if (ret == -1){ /* Suppose server might not be running, try to autospawn (autostart) it */ if (autospawn){ spawn_err = spawn_server(address, is_localhost, &spawn_report); if (!spawn_err) spawn_report = g_strdup("Server successfully autospawned"); ret = connect(connection->socket, sock_address, sock_address_len); }else{ spawn_report = g_strdup("Autospawn disabled"); } if (ret == -1){ if (address->method == SPD_METHOD_INET_SOCKET) *error_result = g_strdup_printf("Error: Can't connect to %s on port %d using inet sockets: %s. " \ "Autospawn: %s", address->inet_socket_host, address->inet_socket_port, strerror(errno), spawn_report); else if (address->method == SPD_METHOD_UNIX_SOCKET) *error_result = g_strdup_printf("Error: Can't connect to unix socket %s: %s. Autospawn: %s", address->unix_socket_name, strerror(errno), spawn_report); else assert (0); SPD_DBG(*error_result); close(connection->socket); return NULL; } } if (address->method == SPD_METHOD_INET_SOCKET) setsockopt(connection->socket, IPPROTO_TCP, TCP_NODELAY, &tcp_no_delay, sizeof(int)); connection->callback_begin = NULL; connection->callback_end = NULL; connection->callback_im = NULL; connection->callback_pause = NULL; connection->callback_resume = NULL; connection->callback_cancel = NULL; connection->mode = mode; /* Create a stream from the socket */ connection->stream = fdopen(connection->socket, "r"); if (!connection->stream) SPD_FATAL("Can't create a stream for socket, fdopen() failed."); /* Switch to line buffering mode */ ret = setvbuf(connection->stream, NULL, _IONBF, SPD_REPLY_BUF_SIZE); if (ret) SPD_FATAL("Can't set buffering, setvbuf failed."); connection->ssip_mutex = xmalloc(sizeof(pthread_mutex_t)); pthread_mutex_init(connection->ssip_mutex, NULL); if (mode == SPD_MODE_THREADED){ SPD_DBG("Initializing threads, condition variables and mutexes..."); connection->events_thread = xmalloc(sizeof(pthread_t)); connection->cond_reply_ready = xmalloc(sizeof(pthread_cond_t)); connection->mutex_reply_ready = xmalloc(sizeof(pthread_mutex_t)); connection->cond_reply_ack = xmalloc(sizeof(pthread_cond_t)); connection->mutex_reply_ack = xmalloc(sizeof(pthread_mutex_t)); pthread_cond_init(connection->cond_reply_ready, NULL); pthread_mutex_init(connection->mutex_reply_ready, NULL); pthread_cond_init(connection->cond_reply_ack, NULL); pthread_mutex_init(connection->mutex_reply_ack, NULL); ret = pthread_create(connection->events_thread, NULL, spd_events_handler, connection); if(ret != 0){ *error_result = strdup("Thread initialization failed"); SPD_DBG(*error_result); return NULL; } } /* By now, the connection is created and operational */ set_client_name = g_strdup_printf("SET SELF CLIENT_NAME \"%s:%s:%s\"", usr_name, client_name, conn_name); ret = spd_execute_command_wo_mutex(connection, set_client_name); xfree(usr_name); xfree(conn_name); xfree(set_client_name); return connection; }
/** * gst_gl_context_get_current_gl_api: * @platform: the #GstGLPlatform to retrieve the API for * @major: (out): (allow-none): the major version * @minor: (out): (allow-none): the minor version * * If an error occurs, @major and @minor aren't modified and %GST_GL_API_NONE is * returned. * * Returns: The version supported by the OpenGL context current in the calling * thread or %GST_GL_API_NONE * * Since: 1.6 */ GstGLAPI gst_gl_context_get_current_gl_api (GstGLPlatform platform, guint * major, guint * minor) { const GLubyte *(*GetString) (GLenum name); #if GST_GL_HAVE_OPENGL void (*GetIntegerv) (GLenum name, GLuint * n); #endif const gchar *version; gint maj, min, n; GstGLAPI ret = (1 << 31); _init_debug (); while (ret != GST_GL_API_NONE) { /* FIXME: attempt to delve into the platform specific GetProcAddress */ GetString = gst_gl_context_get_proc_address_with_platform (platform, ret, "glGetString"); #if GST_GL_HAVE_OPENGL GetIntegerv = gst_gl_context_get_proc_address_with_platform (platform, ret, "glGetIntegerv"); #endif if (!GetString) { goto next; } version = (const gchar *) GetString (GL_VERSION); if (!version) goto next; /* strlen (x.x) == 3 */ n = strlen (version); if (n < 3) goto next; if (g_strstr_len (version, 9, "OpenGL ES")) { /* strlen (OpenGL ES x.x) == 13 */ if (n < 13) goto next; sscanf (&version[10], "%d.%d", &maj, &min); if (maj <= 0 || min < 0) goto next; if (maj == 1) { ret = GST_GL_API_GLES1; break; } else if (maj == 2 || maj == 3) { ret = GST_GL_API_GLES2; break; } goto next; } else { sscanf (version, "%d.%d", &maj, &min); if (maj <= 0 || min < 0) goto next; #if GST_GL_HAVE_OPENGL if (GetIntegerv && (maj > 3 || (maj == 3 && min > 1))) { GLuint context_flags = 0; ret = GST_GL_API_NONE; GetIntegerv (GL_CONTEXT_PROFILE_MASK, &context_flags); if (context_flags & GL_CONTEXT_CORE_PROFILE_BIT) ret |= GST_GL_API_OPENGL3; if (context_flags & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) ret |= GST_GL_API_OPENGL; break; } #endif ret = GST_GL_API_OPENGL; break; } next: /* iterate through the apis */ ret >>= 1; } if (ret == GST_GL_API_NONE) return GST_GL_API_NONE; if (major) *major = maj; if (minor) *minor = min; return ret; }