static void render_nv12(struct obs_core_video *video, gs_texture_t *target,
int cur_texture, int prev_texture, const char *tech_name,
uint32_t width, uint32_t height)
{
gs_texture_t *texture = video->output_textures[prev_texture];
gs_effect_t *effect = video->conversion_effect;
gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image");
gs_technique_t *tech = gs_effect_get_technique(effect, tech_name);
size_t passes, i;
gs_effect_set_texture(image, texture);
gs_set_render_target(target, NULL);
set_render_size(width, height);
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);
}
static inline void render_output_texture(struct obs_core_video *video,
int cur_texture, int prev_texture)
{
profile_start(render_output_texture_name);
gs_texture_t *texture = video->render_textures[prev_texture];
gs_texture_t *target = video->output_textures[cur_texture];
uint32_t width = gs_texture_get_width(target);
uint32_t height = gs_texture_get_height(target);
struct vec2 base_i;
vec2_set(&base_i,
1.0f / (float)video->base_width,
1.0f / (float)video->base_height);
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, "Draw");
} else {
tech = gs_effect_get_technique(effect, "DrawMatrix");
}
gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image");
gs_eparam_t *matrix = gs_effect_get_param_by_name(effect,
"color_matrix");
gs_eparam_t *bres_i = gs_effect_get_param_by_name(effect,
"base_dimension_i");
size_t passes, i;
if (!video->textures_rendered[prev_texture])
goto end;
gs_set_render_target(target, NULL);
set_render_size(width, height);
if (bres_i)
gs_effect_set_vec2(bres_i, &base_i);
gs_effect_set_val(matrix, video->color_matrix, sizeof(float) * 16);
gs_effect_set_texture(image, texture);
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);
video->textures_output[cur_texture] = true;
end:
profile_end(render_output_texture_name);
}
static void render_convert_texture(struct obs_core_video *video,
int cur_texture, int prev_texture)
{
profile_start(render_convert_texture_name);
gs_texture_t *texture = video->output_textures[prev_texture];
gs_texture_t *target = video->convert_textures[cur_texture];
float fwidth = (float)video->output_width;
float fheight = (float)video->output_height;
size_t passes, i;
gs_effect_t *effect = video->conversion_effect;
gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image");
gs_technique_t *tech = gs_effect_get_technique(effect,
video->conversion_tech);
if (!video->textures_output[prev_texture])
goto end;
set_eparam(effect, "u_plane_offset", (float)video->plane_offsets[1]);
set_eparam(effect, "v_plane_offset", (float)video->plane_offsets[2]);
set_eparam(effect, "width", fwidth);
set_eparam(effect, "height", fheight);
set_eparam(effect, "width_i", 1.0f / fwidth);
set_eparam(effect, "height_i", 1.0f / fheight);
set_eparam(effect, "width_d2", fwidth * 0.5f);
set_eparam(effect, "height_d2", fheight * 0.5f);
set_eparam(effect, "width_d2_i", 1.0f / (fwidth * 0.5f));
set_eparam(effect, "height_d2_i", 1.0f / (fheight * 0.5f));
set_eparam(effect, "input_height", (float)video->conversion_height);
gs_effect_set_texture(image, texture);
gs_set_render_target(target, NULL);
set_render_size(video->output_width, video->conversion_height);
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, video->output_width,
video->conversion_height);
gs_technique_end_pass(tech);
}
gs_technique_end(tech);
gs_enable_blending(true);
video->textures_converted[cur_texture] = true;
end:
profile_end(render_convert_texture_name);
}
void xcursor_render(xcursor_t *data) {
/* TODO: why do i need effects ? */
effect_t effect = gs_geteffect();
eparam_t image = effect_getparambyname(effect, "image");
effect_settexture(effect, image, data->tex);
gs_matrix_push();
gs_matrix_translate3f(-data->pos_x, -data->pos_y, 0);
gs_enable_blending(True);
gs_blendfunction(GS_BLEND_ONE, GS_BLEND_INVSRCALPHA);
gs_draw_sprite(data->tex, 0, 0, 0);
gs_enable_blending(False);
gs_matrix_pop();
}
static inline void set_render_size(uint32_t width, uint32_t height)
{
gs_enable_depthtest(false);
gs_enable_blending(false);
gs_setcullmode(GS_NEITHER);
gs_ortho(0.0f, (float)width, 0.0f, (float)height, -100.0f, 100.0f);
gs_setviewport(0, 0, width, height);
}
void xcursor_render(xcursor_t *data) {
gs_effect_t *effect = gs_get_effect();
gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image");
gs_effect_set_texture(image, data->tex);
gs_matrix_push();
gs_matrix_translate3f(data->render_x, data->render_y, 0.0f);
gs_enable_blending(True);
gs_blend_function(GS_BLEND_ONE, GS_BLEND_INVSRCALPHA);
gs_draw_sprite(data->tex, 0, 0, 0);
gs_matrix_pop();
}
void XCompcapMain::render(effect_t effect)
{
PLock lock(&p->lock, true);
if (!lock.isLocked() || !p->tex)
return;
eparam_t image = effect_getparambyname(effect, "image");
effect_settexture(image, p->tex);
gs_enable_blending(false);
gs_draw_sprite(p->tex, 0, 0, 0);
gs_reset_blend_state();
}
static inline void render_video(struct obs_core_video *video,
bool raw_active, const bool gpu_active,
int cur_texture, int prev_texture)
{
gs_begin_scene();
gs_enable_depth_test(false);
gs_set_cull_mode(GS_NEITHER);
render_main_texture(video, cur_texture);
if (raw_active || gpu_active) {
render_output_texture(video, cur_texture, prev_texture);
#ifdef _WIN32
if (gpu_active) {
gs_flush();
}
#endif
}
if (raw_active || gpu_active) {
if (video->gpu_conversion) {
if (video->using_nv12_tex)
render_convert_texture_nv12(video,
cur_texture, prev_texture);
else
render_convert_texture(video,
cur_texture, prev_texture);
}
#ifdef _WIN32
if (gpu_active) {
gs_flush();
output_gpu_encoders(video, raw_active, prev_texture);
}
#endif
if (raw_active)
stage_output_texture(video, cur_texture, prev_texture);
}
gs_set_render_target(NULL, NULL);
gs_enable_blending(true);
gs_end_scene();
}
/**
* Render the capture data
*/
static void xshm_video_render(void *vptr, gs_effect_t effect)
{
XSHM_DATA(vptr);
if (!data->xshm)
return;
gs_eparam_t image = gs_effect_get_param_by_name(effect, "image");
gs_effect_set_texture(image, data->texture);
gs_enable_blending(false);
gs_draw_sprite(data->texture, 0, 0, 0);
if (data->show_cursor)
xcursor_render(data->cursor);
gs_reset_blend_state();
}
void XCompcapMain::render(gs_effect_t *effect)
{
PLock lock(&p->lock, true);
if (!lock.isLocked() || !p->tex)
return;
gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image");
gs_effect_set_texture(image, p->tex);
gs_enable_blending(false);
gs_draw_sprite(p->tex, 0, 0, 0);
if (p->cursor && p->gltex && p->show_cursor && !p->cursor_outside)
xcursor_render(p->cursor);
gs_reset_blend_state();
}
static inline void render_video(struct obs_core_video *video, int cur_texture,
int prev_texture)
{
gs_begin_scene();
gs_enable_depth_test(false);
gs_set_cull_mode(GS_NEITHER);
render_main_texture(video, cur_texture);
render_output_texture(video, cur_texture, prev_texture);
if (video->gpu_conversion)
render_convert_texture(video, cur_texture, prev_texture);
stage_output_texture(video, cur_texture, prev_texture);
gs_set_render_target(NULL, NULL);
gs_enable_blending(true);
gs_end_scene();
}