jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
obs-studio/libobs/obs-scene.h

83 lines
2.3 KiB
C
Raw Normal View History

first commit
2013-09-30 19:37:13 -07:00
/******************************************************************************
Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
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
With the permission of my fellow contributors, I'm switching obs-studio back to GPL v2+ to prevent issues between this project and the original OBS project, and for personal reasons to avoid legal ambiguity (not political reasons, I admittedly would prefer GPL v3+)
2013-12-02 21:24:38 -08:00
the Free Software Foundation, either version 2 of the License, or
first commit
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/>.
******************************************************************************/
modernize header guards to #pragma once
2013-10-14 04:21:15 -07:00
#pragma once
first commit
2013-09-30 19:37:13 -07:00
#include "obs.h"
Revamp API and start using doxygen The API used to be designed in such a way to where it would expect exports for each individual source/output/encoder/etc. You would export functions for each and it would automatically load those functions based on a specific naming scheme from the module. The idea behind this was that I wanted to limit the usage of structures in the API so only functions could be used. It was an interesting idea in theory, but this idea turned out to be flawed in a number of ways: 1.) Requiring exports to create sources/outputs/encoders/etc meant that you could not create them by any other means, which meant that things like faruton's .net plugin would become difficult. 2.) Export function declarations could not be checked, therefore if you created a function with the wrong parameters and parameter types, the compiler wouldn't know how to check for that. 3.) Required overly complex load functions in libobs just to handle it. It makes much more sense to just have a load function that you call manually. Complexity is the bane of all good programs. 4.) It required that you have functions of specific names, which looked and felt somewhat unsightly. So, to fix these issues, I replaced it with a more commonly used API scheme, seen commonly in places like kernels and typical C libraries with abstraction. You simply create a structure that contains the callback definitions, and you pass it to a function to register that definition (such as obs_register_source), which you call in the obs_module_load of the module. It will also automatically check the structure size and ensure that it only loads the required values if the structure happened to add new values in an API change. The "main" source file for each module must include obs-module.h, and must use OBS_DECLARE_MODULE() within that source file. Also, started writing some doxygen documentation in to the main library headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
#include "obs-internal.h"
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
#include "graphics/matrix4.h"
first commit
2013-09-30 19:37:13 -07:00
/* how obs scene! */
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
struct item_action {
bool visible;
uint64_t timestamp;
};
first commit
2013-09-30 19:37:13 -07:00
struct obs_scene_item {
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
volatile long ref;
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
volatile bool removed;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
struct obs_scene *parent;
struct obs_source *source;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
volatile long active_refs;
libobs: Add functions to defer scene item update Allows the ability to defer updating the item transform until all functions have been executed.
2016-03-30 18:35:59 -07:00
volatile long defer_update;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
bool user_visible;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
bool visible;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
bool selected;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
gs_texrender_t *item_render;
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
struct obs_sceneitem_crop crop;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
struct vec2 pos;
struct vec2 scale;
float rot;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
uint32_t align;
/* last width/height of the source, this is used to check whether
Fix various typos across multiple modules
2017-03-19 04:35:51 -07:00
* the transform needs updating */
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
uint32_t last_width;
uint32_t last_height;
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
struct vec2 output_scale;
enum obs_scale_type scale_filter;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
struct matrix4 box_transform;
struct matrix4 draw_transform;
enum obs_bounds_type bounds_type;
uint32_t bounds_align;
struct vec2 bounds;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
obs_hotkey_pair_id toggle_visibility;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
pthread_mutex_t actions_mutex;
DARRAY(struct item_action) audio_actions;
forgot to lock the mutex when destroying a scene item
2014-01-01 09:28:37 -08:00
/* would do **prev_next, but not really great for reordering */
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
struct obs_scene_item *prev;
struct obs_scene_item *next;
first commit
2013-09-30 19:37:13 -07:00
};
struct obs_scene {
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
struct obs_source *source;
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
pthread_mutex_t video_mutex;
pthread_mutex_t audio_mutex;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
struct obs_scene_item *first_item;
first commit
2013-09-30 19:37:13 -07:00
};