diff --git a/obs/obs-app.cpp b/obs/obs-app.cpp index 8e6e40f19..ae1b6e48f 100644 --- a/obs/obs-app.cpp +++ b/obs/obs-app.cpp @@ -188,8 +188,8 @@ void OBSApp::OBSInit() #define INPUT_AUDIO_SOURCE "wasapi_input_capture" #define OUTPUT_AUDIO_SOURCE "wasapi_output_capture" #else -#define INPUT_AUDIO_SOURCE "" -#define OUTPUT_AUDIO_SOURCE "" +#define INPUT_AUDIO_SOURCE "pulse_input_capture" +#define OUTPUT_AUDIO_SOURCE "pulse_output_capture" #endif const char *OBSApp::InputAudioSource() const diff --git a/obs/window-basic-main.cpp b/obs/window-basic-main.cpp index 787e25d86..5241d8f51 100644 --- a/obs/window-basic-main.cpp +++ b/obs/window-basic-main.cpp @@ -172,6 +172,9 @@ void OBSBasic::OBSInit() #elif _WIN32 obs_load_module("win-wasapi"); obs_load_module("win-capture"); +#else + obs_load_module("linux-xshm"); + obs_load_module("linux-pulseaudio"); #endif ResetAudioDevices(); diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt index 101b5953a..241e4ebfa 100644 --- a/plugins/CMakeLists.txt +++ b/plugins/CMakeLists.txt @@ -6,6 +6,9 @@ if(WIN32) add_subdirectory(win-capture) elseif(APPLE) add_subdirectory(mac-capture) +elseif("${CMAKE_SYSTEM_NAME}" MATCHES "Linux") + add_subdirectory(linux-xshm) + add_subdirectory(linux-pulseaudio) endif() add_subdirectory(obs-ffmpeg) diff --git a/plugins/linux-pulseaudio/CMakeLists.txt b/plugins/linux-pulseaudio/CMakeLists.txt new file mode 100644 index 000000000..d5258a94e --- /dev/null +++ b/plugins/linux-pulseaudio/CMakeLists.txt @@ -0,0 +1,18 @@ +find_package(PulseAudio REQUIRED) + +include_directories(SYSTEM "${CMAKE_SOURCE_DIR}/libobs") + +set(linux-pulseaudio_SOURCES + linux-pulseaudio.c + pulse-input.c +) + +add_library(linux-pulseaudio MODULE + ${linux-pulseaudio_SOURCES} +) +target_link_libraries(linux-pulseaudio + libobs + ${PULSEAUDIO_LIBRARY} +) + +install_obs_plugin(linux-pulseaudio) diff --git a/plugins/linux-pulseaudio/linux-pulseaudio.c b/plugins/linux-pulseaudio/linux-pulseaudio.c new file mode 100644 index 000000000..1993dddce --- /dev/null +++ b/plugins/linux-pulseaudio/linux-pulseaudio.c @@ -0,0 +1,30 @@ +/* +Copyright (C) 2014 by Leonhard Oelke + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ +#include + +OBS_DECLARE_MODULE() + +extern struct obs_source_info pulse_input_capture; +extern struct obs_source_info pulse_output_capture; + +bool obs_module_load(uint32_t obs_version) +{ + UNUSED_PARAMETER(obs_version); + obs_register_source(&pulse_input_capture); + obs_register_source(&pulse_output_capture); + return true; +} diff --git a/plugins/linux-pulseaudio/pulse-input.c b/plugins/linux-pulseaudio/pulse-input.c new file mode 100644 index 000000000..4dca35da7 --- /dev/null +++ b/plugins/linux-pulseaudio/pulse-input.c @@ -0,0 +1,682 @@ +/* +Copyright (C) 2014 by Leonhard Oelke + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include + +#define PULSE_DATA(voidptr) struct pulse_data *data = voidptr; + +/* + * delay in usecs before starting to record, this eliminates problems with + * pulse audio sending weird data/timestamps when the stream is connected + * + * for more information see: + * github.com/MaartenBaert/ssr/blob/master/src/AV/Input/PulseAudioInput.cpp + */ +const uint64_t pulse_start_delay = 100000; + +struct pulse_data { + pthread_t thread; + os_event_t event; + obs_source_t source; + + enum speaker_layout speakers; + pa_sample_format_t format; + uint_fast32_t samples_per_sec; + uint_fast8_t channels; + + uint_fast32_t bytes_per_frame; + + pa_mainloop *mainloop; + pa_context *context; + pa_stream *stream; + pa_proplist *props; +}; + +struct pulse_context_change { + pa_threaded_mainloop *mainloop; + pa_context_state_t state; +}; + +struct pulse_enumerate { + pa_threaded_mainloop *mainloop; + obs_property_t devices; + bool input; +}; + +/* + * get obs from pulse audio format + */ +static enum audio_format pulse_to_obs_audio_format( + pa_sample_format_t format) +{ + switch (format) { + case PA_SAMPLE_U8: + return AUDIO_FORMAT_U8BIT; + case PA_SAMPLE_S16LE: + return AUDIO_FORMAT_16BIT; + case PA_SAMPLE_S24_32LE: + return AUDIO_FORMAT_32BIT; + case PA_SAMPLE_FLOAT32LE: + return AUDIO_FORMAT_FLOAT; + default: + return AUDIO_FORMAT_UNKNOWN; + } + + return AUDIO_FORMAT_UNKNOWN; +} + +/* + * get the number of frames from bytes and current format + */ +static uint_fast32_t frames_to_bytes(struct pulse_data *data, size_t bytes) +{ + return (bytes / data->bytes_per_frame); +} + +/* + * get the buffer size needed for length msec with current settings + */ +static uint_fast32_t get_buffer_size(struct pulse_data *data, + uint_fast32_t length) +{ + return (length * data->samples_per_sec * data->bytes_per_frame) / 1000; +} + +/* + * Get latency for a pulse audio stream + */ +static int pulse_get_stream_latency(pa_stream *stream, int64_t *latency) +{ + int ret; + int sign; + pa_usec_t abs; + + ret = pa_stream_get_latency(stream, &abs, &sign); + *latency = (sign) ? -(int64_t) abs : (int64_t) abs; + return ret; +} + +/* + * Iterate the mainloop + * + * The custom implementation gives better performance than the function + * provided by pulse audio, maybe due to the timeout set in prepare ? + */ +static void pulse_iterate(struct pulse_data *data) +{ + if (pa_mainloop_prepare(data->mainloop, 1000) < 0) { + blog(LOG_ERROR, "Unable to prepare main loop"); + return; + } + if (pa_mainloop_poll(data->mainloop) < 0) { + blog(LOG_ERROR, "Unable to poll main loop"); + return; + } + if (pa_mainloop_dispatch(data->mainloop) < 0) + blog(LOG_ERROR, "Unable to dispatch main loop"); +} + +/* + * Server info callback, this is called from pa_mainloop_dispatch + * TODO: how to free the server info struct ? + */ +static void pulse_get_server_info_cb(pa_context *c, const pa_server_info *i, + void *userdata) +{ + UNUSED_PARAMETER(c); + PULSE_DATA(userdata); + + const pa_sample_spec *spec = &i->sample_spec; + data->format = spec->format; + data->samples_per_sec = spec->rate; + + blog(LOG_DEBUG, "pulse-input: Default format: %s, %u Hz, %u channels", + pa_sample_format_to_string(spec->format), + spec->rate, + spec->channels); +} + +/* + * Request pulse audio server info + * TODO: handle failures ? + */ +static int pulse_get_server_info(struct pulse_data *data) +{ + pa_server_info_cb_t cb = pulse_get_server_info_cb; + pa_operation *op = pa_context_get_server_info(data->context, cb, data); + + for(;;) { + pulse_iterate(data); + pa_operation_state_t state = pa_operation_get_state(op); + if (state == PA_OPERATION_DONE) { + pa_operation_unref(op); + break; + } + } + + return 0; +} + +/* + * Create a new pulse audio main loop and connect to the server + * + * Returns a negative value on error + */ +static int pulse_connect(struct pulse_data *data) +{ + data->mainloop = pa_mainloop_new(); + if (!data->mainloop) { + blog(LOG_ERROR, "pulse-input: Unable to create main loop"); + return -1; + } + + data->context = pa_context_new_with_proplist( + pa_mainloop_get_api(data->mainloop), "OBS Studio", data->props); + if (!data->context) { + blog(LOG_ERROR, "pulse-input: Unable to create context"); + return -1; + } + + int status = pa_context_connect( + data->context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL); + if (status < 0) { + blog(LOG_ERROR, "pulse-input: Unable to connect! Status: %d", + status); + return -1; + } + + // wait until connected + for (;;) { + pulse_iterate(data); + pa_context_state_t state = pa_context_get_state(data->context); + if (state == PA_CONTEXT_READY) { + blog(LOG_DEBUG, "pulse-input: Context ready"); + break; + } + if (!PA_CONTEXT_IS_GOOD(state)) { + blog(LOG_ERROR, "pulse-input: Context connect failed"); + return -1; + } + } + + return 0; +} + +/* + * Disconnect from the pulse audio server and destroy the main loop + */ +static void pulse_disconnect(struct pulse_data *data) +{ + if (data->context) { + pa_context_disconnect(data->context); + pa_context_unref(data->context); + } + + if (data->mainloop) + pa_mainloop_free(data->mainloop); +} + +/* + * Create a new pulse audio stream and connect to it + * + * Return a negative value on error + */ +static int pulse_connect_stream(struct pulse_data *data) +{ + pa_sample_spec spec; + spec.format = data->format; + spec.rate = data->samples_per_sec; + spec.channels = get_audio_channels(data->speakers); + + if (!pa_sample_spec_valid(&spec)) { + blog(LOG_ERROR, "pulse-input: Sample spec is not valid"); + return -1; + } + + data->bytes_per_frame = pa_frame_size(&spec); + blog(LOG_DEBUG, "pulse-input: %u bytes per frame", + (unsigned int) data->bytes_per_frame); + + pa_buffer_attr attr; + attr.fragsize = get_buffer_size(data, 250); + attr.maxlength = (uint32_t) -1; + attr.minreq = (uint32_t) -1; + attr.prebuf = (uint32_t) -1; + attr.tlength = (uint32_t) -1; + + data->stream = pa_stream_new_with_proplist(data->context, + obs_source_getname(data->source), &spec, NULL, data->props); + if (!data->stream) { + blog(LOG_ERROR, "pulse-input: Unable to create stream"); + return -1; + } + pa_stream_flags_t flags = + PA_STREAM_INTERPOLATE_TIMING + | PA_STREAM_AUTO_TIMING_UPDATE + | PA_STREAM_ADJUST_LATENCY; + if (pa_stream_connect_record(data->stream, NULL, &attr, flags) < 0) { + blog(LOG_ERROR, "pulse-input: Unable to connect to stream"); + return -1; + } + + for (;;) { + pulse_iterate(data); + pa_stream_state_t state = pa_stream_get_state(data->stream); + if (state == PA_STREAM_READY) { + blog(LOG_DEBUG, "pulse-input: Stream ready"); + break; + } + if (!PA_STREAM_IS_GOOD(state)) { + blog(LOG_ERROR, "pulse-input: Stream connect failed"); + return -1; + } + } + + return 0; +} + +/* + * Disconnect from the pulse audio stream + */ +static void pulse_diconnect_stream(struct pulse_data *data) +{ + if (data->stream) { + pa_stream_disconnect(data->stream); + pa_stream_unref(data->stream); + } +} + +/* + * Loop to skip the first few samples of a stream + */ +static int pulse_skip(struct pulse_data *data) +{ + uint64_t skip = 1; + const void *frames; + size_t bytes; + uint64_t pa_time; + + while (os_event_try(data->event) == EAGAIN) { + pulse_iterate(data); + pa_stream_peek(data->stream, &frames, &bytes); + + if (!bytes) + continue; + if (!frames || pa_stream_get_time(data->stream, &pa_time) < 0) { + pa_stream_drop(data->stream); + continue; + } + + if (skip == 1 && pa_time) + skip = pa_time; + if (skip + pulse_start_delay < pa_time) + return 0; + + pa_stream_drop(data->stream); + } + + return -1; +} + +/* + * Worker thread to get audio data + * + * Will run until signaled + */ +static void *pulse_thread(void *vptr) +{ + PULSE_DATA(vptr); + + if (pulse_connect(data) < 0) + return NULL; + if (pulse_get_server_info(data) < 0) + return NULL; + if (pulse_connect_stream(data) < 0) + return NULL; + + if (pulse_skip(data) < 0) + return NULL; + + blog(LOG_DEBUG, "pulse-input: Start recording"); + + const void *frames; + size_t bytes; + uint64_t pa_time; + int64_t pa_latency; + + struct source_audio out; + out.speakers = data->speakers; + out.samples_per_sec = data->samples_per_sec; + out.format = pulse_to_obs_audio_format(data->format); + + while (os_event_try(data->event) == EAGAIN) { + pulse_iterate(data); + + pa_stream_peek(data->stream, &frames, &bytes); + + // check if we got data + if (!bytes) + continue; + if (!frames) { + blog(LOG_DEBUG, + "pulse-input: Got audio hole of %u bytes", + (unsigned int) bytes); + pa_stream_drop(data->stream); + continue; + } + + if (pa_stream_get_time(data->stream, &pa_time) < 0) { + blog(LOG_ERROR, + "pulse-input: Failed to get timing info !"); + pa_stream_drop(data->stream); + continue; + } + + pulse_get_stream_latency(data->stream, &pa_latency); + + out.data[0] = (uint8_t *) frames; + out.frames = frames_to_bytes(data, bytes); + out.timestamp = (pa_time - pa_latency) * 1000; + obs_source_output_audio(data->source, &out); + + pa_stream_drop(data->stream); + } + + pulse_diconnect_stream(data); + pulse_disconnect(data); + + return NULL; +} + +/* + * Create a new pulseaudio context + */ +static pa_context *pulse_context_create(pa_threaded_mainloop *m) +{ + pa_context *c; + pa_proplist *p; + + p = pa_proplist_new(); + pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, "OBS Studio"); + pa_proplist_sets(p, PA_PROP_APPLICATION_ICON_NAME, "application-exit"); + pa_proplist_sets(p, PA_PROP_MEDIA_ROLE, "production"); + + pa_threaded_mainloop_lock(m); + c = pa_context_new_with_proplist(pa_threaded_mainloop_get_api(m), + "OBS Studio", p); + pa_threaded_mainloop_unlock(m); + + pa_proplist_free(p); + + return c; +} + +/** + * Context state callback + */ +static void pulse_context_state_changed(pa_context *c, void *userdata) +{ + struct pulse_context_change *ctx = + (struct pulse_context_change *) userdata; + ctx->state = pa_context_get_state(c); + + pa_threaded_mainloop_signal(ctx->mainloop, 0); +} + +/* + * Connect context + */ +static int pulse_context_connect(pa_threaded_mainloop *m, pa_context *c) +{ + int status = 0; + struct pulse_context_change ctx; + ctx.mainloop = m; + ctx.state = PA_CONTEXT_UNCONNECTED; + + pa_threaded_mainloop_lock(m); + pa_context_set_state_callback(c, pulse_context_state_changed, + (void *) &ctx); + + status = pa_context_connect(c, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL); + if (status < 0) { + blog(LOG_ERROR, "pulse-input: Unable to connect! Status: %d", + status); + } + else { + for (;;) { + if (ctx.state == PA_CONTEXT_READY) { + blog(LOG_DEBUG, "pulse-input: Context Ready"); + break; + } + if (!PA_CONTEXT_IS_GOOD(ctx.state)) { + blog(LOG_ERROR, + "pulse-input: Context connect failed !"); + status = -1; + break; + } + pa_threaded_mainloop_wait(m); + } + } + + pa_threaded_mainloop_unlock(m); + return status; +} + +/* + * Source properties callback + */ +static void pulse_source_info(pa_context *c, const pa_source_info *i, int eol, + void *userdata) +{ + UNUSED_PARAMETER(c); + + if (eol != 0) + return; + + struct pulse_enumerate *e = (struct pulse_enumerate *) userdata; + + if ((e->input) ^ (i->monitor_of_sink == PA_INVALID_INDEX)) + return; + + blog(LOG_DEBUG, "pulse-input: Got source #%u '%s'", + i->index, i->description); + + obs_property_list_add_item(e->devices, i->description, i->name); + + pa_threaded_mainloop_signal(e->mainloop, 0); +} + +/* + * enumerate input/output devices + */ +static void pulse_enumerate_devices(obs_properties_t props, bool input) +{ + pa_context *c; + pa_operation *op; + pa_threaded_mainloop *m = pa_threaded_mainloop_new(); + struct pulse_enumerate e; + + e.mainloop = m; + e.devices = obs_properties_add_list(props, "device_id", "Device", + OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING); + e.input = input; + + pa_threaded_mainloop_start(m); + c = pulse_context_create(m); + + if (pulse_context_connect(m, c) < 0) + goto fail; + + pa_threaded_mainloop_lock(m); + + op = pa_context_get_source_info_list(c, pulse_source_info, (void *) &e); + while (pa_operation_get_state(op) == PA_OPERATION_RUNNING) + pa_threaded_mainloop_wait(m); + pa_operation_unref(op); + + pa_threaded_mainloop_unlock(m); + + pa_context_disconnect(c); +fail: + pa_context_unref(c); + pa_threaded_mainloop_stop(m); + pa_threaded_mainloop_free(m); +} + +/* + * get plugin properties + */ +static obs_properties_t pulse_properties(const char *locale, bool input) +{ + UNUSED_PARAMETER(locale); + + blog(LOG_DEBUG, "pulse-input: properties requested !"); + + obs_properties_t props = obs_properties_create(); + + pulse_enumerate_devices(props, input); + + return props; +} + +static obs_properties_t pulse_input_properties(const char *locale) +{ + return pulse_properties(locale, true); +} + +static obs_properties_t pulse_output_properties(const char *locale) +{ + return pulse_properties(locale, false); +} + +/* + * get plugin defaults + */ +static void pulse_defaults(obs_data_t settings) +{ + obs_data_set_default_string(settings, "device_id", "default"); +} + +/* + * Returns the name of the plugin + */ +static const char *pulse_input_getname(const char *locale) +{ + UNUSED_PARAMETER(locale); + return "Pulse Audio Input Capture"; +} + +static const char *pulse_output_getname(const char *locale) +{ + UNUSED_PARAMETER(locale); + return "Pulse Audio Output Capture"; +} + +/* + * Destroy the plugin object and free all memory + */ +static void pulse_destroy(void *vptr) +{ + PULSE_DATA(vptr); + + if (!data) + return; + + if (data->thread) { + void *ret; + os_event_signal(data->event); + pthread_join(data->thread, &ret); + } + + os_event_destroy(data->event); + + pa_proplist_free(data->props); + + blog(LOG_DEBUG, "pulse-input: Input destroyed"); + + bfree(data); +} + +/* + * Create the plugin object + */ +static void *pulse_create(obs_data_t settings, obs_source_t source) +{ + UNUSED_PARAMETER(settings); + + struct pulse_data *data = bmalloc(sizeof(struct pulse_data)); + memset(data, 0, sizeof(struct pulse_data)); + + data->source = source; + data->speakers = SPEAKERS_STEREO; + + blog(LOG_DEBUG, "pulse-input: obs wants '%s'", + obs_data_getstring(settings, "device_id")); + + /* TODO: use obs-studio icon */ + data->props = pa_proplist_new(); + pa_proplist_sets(data->props, PA_PROP_APPLICATION_NAME, + "OBS Studio"); + pa_proplist_sets(data->props, PA_PROP_APPLICATION_ICON_NAME, + "application-exit"); + pa_proplist_sets(data->props, PA_PROP_MEDIA_ROLE, + "production"); + + if (os_event_init(&data->event, OS_EVENT_TYPE_MANUAL) != 0) + goto fail; + if (pthread_create(&data->thread, NULL, pulse_thread, data) != 0) + goto fail; + + return data; + +fail: + pulse_destroy(data); + return NULL; +} + +struct obs_source_info pulse_input_capture = { + .id = "pulse_input_capture", + .type = OBS_SOURCE_TYPE_INPUT, + .output_flags = OBS_SOURCE_AUDIO, + .getname = pulse_input_getname, + .create = pulse_create, + .destroy = pulse_destroy, + .defaults = pulse_defaults, + .properties = pulse_input_properties +}; + +struct obs_source_info pulse_output_capture = { + .id = "pulse_output_capture", + .type = OBS_SOURCE_TYPE_INPUT, + .output_flags = OBS_SOURCE_AUDIO, + .getname = pulse_output_getname, + .create = pulse_create, + .destroy = pulse_destroy, + .defaults = pulse_defaults, + .properties = pulse_output_properties +}; diff --git a/plugins/linux-xshm/CMakeLists.txt b/plugins/linux-xshm/CMakeLists.txt new file mode 100644 index 000000000..347aed6af --- /dev/null +++ b/plugins/linux-xshm/CMakeLists.txt @@ -0,0 +1,25 @@ +find_package(X11 REQUIRED) + +include_directories(SYSTEM "${CMAKE_SOURCE_DIR}/libobs") + +set(linux-xshm_SOURCES + linux-xshm.c + xcursor.c + xshm-input.c +) +set(linux-xshm_HEADERS + xcursor.h +) + +add_library(linux-xshm MODULE + ${linux-xshm_SOURCES} + ${linux-xshm_HEADERS} +) +target_link_libraries(linux-xshm + libobs + ${X11_LIBRARIES} + ${X11_XShm_LIB} + ${X11_Xfixes_LIB} +) + +install_obs_plugin(linux-xshm) diff --git a/plugins/linux-xshm/linux-xshm.c b/plugins/linux-xshm/linux-xshm.c new file mode 100644 index 000000000..41aebec61 --- /dev/null +++ b/plugins/linux-xshm/linux-xshm.c @@ -0,0 +1,28 @@ +/* +Copyright (C) 2014 by Leonhard Oelke + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ +#include + +OBS_DECLARE_MODULE() + +extern struct obs_source_info xshm_input; + +bool obs_module_load(uint32_t obs_version) +{ + UNUSED_PARAMETER(obs_version); + obs_register_source(&xshm_input); + return true; +} diff --git a/plugins/linux-xshm/xcursor.c b/plugins/linux-xshm/xcursor.c new file mode 100644 index 000000000..cc7c7aa78 --- /dev/null +++ b/plugins/linux-xshm/xcursor.c @@ -0,0 +1,112 @@ +/* +Copyright (C) 2014 by Leonhard Oelke + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ + +#include +#include + +#include +#include "xcursor.h" + +/* + * Get pixel data for the cursor + * + * XFixes has the data defined as unsigned long, so we can not use memcpy. + * Theres a lot of talk about this in other implementation and they tend to + * be really complicated, but this naive approach seems to work fine ... + */ +static uint32_t *xcursor_pixels(XFixesCursorImage *xc) { + uint_fast32_t size = xc->width * xc->height; + uint32_t *pixels = bmalloc(size * sizeof(uint32_t)); + + for (uint_fast32_t i = 0; i < size; ++i) + pixels[i] = (uint32_t) xc->pixels[i]; + + return pixels; +} + +/* + * Create the cursor texture, either by updating if the new cursor has the same + * size or by creating a new texture if the size is different + */ +static void xcursor_create(xcursor_t *data, XFixesCursorImage *xc) { + uint32_t *pixels = xcursor_pixels(xc); + + if (data->tex + && data->last_height == xc->width + && data->last_width == xc->height) { + texture_setimage(data->tex, (void **) pixels, + xc->width * sizeof(uint32_t), False); + } else { + if (data->tex) + texture_destroy(data->tex); + + data->tex = gs_create_texture(xc->width, xc->height, + GS_RGBA, 1, (const void **) &pixels, GS_DYNAMIC); + } + + bfree(pixels); + + data->last_serial = xc->cursor_serial; + data->last_width = xc->width; + data->last_height = xc->height; +} + +xcursor_t *xcursor_init(Display *dpy) { + xcursor_t *data = bmalloc(sizeof(xcursor_t)); + memset(data, 0, sizeof(xcursor_t)); + + data->dpy = dpy; + xcursor_tick(data); + + return data; +} + +void xcursor_destroy(xcursor_t *data) { + if (data->tex) + texture_destroy(data->tex); + bfree(data); +} + +void xcursor_tick(xcursor_t *data) { + XFixesCursorImage *xc = XFixesGetCursorImage(data->dpy); + + if (!data->tex || data->last_serial != xc->cursor_serial) + xcursor_create(data, xc); + data->pos_x = -1.0 * (xc->x - xc->xhot); + data->pos_y = -1.0 * (xc->y - xc->yhot); + + XFree(xc); +} + +void xcursor_render(xcursor_t *data) { + /* TODO: why do i need effects ? */ + effect_t effect = gs_geteffect(); + eparam_t image = effect_getparambyname(effect, "image"); + + effect_settexture(effect, image, data->tex); + + gs_matrix_push(); + + gs_matrix_translate3f(data->pos_x, data->pos_y, 0); + + gs_enable_blending(True); + gs_blendfunction(GS_BLEND_ONE, GS_BLEND_INVSRCALPHA); + gs_draw_sprite(data->tex, 0, 0, 0); + gs_enable_blending(False); + + gs_matrix_pop(); +} diff --git a/plugins/linux-xshm/xcursor.h b/plugins/linux-xshm/xcursor.h new file mode 100644 index 000000000..69dfe4297 --- /dev/null +++ b/plugins/linux-xshm/xcursor.h @@ -0,0 +1,64 @@ +/* +Copyright (C) 2014 by Leonhard Oelke + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ + +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + Display *dpy; + float pos_x; + float pos_y; + unsigned long last_serial; + unsigned short int last_width; + unsigned short int last_height; + texture_t tex; +} xcursor_t; + +/** + * Initializes the xcursor object + * + * This needs to be executed within a valid render context + */ +xcursor_t *xcursor_init(Display *dpy); + +/** + * Destroys the xcursor object + */ +void xcursor_destroy(xcursor_t *data); + +/** + * Update the cursor texture + * + * This needs to be executed within a valid render context + */ +void xcursor_tick(xcursor_t *data); + +/** + * Draw the cursor + * + * This needs to be executed within a valid render context + */ +void xcursor_render(xcursor_t *data); + +#ifdef __cplusplus +} +#endif diff --git a/plugins/linux-xshm/xshm-input.c b/plugins/linux-xshm/xshm-input.c new file mode 100644 index 000000000..51914c406 --- /dev/null +++ b/plugins/linux-xshm/xshm-input.c @@ -0,0 +1,206 @@ +/* +Copyright (C) 2014 by Leonhard Oelke + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ +#include +#include + +#include +#include +#include +#include + +#include +#include "xcursor.h" + +#define XSHM_DATA(voidptr) struct xshm_data *data = voidptr; + +struct xshm_data { + Display *dpy; + Window root_window; + uint32_t width, height; + int shm_attached; + XShmSegmentInfo shm_info; + XImage *image; + texture_t texture; + xcursor_t *cursor; +}; + +static const char* xshm_getname(const char* locale) +{ + UNUSED_PARAMETER(locale); + return "X11 Shared Memory Screen Input"; +} + +static void xshm_destroy(void *vptr) +{ + XSHM_DATA(vptr); + + if (!data) + return; + + gs_entercontext(obs_graphics()); + + texture_destroy(data->texture); + xcursor_destroy(data->cursor); + + gs_leavecontext(); + + if (data->shm_attached) + XShmDetach(data->dpy, &data->shm_info); + + if (data->shm_info.shmaddr != (char *) -1) { + shmdt(data->shm_info.shmaddr); + data->shm_info.shmaddr = (char *) -1; + } + + if (data->shm_info.shmid != -1) + shmctl(data->shm_info.shmid, IPC_RMID, NULL); + + if (data->image) + XDestroyImage(data->image); + + if (data->dpy) + XCloseDisplay(data->dpy); + + bfree(data); +} + +static void *xshm_create(obs_data_t settings, obs_source_t source) +{ + UNUSED_PARAMETER(settings); + UNUSED_PARAMETER(source); + + + struct xshm_data *data = bmalloc(sizeof(struct xshm_data)); + memset(data, 0, sizeof(struct xshm_data)); + + data->dpy = XOpenDisplay(NULL); + if (!data->dpy) + goto fail; + + Screen *screen = XDefaultScreenOfDisplay(data->dpy); + data->width = WidthOfScreen(screen); + data->height = HeightOfScreen(screen); + data->root_window = XRootWindowOfScreen(screen); + Visual *visual = DefaultVisualOfScreen(screen); + int depth = DefaultDepthOfScreen(screen); + + if (!XShmQueryExtension(data->dpy)) + goto fail; + + data->image = XShmCreateImage(data->dpy, visual, depth, + ZPixmap, NULL, &data->shm_info, data->width, data->height); + if (!data->image) + goto fail; + + data->shm_info.shmid = shmget(IPC_PRIVATE, + data->image->bytes_per_line * data->image->height, + IPC_CREAT | 0700); + if (data->shm_info.shmid < 0) + goto fail; + + data->shm_info.shmaddr + = data->image->data + = (char *) shmat(data->shm_info.shmid, 0, 0); + if (data->shm_info.shmaddr == (char *) -1) + goto fail; + data->shm_info.readOnly = False; + + + if (!XShmAttach(data->dpy, &data->shm_info)) + goto fail; + data->shm_attached = 1; + + if (!XShmGetImage(data->dpy, data->root_window, data->image, + 0, 0, AllPlanes)) { + goto fail; + } + + + gs_entercontext(obs_graphics()); + data->texture = gs_create_texture(data->width, data->height, + GS_BGRA, 1, (const void**) &data->image->data, GS_DYNAMIC); + data->cursor = xcursor_init(data->dpy); + gs_leavecontext(); + + if (!data->texture) + goto fail; + + return data; + +fail: + xshm_destroy(data); + return NULL; +} + +static void xshm_video_tick(void *vptr, float seconds) +{ + UNUSED_PARAMETER(seconds); + XSHM_DATA(vptr); + + gs_entercontext(obs_graphics()); + + + XShmGetImage(data->dpy, data->root_window, data->image, + 0, 0, AllPlanes); + texture_setimage(data->texture, (void *) data->image->data, + data->width * 4, False); + + xcursor_tick(data->cursor); + + gs_leavecontext(); +} + +static void xshm_video_render(void *vptr, effect_t effect) +{ + XSHM_DATA(vptr); + + eparam_t image = effect_getparambyname(effect, "image"); + effect_settexture(effect, image, data->texture); + + gs_enable_blending(False); + + gs_draw_sprite(data->texture, 0, 0, 0); + + xcursor_render(data->cursor); +} + +static uint32_t xshm_getwidth(void *vptr) +{ + XSHM_DATA(vptr); + + return texture_getwidth(data->texture); +} + +static uint32_t xshm_getheight(void *vptr) +{ + XSHM_DATA(vptr); + + return texture_getheight(data->texture); +} + +struct obs_source_info xshm_input = { + .id = "xshm_input", + .type = OBS_SOURCE_TYPE_INPUT, + .output_flags = OBS_SOURCE_VIDEO, + .getname = xshm_getname, + .create = xshm_create, + .destroy = xshm_destroy, + .video_tick = xshm_video_tick, + .video_render = xshm_video_render, + .getwidth = xshm_getwidth, + .getheight = xshm_getheight +};