mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-07-14 23:34:08 +00:00
8b3416c1e7
(This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
1064 lines
28 KiB
C
1064 lines
28 KiB
C
/******************************************************************************
|
|
Copyright (C) 2013-2014 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
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
******************************************************************************/
|
|
|
|
#include <time.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "obs.h"
|
|
#include "obs-internal.h"
|
|
#include "graphics/vec4.h"
|
|
#include "media-io/format-conversion.h"
|
|
#include "media-io/video-frame.h"
|
|
|
|
#ifdef _WIN32
|
|
#define WIN32_MEAN_AND_LEAN
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
static uint64_t tick_sources(uint64_t cur_time, uint64_t last_time)
|
|
{
|
|
struct obs_core_data *data = &obs->data;
|
|
struct obs_source *source;
|
|
uint64_t delta_time;
|
|
float seconds;
|
|
|
|
if (!last_time)
|
|
last_time = cur_time -
|
|
video_output_get_frame_time(obs->video.video);
|
|
|
|
delta_time = cur_time - last_time;
|
|
seconds = (float)((double)delta_time / 1000000000.0);
|
|
|
|
/* ------------------------------------- */
|
|
/* call tick callbacks */
|
|
|
|
pthread_mutex_lock(&obs->data.draw_callbacks_mutex);
|
|
|
|
for (size_t i = obs->data.tick_callbacks.num; i > 0; i--) {
|
|
struct tick_callback *callback;
|
|
callback = obs->data.tick_callbacks.array + (i - 1);
|
|
callback->tick(callback->param, seconds);
|
|
}
|
|
|
|
pthread_mutex_unlock(&obs->data.draw_callbacks_mutex);
|
|
|
|
/* ------------------------------------- */
|
|
/* call the tick function of each source */
|
|
|
|
pthread_mutex_lock(&data->sources_mutex);
|
|
|
|
source = data->first_source;
|
|
while (source) {
|
|
obs_source_t *s = obs_source_get_ref(source);
|
|
|
|
if (s) {
|
|
obs_source_video_tick(s, seconds);
|
|
obs_source_release(s);
|
|
}
|
|
|
|
source = (struct obs_source *)source->context.next;
|
|
}
|
|
|
|
pthread_mutex_unlock(&data->sources_mutex);
|
|
|
|
return cur_time;
|
|
}
|
|
|
|
/* in obs-display.c */
|
|
extern void render_display(struct obs_display *display);
|
|
|
|
static inline void render_displays(void)
|
|
{
|
|
struct obs_display *display;
|
|
|
|
if (!obs->data.valid)
|
|
return;
|
|
|
|
gs_enter_context(obs->video.graphics);
|
|
|
|
/* render extra displays/swaps */
|
|
pthread_mutex_lock(&obs->data.displays_mutex);
|
|
|
|
display = obs->data.first_display;
|
|
while (display) {
|
|
render_display(display);
|
|
display = display->next;
|
|
}
|
|
|
|
pthread_mutex_unlock(&obs->data.displays_mutex);
|
|
|
|
gs_leave_context();
|
|
}
|
|
|
|
static inline void set_render_size(uint32_t width, uint32_t height)
|
|
{
|
|
gs_enable_depth_test(false);
|
|
gs_set_cull_mode(GS_NEITHER);
|
|
|
|
gs_ortho(0.0f, (float)width, 0.0f, (float)height, -100.0f, 100.0f);
|
|
gs_set_viewport(0, 0, width, height);
|
|
}
|
|
|
|
static inline void unmap_last_surface(struct obs_core_video *video)
|
|
{
|
|
for (int c = 0; c < NUM_CHANNELS; ++c) {
|
|
if (video->mapped_surfaces[c]) {
|
|
gs_stagesurface_unmap(video->mapped_surfaces[c]);
|
|
video->mapped_surfaces[c] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
static const char *render_main_texture_name = "render_main_texture";
|
|
static inline void render_main_texture(struct obs_core_video *video)
|
|
{
|
|
profile_start(render_main_texture_name);
|
|
GS_DEBUG_MARKER_BEGIN(GS_DEBUG_COLOR_MAIN_TEXTURE,
|
|
render_main_texture_name);
|
|
|
|
struct vec4 clear_color;
|
|
vec4_set(&clear_color, 0.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
gs_set_render_target(video->render_texture, NULL);
|
|
gs_clear(GS_CLEAR_COLOR, &clear_color, 1.0f, 0);
|
|
|
|
set_render_size(video->base_width, video->base_height);
|
|
|
|
pthread_mutex_lock(&obs->data.draw_callbacks_mutex);
|
|
|
|
for (size_t i = obs->data.draw_callbacks.num; i > 0; i--) {
|
|
struct draw_callback *callback;
|
|
callback = obs->data.draw_callbacks.array + (i - 1);
|
|
|
|
callback->draw(callback->param, video->base_width,
|
|
video->base_height);
|
|
}
|
|
|
|
pthread_mutex_unlock(&obs->data.draw_callbacks_mutex);
|
|
|
|
obs_view_render(&obs->data.main_view);
|
|
|
|
video->texture_rendered = true;
|
|
|
|
GS_DEBUG_MARKER_END();
|
|
profile_end(render_main_texture_name);
|
|
}
|
|
|
|
static inline gs_effect_t *
|
|
get_scale_effect_internal(struct obs_core_video *video)
|
|
{
|
|
/* if the dimension is under half the size of the original image,
|
|
* bicubic/lanczos can't sample enough pixels to create an accurate
|
|
* image, so use the bilinear low resolution effect instead */
|
|
if (video->output_width < (video->base_width / 2) &&
|
|
video->output_height < (video->base_height / 2)) {
|
|
return video->bilinear_lowres_effect;
|
|
}
|
|
|
|
switch (video->scale_type) {
|
|
case OBS_SCALE_BILINEAR:
|
|
return video->default_effect;
|
|
case OBS_SCALE_LANCZOS:
|
|
return video->lanczos_effect;
|
|
case OBS_SCALE_AREA:
|
|
return video->area_effect;
|
|
case OBS_SCALE_BICUBIC:
|
|
default:;
|
|
}
|
|
|
|
return video->bicubic_effect;
|
|
}
|
|
|
|
static inline bool resolution_close(struct obs_core_video *video,
|
|
uint32_t width, uint32_t height)
|
|
{
|
|
long width_cmp = (long)video->base_width - (long)width;
|
|
long height_cmp = (long)video->base_height - (long)height;
|
|
|
|
return labs(width_cmp) <= 16 && labs(height_cmp) <= 16;
|
|
}
|
|
|
|
static inline gs_effect_t *get_scale_effect(struct obs_core_video *video,
|
|
uint32_t width, uint32_t height)
|
|
{
|
|
if (resolution_close(video, width, height)) {
|
|
return video->default_effect;
|
|
} else {
|
|
/* if the scale method couldn't be loaded, use either bicubic
|
|
* or bilinear by default */
|
|
gs_effect_t *effect = get_scale_effect_internal(video);
|
|
if (!effect)
|
|
effect = !!video->bicubic_effect
|
|
? video->bicubic_effect
|
|
: video->default_effect;
|
|
return effect;
|
|
}
|
|
}
|
|
|
|
static const char *render_output_texture_name = "render_output_texture";
|
|
static inline gs_texture_t *render_output_texture(struct obs_core_video *video)
|
|
{
|
|
gs_texture_t *texture = video->render_texture;
|
|
gs_texture_t *target = video->output_texture;
|
|
uint32_t width = gs_texture_get_width(target);
|
|
uint32_t height = gs_texture_get_height(target);
|
|
|
|
gs_effect_t *effect = get_scale_effect(video, width, height);
|
|
gs_technique_t *tech;
|
|
|
|
if (video->ovi.output_format == VIDEO_FORMAT_RGBA) {
|
|
tech = gs_effect_get_technique(effect, "DrawAlphaDivide");
|
|
} else {
|
|
if ((effect == video->default_effect) &&
|
|
(width == video->base_width) &&
|
|
(height == video->base_height))
|
|
return texture;
|
|
|
|
tech = gs_effect_get_technique(effect, "Draw");
|
|
}
|
|
|
|
profile_start(render_output_texture_name);
|
|
|
|
gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image");
|
|
gs_eparam_t *bres =
|
|
gs_effect_get_param_by_name(effect, "base_dimension");
|
|
gs_eparam_t *bres_i =
|
|
gs_effect_get_param_by_name(effect, "base_dimension_i");
|
|
size_t passes, i;
|
|
|
|
gs_set_render_target(target, NULL);
|
|
set_render_size(width, height);
|
|
|
|
if (bres) {
|
|
struct vec2 base;
|
|
vec2_set(&base, (float)video->base_width,
|
|
(float)video->base_height);
|
|
gs_effect_set_vec2(bres, &base);
|
|
}
|
|
|
|
if (bres_i) {
|
|
struct vec2 base_i;
|
|
vec2_set(&base_i, 1.0f / (float)video->base_width,
|
|
1.0f / (float)video->base_height);
|
|
gs_effect_set_vec2(bres_i, &base_i);
|
|
}
|
|
|
|
gs_effect_set_texture_srgb(image, texture);
|
|
|
|
gs_enable_framebuffer_srgb(true);
|
|
gs_enable_blending(false);
|
|
passes = gs_technique_begin(tech);
|
|
for (i = 0; i < passes; i++) {
|
|
gs_technique_begin_pass(tech, i);
|
|
gs_draw_sprite(texture, 0, width, height);
|
|
gs_technique_end_pass(tech);
|
|
}
|
|
gs_technique_end(tech);
|
|
gs_enable_blending(true);
|
|
gs_enable_framebuffer_srgb(false);
|
|
|
|
profile_end(render_output_texture_name);
|
|
|
|
return target;
|
|
}
|
|
|
|
static void render_convert_plane(gs_effect_t *effect, gs_texture_t *target,
|
|
const char *tech_name)
|
|
{
|
|
gs_technique_t *tech = gs_effect_get_technique(effect, tech_name);
|
|
|
|
const uint32_t width = gs_texture_get_width(target);
|
|
const uint32_t height = gs_texture_get_height(target);
|
|
|
|
gs_set_render_target(target, NULL);
|
|
set_render_size(width, height);
|
|
|
|
size_t passes = gs_technique_begin(tech);
|
|
for (size_t i = 0; i < passes; i++) {
|
|
gs_technique_begin_pass(tech, i);
|
|
gs_draw(GS_TRIS, 0, 3);
|
|
gs_technique_end_pass(tech);
|
|
}
|
|
gs_technique_end(tech);
|
|
}
|
|
|
|
static const char *render_convert_texture_name = "render_convert_texture";
|
|
static void render_convert_texture(struct obs_core_video *video,
|
|
gs_texture_t *texture)
|
|
{
|
|
profile_start(render_convert_texture_name);
|
|
|
|
gs_effect_t *effect = video->conversion_effect;
|
|
gs_eparam_t *color_vec0 =
|
|
gs_effect_get_param_by_name(effect, "color_vec0");
|
|
gs_eparam_t *color_vec1 =
|
|
gs_effect_get_param_by_name(effect, "color_vec1");
|
|
gs_eparam_t *color_vec2 =
|
|
gs_effect_get_param_by_name(effect, "color_vec2");
|
|
gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image");
|
|
gs_eparam_t *width_i = gs_effect_get_param_by_name(effect, "width_i");
|
|
|
|
struct vec4 vec0, vec1, vec2;
|
|
vec4_set(&vec0, video->color_matrix[4], video->color_matrix[5],
|
|
video->color_matrix[6], video->color_matrix[7]);
|
|
vec4_set(&vec1, video->color_matrix[0], video->color_matrix[1],
|
|
video->color_matrix[2], video->color_matrix[3]);
|
|
vec4_set(&vec2, video->color_matrix[8], video->color_matrix[9],
|
|
video->color_matrix[10], video->color_matrix[11]);
|
|
|
|
gs_enable_blending(false);
|
|
|
|
if (video->convert_textures[0]) {
|
|
gs_effect_set_texture(image, texture);
|
|
gs_effect_set_vec4(color_vec0, &vec0);
|
|
render_convert_plane(effect, video->convert_textures[0],
|
|
video->conversion_techs[0]);
|
|
|
|
if (video->convert_textures[1]) {
|
|
gs_effect_set_texture(image, texture);
|
|
gs_effect_set_vec4(color_vec1, &vec1);
|
|
if (!video->convert_textures[2])
|
|
gs_effect_set_vec4(color_vec2, &vec2);
|
|
gs_effect_set_float(width_i, video->conversion_width_i);
|
|
render_convert_plane(effect, video->convert_textures[1],
|
|
video->conversion_techs[1]);
|
|
|
|
if (video->convert_textures[2]) {
|
|
gs_effect_set_texture(image, texture);
|
|
gs_effect_set_vec4(color_vec2, &vec2);
|
|
gs_effect_set_float(width_i,
|
|
video->conversion_width_i);
|
|
render_convert_plane(
|
|
effect, video->convert_textures[2],
|
|
video->conversion_techs[2]);
|
|
}
|
|
}
|
|
}
|
|
|
|
gs_enable_blending(true);
|
|
|
|
video->texture_converted = true;
|
|
|
|
profile_end(render_convert_texture_name);
|
|
}
|
|
|
|
static const char *stage_output_texture_name = "stage_output_texture";
|
|
static inline void stage_output_texture(struct obs_core_video *video,
|
|
int cur_texture)
|
|
{
|
|
profile_start(stage_output_texture_name);
|
|
|
|
unmap_last_surface(video);
|
|
|
|
if (!video->gpu_conversion) {
|
|
gs_stagesurf_t *copy = video->copy_surfaces[cur_texture][0];
|
|
if (copy)
|
|
gs_stage_texture(copy, video->output_texture);
|
|
|
|
video->textures_copied[cur_texture] = true;
|
|
} else if (video->texture_converted) {
|
|
for (int i = 0; i < NUM_CHANNELS; i++) {
|
|
gs_stagesurf_t *copy =
|
|
video->copy_surfaces[cur_texture][i];
|
|
if (copy)
|
|
gs_stage_texture(copy,
|
|
video->convert_textures[i]);
|
|
}
|
|
|
|
video->textures_copied[cur_texture] = true;
|
|
}
|
|
|
|
profile_end(stage_output_texture_name);
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
static inline bool queue_frame(struct obs_core_video *video, bool raw_active,
|
|
struct obs_vframe_info *vframe_info)
|
|
{
|
|
bool duplicate =
|
|
!video->gpu_encoder_avail_queue.size ||
|
|
(video->gpu_encoder_queue.size && vframe_info->count > 1);
|
|
|
|
if (duplicate) {
|
|
struct obs_tex_frame *tf = circlebuf_data(
|
|
&video->gpu_encoder_queue,
|
|
video->gpu_encoder_queue.size - sizeof(*tf));
|
|
|
|
/* texture-based encoding is stopping */
|
|
if (!tf) {
|
|
return false;
|
|
}
|
|
|
|
tf->count++;
|
|
os_sem_post(video->gpu_encode_semaphore);
|
|
goto finish;
|
|
}
|
|
|
|
struct obs_tex_frame tf;
|
|
circlebuf_pop_front(&video->gpu_encoder_avail_queue, &tf, sizeof(tf));
|
|
|
|
if (tf.released) {
|
|
gs_texture_acquire_sync(tf.tex, tf.lock_key, GS_WAIT_INFINITE);
|
|
tf.released = false;
|
|
}
|
|
|
|
/* the vframe_info->count > 1 case causing a copy can only happen if by
|
|
* some chance the very first frame has to be duplicated for whatever
|
|
* reason. otherwise, it goes to the 'duplicate' case above, which
|
|
* will ensure better performance. */
|
|
if (raw_active || vframe_info->count > 1) {
|
|
gs_copy_texture(tf.tex, video->convert_textures[0]);
|
|
} else {
|
|
gs_texture_t *tex = video->convert_textures[0];
|
|
gs_texture_t *tex_uv = video->convert_textures[1];
|
|
|
|
video->convert_textures[0] = tf.tex;
|
|
video->convert_textures[1] = tf.tex_uv;
|
|
|
|
tf.tex = tex;
|
|
tf.tex_uv = tex_uv;
|
|
}
|
|
|
|
tf.count = 1;
|
|
tf.timestamp = vframe_info->timestamp;
|
|
tf.released = true;
|
|
tf.handle = gs_texture_get_shared_handle(tf.tex);
|
|
gs_texture_release_sync(tf.tex, ++tf.lock_key);
|
|
circlebuf_push_back(&video->gpu_encoder_queue, &tf, sizeof(tf));
|
|
|
|
os_sem_post(video->gpu_encode_semaphore);
|
|
|
|
finish:
|
|
return --vframe_info->count;
|
|
}
|
|
|
|
extern void full_stop(struct obs_encoder *encoder);
|
|
|
|
static inline void encode_gpu(struct obs_core_video *video, bool raw_active,
|
|
struct obs_vframe_info *vframe_info)
|
|
{
|
|
while (queue_frame(video, raw_active, vframe_info))
|
|
;
|
|
}
|
|
|
|
static const char *output_gpu_encoders_name = "output_gpu_encoders";
|
|
static void output_gpu_encoders(struct obs_core_video *video, bool raw_active)
|
|
{
|
|
profile_start(output_gpu_encoders_name);
|
|
|
|
if (!video->texture_converted)
|
|
goto end;
|
|
if (!video->vframe_info_buffer_gpu.size)
|
|
goto end;
|
|
|
|
struct obs_vframe_info vframe_info;
|
|
circlebuf_pop_front(&video->vframe_info_buffer_gpu, &vframe_info,
|
|
sizeof(vframe_info));
|
|
|
|
pthread_mutex_lock(&video->gpu_encoder_mutex);
|
|
encode_gpu(video, raw_active, &vframe_info);
|
|
pthread_mutex_unlock(&video->gpu_encoder_mutex);
|
|
|
|
end:
|
|
profile_end(output_gpu_encoders_name);
|
|
}
|
|
#endif
|
|
|
|
static inline void render_video(struct obs_core_video *video, bool raw_active,
|
|
const bool gpu_active, int cur_texture)
|
|
{
|
|
gs_begin_scene();
|
|
|
|
gs_enable_depth_test(false);
|
|
gs_set_cull_mode(GS_NEITHER);
|
|
|
|
render_main_texture(video);
|
|
|
|
if (raw_active || gpu_active) {
|
|
gs_texture_t *texture = render_output_texture(video);
|
|
|
|
#ifdef _WIN32
|
|
if (gpu_active)
|
|
gs_flush();
|
|
#endif
|
|
|
|
if (video->gpu_conversion)
|
|
render_convert_texture(video, texture);
|
|
|
|
#ifdef _WIN32
|
|
if (gpu_active) {
|
|
gs_flush();
|
|
output_gpu_encoders(video, raw_active);
|
|
}
|
|
#endif
|
|
|
|
if (raw_active)
|
|
stage_output_texture(video, cur_texture);
|
|
}
|
|
|
|
gs_set_render_target(NULL, NULL);
|
|
gs_enable_blending(true);
|
|
|
|
gs_end_scene();
|
|
}
|
|
|
|
static inline bool download_frame(struct obs_core_video *video,
|
|
int prev_texture, struct video_data *frame)
|
|
{
|
|
if (!video->textures_copied[prev_texture])
|
|
return false;
|
|
|
|
for (int channel = 0; channel < NUM_CHANNELS; ++channel) {
|
|
gs_stagesurf_t *surface =
|
|
video->copy_surfaces[prev_texture][channel];
|
|
if (surface) {
|
|
if (!gs_stagesurface_map(surface, &frame->data[channel],
|
|
&frame->linesize[channel]))
|
|
return false;
|
|
|
|
video->mapped_surfaces[channel] = surface;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const uint8_t *set_gpu_converted_plane(uint32_t width, uint32_t height,
|
|
uint32_t linesize_input,
|
|
uint32_t linesize_output,
|
|
const uint8_t *in, uint8_t *out)
|
|
{
|
|
if ((width == linesize_input) && (width == linesize_output)) {
|
|
size_t total = (size_t)width * (size_t)height;
|
|
memcpy(out, in, total);
|
|
in += total;
|
|
} else {
|
|
for (size_t y = 0; y < height; y++) {
|
|
memcpy(out, in, width);
|
|
out += linesize_output;
|
|
in += linesize_input;
|
|
}
|
|
}
|
|
|
|
return in;
|
|
}
|
|
|
|
static void set_gpu_converted_data(struct obs_core_video *video,
|
|
struct video_frame *output,
|
|
const struct video_data *input,
|
|
const struct video_output_info *info)
|
|
{
|
|
if (video->using_nv12_tex) {
|
|
const uint32_t width = info->width;
|
|
const uint32_t height = info->height;
|
|
|
|
const uint8_t *const in_uv = set_gpu_converted_plane(
|
|
width, height, input->linesize[0], output->linesize[0],
|
|
input->data[0], output->data[0]);
|
|
|
|
const uint32_t height_d2 = height / 2;
|
|
set_gpu_converted_plane(width, height_d2, input->linesize[0],
|
|
output->linesize[1], in_uv,
|
|
output->data[1]);
|
|
} else {
|
|
switch (info->format) {
|
|
case VIDEO_FORMAT_I420: {
|
|
const uint32_t width = info->width;
|
|
const uint32_t height = info->height;
|
|
|
|
set_gpu_converted_plane(width, height,
|
|
input->linesize[0],
|
|
output->linesize[0],
|
|
input->data[0],
|
|
output->data[0]);
|
|
|
|
const uint32_t width_d2 = width / 2;
|
|
const uint32_t height_d2 = height / 2;
|
|
|
|
set_gpu_converted_plane(width_d2, height_d2,
|
|
input->linesize[1],
|
|
output->linesize[1],
|
|
input->data[1],
|
|
output->data[1]);
|
|
|
|
set_gpu_converted_plane(width_d2, height_d2,
|
|
input->linesize[2],
|
|
output->linesize[2],
|
|
input->data[2],
|
|
output->data[2]);
|
|
|
|
break;
|
|
}
|
|
case VIDEO_FORMAT_NV12: {
|
|
const uint32_t width = info->width;
|
|
const uint32_t height = info->height;
|
|
|
|
set_gpu_converted_plane(width, height,
|
|
input->linesize[0],
|
|
output->linesize[0],
|
|
input->data[0],
|
|
output->data[0]);
|
|
|
|
const uint32_t height_d2 = height / 2;
|
|
set_gpu_converted_plane(width, height_d2,
|
|
input->linesize[1],
|
|
output->linesize[1],
|
|
input->data[1],
|
|
output->data[1]);
|
|
|
|
break;
|
|
}
|
|
case VIDEO_FORMAT_I444: {
|
|
const uint32_t width = info->width;
|
|
const uint32_t height = info->height;
|
|
|
|
set_gpu_converted_plane(width, height,
|
|
input->linesize[0],
|
|
output->linesize[0],
|
|
input->data[0],
|
|
output->data[0]);
|
|
|
|
set_gpu_converted_plane(width, height,
|
|
input->linesize[1],
|
|
output->linesize[1],
|
|
input->data[1],
|
|
output->data[1]);
|
|
|
|
set_gpu_converted_plane(width, height,
|
|
input->linesize[2],
|
|
output->linesize[2],
|
|
input->data[2],
|
|
output->data[2]);
|
|
|
|
break;
|
|
}
|
|
|
|
case VIDEO_FORMAT_NONE:
|
|
case VIDEO_FORMAT_YVYU:
|
|
case VIDEO_FORMAT_YUY2:
|
|
case VIDEO_FORMAT_UYVY:
|
|
case VIDEO_FORMAT_RGBA:
|
|
case VIDEO_FORMAT_BGRA:
|
|
case VIDEO_FORMAT_BGRX:
|
|
case VIDEO_FORMAT_Y800:
|
|
case VIDEO_FORMAT_BGR3:
|
|
case VIDEO_FORMAT_I422:
|
|
case VIDEO_FORMAT_I40A:
|
|
case VIDEO_FORMAT_I42A:
|
|
case VIDEO_FORMAT_YUVA:
|
|
case VIDEO_FORMAT_AYUV:
|
|
/* unimplemented */
|
|
;
|
|
}
|
|
}
|
|
}
|
|
|
|
static inline void copy_rgbx_frame(struct video_frame *output,
|
|
const struct video_data *input,
|
|
const struct video_output_info *info)
|
|
{
|
|
uint8_t *in_ptr = input->data[0];
|
|
uint8_t *out_ptr = output->data[0];
|
|
|
|
/* if the line sizes match, do a single copy */
|
|
if (input->linesize[0] == output->linesize[0]) {
|
|
memcpy(out_ptr, in_ptr,
|
|
(size_t)input->linesize[0] * (size_t)info->height);
|
|
} else {
|
|
const size_t copy_size = (size_t)info->width * 4;
|
|
for (size_t y = 0; y < info->height; y++) {
|
|
memcpy(out_ptr, in_ptr, copy_size);
|
|
in_ptr += input->linesize[0];
|
|
out_ptr += output->linesize[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
static inline void output_video_data(struct obs_core_video *video,
|
|
struct video_data *input_frame, int count)
|
|
{
|
|
const struct video_output_info *info;
|
|
struct video_frame output_frame;
|
|
bool locked;
|
|
|
|
info = video_output_get_info(video->video);
|
|
|
|
locked = video_output_lock_frame(video->video, &output_frame, count,
|
|
input_frame->timestamp);
|
|
if (locked) {
|
|
if (video->gpu_conversion) {
|
|
set_gpu_converted_data(video, &output_frame,
|
|
input_frame, info);
|
|
} else {
|
|
copy_rgbx_frame(&output_frame, input_frame, info);
|
|
}
|
|
|
|
video_output_unlock_frame(video->video);
|
|
}
|
|
}
|
|
|
|
static inline void video_sleep(struct obs_core_video *video, bool raw_active,
|
|
const bool gpu_active, uint64_t *p_time,
|
|
uint64_t interval_ns)
|
|
{
|
|
struct obs_vframe_info vframe_info;
|
|
uint64_t cur_time = *p_time;
|
|
uint64_t t = cur_time + interval_ns;
|
|
int count;
|
|
|
|
if (os_sleepto_ns(t)) {
|
|
*p_time = t;
|
|
count = 1;
|
|
} else {
|
|
count = (int)((os_gettime_ns() - cur_time) / interval_ns);
|
|
*p_time = cur_time + interval_ns * count;
|
|
}
|
|
|
|
video->total_frames += count;
|
|
video->lagged_frames += count - 1;
|
|
|
|
vframe_info.timestamp = cur_time;
|
|
vframe_info.count = count;
|
|
|
|
if (raw_active)
|
|
circlebuf_push_back(&video->vframe_info_buffer, &vframe_info,
|
|
sizeof(vframe_info));
|
|
if (gpu_active)
|
|
circlebuf_push_back(&video->vframe_info_buffer_gpu,
|
|
&vframe_info, sizeof(vframe_info));
|
|
}
|
|
|
|
static const char *output_frame_gs_context_name = "gs_context(video->graphics)";
|
|
static const char *output_frame_render_video_name = "render_video";
|
|
static const char *output_frame_download_frame_name = "download_frame";
|
|
static const char *output_frame_gs_flush_name = "gs_flush";
|
|
static const char *output_frame_output_video_data_name = "output_video_data";
|
|
static inline void output_frame(bool raw_active, const bool gpu_active)
|
|
{
|
|
struct obs_core_video *video = &obs->video;
|
|
int cur_texture = video->cur_texture;
|
|
int prev_texture = cur_texture == 0 ? NUM_TEXTURES - 1
|
|
: cur_texture - 1;
|
|
struct video_data frame;
|
|
bool frame_ready = 0;
|
|
|
|
memset(&frame, 0, sizeof(struct video_data));
|
|
|
|
profile_start(output_frame_gs_context_name);
|
|
gs_enter_context(video->graphics);
|
|
|
|
profile_start(output_frame_render_video_name);
|
|
GS_DEBUG_MARKER_BEGIN(GS_DEBUG_COLOR_RENDER_VIDEO,
|
|
output_frame_render_video_name);
|
|
render_video(video, raw_active, gpu_active, cur_texture);
|
|
GS_DEBUG_MARKER_END();
|
|
profile_end(output_frame_render_video_name);
|
|
|
|
if (raw_active) {
|
|
profile_start(output_frame_download_frame_name);
|
|
frame_ready = download_frame(video, prev_texture, &frame);
|
|
profile_end(output_frame_download_frame_name);
|
|
}
|
|
|
|
profile_start(output_frame_gs_flush_name);
|
|
gs_flush();
|
|
profile_end(output_frame_gs_flush_name);
|
|
|
|
gs_leave_context();
|
|
profile_end(output_frame_gs_context_name);
|
|
|
|
if (raw_active && frame_ready) {
|
|
struct obs_vframe_info vframe_info;
|
|
circlebuf_pop_front(&video->vframe_info_buffer, &vframe_info,
|
|
sizeof(vframe_info));
|
|
|
|
frame.timestamp = vframe_info.timestamp;
|
|
profile_start(output_frame_output_video_data_name);
|
|
output_video_data(video, &frame, vframe_info.count);
|
|
profile_end(output_frame_output_video_data_name);
|
|
}
|
|
|
|
if (++video->cur_texture == NUM_TEXTURES)
|
|
video->cur_texture = 0;
|
|
}
|
|
|
|
#define NBSP "\xC2\xA0"
|
|
|
|
static void clear_base_frame_data(void)
|
|
{
|
|
struct obs_core_video *video = &obs->video;
|
|
video->texture_rendered = false;
|
|
video->texture_converted = false;
|
|
circlebuf_free(&video->vframe_info_buffer);
|
|
video->cur_texture = 0;
|
|
}
|
|
|
|
static void clear_raw_frame_data(void)
|
|
{
|
|
struct obs_core_video *video = &obs->video;
|
|
memset(video->textures_copied, 0, sizeof(video->textures_copied));
|
|
circlebuf_free(&video->vframe_info_buffer);
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
static void clear_gpu_frame_data(void)
|
|
{
|
|
struct obs_core_video *video = &obs->video;
|
|
circlebuf_free(&video->vframe_info_buffer_gpu);
|
|
}
|
|
#endif
|
|
|
|
extern THREAD_LOCAL bool is_graphics_thread;
|
|
|
|
static void execute_graphics_tasks(void)
|
|
{
|
|
struct obs_core_video *video = &obs->video;
|
|
bool tasks_remaining = true;
|
|
|
|
while (tasks_remaining) {
|
|
pthread_mutex_lock(&video->task_mutex);
|
|
if (video->tasks.size) {
|
|
struct obs_task_info info;
|
|
circlebuf_pop_front(&video->tasks, &info, sizeof(info));
|
|
info.task(info.param);
|
|
}
|
|
tasks_remaining = !!video->tasks.size;
|
|
pthread_mutex_unlock(&video->task_mutex);
|
|
}
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
|
|
struct winrt_exports {
|
|
void (*winrt_initialize)();
|
|
void (*winrt_uninitialize)();
|
|
struct winrt_disaptcher *(*winrt_dispatcher_init)();
|
|
void (*winrt_dispatcher_free)(struct winrt_disaptcher *dispatcher);
|
|
void (*winrt_capture_thread_start)();
|
|
void (*winrt_capture_thread_stop)();
|
|
};
|
|
|
|
#define WINRT_IMPORT(func) \
|
|
do { \
|
|
exports->func = os_dlsym(module, #func); \
|
|
if (!exports->func) { \
|
|
success = false; \
|
|
blog(LOG_ERROR, \
|
|
"Could not load function '%s' from " \
|
|
"module '%s'", \
|
|
#func, module_name); \
|
|
} \
|
|
} while (false)
|
|
|
|
static bool load_winrt_imports(struct winrt_exports *exports, void *module,
|
|
const char *module_name)
|
|
{
|
|
bool success = true;
|
|
|
|
WINRT_IMPORT(winrt_initialize);
|
|
WINRT_IMPORT(winrt_uninitialize);
|
|
WINRT_IMPORT(winrt_dispatcher_init);
|
|
WINRT_IMPORT(winrt_dispatcher_free);
|
|
WINRT_IMPORT(winrt_capture_thread_start);
|
|
WINRT_IMPORT(winrt_capture_thread_stop);
|
|
|
|
return success;
|
|
}
|
|
|
|
struct winrt_state {
|
|
bool loaded;
|
|
void *winrt_module;
|
|
struct winrt_exports exports;
|
|
struct winrt_disaptcher *dispatcher;
|
|
};
|
|
|
|
static void init_winrt_state(struct winrt_state *winrt)
|
|
{
|
|
static const char *const module_name = "libobs-winrt";
|
|
|
|
winrt->winrt_module = os_dlopen(module_name);
|
|
winrt->loaded = winrt->winrt_module &&
|
|
load_winrt_imports(&winrt->exports, winrt->winrt_module,
|
|
module_name);
|
|
winrt->dispatcher = NULL;
|
|
if (winrt->loaded) {
|
|
winrt->exports.winrt_initialize();
|
|
winrt->dispatcher = winrt->exports.winrt_dispatcher_init();
|
|
|
|
gs_enter_context(obs->video.graphics);
|
|
winrt->exports.winrt_capture_thread_start();
|
|
gs_leave_context();
|
|
}
|
|
}
|
|
|
|
static void uninit_winrt_state(struct winrt_state *winrt)
|
|
{
|
|
if (winrt->winrt_module) {
|
|
if (winrt->loaded) {
|
|
winrt->exports.winrt_capture_thread_stop();
|
|
if (winrt->dispatcher)
|
|
winrt->exports.winrt_dispatcher_free(
|
|
winrt->dispatcher);
|
|
winrt->exports.winrt_uninitialize();
|
|
}
|
|
|
|
os_dlclose(winrt->winrt_module);
|
|
}
|
|
}
|
|
|
|
#endif // #ifdef _WIN32
|
|
|
|
static const char *tick_sources_name = "tick_sources";
|
|
static const char *render_displays_name = "render_displays";
|
|
static const char *output_frame_name = "output_frame";
|
|
bool obs_graphics_thread_loop(struct obs_graphics_context *context)
|
|
{
|
|
/* defer loop break to clean up sources */
|
|
const bool stop_requested = video_output_stopped(obs->video.video);
|
|
|
|
uint64_t frame_start = os_gettime_ns();
|
|
uint64_t frame_time_ns;
|
|
bool raw_active = obs->video.raw_active > 0;
|
|
#ifdef _WIN32
|
|
const bool gpu_active = obs->video.gpu_encoder_active > 0;
|
|
const bool active = raw_active || gpu_active;
|
|
#else
|
|
const bool gpu_active = 0;
|
|
const bool active = raw_active;
|
|
#endif
|
|
|
|
if (!context->was_active && active)
|
|
clear_base_frame_data();
|
|
if (!context->raw_was_active && raw_active)
|
|
clear_raw_frame_data();
|
|
#ifdef _WIN32
|
|
if (!context->gpu_was_active && gpu_active)
|
|
clear_gpu_frame_data();
|
|
|
|
context->gpu_was_active = gpu_active;
|
|
#endif
|
|
context->raw_was_active = raw_active;
|
|
context->was_active = active;
|
|
|
|
profile_start(context->video_thread_name);
|
|
|
|
gs_enter_context(obs->video.graphics);
|
|
gs_begin_frame();
|
|
gs_leave_context();
|
|
|
|
profile_start(tick_sources_name);
|
|
context->last_time =
|
|
tick_sources(obs->video.video_time, context->last_time);
|
|
profile_end(tick_sources_name);
|
|
|
|
execute_graphics_tasks();
|
|
|
|
#ifdef _WIN32
|
|
MSG msg;
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
#endif
|
|
|
|
profile_start(output_frame_name);
|
|
output_frame(raw_active, gpu_active);
|
|
profile_end(output_frame_name);
|
|
|
|
profile_start(render_displays_name);
|
|
render_displays();
|
|
profile_end(render_displays_name);
|
|
|
|
frame_time_ns = os_gettime_ns() - frame_start;
|
|
|
|
profile_end(context->video_thread_name);
|
|
|
|
profile_reenable_thread();
|
|
|
|
video_sleep(&obs->video, raw_active, gpu_active, &obs->video.video_time,
|
|
context->interval);
|
|
|
|
context->frame_time_total_ns += frame_time_ns;
|
|
context->fps_total_ns += (obs->video.video_time - context->last_time);
|
|
context->fps_total_frames++;
|
|
|
|
if (context->fps_total_ns >= 1000000000ULL) {
|
|
obs->video.video_fps =
|
|
(double)context->fps_total_frames /
|
|
((double)context->fps_total_ns / 1000000000.0);
|
|
obs->video.video_avg_frame_time_ns =
|
|
context->frame_time_total_ns /
|
|
(uint64_t)context->fps_total_frames;
|
|
|
|
context->frame_time_total_ns = 0;
|
|
context->fps_total_ns = 0;
|
|
context->fps_total_frames = 0;
|
|
}
|
|
|
|
return !stop_requested;
|
|
}
|
|
|
|
void *obs_graphics_thread(void *param)
|
|
{
|
|
#ifdef _WIN32
|
|
struct winrt_state winrt;
|
|
init_winrt_state(&winrt);
|
|
#endif // #ifdef _WIN32
|
|
|
|
is_graphics_thread = true;
|
|
|
|
const uint64_t interval = video_output_get_frame_time(obs->video.video);
|
|
|
|
obs->video.video_time = os_gettime_ns();
|
|
obs->video.video_frame_interval_ns = interval;
|
|
|
|
os_set_thread_name("libobs: graphics thread");
|
|
|
|
const char *video_thread_name = profile_store_name(
|
|
obs_get_profiler_name_store(),
|
|
"obs_graphics_thread(%g" NBSP "ms)", interval / 1000000.);
|
|
profile_register_root(video_thread_name, interval);
|
|
|
|
srand((unsigned int)time(NULL));
|
|
|
|
struct obs_graphics_context context;
|
|
context.interval = video_output_get_frame_time(obs->video.video);
|
|
context.frame_time_total_ns = 0;
|
|
context.fps_total_ns = 0;
|
|
context.fps_total_frames = 0;
|
|
context.last_time = 0;
|
|
#ifdef _WIN32
|
|
context.gpu_was_active = false;
|
|
#endif
|
|
context.raw_was_active = false;
|
|
context.was_active = false;
|
|
context.video_thread_name = video_thread_name;
|
|
|
|
#ifdef __APPLE__
|
|
while (obs_graphics_thread_loop_autorelease(&context))
|
|
#else
|
|
while (obs_graphics_thread_loop(&context))
|
|
#endif
|
|
;
|
|
|
|
#ifdef _WIN32
|
|
uninit_winrt_state(&winrt);
|
|
#endif
|
|
|
|
UNUSED_PARAMETER(param);
|
|
return NULL;
|
|
}
|