obs-studio/libobs/obs-scene.c

3957 lines
97 KiB
C
Raw Normal View History

2013-09-30 19:37:13 -07:00
/******************************************************************************
Copyright (C) 2013-2015 by Hugh Bailey <obs.jim@gmail.com>
Philippe Groarke <philippe.groarke@gmail.com>
2013-09-30 19:37:13 -07:00
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
2013-09-30 19:37:13 -07:00
(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 <http://www.gnu.org/licenses/>.
******************************************************************************/
#include "util/threading.h"
#include "util/util_uint64.h"
2013-09-30 19:37:13 -07:00
#include "graphics/math-defs.h"
#include "obs-scene.h"
#include "obs-internal.h"
2013-09-30 19:37:13 -07:00
const struct obs_source_info group_info;
static void resize_group(obs_sceneitem_t *group);
static void resize_scene(obs_scene_t *scene);
static void signal_parent(obs_scene_t *parent, const char *name,
calldata_t *params);
static void get_ungrouped_transform(obs_sceneitem_t *group, struct vec2 *pos,
struct vec2 *scale, float *rot);
static inline bool crop_enabled(const struct obs_sceneitem_crop *crop);
static inline bool item_texture_enabled(const struct obs_scene_item *item);
static void init_hotkeys(obs_scene_t *scene, obs_sceneitem_t *item,
const char *name);
/* NOTE: For proper mutex lock order (preventing mutual cross-locks), never
* lock the graphics mutex inside either of the scene mutexes.
*
* Another thing that must be done to prevent that cross-lock (and improve
* performance), is to not create/release/update sources within the scene
* mutexes.
*
* It's okay to lock the graphics mutex before locking either of the scene
* mutexes, but not after.
*/
static const char *obs_scene_signals[] = {
"void item_add(ptr scene, ptr item)",
"void item_remove(ptr scene, ptr item)",
"void reorder(ptr scene)",
"void refresh(ptr scene)",
"void item_visible(ptr scene, ptr item, bool visible)",
"void item_select(ptr scene, ptr item)",
"void item_deselect(ptr scene, ptr item)",
"void item_transform(ptr scene, ptr item)",
"void item_locked(ptr scene, ptr item, bool locked)",
NULL,
};
static const struct {
enum gs_blend_type src_color;
enum gs_blend_type src_alpha;
enum gs_blend_type dst_color;
enum gs_blend_type dst_alpha;
enum gs_blend_op_type op;
} obs_blend_mode_params[] = {
/* clang-format off */
// OBS_BLEND_NORMAL
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_INVSRCALPHA,
GS_BLEND_INVSRCALPHA,
GS_BLEND_OP_ADD,
},
// OBS_BLEND_ADDITIVE
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_OP_ADD,
},
// OBS_BLEND_SUBTRACT
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_OP_REVERSE_SUBTRACT,
},
// OBS_BLEND_SCREEN
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_INVSRCCOLOR,
GS_BLEND_INVSRCALPHA,
GS_BLEND_OP_ADD
},
// OBS_BLEND_MULTIPLY
{
GS_BLEND_DSTCOLOR,
GS_BLEND_DSTALPHA,
GS_BLEND_INVSRCALPHA,
GS_BLEND_INVSRCALPHA,
GS_BLEND_OP_ADD
},
// OBS_BLEND_LIGHTEN
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_OP_MAX,
},
// OBS_BLEND_DARKEN
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_OP_MIN,
},
/* clang-format on */
};
static inline void signal_item_remove(struct obs_scene_item *item)
{
struct calldata params;
uint8_t stack[128];
calldata_init_fixed(&params, stack, sizeof(stack));
calldata_set_ptr(&params, "item", item);
signal_parent(item->parent, "item_remove", &params);
}
static const char *scene_getname(void *unused)
{
UNUSED_PARAMETER(unused);
return "Scene";
}
static const char *group_getname(void *unused)
{
UNUSED_PARAMETER(unused);
return "Group";
}
static void *scene_create(obs_data_t *settings, struct obs_source *source)
2013-09-30 19:37:13 -07:00
{
struct obs_scene *scene = bzalloc(sizeof(struct obs_scene));
scene->source = source;
if (strcmp(source->info.id, group_info.id) == 0) {
scene->is_group = true;
scene->custom_size = true;
scene->cx = 0;
scene->cy = 0;
}
signal_handler_add_array(obs_source_get_signal_handler(source),
obs_scene_signals);
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&scene->audio_mutex) != 0) {
blog(LOG_ERROR, "scene_create: Couldn't initialize audio "
"mutex");
goto fail;
}
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&scene->video_mutex) != 0) {
blog(LOG_ERROR, "scene_create: Couldn't initialize video "
"mutex");
goto fail;
}
2013-09-30 19:37:13 -07:00
UNUSED_PARAMETER(settings);
2013-09-30 19:37:13 -07:00
return scene;
fail:
bfree(scene);
return NULL;
2013-09-30 19:37:13 -07:00
}
#define audio_lock(scene) pthread_mutex_lock(&scene->audio_mutex)
#define video_lock(scene) pthread_mutex_lock(&scene->video_mutex)
#define audio_unlock(scene) pthread_mutex_unlock(&scene->audio_mutex)
#define video_unlock(scene) pthread_mutex_unlock(&scene->video_mutex)
static inline void full_lock(struct obs_scene *scene)
{
video_lock(scene);
audio_lock(scene);
}
static inline void full_unlock(struct obs_scene *scene)
{
audio_unlock(scene);
video_unlock(scene);
}
static void set_visibility(struct obs_scene_item *item, bool vis);
static inline void detach_sceneitem(struct obs_scene_item *item);
static inline void remove_without_release(struct obs_scene_item *item)
{
item->removed = true;
set_visibility(item, false);
signal_item_remove(item);
detach_sceneitem(item);
}
static void remove_all_items(struct obs_scene *scene)
2013-09-30 19:37:13 -07:00
{
2014-01-30 11:41:11 -08:00
struct obs_scene_item *item;
DARRAY(struct obs_scene_item *) items;
da_init(items);
full_lock(scene);
2013-09-30 19:37:13 -07:00
2014-01-30 11:41:11 -08:00
item = scene->first_item;
while (item) {
struct obs_scene_item *del_item = item;
item = item->next;
remove_without_release(del_item);
da_push_back(items, &del_item);
}
2013-09-30 19:37:13 -07:00
full_unlock(scene);
for (size_t i = 0; i < items.num; i++)
obs_sceneitem_release(items.array[i]);
da_free(items);
}
static void scene_destroy(void *data)
{
struct obs_scene *scene = data;
remove_all_items(scene);
pthread_mutex_destroy(&scene->video_mutex);
pthread_mutex_destroy(&scene->audio_mutex);
2013-09-30 19:37:13 -07:00
bfree(scene);
}
static inline bool transition_active(obs_source_t *transition)
{
return transition && (transition->transitioning_audio ||
transition->transitioning_video);
}
static void scene_enum_sources(void *data, obs_source_enum_proc_t enum_callback,
void *param, bool active)
{
struct obs_scene *scene = data;
struct obs_scene_item *item;
struct obs_scene_item *next;
full_lock(scene);
item = scene->first_item;
while (item) {
next = item->next;
obs_sceneitem_addref(item);
if (active) {
if (item->visible &&
transition_active(item->show_transition))
enum_callback(scene->source,
item->show_transition, param);
else if (!item->visible &&
transition_active(item->hide_transition))
enum_callback(scene->source,
item->hide_transition, param);
else if (os_atomic_load_long(&item->active_refs) > 0)
enum_callback(scene->source, item->source,
param);
} else {
if (item->show_transition)
enum_callback(scene->source,
item->show_transition, param);
if (item->hide_transition)
enum_callback(scene->source,
item->hide_transition, param);
enum_callback(scene->source, item->source, param);
}
obs_sceneitem_release(item);
item = next;
}
full_unlock(scene);
}
static void scene_enum_active_sources(void *data,
obs_source_enum_proc_t enum_callback,
void *param)
{
scene_enum_sources(data, enum_callback, param, true);
}
static void scene_enum_all_sources(void *data,
obs_source_enum_proc_t enum_callback,
void *param)
{
scene_enum_sources(data, enum_callback, param, false);
}
static inline void detach_sceneitem(struct obs_scene_item *item)
{
if (item->prev)
item->prev->next = item->next;
else
item->parent->first_item = item->next;
if (item->next)
item->next->prev = item->prev;
item->parent = NULL;
}
2014-05-15 17:40:53 -07:00
static inline void attach_sceneitem(struct obs_scene *parent,
struct obs_scene_item *item,
struct obs_scene_item *prev)
{
item->prev = prev;
2014-05-15 17:40:53 -07:00
item->parent = parent;
if (prev) {
item->next = prev->next;
if (prev->next)
prev->next->prev = item;
prev->next = item;
} else {
item->next = parent->first_item;
if (parent->first_item)
parent->first_item->prev = item;
parent->first_item = item;
}
}
void add_alignment(struct vec2 *v, uint32_t align, int cx, int cy)
{
if (align & OBS_ALIGN_RIGHT)
v->x += (float)cx;
else if ((align & OBS_ALIGN_LEFT) == 0)
v->x += (float)(cx / 2);
if (align & OBS_ALIGN_BOTTOM)
v->y += (float)cy;
else if ((align & OBS_ALIGN_TOP) == 0)
v->y += (float)(cy / 2);
}
static void calculate_bounds_data(struct obs_scene_item *item,
struct vec2 *origin, struct vec2 *scale,
uint32_t *cx, uint32_t *cy)
{
float width = (float)(*cx) * fabsf(scale->x);
float height = (float)(*cy) * fabsf(scale->y);
float item_aspect = width / height;
float bounds_aspect = item->bounds.x / item->bounds.y;
uint32_t bounds_type = item->bounds_type;
float width_diff, height_diff;
UI: Add scene editing So, scene editing was interesting (and by interesting I mean excruciating). I almost implemented 'manipulator' visuals (ala 3dsmax for example), and used 3 modes for controlling position/rotation/size, but in a 2D editing, it felt clunky, so I defaulted back to simply click-and-drag for movement, and then took a similar though slightly different looking approach for handling scaling and reszing. I also added a number of menu item helpers related to positioning, scaling, rotating, flipping, and resetting the transform back to default. There is also a new 'transform' dialog (accessible via menu) which will allow you to manually edit every single transform variable of a scene item directly if desired. If a scene item does not have bounds active, pulling on the sides of a source will cause it to resize it via base scale rather than by the bounding box system (if the source resizes that scale will apply). If bounds are active, it will modify the bounding box only instead. How a source scales when a bounding box is active depends on the type of bounds being used. You can set it to scale to the inner bounds, the outer bounds, scale to bounds width only, scale to bounds height only, and a setting to stretch to bounds (which forces a source to always draw at the bounding box size rather than be affected by its internal size). You can also set it to be used as a 'maximum' size, so that the source doesn't necessarily get scaled unless it extends beyond the bounds. Like in OBS1, objects will snap to the edges unless the control key is pressed. However, this will now happen even if the object is rotated or oriented in any strange way. Snapping will also occur when stretching or changing the bounding box size.
2014-06-15 00:54:48 -07:00
if (item->bounds_type == OBS_BOUNDS_MAX_ONLY)
if (width > item->bounds.x || height > item->bounds.y)
bounds_type = OBS_BOUNDS_SCALE_INNER;
if (bounds_type == OBS_BOUNDS_SCALE_INNER ||
bounds_type == OBS_BOUNDS_SCALE_OUTER) {
bool use_width = (bounds_aspect < item_aspect);
float mul;
if (item->bounds_type == OBS_BOUNDS_SCALE_OUTER)
use_width = !use_width;
mul = use_width ? item->bounds.x / width
: item->bounds.y / height;
vec2_mulf(scale, scale, mul);
UI: Add scene editing So, scene editing was interesting (and by interesting I mean excruciating). I almost implemented 'manipulator' visuals (ala 3dsmax for example), and used 3 modes for controlling position/rotation/size, but in a 2D editing, it felt clunky, so I defaulted back to simply click-and-drag for movement, and then took a similar though slightly different looking approach for handling scaling and reszing. I also added a number of menu item helpers related to positioning, scaling, rotating, flipping, and resetting the transform back to default. There is also a new 'transform' dialog (accessible via menu) which will allow you to manually edit every single transform variable of a scene item directly if desired. If a scene item does not have bounds active, pulling on the sides of a source will cause it to resize it via base scale rather than by the bounding box system (if the source resizes that scale will apply). If bounds are active, it will modify the bounding box only instead. How a source scales when a bounding box is active depends on the type of bounds being used. You can set it to scale to the inner bounds, the outer bounds, scale to bounds width only, scale to bounds height only, and a setting to stretch to bounds (which forces a source to always draw at the bounding box size rather than be affected by its internal size). You can also set it to be used as a 'maximum' size, so that the source doesn't necessarily get scaled unless it extends beyond the bounds. Like in OBS1, objects will snap to the edges unless the control key is pressed. However, this will now happen even if the object is rotated or oriented in any strange way. Snapping will also occur when stretching or changing the bounding box size.
2014-06-15 00:54:48 -07:00
} else if (bounds_type == OBS_BOUNDS_SCALE_TO_WIDTH) {
vec2_mulf(scale, scale, item->bounds.x / width);
UI: Add scene editing So, scene editing was interesting (and by interesting I mean excruciating). I almost implemented 'manipulator' visuals (ala 3dsmax for example), and used 3 modes for controlling position/rotation/size, but in a 2D editing, it felt clunky, so I defaulted back to simply click-and-drag for movement, and then took a similar though slightly different looking approach for handling scaling and reszing. I also added a number of menu item helpers related to positioning, scaling, rotating, flipping, and resetting the transform back to default. There is also a new 'transform' dialog (accessible via menu) which will allow you to manually edit every single transform variable of a scene item directly if desired. If a scene item does not have bounds active, pulling on the sides of a source will cause it to resize it via base scale rather than by the bounding box system (if the source resizes that scale will apply). If bounds are active, it will modify the bounding box only instead. How a source scales when a bounding box is active depends on the type of bounds being used. You can set it to scale to the inner bounds, the outer bounds, scale to bounds width only, scale to bounds height only, and a setting to stretch to bounds (which forces a source to always draw at the bounding box size rather than be affected by its internal size). You can also set it to be used as a 'maximum' size, so that the source doesn't necessarily get scaled unless it extends beyond the bounds. Like in OBS1, objects will snap to the edges unless the control key is pressed. However, this will now happen even if the object is rotated or oriented in any strange way. Snapping will also occur when stretching or changing the bounding box size.
2014-06-15 00:54:48 -07:00
} else if (bounds_type == OBS_BOUNDS_SCALE_TO_HEIGHT) {
vec2_mulf(scale, scale, item->bounds.y / height);
UI: Add scene editing So, scene editing was interesting (and by interesting I mean excruciating). I almost implemented 'manipulator' visuals (ala 3dsmax for example), and used 3 modes for controlling position/rotation/size, but in a 2D editing, it felt clunky, so I defaulted back to simply click-and-drag for movement, and then took a similar though slightly different looking approach for handling scaling and reszing. I also added a number of menu item helpers related to positioning, scaling, rotating, flipping, and resetting the transform back to default. There is also a new 'transform' dialog (accessible via menu) which will allow you to manually edit every single transform variable of a scene item directly if desired. If a scene item does not have bounds active, pulling on the sides of a source will cause it to resize it via base scale rather than by the bounding box system (if the source resizes that scale will apply). If bounds are active, it will modify the bounding box only instead. How a source scales when a bounding box is active depends on the type of bounds being used. You can set it to scale to the inner bounds, the outer bounds, scale to bounds width only, scale to bounds height only, and a setting to stretch to bounds (which forces a source to always draw at the bounding box size rather than be affected by its internal size). You can also set it to be used as a 'maximum' size, so that the source doesn't necessarily get scaled unless it extends beyond the bounds. Like in OBS1, objects will snap to the edges unless the control key is pressed. However, this will now happen even if the object is rotated or oriented in any strange way. Snapping will also occur when stretching or changing the bounding box size.
2014-06-15 00:54:48 -07:00
} else if (bounds_type == OBS_BOUNDS_STRETCH) {
scale->x = item->bounds.x / (float)(*cx);
scale->y = item->bounds.y / (float)(*cy);
}
width = (float)(*cx) * scale->x;
height = (float)(*cy) * scale->y;
width_diff = item->bounds.x - width;
height_diff = item->bounds.y - height;
*cx = (uint32_t)item->bounds.x;
*cy = (uint32_t)item->bounds.y;
add_alignment(origin, item->bounds_align, (int)-width_diff,
(int)-height_diff);
}
static inline uint32_t calc_cx(const struct obs_scene_item *item,
uint32_t width)
{
uint32_t crop_cx = item->crop.left + item->crop.right;
return (crop_cx > width) ? 2 : (width - crop_cx);
}
static inline uint32_t calc_cy(const struct obs_scene_item *item,
uint32_t height)
{
uint32_t crop_cy = item->crop.top + item->crop.bottom;
return (crop_cy > height) ? 2 : (height - crop_cy);
}
static void update_item_transform(struct obs_scene_item *item, bool update_tex)
{
uint32_t width;
uint32_t height;
uint32_t cx;
uint32_t cy;
struct vec2 base_origin;
struct vec2 origin;
struct vec2 scale;
struct calldata params;
uint8_t stack[128];
if (os_atomic_load_long(&item->defer_update) > 0)
return;
width = obs_source_get_width(item->source);
height = obs_source_get_height(item->source);
cx = calc_cx(item, width);
cy = calc_cy(item, height);
scale = item->scale;
item->last_width = width;
item->last_height = height;
width = cx;
height = cy;
vec2_zero(&base_origin);
vec2_zero(&origin);
/* ----------------------- */
if (item->bounds_type != OBS_BOUNDS_NONE) {
calculate_bounds_data(item, &origin, &scale, &cx, &cy);
} else {
cx = (uint32_t)((float)cx * scale.x);
cy = (uint32_t)((float)cy * scale.y);
}
add_alignment(&origin, item->align, (int)cx, (int)cy);
matrix4_identity(&item->draw_transform);
matrix4_scale3f(&item->draw_transform, &item->draw_transform, scale.x,
scale.y, 1.0f);
matrix4_translate3f(&item->draw_transform, &item->draw_transform,
-origin.x, -origin.y, 0.0f);
matrix4_rotate_aa4f(&item->draw_transform, &item->draw_transform, 0.0f,
0.0f, 1.0f, RAD(item->rot));
matrix4_translate3f(&item->draw_transform, &item->draw_transform,
item->pos.x, item->pos.y, 0.0f);
item->output_scale = scale;
/* ----------------------- */
if (item->bounds_type != OBS_BOUNDS_NONE) {
vec2_copy(&scale, &item->bounds);
} else {
scale.x = (float)width * item->scale.x;
scale.y = (float)height * item->scale.y;
}
item->box_scale = scale;
add_alignment(&base_origin, item->align, (int)scale.x, (int)scale.y);
matrix4_identity(&item->box_transform);
matrix4_scale3f(&item->box_transform, &item->box_transform, scale.x,
scale.y, 1.0f);
matrix4_translate3f(&item->box_transform, &item->box_transform,
-base_origin.x, -base_origin.y, 0.0f);
matrix4_rotate_aa4f(&item->box_transform, &item->box_transform, 0.0f,
0.0f, 1.0f, RAD(item->rot));
matrix4_translate3f(&item->box_transform, &item->box_transform,
item->pos.x, item->pos.y, 0.0f);
/* ----------------------- */
calldata_init_fixed(&params, stack, sizeof(stack));
calldata_set_ptr(&params, "item", item);
signal_parent(item->parent, "item_transform", &params);
if (!update_tex)
return;
os_atomic_set_bool(&item->update_transform, false);
}
static inline bool source_size_changed(struct obs_scene_item *item)
{
uint32_t width = obs_source_get_width(item->source);
uint32_t height = obs_source_get_height(item->source);
return item->last_width != width || item->last_height != height;
}
static inline bool crop_enabled(const struct obs_sceneitem_crop *crop)
{
return crop->left || crop->right || crop->top || crop->bottom;
}
static inline bool scale_filter_enabled(const struct obs_scene_item *item)
{
return item->scale_filter != OBS_SCALE_DISABLE;
}
static inline bool default_blending_enabled(const struct obs_scene_item *item)
{
return item->blend_type == OBS_BLEND_NORMAL;
}
static inline bool item_is_scene(const struct obs_scene_item *item)
{
return item->source && item->source->info.type == OBS_SOURCE_TYPE_SCENE;
}
static inline bool item_texture_enabled(const struct obs_scene_item *item)
{
return crop_enabled(&item->crop) || scale_filter_enabled(item) ||
(item->blend_method == OBS_BLEND_METHOD_SRGB_OFF) ||
!default_blending_enabled(item) ||
(item_is_scene(item) && !item->is_group);
}
static void render_item_texture(struct obs_scene_item *item,
enum gs_color_space current_space,
enum gs_color_space source_space)
{
gs_texture_t *tex = gs_texrender_get_texture(item->item_render);
if (!tex) {
return;
}
GS_DEBUG_MARKER_BEGIN(GS_DEBUG_COLOR_ITEM_TEXTURE,
"render_item_texture");
gs_effect_t *effect = obs->video.default_effect;
enum obs_scale_type type = item->scale_filter;
uint32_t cx = gs_texture_get_width(tex);
uint32_t cy = gs_texture_get_height(tex);
bool upscale = false;
if (type != OBS_SCALE_DISABLE) {
if (type == OBS_SCALE_POINT) {
gs_eparam_t *image =
gs_effect_get_param_by_name(effect, "image");
gs_effect_set_next_sampler(image,
obs->video.point_sampler);
} else if (!close_float(item->output_scale.x, 1.0f, EPSILON) ||
!close_float(item->output_scale.y, 1.0f, EPSILON)) {
if (item->output_scale.x < 0.5f ||
item->output_scale.y < 0.5f) {
effect = obs->video.bilinear_lowres_effect;
} else if (type == OBS_SCALE_BICUBIC) {
effect = obs->video.bicubic_effect;
} else if (type == OBS_SCALE_LANCZOS) {
effect = obs->video.lanczos_effect;
} else if (type == OBS_SCALE_AREA) {
effect = obs->video.area_effect;
upscale = (item->output_scale.x >= 1.0f) &&
(item->output_scale.y >= 1.0f);
}
gs_eparam_t *const scale_param =
gs_effect_get_param_by_name(effect,
"base_dimension");
if (scale_param) {
2019-07-25 00:39:28 -07:00
struct vec2 base_res = {(float)cx, (float)cy};
2019-07-25 00:39:28 -07:00
gs_effect_set_vec2(scale_param, &base_res);
}
gs_eparam_t *const scale_i_param =
gs_effect_get_param_by_name(effect,
"base_dimension_i");
if (scale_i_param) {
struct vec2 base_res_i = {1.0f / (float)cx,
1.0f / (float)cy};
gs_effect_set_vec2(scale_i_param, &base_res_i);
}
}
}
float multiplier = 1.f;
switch (current_space) {
case GS_CS_709_SCRGB:
switch (source_space) {
case GS_CS_SRGB:
case GS_CS_SRGB_16F:
case GS_CS_709_EXTENDED:
multiplier = obs_get_video_sdr_white_level() / 80.f;
}
}
switch (source_space) {
case GS_CS_709_SCRGB:
switch (current_space) {
case GS_CS_SRGB:
case GS_CS_SRGB_16F:
case GS_CS_709_EXTENDED:
multiplier = 80.f / obs_get_video_sdr_white_level();
}
}
const char *tech_name = "Draw";
if (upscale) {
tech_name = "DrawUpscale";
switch (source_space) {
case GS_CS_SRGB:
case GS_CS_SRGB_16F:
switch (current_space) {
case GS_CS_709_SCRGB:
tech_name = "DrawUpscaleMultiply";
}
break;
case GS_CS_709_EXTENDED:
switch (current_space) {
case GS_CS_SRGB:
case GS_CS_SRGB_16F:
tech_name = "DrawUpscaleTonemap";
break;
case GS_CS_709_SCRGB:
tech_name = "DrawUpscaleMultiply";
}
break;
case GS_CS_709_SCRGB:
switch (current_space) {
case GS_CS_SRGB:
case GS_CS_SRGB_16F:
tech_name = "DrawUpscaleMultiplyTonemap";
break;
case GS_CS_709_EXTENDED:
tech_name = "DrawUpscaleMultiply";
}
}
} else {
switch (source_space) {
case GS_CS_SRGB:
case GS_CS_SRGB_16F:
switch (current_space) {
case GS_CS_709_SCRGB:
tech_name = "DrawMultiply";
}
break;
case GS_CS_709_EXTENDED:
switch (current_space) {
case GS_CS_SRGB:
case GS_CS_SRGB_16F:
tech_name = "DrawTonemap";
break;
case GS_CS_709_SCRGB:
tech_name = "DrawMultiply";
}
break;
case GS_CS_709_SCRGB:
switch (current_space) {
case GS_CS_SRGB:
case GS_CS_SRGB_16F:
tech_name = "DrawMultiplyTonemap";
break;
case GS_CS_709_EXTENDED:
tech_name = "DrawMultiply";
}
}
}
gs_eparam_t *const multiplier_param =
gs_effect_get_param_by_name(effect, "multiplier");
if (multiplier_param)
gs_effect_set_float(multiplier_param, multiplier);
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
gs_blend_state_push();
gs_blend_function_separate(
obs_blend_mode_params[item->blend_type].src_color,
obs_blend_mode_params[item->blend_type].dst_color,
obs_blend_mode_params[item->blend_type].src_alpha,
obs_blend_mode_params[item->blend_type].dst_alpha);
gs_blend_op(obs_blend_mode_params[item->blend_type].op);
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
while (gs_effect_loop(effect, tech_name))
obs_source_draw(tex, 0, 0, 0, 0, 0);
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
gs_blend_state_pop();
GS_DEBUG_MARKER_END();
}
static bool are_texcoords_centered(struct matrix4 *m)
{
static const struct matrix4 identity = {
{1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 1.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f},
};
struct matrix4 copy = identity;
copy.t.x = floorf(m->t.x);
copy.t.y = floorf(m->t.y);
return memcmp(m, &copy, sizeof(*m)) == 0;
}
static inline void render_item(struct obs_scene_item *item)
{
GS_DEBUG_MARKER_BEGIN_FORMAT(GS_DEBUG_COLOR_ITEM, "Item: %s",
obs_source_get_name(item->source));
const bool use_texrender = item_texture_enabled(item);
obs_source_t *const source = item->source;
const enum gs_color_space current_space = gs_get_color_space();
const enum gs_color_space source_space =
obs_source_get_color_space(source, 1, &current_space);
const enum gs_color_format format =
gs_get_format_from_space(source_space);
if (item->item_render &&
(!use_texrender ||
(gs_texrender_get_format(item->item_render) != format))) {
gs_texrender_destroy(item->item_render);
item->item_render = NULL;
}
if (!item->item_render && use_texrender) {
item->item_render = gs_texrender_create(format, GS_ZS_NONE);
}
if (item->item_render) {
uint32_t width = obs_source_get_width(item->source);
uint32_t height = obs_source_get_height(item->source);
if (!width || !height) {
goto cleanup;
}
uint32_t cx = calc_cx(item, width);
uint32_t cy = calc_cy(item, height);
if (cx && cy &&
gs_texrender_begin_with_color_space(item->item_render, cx,
cy, source_space)) {
float cx_scale = (float)width / (float)cx;
float cy_scale = (float)height / (float)cy;
struct vec4 clear_color;
vec4_zero(&clear_color);
gs_clear(GS_CLEAR_COLOR, &clear_color, 0.0f, 0);
gs_ortho(0.0f, (float)width, 0.0f, (float)height,
-100.0f, 100.0f);
gs_matrix_scale3f(cx_scale, cy_scale, 1.0f);
gs_matrix_translate3f(-(float)item->crop.left,
-(float)item->crop.top, 0.0f);
if (item->user_visible &&
transition_active(item->show_transition)) {
const int cx =
obs_source_get_width(item->source);
const int cy =
obs_source_get_height(item->source);
obs_transition_set_size(item->show_transition,
cx, cy);
obs_source_video_render(item->show_transition);
} else if (!item->user_visible &&
transition_active(item->hide_transition)) {
const int cx =
obs_source_get_width(item->source);
const int cy =
obs_source_get_height(item->source);
obs_transition_set_size(item->hide_transition,
cx, cy);
obs_source_video_render(item->hide_transition);
} else {
obs_source_set_texcoords_centered(item->source,
true);
obs_source_video_render(item->source);
obs_source_set_texcoords_centered(item->source,
false);
}
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
gs_texrender_end(item->item_render);
}
}
const bool linear_srgb =
!item->item_render ||
(item->blend_method != OBS_BLEND_METHOD_SRGB_OFF);
const bool previous = gs_set_linear_srgb(linear_srgb);
gs_matrix_push();
gs_matrix_mul(&item->draw_transform);
if (item->item_render) {
render_item_texture(item, current_space, source_space);
} else if (item->user_visible &&
transition_active(item->show_transition)) {
const int cx = obs_source_get_width(item->source);
const int cy = obs_source_get_height(item->source);
obs_transition_set_size(item->show_transition, cx, cy);
obs_source_video_render(item->show_transition);
} else if (!item->user_visible &&
transition_active(item->hide_transition)) {
const int cx = obs_source_get_width(item->source);
const int cy = obs_source_get_height(item->source);
obs_transition_set_size(item->hide_transition, cx, cy);
obs_source_video_render(item->hide_transition);
} else {
const bool centered =
are_texcoords_centered(&item->draw_transform);
obs_source_set_texcoords_centered(item->source, centered);
obs_source_video_render(item->source);
obs_source_set_texcoords_centered(item->source, false);
}
gs_matrix_pop();
gs_set_linear_srgb(previous);
cleanup:
GS_DEBUG_MARKER_END();
}
static void scene_video_tick(void *data, float seconds)
{
struct obs_scene *scene = data;
struct obs_scene_item *item;
video_lock(scene);
item = scene->first_item;
while (item) {
if (item->item_render)
gs_texrender_reset(item->item_render);
item = item->next;
}
video_unlock(scene);
UNUSED_PARAMETER(seconds);
}
/* assumes video lock */
static void
update_transforms_and_prune_sources(obs_scene_t *scene,
struct darray *remove_items,
obs_sceneitem_t *group_sceneitem)
{
struct obs_scene_item *item = scene->first_item;
bool rebuild_group =
group_sceneitem &&
os_atomic_load_bool(&group_sceneitem->update_group_resize);
while (item) {
if (obs_source_removed(item->source)) {
struct obs_scene_item *del_item = item;
item = item->next;
remove_without_release(del_item);
darray_push_back(sizeof(struct obs_scene_item *),
remove_items, &del_item);
rebuild_group = true;
continue;
}
if (item->is_group) {
obs_scene_t *group_scene = item->source->context.data;
video_lock(group_scene);
update_transforms_and_prune_sources(group_scene,
remove_items, item);
video_unlock(group_scene);
}
if (os_atomic_load_bool(&item->update_transform) ||
source_size_changed(item)) {
update_item_transform(item, true);
rebuild_group = true;
}
item = item->next;
}
if (rebuild_group && group_sceneitem)
resize_group(group_sceneitem);
}
static void scene_video_render(void *data, gs_effect_t *effect)
2013-09-30 19:37:13 -07:00
{
DARRAY(struct obs_scene_item *) remove_items;
struct obs_scene *scene = data;
struct obs_scene_item *item;
da_init(remove_items);
video_lock(scene);
2013-09-30 19:37:13 -07:00
if (!scene->is_group) {
update_transforms_and_prune_sources(scene, &remove_items.da,
NULL);
}
gs_blend_state_push();
gs_reset_blend_state();
item = scene->first_item;
while (item) {
if (item->user_visible ||
transition_active(item->hide_transition))
render_item(item);
item = item->next;
2013-09-30 19:37:13 -07:00
}
gs_blend_state_pop();
video_unlock(scene);
for (size_t i = 0; i < remove_items.num; i++)
obs_sceneitem_release(remove_items.array[i]);
da_free(remove_items);
UNUSED_PARAMETER(effect);
}
static void set_visibility(struct obs_scene_item *item, bool vis)
{
pthread_mutex_lock(&item->actions_mutex);
da_resize(item->audio_actions, 0);
if (os_atomic_load_long(&item->active_refs) > 0) {
if (!vis)
obs_source_remove_active_child(item->parent->source,
item->source);
} else if (vis) {
obs_source_add_active_child(item->parent->source, item->source);
}
os_atomic_set_long(&item->active_refs, vis ? 1 : 0);
item->visible = vis;
item->user_visible = vis;
pthread_mutex_unlock(&item->actions_mutex);
}
static void scene_load(void *data, obs_data_t *settings);
static void scene_load_item(struct obs_scene *scene, obs_data_t *item_data)
{
const char *name = obs_data_get_string(item_data, "name");
obs_source_t *source;
const char *scale_filter_str;
const char *blend_method_str;
const char *blend_str;
struct obs_scene_item *item;
bool visible;
bool lock;
if (obs_data_get_bool(item_data, "group_item_backup"))
return;
source = obs_get_source_by_name(name);
if (!source) {
blog(LOG_WARNING,
"[scene_load_item] Source %s not "
"found!",
name);
return;
}
item = obs_scene_add(scene, source);
if (!item) {
blog(LOG_WARNING,
"[scene_load_item] Could not add source '%s' "
"to scene '%s'!",
name, obs_source_get_name(scene->source));
obs_source_release(source);
return;
}
item->is_group = strcmp(source->info.id, group_info.id) == 0;
obs_data_set_default_int(item_data, "align",
OBS_ALIGN_TOP | OBS_ALIGN_LEFT);
if (obs_data_has_user_value(item_data, "id"))
item->id = obs_data_get_int(item_data, "id");
item->rot = (float)obs_data_get_double(item_data, "rot");
item->align = (uint32_t)obs_data_get_int(item_data, "align");
visible = obs_data_get_bool(item_data, "visible");
lock = obs_data_get_bool(item_data, "locked");
obs_data_get_vec2(item_data, "pos", &item->pos);
obs_data_get_vec2(item_data, "scale", &item->scale);
obs_data_release(item->private_settings);
item->private_settings =
obs_data_get_obj(item_data, "private_settings");
if (!item->private_settings)
item->private_settings = obs_data_create();
set_visibility(item, visible);
obs_sceneitem_set_locked(item, lock);
item->bounds_type = (enum obs_bounds_type)obs_data_get_int(
item_data, "bounds_type");
item->bounds_align =
(uint32_t)obs_data_get_int(item_data, "bounds_align");
obs_data_get_vec2(item_data, "bounds", &item->bounds);
item->crop.left = (uint32_t)obs_data_get_int(item_data, "crop_left");
item->crop.top = (uint32_t)obs_data_get_int(item_data, "crop_top");
item->crop.right = (uint32_t)obs_data_get_int(item_data, "crop_right");
item->crop.bottom =
(uint32_t)obs_data_get_int(item_data, "crop_bottom");
scale_filter_str = obs_data_get_string(item_data, "scale_filter");
item->scale_filter = OBS_SCALE_DISABLE;
if (scale_filter_str) {
if (astrcmpi(scale_filter_str, "point") == 0)
item->scale_filter = OBS_SCALE_POINT;
else if (astrcmpi(scale_filter_str, "bilinear") == 0)
item->scale_filter = OBS_SCALE_BILINEAR;
else if (astrcmpi(scale_filter_str, "bicubic") == 0)
item->scale_filter = OBS_SCALE_BICUBIC;
else if (astrcmpi(scale_filter_str, "lanczos") == 0)
item->scale_filter = OBS_SCALE_LANCZOS;
else if (astrcmpi(scale_filter_str, "area") == 0)
item->scale_filter = OBS_SCALE_AREA;
}
blend_method_str = obs_data_get_string(item_data, "blend_method");
item->blend_method = OBS_BLEND_METHOD_DEFAULT;
if (blend_method_str) {
if (astrcmpi(blend_method_str, "srgb_off") == 0)
item->blend_method = OBS_BLEND_METHOD_SRGB_OFF;
}
blend_str = obs_data_get_string(item_data, "blend_type");
item->blend_type = OBS_BLEND_NORMAL;
if (blend_str) {
if (astrcmpi(blend_str, "additive") == 0)
item->blend_type = OBS_BLEND_ADDITIVE;
else if (astrcmpi(blend_str, "subtract") == 0)
item->blend_type = OBS_BLEND_SUBTRACT;
else if (astrcmpi(blend_str, "screen") == 0)
item->blend_type = OBS_BLEND_SCREEN;
else if (astrcmpi(blend_str, "multiply") == 0)
item->blend_type = OBS_BLEND_MULTIPLY;
else if (astrcmpi(blend_str, "lighten") == 0)
item->blend_type = OBS_BLEND_LIGHTEN;
else if (astrcmpi(blend_str, "darken") == 0)
item->blend_type = OBS_BLEND_DARKEN;
}
obs_data_t *show_data = obs_data_get_obj(item_data, "show_transition");
if (show_data) {
obs_sceneitem_transition_load(item, show_data, true);
obs_data_release(show_data);
}
obs_data_t *hide_data = obs_data_get_obj(item_data, "hide_transition");
if (hide_data) {
obs_sceneitem_transition_load(item, hide_data, false);
obs_data_release(hide_data);
}
obs_source_release(source);
update_item_transform(item, false);
}
static void scene_load(void *data, obs_data_t *settings)
{
struct obs_scene *scene = data;
obs_data_array_t *items = obs_data_get_array(settings, "items");
size_t count, i;
remove_all_items(scene);
if (!items)
return;
count = obs_data_array_count(items);
for (i = 0; i < count; i++) {
obs_data_t *item_data = obs_data_array_item(items, i);
scene_load_item(scene, item_data);
obs_data_release(item_data);
}
if (obs_data_has_user_value(settings, "id_counter"))
scene->id_counter = obs_data_get_int(settings, "id_counter");
if (obs_data_get_bool(settings, "custom_size")) {
scene->cx = (uint32_t)obs_data_get_int(settings, "cx");
scene->cy = (uint32_t)obs_data_get_int(settings, "cy");
scene->custom_size = true;
}
obs_data_array_release(items);
}
static void scene_save(void *data, obs_data_t *settings);
static void scene_save_item(obs_data_array_t *array,
struct obs_scene_item *item,
struct obs_scene_item *backup_group)
{
obs_data_t *item_data = obs_data_create();
const char *name = obs_source_get_name(item->source);
const char *scale_filter;
const char *blend_method;
const char *blend_type;
struct vec2 pos = item->pos;
struct vec2 scale = item->scale;
float rot = item->rot;
if (backup_group) {
get_ungrouped_transform(backup_group, &pos, &scale, &rot);
}
obs_data_set_string(item_data, "name", name);
obs_data_set_bool(item_data, "visible", item->user_visible);
obs_data_set_bool(item_data, "locked", item->locked);
obs_data_set_double(item_data, "rot", rot);
obs_data_set_vec2(item_data, "pos", &pos);
obs_data_set_vec2(item_data, "scale", &scale);
obs_data_set_int(item_data, "align", (int)item->align);
obs_data_set_int(item_data, "bounds_type", (int)item->bounds_type);
obs_data_set_int(item_data, "bounds_align", (int)item->bounds_align);
obs_data_set_vec2(item_data, "bounds", &item->bounds);
obs_data_set_int(item_data, "crop_left", (int)item->crop.left);
obs_data_set_int(item_data, "crop_top", (int)item->crop.top);
obs_data_set_int(item_data, "crop_right", (int)item->crop.right);
obs_data_set_int(item_data, "crop_bottom", (int)item->crop.bottom);
obs_data_set_int(item_data, "id", item->id);
obs_data_set_bool(item_data, "group_item_backup", !!backup_group);
if (item->is_group) {
obs_scene_t *group_scene = item->source->context.data;
obs_sceneitem_t *group_item;
/* save group items as part of main scene, but ignored.
* causes an automatic ungroup if scene collection file
* is loaded in previous versions. */
full_lock(group_scene);
group_item = group_scene->first_item;
while (group_item) {
scene_save_item(array, group_item, item);
group_item = group_item->next;
}
full_unlock(group_scene);
}
if (item->scale_filter == OBS_SCALE_POINT)
scale_filter = "point";
else if (item->scale_filter == OBS_SCALE_BILINEAR)
scale_filter = "bilinear";
else if (item->scale_filter == OBS_SCALE_BICUBIC)
scale_filter = "bicubic";
else if (item->scale_filter == OBS_SCALE_LANCZOS)
scale_filter = "lanczos";
else if (item->scale_filter == OBS_SCALE_AREA)
scale_filter = "area";
else
scale_filter = "disable";
obs_data_set_string(item_data, "scale_filter", scale_filter);
if (item->blend_method == OBS_BLEND_METHOD_SRGB_OFF)
blend_method = "srgb_off";
else
blend_method = "default";
obs_data_set_string(item_data, "blend_method", blend_method);
if (item->blend_type == OBS_BLEND_NORMAL)
blend_type = "normal";
else if (item->blend_type == OBS_BLEND_ADDITIVE)
blend_type = "additive";
else if (item->blend_type == OBS_BLEND_SUBTRACT)
blend_type = "subtract";
else if (item->blend_type == OBS_BLEND_SCREEN)
blend_type = "screen";
else if (item->blend_type == OBS_BLEND_MULTIPLY)
blend_type = "multiply";
else if (item->blend_type == OBS_BLEND_LIGHTEN)
blend_type = "lighten";
else if (item->blend_type == OBS_BLEND_DARKEN)
blend_type = "darken";
else
blend_type = "normal";
obs_data_set_string(item_data, "blend_type", blend_type);
obs_data_t *show_data = obs_sceneitem_transition_save(item, true);
obs_data_set_obj(item_data, "show_transition", show_data);
obs_data_release(show_data);
obs_data_t *hide_data = obs_sceneitem_transition_save(item, false);
obs_data_set_obj(item_data, "hide_transition", hide_data);
obs_data_release(hide_data);
obs_data_set_obj(item_data, "private_settings", item->private_settings);
obs_data_array_push_back(array, item_data);
obs_data_release(item_data);
}
static void scene_save(void *data, obs_data_t *settings)
{
struct obs_scene *scene = data;
obs_data_array_t *array = obs_data_array_create();
struct obs_scene_item *item;
full_lock(scene);
item = scene->first_item;
while (item) {
scene_save_item(array, item, NULL);
item = item->next;
}
obs_data_set_int(settings, "id_counter", scene->id_counter);
obs_data_set_bool(settings, "custom_size", scene->custom_size);
if (scene->custom_size) {
obs_data_set_int(settings, "cx", scene->cx);
obs_data_set_int(settings, "cy", scene->cy);
}
full_unlock(scene);
obs_data_set_array(settings, "items", array);
obs_data_array_release(array);
}
static uint32_t scene_getwidth(void *data)
{
obs_scene_t *scene = data;
return scene->custom_size ? scene->cx : obs->video.base_width;
2013-09-30 19:37:13 -07:00
}
static uint32_t scene_getheight(void *data)
2013-09-30 19:37:13 -07:00
{
obs_scene_t *scene = data;
return scene->custom_size ? scene->cy : obs->video.base_height;
2013-09-30 19:37:13 -07:00
}
static void apply_scene_item_audio_actions(struct obs_scene_item *item,
float *buf, uint64_t ts,
size_t sample_rate)
{
bool cur_visible = item->visible;
uint64_t frame_num = 0;
size_t deref_count = 0;
pthread_mutex_lock(&item->actions_mutex);
for (size_t i = 0; i < item->audio_actions.num; i++) {
struct item_action action = item->audio_actions.array[i];
uint64_t timestamp = action.timestamp;
uint64_t new_frame_num;
if (timestamp < ts)
timestamp = ts;
new_frame_num = util_mul_div64(timestamp - ts, sample_rate,
1000000000ULL);
if (ts && new_frame_num >= AUDIO_OUTPUT_FRAMES)
break;
da_erase(item->audio_actions, i--);
item->visible = action.visible;
if (!item->visible)
deref_count++;
if (buf && new_frame_num > frame_num) {
for (; frame_num < new_frame_num; frame_num++)
buf[frame_num] = cur_visible ? 1.0f : 0.0f;
}
cur_visible = item->visible;
}
if (buf) {
for (; frame_num < AUDIO_OUTPUT_FRAMES; frame_num++)
buf[frame_num] = cur_visible ? 1.0f : 0.0f;
}
pthread_mutex_unlock(&item->actions_mutex);
while (deref_count--) {
if (os_atomic_dec_long(&item->active_refs) == 0) {
obs_source_remove_active_child(item->parent->source,
item->source);
}
}
}
static bool apply_scene_item_volume(struct obs_scene_item *item, float *buf,
uint64_t ts, size_t sample_rate)
{
bool actions_pending;
struct item_action action;
pthread_mutex_lock(&item->actions_mutex);
actions_pending = item->audio_actions.num > 0;
if (actions_pending)
action = item->audio_actions.array[0];
pthread_mutex_unlock(&item->actions_mutex);
if (actions_pending) {
uint64_t duration = util_mul_div64(AUDIO_OUTPUT_FRAMES,
1000000000ULL, sample_rate);
if (!ts || action.timestamp < (ts + duration)) {
apply_scene_item_audio_actions(item, buf, ts,
sample_rate);
return true;
}
}
return false;
}
static void process_all_audio_actions(struct obs_scene_item *item,
size_t sample_rate)
{
while (apply_scene_item_volume(item, NULL, 0, sample_rate))
;
}
static void mix_audio_with_buf(float *p_out, float *p_in, float *buf_in,
size_t pos, size_t count)
{
register float *out = p_out;
register float *buf = buf_in + pos;
register float *in = p_in + pos;
register float *end = in + count;
while (in < end)
*(out++) += *(in++) * *(buf++);
}
static inline void mix_audio(float *p_out, float *p_in, size_t pos,
size_t count)
{
register float *out = p_out;
register float *in = p_in + pos;
register float *end = in + count;
while (in < end)
*(out++) += *(in++);
}
static bool scene_audio_render(void *data, uint64_t *ts_out,
struct obs_source_audio_mix *audio_output,
uint32_t mixers, size_t channels,
size_t sample_rate)
{
uint64_t timestamp = 0;
float buf[AUDIO_OUTPUT_FRAMES];
struct obs_source_audio_mix child_audio;
struct obs_scene *scene = data;
struct obs_scene_item *item;
audio_lock(scene);
item = scene->first_item;
while (item) {
struct obs_source *source;
if (item->visible && transition_active(item->show_transition))
source = item->show_transition;
else if (!item->visible &&
transition_active(item->hide_transition))
source = item->hide_transition;
else
source = item->source;
if (!obs_source_audio_pending(source) &&
(item->visible ||
transition_active(item->hide_transition))) {
uint64_t source_ts =
obs_source_get_audio_timestamp(source);
if (source_ts && (!timestamp || source_ts < timestamp))
timestamp = source_ts;
}
item = item->next;
}
if (!timestamp) {
/* just process all pending audio actions if no audio playing,
* otherwise audio actions will just never be processed */
item = scene->first_item;
while (item) {
process_all_audio_actions(item, sample_rate);
item = item->next;
}
audio_unlock(scene);
return false;
}
item = scene->first_item;
while (item) {
uint64_t source_ts;
size_t pos, count;
bool apply_buf;
struct obs_source *source;
if (item->visible && transition_active(item->show_transition))
source = item->show_transition;
else if (!item->visible &&
transition_active(item->hide_transition))
source = item->hide_transition;
else
source = item->source;
apply_buf = apply_scene_item_volume(item, buf, timestamp,
sample_rate);
if (obs_source_audio_pending(source)) {
item = item->next;
continue;
}
source_ts = obs_source_get_audio_timestamp(source);
if (!source_ts) {
item = item->next;
continue;
}
pos = (size_t)ns_to_audio_frames(sample_rate,
source_ts - timestamp);
count = AUDIO_OUTPUT_FRAMES - pos;
if (!apply_buf && !item->visible &&
!transition_active(item->hide_transition)) {
item = item->next;
continue;
}
obs_source_get_audio_mix(source, &child_audio);
for (size_t mix = 0; mix < MAX_AUDIO_MIXES; mix++) {
if ((mixers & (1 << mix)) == 0)
continue;
for (size_t ch = 0; ch < channels; ch++) {
float *out = audio_output->output[mix].data[ch];
float *in = child_audio.output[mix].data[ch];
if (apply_buf)
mix_audio_with_buf(out, in, buf, pos,
count);
else
mix_audio(out, in, pos, count);
}
}
item = item->next;
}
*ts_out = timestamp;
audio_unlock(scene);
return true;
}
enum gs_color_space
scene_video_get_color_space(void *data, size_t count,
const enum gs_color_space *preferred_spaces)
{
UNUSED_PARAMETER(data);
UNUSED_PARAMETER(count);
UNUSED_PARAMETER(preferred_spaces);
enum gs_color_space space = GS_CS_SRGB;
struct obs_video_info ovi;
if (obs_get_video_info(&ovi)) {
switch (ovi.colorspace) {
case VIDEO_CS_2100_PQ:
case VIDEO_CS_2100_HLG:
space = GS_CS_709_EXTENDED;
}
}
return space;
}
const struct obs_source_info scene_info = {
.id = "scene",
.type = OBS_SOURCE_TYPE_SCENE,
.output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW |
OBS_SOURCE_COMPOSITE | OBS_SOURCE_DO_NOT_DUPLICATE |
OBS_SOURCE_SRGB,
.get_name = scene_getname,
.create = scene_create,
.destroy = scene_destroy,
.video_tick = scene_video_tick,
.video_render = scene_video_render,
.audio_render = scene_audio_render,
.get_width = scene_getwidth,
.get_height = scene_getheight,
.load = scene_load,
.save = scene_save,
.enum_active_sources = scene_enum_active_sources,
.enum_all_sources = scene_enum_all_sources,
.video_get_color_space = scene_video_get_color_space,
};
const struct obs_source_info group_info = {
.id = "group",
.type = OBS_SOURCE_TYPE_SCENE,
.output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW |
OBS_SOURCE_COMPOSITE | OBS_SOURCE_SRGB,
.get_name = group_getname,
.create = scene_create,
.destroy = scene_destroy,
.video_tick = scene_video_tick,
.video_render = scene_video_render,
.audio_render = scene_audio_render,
.get_width = scene_getwidth,
.get_height = scene_getheight,
.load = scene_load,
.save = scene_save,
.enum_active_sources = scene_enum_active_sources,
.enum_all_sources = scene_enum_all_sources,
.video_get_color_space = scene_video_get_color_space,
};
static inline obs_scene_t *create_id(const char *id, const char *name)
2013-09-30 19:37:13 -07:00
{
struct obs_source *source = obs_source_create(id, name, NULL, NULL);
return source->context.data;
2013-09-30 19:37:13 -07:00
}
static inline obs_scene_t *create_private_id(const char *id, const char *name)
{
struct obs_source *source = obs_source_create_private(id, name, NULL);
return source->context.data;
}
obs_scene_t *obs_scene_create(const char *name)
{
return create_id("scene", name);
}
obs_scene_t *obs_scene_create_private(const char *name)
{
return create_private_id("scene", name);
}
static obs_source_t *get_child_at_idx(obs_scene_t *scene, size_t idx)
{
struct obs_scene_item *item = scene->first_item;
while (item && idx--)
item = item->next;
return item ? item->source : NULL;
}
static inline obs_source_t *dup_child(struct darray *array, size_t idx,
obs_scene_t *new_scene, bool private)
{
DARRAY(struct obs_scene_item *) old_items;
obs_source_t *source;
old_items.da = *array;
source = old_items.array[idx]->source;
/* if the old item is referenced more than once in the old scene,
* make sure they're referenced similarly in the new scene to reduce
* load times */
for (size_t i = 0; i < idx; i++) {
struct obs_scene_item *item = old_items.array[i];
if (item->source == source) {
source = get_child_at_idx(new_scene, i);
return obs_source_get_ref(source);
}
}
return obs_source_duplicate(
source, private ? obs_source_get_name(source) : NULL, private);
}
static inline obs_source_t *new_ref(obs_source_t *source)
{
return obs_source_get_ref(source);
}
static inline void duplicate_item_data(struct obs_scene_item *dst,
struct obs_scene_item *src,
bool defer_texture_update,
bool duplicate_hotkeys,
bool duplicate_private_data)
{
struct obs_scene *dst_scene = dst->parent;
if (!src->user_visible)
set_visibility(dst, false);
dst->selected = src->selected;
dst->pos = src->pos;
dst->rot = src->rot;
dst->scale = src->scale;
dst->align = src->align;
dst->last_width = src->last_width;
dst->last_height = src->last_height;
dst->output_scale = src->output_scale;
dst->scale_filter = src->scale_filter;
dst->blend_type = src->blend_type;
dst->box_transform = src->box_transform;
dst->box_scale = src->box_scale;
dst->draw_transform = src->draw_transform;
dst->bounds_type = src->bounds_type;
dst->bounds_align = src->bounds_align;
dst->bounds = src->bounds;
if (src->show_transition) {
obs_source_t *transition = obs_source_duplicate(
src->show_transition,
obs_source_get_name(src->show_transition), true);
obs_sceneitem_set_transition(dst, true, transition);
obs_source_release(transition);
}
if (src->hide_transition) {
obs_source_t *transition = obs_source_duplicate(
src->hide_transition,
obs_source_get_name(src->hide_transition), true);
obs_sceneitem_set_transition(dst, false, transition);
obs_source_release(transition);
}
dst->show_transition_duration = src->show_transition_duration;
dst->hide_transition_duration = src->hide_transition_duration;
if (duplicate_hotkeys && !dst_scene->source->context.private) {
obs_data_array_t *data0 = NULL;
obs_data_array_t *data1 = NULL;
obs_hotkey_pair_save(src->toggle_visibility, &data0, &data1);
obs_hotkey_pair_load(dst->toggle_visibility, data0, data1);
obs_data_array_release(data0);
obs_data_array_release(data1);
}
obs_sceneitem_set_crop(dst, &src->crop);
obs_sceneitem_set_locked(dst, src->locked);
if (defer_texture_update) {
os_atomic_set_bool(&dst->update_transform, true);
}
if (duplicate_private_data) {
obs_data_apply(dst->private_settings, src->private_settings);
}
}
obs_scene_t *obs_scene_duplicate(obs_scene_t *scene, const char *name,
enum obs_scene_duplicate_type type)
{
bool make_unique = ((int)type & (1 << 0)) != 0;
bool make_private = ((int)type & (1 << 1)) != 0;
DARRAY(struct obs_scene_item *) items;
struct obs_scene *new_scene;
struct obs_scene_item *item;
struct obs_source *source;
da_init(items);
if (!obs_ptr_valid(scene, "obs_scene_duplicate"))
return NULL;
/* --------------------------------- */
full_lock(scene);
item = scene->first_item;
while (item) {
da_push_back(items, &item);
obs_sceneitem_addref(item);
item = item->next;
}
full_unlock(scene);
/* --------------------------------- */
new_scene = make_private
? create_private_id(scene->source->info.id, name)
: create_id(scene->source->info.id, name);
obs_source_copy_filters(new_scene->source, scene->source);
obs_data_apply(new_scene->source->private_settings,
scene->source->private_settings);
2018-07-15 18:58:28 -07:00
/* never duplicate sub-items for groups */
if (scene->is_group)
make_unique = false;
for (size_t i = 0; i < items.num; i++) {
item = items.array[i];
source = make_unique ? dup_child(&items.da, i, new_scene,
make_private)
: new_ref(item->source);
if (source) {
struct obs_scene_item *new_item =
obs_scene_add(new_scene, source);
if (!new_item) {
obs_source_release(source);
continue;
}
duplicate_item_data(new_item, item, false, false,
false);
obs_source_release(source);
}
}
for (size_t i = 0; i < items.num; i++)
obs_sceneitem_release(items.array[i]);
2018-07-15 18:58:28 -07:00
if (new_scene->is_group)
resize_scene(new_scene);
da_free(items);
return new_scene;
}
void obs_scene_addref(obs_scene_t *scene)
{
if (scene)
obs_source_addref(scene->source);
}
2022-01-24 13:02:39 -08:00
obs_scene_t *obs_scene_get_ref(obs_scene_t *scene)
{
if (!scene)
return NULL;
if (obs_source_get_ref(scene->source) != NULL)
return scene;
return NULL;
}
void obs_scene_release(obs_scene_t *scene)
2013-09-30 19:37:13 -07:00
{
if (scene)
obs_source_release(scene->source);
2013-09-30 19:37:13 -07:00
}
obs_source_t *obs_scene_get_source(const obs_scene_t *scene)
2013-09-30 19:37:13 -07:00
{
return scene ? scene->source : NULL;
2013-09-30 19:37:13 -07:00
}
obs_scene_t *obs_scene_from_source(const obs_source_t *source)
{
if (!source || strcmp(source->info.id, scene_info.id) != 0)
return NULL;
return source->context.data;
}
2018-07-15 18:58:28 -07:00
obs_scene_t *obs_group_from_source(const obs_source_t *source)
{
if (!source || strcmp(source->info.id, group_info.id) != 0)
2018-07-15 18:58:28 -07:00
return NULL;
return source->context.data;
}
obs_sceneitem_t *obs_scene_find_source(obs_scene_t *scene, const char *name)
{
struct obs_scene_item *item;
2014-02-23 21:39:33 -08:00
if (!scene)
return NULL;
full_lock(scene);
item = scene->first_item;
while (item) {
if (strcmp(item->source->context.name, name) == 0)
break;
item = item->next;
}
full_unlock(scene);
return item;
}
obs_sceneitem_t *obs_scene_find_source_recursive(obs_scene_t *scene,
const char *name)
{
struct obs_scene_item *item;
if (!scene)
return NULL;
full_lock(scene);
item = scene->first_item;
while (item) {
if (strcmp(item->source->context.name, name) == 0)
break;
if (item->is_group) {
obs_scene_t *group = item->source->context.data;
obs_sceneitem_t *child =
obs_scene_find_source(group, name);
if (child) {
item = child;
break;
}
}
item = item->next;
}
full_unlock(scene);
return item;
}
struct sceneitem_check {
obs_source_t *source_in;
obs_sceneitem_t *item_out;
};
bool check_sceneitem_exists(obs_scene_t *scene, obs_sceneitem_t *item,
void *vp_check)
{
UNUSED_PARAMETER(scene);
struct sceneitem_check *check = (struct sceneitem_check *)vp_check;
if (obs_sceneitem_get_source(item) == check->source_in) {
check->item_out = item;
obs_sceneitem_addref(item);
return false;
}
return true;
}
obs_sceneitem_t *obs_scene_sceneitem_from_source(obs_scene_t *scene,
obs_source_t *source)
{
struct sceneitem_check check = {source, NULL};
obs_scene_enum_items(scene, check_sceneitem_exists, (void *)&check);
return check.item_out;
}
obs_sceneitem_t *obs_scene_find_sceneitem_by_id(obs_scene_t *scene, int64_t id)
{
struct obs_scene_item *item;
if (!scene)
return NULL;
full_lock(scene);
item = scene->first_item;
while (item) {
if (item->id == id)
break;
item = item->next;
}
full_unlock(scene);
return item;
}
void obs_scene_enum_items(obs_scene_t *scene,
bool (*callback)(obs_scene_t *, obs_sceneitem_t *,
void *),
void *param)
{
struct obs_scene_item *item;
2014-02-23 21:39:33 -08:00
if (!scene || !callback)
return;
full_lock(scene);
item = scene->first_item;
while (item) {
struct obs_scene_item *next = item->next;
obs_sceneitem_addref(item);
if (!callback(scene, item, param)) {
obs_sceneitem_release(item);
break;
}
obs_sceneitem_release(item);
item = next;
}
full_unlock(scene);
}
2015-05-08 18:33:55 -07:00
static obs_sceneitem_t *sceneitem_get_ref(obs_sceneitem_t *si)
{
long owners = os_atomic_load_long(&si->ref);
2015-05-08 18:33:55 -07:00
while (owners > 0) {
if (os_atomic_compare_exchange_long(&si->ref, &owners,
owners + 1)) {
2015-05-08 18:33:55 -07:00
return si;
}
2015-05-08 18:33:55 -07:00
}
return NULL;
}
static bool hotkey_show_sceneitem(void *data, obs_hotkey_pair_id id,
obs_hotkey_t *hotkey, bool pressed)
2015-05-08 18:33:55 -07:00
{
UNUSED_PARAMETER(id);
UNUSED_PARAMETER(hotkey);
obs_sceneitem_t *si = sceneitem_get_ref(data);
if (pressed && si && !si->user_visible) {
2015-05-08 18:33:55 -07:00
obs_sceneitem_set_visible(si, true);
obs_sceneitem_release(si);
return true;
}
obs_sceneitem_release(si);
return false;
}
static bool hotkey_hide_sceneitem(void *data, obs_hotkey_pair_id id,
obs_hotkey_t *hotkey, bool pressed)
2015-05-08 18:33:55 -07:00
{
UNUSED_PARAMETER(id);
UNUSED_PARAMETER(hotkey);
obs_sceneitem_t *si = sceneitem_get_ref(data);
if (pressed && si && si->user_visible) {
2015-05-08 18:33:55 -07:00
obs_sceneitem_set_visible(si, false);
obs_sceneitem_release(si);
return true;
}
obs_sceneitem_release(si);
return false;
}
static void init_hotkeys(obs_scene_t *scene, obs_sceneitem_t *item,
const char *name)
2015-05-08 18:33:55 -07:00
{
struct dstr show = {0};
struct dstr hide = {0};
struct dstr show_desc = {0};
struct dstr hide_desc = {0};
dstr_copy(&show, "libobs.show_scene_item.%1");
dstr_replace(&show, "%1", name);
dstr_copy(&hide, "libobs.hide_scene_item.%1");
dstr_replace(&hide, "%1", name);
dstr_copy(&show_desc, obs->hotkeys.sceneitem_show);
dstr_replace(&show_desc, "%1", name);
dstr_copy(&hide_desc, obs->hotkeys.sceneitem_hide);
dstr_replace(&hide_desc, "%1", name);
item->toggle_visibility = obs_hotkey_pair_register_source(
scene->source, show.array, show_desc.array, hide.array,
hide_desc.array, hotkey_show_sceneitem, hotkey_hide_sceneitem,
item, item);
2015-05-08 18:33:55 -07:00
dstr_free(&show);
dstr_free(&hide);
dstr_free(&show_desc);
dstr_free(&hide_desc);
}
static void sceneitem_rename_hotkey(const obs_sceneitem_t *scene_item,
const char *new_name)
{
struct dstr show = {0};
struct dstr hide = {0};
struct dstr show_desc = {0};
struct dstr hide_desc = {0};
dstr_copy(&show, "libobs.show_scene_item.%1");
dstr_replace(&show, "%1", new_name);
dstr_copy(&hide, "libobs.hide_scene_item.%1");
dstr_replace(&hide, "%1", new_name);
obs_hotkey_pair_set_names(scene_item->toggle_visibility, show.array,
hide.array);
dstr_copy(&show_desc, obs->hotkeys.sceneitem_show);
dstr_replace(&show_desc, "%1", new_name);
dstr_copy(&hide_desc, obs->hotkeys.sceneitem_hide);
dstr_replace(&hide_desc, "%1", new_name);
obs_hotkey_pair_set_descriptions(scene_item->toggle_visibility,
show_desc.array, hide_desc.array);
dstr_free(&show);
dstr_free(&hide);
dstr_free(&show_desc);
dstr_free(&hide_desc);
}
static void sceneitem_renamed(void *param, calldata_t *data)
{
obs_sceneitem_t *scene_item = param;
const char *name = calldata_string(data, "new_name");
sceneitem_rename_hotkey(scene_item, name);
}
static inline bool source_has_audio(obs_source_t *source)
{
return (source->info.output_flags &
(OBS_SOURCE_AUDIO | OBS_SOURCE_COMPOSITE)) != 0;
}
static obs_sceneitem_t *obs_scene_add_internal(obs_scene_t *scene,
obs_source_t *source,
2022-07-19 23:07:04 -07:00
obs_sceneitem_t *insert_after)
2013-09-30 19:37:13 -07:00
{
struct obs_scene_item *last;
struct obs_scene_item *item;
pthread_mutex_t mutex;
struct item_action action = {.visible = true,
.timestamp = os_gettime_ns()};
if (!scene)
return NULL;
source = obs_source_get_ref(source);
if (!source) {
blog(LOG_ERROR, "Tried to add a NULL source to a scene");
return NULL;
}
if (source->removed) {
blog(LOG_WARNING, "Tried to add a removed source to a scene");
goto release_source_and_fail;
}
if (pthread_mutex_init(&mutex, NULL) != 0) {
blog(LOG_WARNING, "Failed to create scene item mutex");
goto release_source_and_fail;
}
if (!obs_source_add_active_child(scene->source, source)) {
blog(LOG_WARNING, "Failed to add source to scene due to "
"infinite source recursion");
pthread_mutex_destroy(&mutex);
goto release_source_and_fail;
}
item = bzalloc(sizeof(struct obs_scene_item));
item->source = source;
item->id = ++scene->id_counter;
item->parent = scene;
item->ref = 1;
item->align = OBS_ALIGN_TOP | OBS_ALIGN_LEFT;
item->actions_mutex = mutex;
item->user_visible = true;
item->locked = false;
item->is_group = strcmp(source->info.id, group_info.id) == 0;
item->private_settings = obs_data_create();
item->toggle_visibility = OBS_INVALID_HOTKEY_PAIR_ID;
os_atomic_set_long(&item->active_refs, 1);
2013-09-30 19:37:13 -07:00
vec2_set(&item->scale, 1.0f, 1.0f);
matrix4_identity(&item->draw_transform);
matrix4_identity(&item->box_transform);
2013-09-30 19:37:13 -07:00
if (source_has_audio(source)) {
item->visible = false;
da_push_back(item->audio_actions, &action);
} else {
item->visible = true;
}
full_lock(scene);
if (insert_after) {
obs_sceneitem_t *next = insert_after->next;
if (next)
next->prev = item;
item->next = insert_after->next;
item->prev = insert_after;
insert_after->next = item;
} else {
last = scene->first_item;
if (!last) {
scene->first_item = item;
} else {
while (last->next)
last = last->next;
last->next = item;
item->prev = last;
}
}
full_unlock(scene);
if (!scene->source->context.private)
init_hotkeys(scene, item, obs_source_get_name(source));
2015-05-08 18:33:55 -07:00
signal_handler_connect(obs_source_get_signal_handler(source), "rename",
sceneitem_renamed, item);
return item;
release_source_and_fail:
obs_source_release(source);
return NULL;
}
obs_sceneitem_t *obs_scene_add(obs_scene_t *scene, obs_source_t *source)
{
2022-07-19 23:07:04 -07:00
obs_sceneitem_t *item = obs_scene_add_internal(scene, source, NULL);
struct calldata params;
uint8_t stack[128];
if (!item)
return NULL;
calldata_init_fixed(&params, stack, sizeof(stack));
calldata_set_ptr(&params, "scene", scene);
calldata_set_ptr(&params, "item", item);
signal_handler_signal(scene->source->context.signals, "item_add",
&params);
2013-09-30 19:37:13 -07:00
return item;
}
static void obs_sceneitem_destroy(obs_sceneitem_t *item)
2013-09-30 19:37:13 -07:00
{
if (item) {
if (item->item_render) {
obs_enter_graphics();
gs_texrender_destroy(item->item_render);
obs_leave_graphics();
}
obs_data_release(item->private_settings);
2015-05-08 18:33:55 -07:00
obs_hotkey_pair_unregister(item->toggle_visibility);
pthread_mutex_destroy(&item->actions_mutex);
signal_handler_disconnect(
obs_source_get_signal_handler(item->source), "rename",
sceneitem_renamed, item);
if (item->show_transition)
obs_source_release(item->show_transition);
if (item->hide_transition)
obs_source_release(item->hide_transition);
if (item->source)
obs_source_release(item->source);
da_free(item->audio_actions);
2013-09-30 19:37:13 -07:00
bfree(item);
}
}
void obs_sceneitem_addref(obs_sceneitem_t *item)
{
if (item)
os_atomic_inc_long(&item->ref);
}
void obs_sceneitem_release(obs_sceneitem_t *item)
{
if (!item)
return;
if (os_atomic_dec_long(&item->ref) == 0)
obs_sceneitem_destroy(item);
}
void obs_sceneitem_remove(obs_sceneitem_t *item)
{
obs_scene_t *scene;
if (!item)
return;
scene = item->parent;
full_lock(scene);
if (item->removed) {
if (scene)
full_unlock(scene);
return;
}
item->removed = true;
assert(scene != NULL);
assert(scene->source != NULL);
set_visibility(item, false);
signal_item_remove(item);
detach_sceneitem(item);
full_unlock(scene);
obs_sceneitem_set_transition(item, true, NULL);
obs_sceneitem_set_transition(item, false, NULL);
obs_sceneitem_release(item);
}
void obs_sceneitem_save(obs_sceneitem_t *item, obs_data_array_t *arr)
{
scene_save_item(arr, item, NULL);
}
void sceneitem_restore(obs_data_t *data, void *vp)
{
obs_scene_t *scene = (obs_scene_t *)vp;
scene_load_item(scene, data);
}
void obs_sceneitems_add(obs_scene_t *scene, obs_data_array_t *data)
{
obs_data_array_enum(data, sceneitem_restore, scene);
}
obs_scene_t *obs_sceneitem_get_scene(const obs_sceneitem_t *item)
{
2014-02-23 21:39:33 -08:00
return item ? item->parent : NULL;
}
obs_source_t *obs_sceneitem_get_source(const obs_sceneitem_t *item)
{
2014-02-23 21:39:33 -08:00
return item ? item->source : NULL;
2013-09-30 19:37:13 -07:00
}
static void signal_parent(obs_scene_t *parent, const char *command,
calldata_t *params)
{
calldata_set_ptr(params, "scene", parent);
signal_handler_signal(parent->source->context.signals, command, params);
}
struct passthrough {
obs_data_array_t *ids;
obs_data_array_t *scenes_and_groups;
bool all_items;
};
bool save_transform_states(obs_scene_t *scene, obs_sceneitem_t *item,
void *vp_pass)
{
struct passthrough *pass = (struct passthrough *)vp_pass;
if (obs_sceneitem_selected(item) || pass->all_items) {
obs_data_t *temp = obs_data_create();
obs_data_array_t *item_ids = (obs_data_array_t *)pass->ids;
struct obs_transform_info info;
struct obs_sceneitem_crop crop;
obs_sceneitem_get_info(item, &info);
obs_sceneitem_get_crop(item, &crop);
struct vec2 pos = info.pos;
struct vec2 scale = info.scale;
float rot = info.rot;
uint32_t alignment = info.alignment;
uint32_t bounds_type = info.bounds_type;
uint32_t bounds_alignment = info.bounds_alignment;
struct vec2 bounds = info.bounds;
obs_data_set_int(temp, "id", obs_sceneitem_get_id(item));
obs_data_set_vec2(temp, "pos", &pos);
obs_data_set_vec2(temp, "scale", &scale);
obs_data_set_double(temp, "rot", rot);
obs_data_set_int(temp, "alignment", alignment);
obs_data_set_int(temp, "bounds_type", bounds_type);
obs_data_set_vec2(temp, "bounds", &bounds);
obs_data_set_int(temp, "bounds_alignment", bounds_alignment);
obs_data_set_int(temp, "top", crop.top);
obs_data_set_int(temp, "bottom", crop.bottom);
obs_data_set_int(temp, "left", crop.left);
obs_data_set_int(temp, "right", crop.right);
obs_data_array_push_back(item_ids, temp);
obs_data_release(temp);
}
obs_source_t *item_source = obs_sceneitem_get_source(item);
if (obs_source_is_group(item_source)) {
obs_data_t *temp = obs_data_create();
obs_data_array_t *nids = obs_data_array_create();
obs_data_set_string(temp, "scene_name",
obs_source_get_name(item_source));
obs_data_set_bool(temp, "is_group", true);
obs_data_set_string(
temp, "group_parent",
obs_source_get_name(obs_scene_get_source(scene)));
struct passthrough npass = {nids, pass->scenes_and_groups,
pass->all_items};
obs_sceneitem_group_enum_items(item, save_transform_states,
(void *)&npass);
obs_data_set_array(temp, "items", nids);
obs_data_array_push_back(pass->scenes_and_groups, temp);
obs_data_release(temp);
obs_data_array_release(nids);
}
return true;
}
obs_data_t *obs_scene_save_transform_states(obs_scene_t *scene, bool all_items)
{
obs_data_t *wrapper = obs_data_create();
obs_data_array_t *scenes_and_groups = obs_data_array_create();
obs_data_array_t *item_ids = obs_data_array_create();
struct passthrough pass = {item_ids, scenes_and_groups, all_items};
obs_data_t *temp = obs_data_create();
obs_data_set_string(temp, "scene_name",
obs_source_get_name(obs_scene_get_source(scene)));
obs_data_set_bool(temp, "is_group", false);
obs_scene_enum_items(scene, save_transform_states, (void *)&pass);
obs_data_set_array(temp, "items", item_ids);
obs_data_array_push_back(scenes_and_groups, temp);
obs_data_set_array(wrapper, "scenes_and_groups", scenes_and_groups);
obs_data_array_release(item_ids);
obs_data_array_release(scenes_and_groups);
obs_data_release(temp);
return wrapper;
}
void load_transform_states(obs_data_t *temp, void *vp_scene)
{
obs_scene_t *scene = (obs_scene_t *)vp_scene;
int64_t id = obs_data_get_int(temp, "id");
obs_sceneitem_t *item = obs_scene_find_sceneitem_by_id(scene, id);
struct obs_transform_info info;
struct obs_sceneitem_crop crop;
obs_data_get_vec2(temp, "pos", &info.pos);
obs_data_get_vec2(temp, "scale", &info.scale);
info.rot = (float)obs_data_get_double(temp, "rot");
info.alignment = (uint32_t)obs_data_get_int(temp, "alignment");
info.bounds_type =
(enum obs_bounds_type)obs_data_get_int(temp, "bounds_type");
info.bounds_alignment =
(uint32_t)obs_data_get_int(temp, "bounds_alignment");
obs_data_get_vec2(temp, "bounds", &info.bounds);
crop.top = (int)obs_data_get_int(temp, "top");
crop.bottom = (int)obs_data_get_int(temp, "bottom");
crop.left = (int)obs_data_get_int(temp, "left");
crop.right = (int)obs_data_get_int(temp, "right");
obs_sceneitem_defer_update_begin(item);
obs_sceneitem_set_info(item, &info);
obs_sceneitem_set_crop(item, &crop);
obs_sceneitem_defer_update_end(item);
}
void iterate_scenes_and_groups_transform_states(obs_data_t *data, void *vp)
{
obs_data_array_t *items = obs_data_get_array(data, "items");
obs_source_t *scene_source =
obs_get_source_by_name(obs_data_get_string(data, "scene_name"));
obs_scene_t *scene = obs_scene_from_source(scene_source);
if (obs_data_get_bool(data, "is_group")) {
obs_source_t *parent_source = obs_get_source_by_name(
obs_data_get_string(data, "group_parent"));
obs_scene_t *parent = obs_scene_from_source(parent_source);
obs_sceneitem_t *group = obs_scene_get_group(
parent, obs_data_get_string(data, "scene_name"));
scene = obs_sceneitem_group_get_scene(group);
obs_source_release(parent_source);
}
obs_data_array_enum(items, load_transform_states, (void *)scene);
UNUSED_PARAMETER(vp);
obs_data_array_release(items);
obs_source_release(scene_source);
}
void obs_scene_load_transform_states(const char *data)
{
obs_data_t *dat = obs_data_create_from_json(data);
obs_data_array_t *scenes_and_groups =
obs_data_get_array(dat, "scenes_and_groups");
obs_data_array_enum(scenes_and_groups,
iterate_scenes_and_groups_transform_states, NULL);
obs_data_release(dat);
obs_data_array_release(scenes_and_groups);
}
void obs_sceneitem_select(obs_sceneitem_t *item, bool select)
{
struct calldata params;
uint8_t stack[128];
const char *command = select ? "item_select" : "item_deselect";
if (!item || item->selected == select || !item->parent)
return;
item->selected = select;
calldata_init_fixed(&params, stack, sizeof(stack));
calldata_set_ptr(&params, "item", item);
signal_parent(item->parent, command, &params);
}
bool obs_sceneitem_selected(const obs_sceneitem_t *item)
{
return item ? item->selected : false;
}
#define do_update_transform(item) \
do { \
if (!item->parent || item->parent->is_group) \
os_atomic_set_bool(&item->update_transform, true); \
else \
update_item_transform(item, false); \
} while (false)
void obs_sceneitem_set_pos(obs_sceneitem_t *item, const struct vec2 *pos)
2013-09-30 19:37:13 -07:00
{
if (item) {
2014-02-23 21:39:33 -08:00
vec2_copy(&item->pos, pos);
do_update_transform(item);
}
2013-09-30 19:37:13 -07:00
}
void obs_sceneitem_set_rot(obs_sceneitem_t *item, float rot)
2013-09-30 19:37:13 -07:00
{
if (item) {
2014-02-23 21:39:33 -08:00
item->rot = rot;
do_update_transform(item);
}
2013-09-30 19:37:13 -07:00
}
void obs_sceneitem_set_scale(obs_sceneitem_t *item, const struct vec2 *scale)
2013-09-30 19:37:13 -07:00
{
if (item) {
vec2_copy(&item->scale, scale);
do_update_transform(item);
}
2013-09-30 19:37:13 -07:00
}
void obs_sceneitem_set_alignment(obs_sceneitem_t *item, uint32_t alignment)
2013-09-30 19:37:13 -07:00
{
if (item) {
item->align = alignment;
do_update_transform(item);
}
2013-09-30 19:37:13 -07:00
}
static inline void signal_reorder(struct obs_scene_item *item)
2014-05-15 17:40:53 -07:00
{
const char *command = NULL;
struct calldata params;
uint8_t stack[128];
2014-05-15 17:40:53 -07:00
command = "reorder";
2014-05-15 17:40:53 -07:00
calldata_init_fixed(&params, stack, sizeof(stack));
signal_parent(item->parent, command, &params);
2014-05-15 17:40:53 -07:00
}
static inline void signal_refresh(obs_scene_t *scene)
{
const char *command = NULL;
struct calldata params;
uint8_t stack[128];
command = "refresh";
calldata_init_fixed(&params, stack, sizeof(stack));
signal_parent(scene, command, &params);
}
void obs_sceneitem_set_order(obs_sceneitem_t *item,
enum obs_order_movement movement)
2013-09-30 19:37:13 -07:00
{
if (!item)
return;
2014-02-23 21:39:33 -08:00
2014-05-15 17:40:53 -07:00
struct obs_scene_item *next, *prev;
struct obs_scene *scene = obs_scene_get_ref(item->parent);
if (!scene)
return;
2013-09-30 19:37:13 -07:00
full_lock(scene);
2014-05-15 17:40:53 -07:00
next = item->next;
prev = item->prev;
detach_sceneitem(item);
if (movement == OBS_ORDER_MOVE_DOWN) {
2014-05-15 17:40:53 -07:00
attach_sceneitem(scene, item, prev ? prev->prev : NULL);
2013-09-30 19:37:13 -07:00
} else if (movement == OBS_ORDER_MOVE_UP) {
2014-05-15 17:40:53 -07:00
attach_sceneitem(scene, item, next ? next : prev);
2013-09-30 19:37:13 -07:00
} else if (movement == OBS_ORDER_MOVE_TOP) {
2014-05-15 17:40:53 -07:00
struct obs_scene_item *last = next;
if (!last) {
2014-05-15 17:40:53 -07:00
last = prev;
} else {
while (last->next)
last = last->next;
}
2013-09-30 19:37:13 -07:00
2014-05-15 17:40:53 -07:00
attach_sceneitem(scene, item, last);
} else if (movement == OBS_ORDER_MOVE_BOTTOM) {
2014-05-15 17:40:53 -07:00
attach_sceneitem(scene, item, NULL);
2013-09-30 19:37:13 -07:00
}
full_unlock(scene);
signal_reorder(item);
obs_scene_release(scene);
2013-09-30 19:37:13 -07:00
}
int obs_sceneitem_get_order_position(obs_sceneitem_t *item)
{
struct obs_scene *scene = item->parent;
struct obs_scene_item *next = scene->first_item;
full_lock(scene);
int index = 0;
while (next && next != item) {
next = next->next;
++index;
}
full_unlock(scene);
return index;
}
void obs_sceneitem_set_order_position(obs_sceneitem_t *item, int position)
{
if (!item)
return;
struct obs_scene *scene = obs_scene_get_ref(item->parent);
struct obs_scene_item *next;
if (!scene)
return;
full_lock(scene);
detach_sceneitem(item);
next = scene->first_item;
if (position == 0) {
attach_sceneitem(scene, item, NULL);
} else {
for (int i = position; i > 1; --i) {
if (next->next == NULL)
break;
next = next->next;
}
attach_sceneitem(scene, item, next);
}
full_unlock(scene);
signal_reorder(item);
obs_scene_release(scene);
}
void obs_sceneitem_set_bounds_type(obs_sceneitem_t *item,
enum obs_bounds_type type)
{
if (item) {
item->bounds_type = type;
do_update_transform(item);
}
}
void obs_sceneitem_set_bounds_alignment(obs_sceneitem_t *item,
uint32_t alignment)
{
if (item) {
item->bounds_align = alignment;
do_update_transform(item);
}
}
void obs_sceneitem_set_bounds(obs_sceneitem_t *item, const struct vec2 *bounds)
{
if (item) {
item->bounds = *bounds;
do_update_transform(item);
}
}
void obs_sceneitem_get_pos(const obs_sceneitem_t *item, struct vec2 *pos)
2013-09-30 19:37:13 -07:00
{
2014-02-23 21:39:33 -08:00
if (item)
vec2_copy(pos, &item->pos);
2013-09-30 19:37:13 -07:00
}
float obs_sceneitem_get_rot(const obs_sceneitem_t *item)
2013-09-30 19:37:13 -07:00
{
2014-02-23 21:39:33 -08:00
return item ? item->rot : 0.0f;
2013-09-30 19:37:13 -07:00
}
void obs_sceneitem_get_scale(const obs_sceneitem_t *item, struct vec2 *scale)
2013-09-30 19:37:13 -07:00
{
2014-02-23 21:39:33 -08:00
if (item)
vec2_copy(scale, &item->scale);
2013-09-30 19:37:13 -07:00
}
uint32_t obs_sceneitem_get_alignment(const obs_sceneitem_t *item)
{
return item ? item->align : 0;
}
enum obs_bounds_type obs_sceneitem_get_bounds_type(const obs_sceneitem_t *item)
{
return item ? item->bounds_type : OBS_BOUNDS_NONE;
}
uint32_t obs_sceneitem_get_bounds_alignment(const obs_sceneitem_t *item)
{
return item ? item->bounds_align : 0;
}
void obs_sceneitem_get_bounds(const obs_sceneitem_t *item, struct vec2 *bounds)
2013-09-30 19:37:13 -07:00
{
2014-02-23 21:39:33 -08:00
if (item)
*bounds = item->bounds;
}
void obs_sceneitem_get_info(const obs_sceneitem_t *item,
struct obs_transform_info *info)
{
if (item && info) {
info->pos = item->pos;
info->rot = item->rot;
info->scale = item->scale;
info->alignment = item->align;
info->bounds_type = item->bounds_type;
info->bounds_alignment = item->bounds_align;
info->bounds = item->bounds;
}
}
void obs_sceneitem_set_info(obs_sceneitem_t *item,
const struct obs_transform_info *info)
{
if (item && info) {
item->pos = info->pos;
item->rot = info->rot;
item->scale = info->scale;
item->align = info->alignment;
item->bounds_type = info->bounds_type;
item->bounds_align = info->bounds_alignment;
item->bounds = info->bounds;
do_update_transform(item);
}
}
void obs_sceneitem_get_draw_transform(const obs_sceneitem_t *item,
struct matrix4 *transform)
{
if (item)
matrix4_copy(transform, &item->draw_transform);
}
void obs_sceneitem_get_box_transform(const obs_sceneitem_t *item,
struct matrix4 *transform)
{
if (item)
matrix4_copy(transform, &item->box_transform);
2013-09-30 19:37:13 -07:00
}
void obs_sceneitem_get_box_scale(const obs_sceneitem_t *item,
struct vec2 *scale)
{
if (item)
*scale = item->box_scale;
}
bool obs_sceneitem_visible(const obs_sceneitem_t *item)
{
return item ? item->user_visible : false;
}
static bool group_item_transition(obs_scene_t *scene, obs_sceneitem_t *item,
void *param)
{
if (!param || !item)
return true;
const bool visible = *(bool *)param;
if (obs_sceneitem_visible(item))
obs_sceneitem_do_transition(item, visible);
UNUSED_PARAMETER(scene);
return true;
}
bool obs_sceneitem_set_visible(obs_sceneitem_t *item, bool visible)
{
struct calldata cd;
uint8_t stack[256];
struct item_action action = {.visible = visible,
.timestamp = os_gettime_ns()};
if (!item)
return false;
if (item->user_visible == visible)
return false;
if (!item->parent)
return false;
obs_sceneitem_do_transition(item, visible);
if (obs_sceneitem_is_group(item))
obs_sceneitem_group_enum_items(item, group_item_transition,
&visible);
item->user_visible = visible;
if (visible) {
if (os_atomic_inc_long(&item->active_refs) == 1) {
if (!obs_source_add_active_child(item->parent->source,
item->source)) {
os_atomic_dec_long(&item->active_refs);
return false;
}
}
}
calldata_init_fixed(&cd, stack, sizeof(stack));
calldata_set_ptr(&cd, "item", item);
calldata_set_bool(&cd, "visible", visible);
signal_parent(item->parent, "item_visible", &cd);
if (source_has_audio(item->source)) {
pthread_mutex_lock(&item->actions_mutex);
da_push_back(item->audio_actions, &action);
pthread_mutex_unlock(&item->actions_mutex);
} else {
set_visibility(item, visible);
}
return true;
}
2015-06-26 19:18:13 -07:00
bool obs_sceneitem_locked(const obs_sceneitem_t *item)
{
return item ? item->locked : false;
}
bool obs_sceneitem_set_locked(obs_sceneitem_t *item, bool lock)
{
struct calldata cd;
uint8_t stack[256];
if (!item)
return false;
if (item->locked == lock)
return false;
if (!item->parent)
return false;
item->locked = lock;
calldata_init_fixed(&cd, stack, sizeof(stack));
calldata_set_ptr(&cd, "item", item);
calldata_set_bool(&cd, "locked", lock);
signal_parent(item->parent, "item_locked", &cd);
return true;
}
static bool sceneitems_match(obs_scene_t *scene, obs_sceneitem_t *const *items,
size_t size, bool *order_matches)
2015-06-26 18:47:46 -07:00
{
obs_sceneitem_t *item = scene->first_item;
size_t count = 0;
while (item) {
bool found = false;
for (size_t i = 0; i < size; i++) {
if (items[i] != item)
continue;
if (count != i)
*order_matches = false;
found = true;
break;
}
if (!found)
return false;
item = item->next;
count += 1;
}
return count == size;
}
bool obs_scene_reorder_items(obs_scene_t *scene,
obs_sceneitem_t *const *item_order,
size_t item_order_size)
2015-06-26 18:47:46 -07:00
{
if (!scene || !item_order_size)
return false;
scene = obs_scene_get_ref(scene);
if (!scene)
return false;
full_lock(scene);
2015-06-26 18:47:46 -07:00
bool order_matches = true;
if (!sceneitems_match(scene, item_order, item_order_size,
&order_matches) ||
order_matches) {
full_unlock(scene);
2015-06-26 18:47:46 -07:00
obs_scene_release(scene);
return false;
}
scene->first_item = item_order[0];
obs_sceneitem_t *prev = NULL;
for (size_t i = 0; i < item_order_size; i++) {
item_order[i]->prev = prev;
item_order[i]->next = NULL;
if (prev)
prev->next = item_order[i];
prev = item_order[i];
}
full_unlock(scene);
signal_reorder(scene->first_item);
2015-06-26 18:47:46 -07:00
obs_scene_release(scene);
return true;
}
2015-06-26 19:18:13 -07:00
void obs_scene_atomic_update(obs_scene_t *scene,
obs_scene_atomic_update_func func, void *data)
2015-06-26 19:18:13 -07:00
{
if (!scene)
return;
scene = obs_scene_get_ref(scene);
if (!scene)
return;
full_lock(scene);
2015-06-26 19:18:13 -07:00
func(data, scene);
full_unlock(scene);
2015-06-26 19:18:13 -07:00
obs_scene_release(scene);
}
static inline bool crop_equal(const struct obs_sceneitem_crop *crop1,
const struct obs_sceneitem_crop *crop2)
{
return crop1->left == crop2->left && crop1->right == crop2->right &&
crop1->top == crop2->top && crop1->bottom == crop2->bottom;
}
void obs_sceneitem_set_crop(obs_sceneitem_t *item,
const struct obs_sceneitem_crop *crop)
{
if (!obs_ptr_valid(item, "obs_sceneitem_set_crop"))
return;
if (!obs_ptr_valid(crop, "obs_sceneitem_set_crop"))
return;
if (crop_equal(crop, &item->crop))
return;
memcpy(&item->crop, crop, sizeof(*crop));
if (item->crop.left < 0)
item->crop.left = 0;
if (item->crop.right < 0)
item->crop.right = 0;
if (item->crop.top < 0)
item->crop.top = 0;
if (item->crop.bottom < 0)
item->crop.bottom = 0;
os_atomic_set_bool(&item->update_transform, true);
}
void obs_sceneitem_get_crop(const obs_sceneitem_t *item,
struct obs_sceneitem_crop *crop)
{
if (!obs_ptr_valid(item, "obs_sceneitem_get_crop"))
return;
if (!obs_ptr_valid(crop, "obs_sceneitem_get_crop"))
return;
memcpy(crop, &item->crop, sizeof(*crop));
}
void obs_sceneitem_set_scale_filter(obs_sceneitem_t *item,
enum obs_scale_type filter)
{
if (!obs_ptr_valid(item, "obs_sceneitem_set_scale_filter"))
return;
item->scale_filter = filter;
os_atomic_set_bool(&item->update_transform, true);
}
enum obs_scale_type obs_sceneitem_get_scale_filter(obs_sceneitem_t *item)
{
return obs_ptr_valid(item, "obs_sceneitem_get_scale_filter")
? item->scale_filter
: OBS_SCALE_DISABLE;
}
void obs_sceneitem_set_blending_method(obs_sceneitem_t *item,
enum obs_blending_method method)
{
if (!obs_ptr_valid(item, "obs_sceneitem_set_blending_method"))
return;
item->blend_method = method;
}
enum obs_blending_method
obs_sceneitem_get_blending_method(obs_sceneitem_t *item)
{
return obs_ptr_valid(item, "obs_sceneitem_get_blending_method")
? item->blend_method
: OBS_BLEND_METHOD_DEFAULT;
}
void obs_sceneitem_set_blending_mode(obs_sceneitem_t *item,
enum obs_blending_type type)
{
if (!obs_ptr_valid(item, "obs_sceneitem_set_blending_mode"))
return;
item->blend_type = type;
os_atomic_set_bool(&item->update_transform, true);
}
enum obs_blending_type obs_sceneitem_get_blending_mode(obs_sceneitem_t *item)
{
return obs_ptr_valid(item, "obs_sceneitem_get_blending_mode")
? item->blend_type
: OBS_BLEND_NORMAL;
}
void obs_sceneitem_defer_update_begin(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_defer_update_begin"))
return;
os_atomic_inc_long(&item->defer_update);
}
void obs_sceneitem_defer_update_end(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_defer_update_end"))
return;
if (os_atomic_dec_long(&item->defer_update) == 0)
do_update_transform(item);
}
void obs_sceneitem_defer_group_resize_begin(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_defer_group_resize_begin"))
return;
os_atomic_inc_long(&item->defer_group_resize);
}
void obs_sceneitem_defer_group_resize_end(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_defer_group_resize_end"))
return;
if (os_atomic_dec_long(&item->defer_group_resize) == 0)
os_atomic_set_bool(&item->update_group_resize, true);
}
int64_t obs_sceneitem_get_id(const obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_get_id"))
return 0;
return item->id;
}
void obs_sceneitem_set_id(obs_sceneitem_t *item, int64_t id)
{
item->id = id;
}
obs_data_t *obs_sceneitem_get_private_settings(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_get_private_settings"))
return NULL;
obs_data_addref(item->private_settings);
return item->private_settings;
}
static inline void transform_val(struct vec2 *v2, struct matrix4 *transform)
{
struct vec3 v;
vec3_set(&v, v2->x, v2->y, 0.0f);
vec3_transform(&v, &v, transform);
v2->x = v.x;
v2->y = v.y;
}
static void get_ungrouped_transform(obs_sceneitem_t *group, struct vec2 *pos,
struct vec2 *scale, float *rot)
{
struct matrix4 transform;
struct matrix4 mat;
struct vec4 x_base;
vec4_set(&x_base, 1.0f, 0.0f, 0.0f, 0.0f);
matrix4_copy(&transform, &group->draw_transform);
transform_val(pos, &transform);
vec4_set(&transform.t, 0.0f, 0.0f, 0.0f, 1.0f);
vec4_set(&mat.x, scale->x, 0.0f, 0.0f, 0.0f);
vec4_set(&mat.y, 0.0f, scale->y, 0.0f, 0.0f);
vec4_set(&mat.z, 0.0f, 0.0f, 1.0f, 0.0f);
vec4_set(&mat.t, 0.0f, 0.0f, 0.0f, 1.0f);
matrix4_mul(&mat, &mat, &transform);
scale->x = vec4_len(&mat.x) * (scale->x > 0.0f ? 1.0f : -1.0f);
scale->y = vec4_len(&mat.y) * (scale->y > 0.0f ? 1.0f : -1.0f);
*rot += group->rot;
}
static void remove_group_transform(obs_sceneitem_t *group,
obs_sceneitem_t *item)
{
obs_scene_t *parent = item->parent;
if (!parent || !group)
return;
get_ungrouped_transform(group, &item->pos, &item->scale, &item->rot);
update_item_transform(item, false);
}
static void apply_group_transform(obs_sceneitem_t *item, obs_sceneitem_t *group)
{
struct matrix4 transform;
struct matrix4 mat;
struct vec4 x_base;
vec4_set(&x_base, 1.0f, 0.0f, 0.0f, 0.0f);
matrix4_inv(&transform, &group->draw_transform);
transform_val(&item->pos, &transform);
vec4_set(&transform.t, 0.0f, 0.0f, 0.0f, 1.0f);
vec4_set(&mat.x, item->scale.x, 0.0f, 0.0f, 0.0f);
vec4_set(&mat.y, 0.0f, item->scale.y, 0.0f, 0.0f);
vec4_set(&mat.z, 0.0f, 0.0f, 1.0f, 0.0f);
vec4_set(&mat.t, 0.0f, 0.0f, 0.0f, 1.0f);
matrix4_mul(&mat, &mat, &transform);
item->scale.x =
vec4_len(&mat.x) * (item->scale.x > 0.0f ? 1.0f : -1.0f);
item->scale.y =
vec4_len(&mat.y) * (item->scale.y > 0.0f ? 1.0f : -1.0f);
item->rot -= group->rot;
update_item_transform(item, false);
}
static bool resize_scene_base(obs_scene_t *scene, struct vec2 *minv,
struct vec2 *maxv, struct vec2 *scale)
{
vec2_set(minv, M_INFINITE, M_INFINITE);
vec2_set(maxv, -M_INFINITE, -M_INFINITE);
obs_sceneitem_t *item = scene->first_item;
if (!item) {
scene->cx = 0;
scene->cy = 0;
return false;
}
while (item) {
#define get_min_max(x_val, y_val) \
do { \
struct vec3 v; \
vec3_set(&v, x_val, y_val, 0.0f); \
vec3_transform(&v, &v, &item->box_transform); \
if (v.x < minv->x) \
minv->x = v.x; \
if (v.y < minv->y) \
minv->y = v.y; \
if (v.x > maxv->x) \
maxv->x = v.x; \
if (v.y > maxv->y) \
maxv->y = v.y; \
} while (false)
get_min_max(0.0f, 0.0f);
get_min_max(1.0f, 0.0f);
get_min_max(0.0f, 1.0f);
get_min_max(1.0f, 1.0f);
#undef get_min_max
item = item->next;
}
item = scene->first_item;
while (item) {
vec2_sub(&item->pos, &item->pos, minv);
update_item_transform(item, false);
item = item->next;
}
vec2_sub(scale, maxv, minv);
scene->cx = (uint32_t)ceilf(scale->x);
scene->cy = (uint32_t)ceilf(scale->y);
return true;
}
static void resize_scene(obs_scene_t *scene)
{
struct vec2 minv;
struct vec2 maxv;
struct vec2 scale;
resize_scene_base(scene, &minv, &maxv, &scale);
}
/* assumes group scene and parent scene is locked */
static void resize_group(obs_sceneitem_t *group)
{
obs_scene_t *scene = group->source->context.data;
struct vec2 minv;
struct vec2 maxv;
struct vec2 scale;
if (os_atomic_load_long(&group->defer_group_resize) > 0)
return;
if (!resize_scene_base(scene, &minv, &maxv, &scale))
return;
if (group->bounds_type == OBS_BOUNDS_NONE) {
struct vec2 new_pos;
if ((group->align & OBS_ALIGN_LEFT) != 0)
new_pos.x = minv.x;
else if ((group->align & OBS_ALIGN_RIGHT) != 0)
new_pos.x = maxv.x;
else
new_pos.x = (maxv.x - minv.x) * 0.5f + minv.x;
if ((group->align & OBS_ALIGN_TOP) != 0)
new_pos.y = minv.y;
else if ((group->align & OBS_ALIGN_BOTTOM) != 0)
new_pos.y = maxv.y;
else
new_pos.y = (maxv.y - minv.y) * 0.5f + minv.y;
transform_val(&new_pos, &group->draw_transform);
vec2_copy(&group->pos, &new_pos);
}
os_atomic_set_bool(&group->update_group_resize, false);
update_item_transform(group, false);
}
obs_sceneitem_t *obs_scene_add_group(obs_scene_t *scene, const char *name)
{
return obs_scene_insert_group(scene, name, NULL, 0);
}
obs_sceneitem_t *obs_scene_add_group2(obs_scene_t *scene, const char *name,
bool signal)
{
return obs_scene_insert_group2(scene, name, NULL, 0, signal);
}
obs_sceneitem_t *obs_scene_insert_group(obs_scene_t *scene, const char *name,
obs_sceneitem_t **items, size_t count)
{
if (!scene)
return NULL;
/* don't allow groups or sub-items of other groups */
for (size_t i = count; i > 0; i--) {
obs_sceneitem_t *item = items[i - 1];
if (item->parent != scene || item->is_group)
return NULL;
}
obs_scene_t *sub_scene = create_id("group", name);
obs_sceneitem_t *last_item = items ? items[count - 1] : NULL;
2022-07-19 23:07:04 -07:00
obs_sceneitem_t *item =
obs_scene_add_internal(scene, sub_scene->source, last_item);
obs_scene_release(sub_scene);
if (!items || !count)
return item;
/* ------------------------- */
full_lock(scene);
full_lock(sub_scene);
2018-08-10 16:55:49 -07:00
sub_scene->first_item = items[0];
for (size_t i = count; i > 0; i--) {
size_t idx = i - 1;
remove_group_transform(item, items[idx]);
detach_sceneitem(items[idx]);
}
for (size_t i = 0; i < count; i++) {
size_t idx = i;
if (idx != (count - 1)) {
size_t next_idx = idx + 1;
items[idx]->next = items[next_idx];
items[next_idx]->prev = items[idx];
} else {
items[idx]->next = NULL;
}
items[idx]->parent = sub_scene;
apply_group_transform(items[idx], item);
}
items[0]->prev = NULL;
resize_group(item);
full_unlock(sub_scene);
full_unlock(scene);
struct calldata params;
uint8_t stack[128];
calldata_init_fixed(&params, stack, sizeof(stack));
calldata_set_ptr(&params, "scene", scene);
calldata_set_ptr(&params, "item", item);
signal_handler_signal(scene->source->context.signals, "item_add",
&params);
/* ------------------------- */
return item;
}
obs_sceneitem_t *obs_scene_insert_group2(obs_scene_t *scene, const char *name,
obs_sceneitem_t **items, size_t count,
bool signal)
{
obs_sceneitem_t *item =
obs_scene_insert_group(scene, name, items, count);
if (signal && item)
signal_refresh(scene);
return item;
}
obs_sceneitem_t *obs_scene_get_group(obs_scene_t *scene, const char *name)
{
if (!scene || !name || !*name) {
return NULL;
}
obs_sceneitem_t *group = NULL;
obs_sceneitem_t *item;
full_lock(scene);
item = scene->first_item;
while (item) {
if (item->is_group && item->source->context.name) {
if (strcmp(item->source->context.name, name) == 0) {
group = item;
break;
}
}
item = item->next;
}
full_unlock(scene);
return group;
}
bool obs_sceneitem_is_group(obs_sceneitem_t *item)
{
return item && item->is_group;
}
obs_scene_t *obs_sceneitem_group_get_scene(const obs_sceneitem_t *item)
{
return (item && item->is_group) ? item->source->context.data : NULL;
}
void obs_sceneitem_group_ungroup(obs_sceneitem_t *item)
{
if (!item || !item->is_group)
return;
obs_scene_t *scene = item->parent;
obs_scene_t *subscene = item->source->context.data;
obs_sceneitem_t *insert_after = item;
obs_sceneitem_t *first;
obs_sceneitem_t *last;
signal_item_remove(item);
full_lock(scene);
/* ------------------------- */
full_lock(subscene);
first = subscene->first_item;
last = first;
while (last) {
obs_sceneitem_t *dst;
remove_group_transform(item, last);
2022-07-19 23:07:04 -07:00
dst = obs_scene_add_internal(scene, last->source, insert_after);
duplicate_item_data(dst, last, true, true, true);
apply_group_transform(last, item);
if (!last->next)
break;
insert_after = dst;
last = last->next;
}
full_unlock(subscene);
/* ------------------------- */
detach_sceneitem(item);
full_unlock(scene);
obs_sceneitem_release(item);
}
void obs_sceneitem_group_ungroup2(obs_sceneitem_t *item, bool signal)
{
obs_scene_t *scene = item->parent;
obs_sceneitem_group_ungroup(item);
if (signal)
signal_refresh(scene);
}
void obs_sceneitem_group_add_item(obs_sceneitem_t *group, obs_sceneitem_t *item)
{
if (!group || !group->is_group || !item)
return;
obs_scene_t *scene = group->parent;
obs_scene_t *groupscene = group->source->context.data;
if (item->parent != scene)
return;
if (item->parent == groupscene)
return;
/* ------------------------- */
full_lock(scene);
full_lock(groupscene);
remove_group_transform(group, item);
detach_sceneitem(item);
attach_sceneitem(groupscene, item, NULL);
apply_group_transform(item, group);
resize_group(group);
full_unlock(groupscene);
full_unlock(scene);
/* ------------------------- */
signal_refresh(scene);
}
void obs_sceneitem_group_remove_item(obs_sceneitem_t *group,
obs_sceneitem_t *item)
{
if (!item || !group || !group->is_group)
return;
obs_scene_t *groupscene = item->parent;
obs_scene_t *scene = group->parent;
/* ------------------------- */
full_lock(scene);
full_lock(groupscene);
remove_group_transform(group, item);
detach_sceneitem(item);
attach_sceneitem(scene, item, NULL);
resize_group(group);
full_unlock(groupscene);
full_unlock(scene);
/* ------------------------- */
signal_refresh(scene);
}
2020-02-09 18:36:58 -08:00
static void
build_current_order_info(obs_scene_t *scene,
struct obs_sceneitem_order_info **items_out,
size_t *size_out)
{
DARRAY(struct obs_sceneitem_order_info) items;
da_init(items);
obs_sceneitem_t *item = scene->first_item;
while (item) {
struct obs_sceneitem_order_info info = {0};
info.item = item;
da_push_back(items, &info);
if (item->is_group) {
obs_scene_t *sub_scene = item->source->context.data;
full_lock(sub_scene);
obs_sceneitem_t *sub_item = sub_scene->first_item;
while (sub_item) {
info.group = item;
info.item = sub_item;
da_push_back(items, &info);
sub_item = sub_item->next;
}
full_unlock(sub_scene);
}
item = item->next;
}
*items_out = items.array;
*size_out = items.num;
}
static bool sceneitems_match2(obs_scene_t *scene,
struct obs_sceneitem_order_info *items,
size_t size)
{
struct obs_sceneitem_order_info *cur_items;
size_t cur_size;
build_current_order_info(scene, &cur_items, &cur_size);
if (cur_size != size) {
bfree(cur_items);
return false;
}
for (size_t i = 0; i < size; i++) {
struct obs_sceneitem_order_info *new = &items[i];
struct obs_sceneitem_order_info *old = &cur_items[i];
if (new->group != old->group || new->item != old->item) {
bfree(cur_items);
return false;
}
}
bfree(cur_items);
return true;
}
static obs_sceneitem_t *
get_sceneitem_parent_group(obs_scene_t *scene, obs_sceneitem_t *group_subitem)
{
if (group_subitem->is_group)
return NULL;
obs_sceneitem_t *item = scene->first_item;
while (item) {
if (item->is_group &&
item->source->context.data == group_subitem->parent)
return item;
item = item->next;
}
return NULL;
}
bool obs_scene_reorder_items2(obs_scene_t *scene,
struct obs_sceneitem_order_info *item_order,
size_t item_order_size)
{
if (!scene || !item_order_size || !item_order)
return false;
scene = obs_scene_get_ref(scene);
if (!scene)
return false;
full_lock(scene);
if (sceneitems_match2(scene, item_order, item_order_size)) {
full_unlock(scene);
obs_scene_release(scene);
return false;
}
for (size_t i = 0; i < item_order_size; i++) {
struct obs_sceneitem_order_info *info = &item_order[i];
if (!info->item->is_group) {
obs_sceneitem_t *group =
get_sceneitem_parent_group(scene, info->item);
remove_group_transform(group, info->item);
}
}
scene->first_item = item_order[0].item;
obs_sceneitem_t *prev = NULL;
for (size_t i = 0; i < item_order_size; i++) {
struct obs_sceneitem_order_info *info = &item_order[i];
obs_sceneitem_t *item = info->item;
if (info->item->is_group) {
obs_sceneitem_t *sub_prev = NULL;
obs_scene_t *sub_scene =
info->item->source->context.data;
sub_scene->first_item = NULL;
obs_scene_addref(sub_scene);
full_lock(sub_scene);
for (i++; i < item_order_size; i++) {
struct obs_sceneitem_order_info *sub_info =
&item_order[i];
obs_sceneitem_t *sub_item = sub_info->item;
if (sub_info->group != info->item) {
i--;
break;
}
if (!sub_scene->first_item)
sub_scene->first_item = sub_item;
sub_item->prev = sub_prev;
sub_item->next = NULL;
sub_item->parent = sub_scene;
if (sub_prev)
sub_prev->next = sub_item;
apply_group_transform(sub_info->item,
sub_info->group);
sub_prev = sub_item;
}
resize_group(info->item);
full_unlock(sub_scene);
obs_scene_release(sub_scene);
}
item->prev = prev;
item->next = NULL;
item->parent = scene;
if (prev)
prev->next = item;
prev = item;
}
full_unlock(scene);
signal_reorder(scene->first_item);
obs_scene_release(scene);
return true;
}
obs_sceneitem_t *obs_sceneitem_get_group(obs_scene_t *scene,
obs_sceneitem_t *group_subitem)
{
if (!scene || !group_subitem || group_subitem->is_group)
return NULL;
full_lock(scene);
obs_sceneitem_t *group =
get_sceneitem_parent_group(scene, group_subitem);
full_unlock(scene);
return group;
}
bool obs_source_is_group(const obs_source_t *source)
{
return source && strcmp(source->info.id, group_info.id) == 0;
}
2021-04-09 04:13:41 -07:00
bool obs_source_is_scene(const obs_source_t *source)
{
return source && strcmp(source->info.id, scene_info.id) == 0;
}
bool obs_scene_is_group(const obs_scene_t *scene)
{
return scene ? scene->is_group : false;
}
void obs_sceneitem_group_enum_items(obs_sceneitem_t *group,
bool (*callback)(obs_scene_t *,
obs_sceneitem_t *, void *),
void *param)
{
if (!group || !group->is_group)
return;
obs_scene_t *scene = group->source->context.data;
if (scene)
obs_scene_enum_items(scene, callback, param);
}
void obs_sceneitem_force_update_transform(obs_sceneitem_t *item)
{
if (!item)
return;
if (os_atomic_set_bool(&item->update_transform, false))
update_item_transform(item, false);
}
void obs_sceneitem_set_show_transition(obs_sceneitem_t *item,
obs_source_t *transition)
{
if (!item)
return;
if (item->show_transition)
obs_source_release(item->show_transition);
item->show_transition = obs_source_get_ref(transition);
}
void obs_sceneitem_set_show_transition_duration(obs_sceneitem_t *item,
uint32_t duration_ms)
{
if (!item)
return;
item->show_transition_duration = duration_ms;
}
obs_source_t *obs_sceneitem_get_show_transition(obs_sceneitem_t *item)
{
if (!item)
return NULL;
return item->show_transition;
}
uint32_t obs_sceneitem_get_show_transition_duration(obs_sceneitem_t *item)
{
if (!item)
return 0;
return item->show_transition_duration;
}
void obs_sceneitem_set_hide_transition(obs_sceneitem_t *item,
obs_source_t *transition)
{
if (!item)
return;
if (item->hide_transition)
obs_source_release(item->hide_transition);
item->hide_transition = obs_source_get_ref(transition);
}
void obs_sceneitem_set_hide_transition_duration(obs_sceneitem_t *item,
uint32_t duration_ms)
{
if (!item)
return;
item->hide_transition_duration = duration_ms;
}
obs_source_t *obs_sceneitem_get_hide_transition(obs_sceneitem_t *item)
{
if (!item)
return NULL;
return item->hide_transition;
}
uint32_t obs_sceneitem_get_hide_transition_duration(obs_sceneitem_t *item)
{
if (!item)
return 0;
return item->hide_transition_duration;
}
void obs_sceneitem_set_transition(obs_sceneitem_t *item, bool show,
obs_source_t *transition)
{
if (!item)
return;
obs_source_t **target = show ? &item->show_transition
: &item->hide_transition;
if (*target)
obs_source_release(*target);
*target = obs_source_get_ref(transition);
}
obs_source_t *obs_sceneitem_get_transition(obs_sceneitem_t *item, bool show)
{
if (!item)
return NULL;
return show ? item->show_transition : item->hide_transition;
}
void obs_sceneitem_set_transition_duration(obs_sceneitem_t *item, bool show,
uint32_t duration_ms)
{
if (!item)
return;
if (show)
item->show_transition_duration = duration_ms;
else
item->hide_transition_duration = duration_ms;
}
uint32_t obs_sceneitem_get_transition_duration(obs_sceneitem_t *item, bool show)
{
if (!item)
return 0;
return show ? item->show_transition_duration
: item->hide_transition_duration;
}
void obs_sceneitem_transition_stop(void *data, calldata_t *calldata)
{
obs_source_t *parent = data;
obs_source_t *transition;
calldata_get_ptr(calldata, "source", &transition);
obs_source_remove_active_child(parent, transition);
signal_handler_t *sh = obs_source_get_signal_handler(transition);
if (sh)
signal_handler_disconnect(sh, "transition_stop",
obs_sceneitem_transition_stop,
parent);
}
void obs_sceneitem_do_transition(obs_sceneitem_t *item, bool visible)
{
if (!item)
return;
if (transition_active(item->show_transition))
obs_transition_force_stop(item->show_transition);
if (transition_active(item->hide_transition))
obs_transition_force_stop(item->hide_transition);
obs_source_t *transition = obs_sceneitem_get_transition(item, visible);
if (!transition)
return;
int duration =
(int)obs_sceneitem_get_transition_duration(item, visible);
const int cx = obs_source_get_width(item->source);
const int cy = obs_source_get_height(item->source);
obs_transition_set_size(transition, cx, cy);
obs_transition_set_alignment(transition, OBS_ALIGN_CENTER);
obs_transition_set_scale_type(transition, OBS_TRANSITION_SCALE_ASPECT);
if (duration == 0)
duration = 300;
obs_scene_t *scene = obs_sceneitem_get_scene(item);
obs_source_t *parent = obs_scene_get_source(scene);
obs_source_add_active_child(parent, transition);
signal_handler_t *sh = obs_source_get_signal_handler(transition);
if (sh)
signal_handler_connect(sh, "transition_stop",
obs_sceneitem_transition_stop, parent);
if (!visible) {
obs_transition_set(transition, item->source);
obs_transition_start(transition, OBS_TRANSITION_MODE_AUTO,
duration, NULL);
} else {
obs_transition_set(transition, NULL);
obs_transition_start(transition, OBS_TRANSITION_MODE_AUTO,
duration, item->source);
}
}
void obs_sceneitem_transition_load(struct obs_scene_item *item,
obs_data_t *data, bool show)
{
if (!item || !data)
return;
const char *id = obs_data_get_string(data, "id");
if (id && strlen(id)) {
const char *tn = obs_data_get_string(data, "name");
obs_data_t *s = obs_data_get_obj(data, "transition");
obs_source_t *t = obs_source_create_private(id, tn, s);
obs_sceneitem_set_transition(item, show, t);
obs_source_release(t);
obs_data_release(s);
} else {
obs_sceneitem_set_transition(item, show, NULL);
}
2022-03-24 23:03:35 -07:00
obs_sceneitem_set_transition_duration(
item, show, (uint32_t)obs_data_get_int(data, "duration"));
}
obs_data_t *obs_sceneitem_transition_save(struct obs_scene_item *item,
bool show)
{
obs_data_t *data = obs_data_create();
struct obs_source *transition = show ? item->show_transition
: item->hide_transition;
if (transition) {
obs_data_set_string(data, "id",
obs_source_get_unversioned_id(transition));
obs_data_set_string(data, "versioned_id",
obs_source_get_id(transition));
obs_data_set_string(data, "name",
obs_source_get_name(transition));
obs_data_t *s = obs_source_get_settings(transition);
obs_data_set_obj(data, "transition", s);
obs_data_release(s);
}
obs_data_set_int(data, "duration",
show ? item->show_transition_duration
: item->hide_transition_duration);
return data;
}
void obs_scene_prune_sources(obs_scene_t *scene)
{
DARRAY(struct obs_scene_item *) remove_items;
da_init(remove_items);
video_lock(scene);
update_transforms_and_prune_sources(scene, &remove_items.da, NULL);
video_unlock(scene);
for (size_t i = 0; i < remove_items.num; i++)
obs_sceneitem_release(remove_items.array[i]);
da_free(remove_items);
}