static void rtmp_common_update(void *data, obs_data_t settings)
{
struct rtmp_common *service = data;
bfree(service->service);
bfree(service->server);
bfree(service->key);
service->service = bstrdup(obs_data_getstring(settings, "service"));
service->server = bstrdup(obs_data_getstring(settings, "server"));
service->key = bstrdup(obs_data_getstring(settings, "key"));
}
/*
* 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;
}
static void image_source_update(void *data, obs_data_t settings)
{
struct image_source *context = data;
const char *file = obs_data_getstring(settings, "file");
gs_entercontext(obs_graphics());
if (context->tex) {
texture_destroy(context->tex);
context->tex = NULL;
}
if (file) {
context->tex = gs_create_texture_from_file(file);
if (context->tex) {
context->cx = texture_getwidth(context->tex);
context->cy = texture_getheight(context->tex);
} else {
warn("failed to load texture '%s'", file);
context->cx = 0;
context->cy = 0;
}
}
gs_leavecontext();
}
obs_source_t obs_load_source(obs_data_t source_data)
{
obs_source_t source;
const char *name = obs_data_getstring(source_data, "name");
const char *id = obs_data_getstring(source_data, "id");
obs_data_t settings = obs_data_getobj(source_data, "settings");
double volume;
source = obs_source_create(OBS_SOURCE_TYPE_INPUT, id, name, settings);
obs_data_set_default_double(source_data, "volume", 1.0);
volume = obs_data_getdouble(source_data, "volume");
obs_source_setvolume(source, (float)volume);
obs_data_release(settings);
return source;
}
/*
* Create the plugin object
*/
static void *pulse_create(obs_data_t settings, obs_source_t source)
{
struct pulse_data *data = bzalloc(sizeof(struct pulse_data));
data->source = source;
data->speakers = SPEAKERS_STEREO;
data->device = bstrdup(obs_data_getstring(settings, "device_id"));
pulse_init();
if (pulse_start_recording(data) < 0)
goto fail;
return data;
fail:
pulse_destroy(data);
return NULL;
}
/**
* Update the input settings
*/
static void pulse_update(void *vptr, obs_data_t settings)
{
PULSE_DATA(vptr);
bool restart = false;
const char *new_device;
new_device = obs_data_getstring(settings, "device_id");
if (!data->device || strcmp(data->device, new_device) != 0) {
if (data->device)
bfree(data->device);
data->device = bstrdup(new_device);
restart = true;
}
if (!restart)
return;
if (data->stream)
pulse_stop_recording(data);
pulse_start_recording(data);
}
void XCompcapMain::updateSettings(obs_data_t settings)
{
PLock lock(&p->lock);
XErrorLock xlock;
ObsGsContextHolder obsctx;
blog(LOG_DEBUG, "Settings updating");
Window prevWin = p->win;
xcc_cleanup(p);
if (settings) {
const char *windowName = obs_data_getstring(settings,
"capture_window");
p->win = getWindowFromString(windowName);
p->cut_top = obs_data_getint(settings, "cut_top");
p->cut_left = obs_data_getint(settings, "cut_left");
p->cut_right = obs_data_getint(settings, "cut_right");
p->cut_bot = obs_data_getint(settings, "cut_bot");
p->lockX = obs_data_getbool(settings, "lock_x");
p->swapRedBlue = obs_data_getbool(settings, "swap_redblue");
} else {
p->win = prevWin;
}
xlock.resetError();
XCompositeRedirectWindow(xdisp, p->win, CompositeRedirectAutomatic);
if (xlock.gotError()) {
blog(LOG_ERROR, "XCompositeRedirectWindow failed: %s",
xlock.getErrorText().c_str());
return;
}
XSelectInput(xdisp, p->win, StructureNotifyMask);
XSync(xdisp, 0);
XWindowAttributes attr;
if (!XGetWindowAttributes(xdisp, p->win, &attr)) {
p->win = 0;
p->width = 0;
p->height = 0;
return;
}
gs_color_format cf = GS_RGBA;
p->width = attr.width;
p->height = attr.height;
if (p->cut_top + p->cut_bot < (int)p->height) {
p->cur_cut_top = p->cut_top;
p->cur_cut_bot = p->cut_bot;
} else {
p->cur_cut_top = 0;
p->cur_cut_bot = 0;
}
if (p->cut_left + p->cut_right < (int)p->width) {
p->cur_cut_left = p->cut_left;
p->cur_cut_right = p->cut_right;
} else {
p->cur_cut_left = 0;
p->cur_cut_right = 0;
}
if (p->tex)
texture_destroy(p->tex);
uint8_t *texData = new uint8_t[width() * height() * 4];
for (unsigned int i = 0; i < width() * height() * 4; i += 4) {
texData[i + 0] = p->swapRedBlue ? 0 : 0xFF;
texData[i + 1] = 0;
texData[i + 2] = p->swapRedBlue ? 0xFF : 0;
texData[i + 3] = 0xFF;
}
const uint8_t* texDataArr[] = { texData, 0 };
p->tex = gs_create_texture(width(), height(), cf, 1,
texDataArr, 0);
delete[] texData;
if (p->swapRedBlue) {
GLuint tex = *(GLuint*)texture_getobj(p->tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
glBindTexture(GL_TEXTURE_2D, 0);
}
const int attrs[] =
{
GLX_BIND_TO_TEXTURE_RGBA_EXT, GL_TRUE,
GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
GLX_DOUBLEBUFFER, GL_FALSE,
None
};
int nelem = 0;
GLXFBConfig* configs = glXChooseFBConfig(xdisp,
XCompcap::getRootWindowScreen(attr.root),
attrs, &nelem);
if (nelem <= 0) {
blog(LOG_ERROR, "no matching fb config found");
p->win = 0;
p->height = 0;
p->width = 0;
return;
}
glXGetFBConfigAttrib(xdisp, configs[0], GLX_Y_INVERTED_EXT, &nelem);
p->inverted = nelem != 0;
xlock.resetError();
p->pixmap = XCompositeNameWindowPixmap(xdisp, p->win);
if (xlock.gotError()) {
blog(LOG_ERROR, "XCompositeNameWindowPixmap failed: %s",
xlock.getErrorText().c_str());
p->pixmap = 0;
XFree(configs);
return;
}
const int attribs[] =
{
GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGBA_EXT,
None
};
p->glxpixmap = glXCreatePixmap(xdisp, configs[0], p->pixmap, attribs);
if (xlock.gotError()) {
blog(LOG_ERROR, "glXCreatePixmap failed: %s",
xlock.getErrorText().c_str());
XFreePixmap(xdisp, p->pixmap);
XFree(configs);
p->pixmap = 0;
p->glxpixmap = 0;
return;
}
XFree(configs);
p->gltex = gs_create_texture(p->width, p->height, cf, 1, 0,
GS_GL_DUMMYTEX);
GLuint gltex = *(GLuint*)texture_getobj(p->gltex);
glBindTexture(GL_TEXTURE_2D, gltex);
glXBindTexImageEXT(xdisp, p->glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
