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

Merge pull request #6146 from jpark37/hdr-main-preview

Browse Source 
libobs, UI: Add support for color spaces
This commit is contained in:
Jim 2022-03-24 16:56:59 -07:00 committed by GitHub
commit 8d15aea69d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 615 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
UI/data/locale/en-US.ini
View File

@ -1036,6 +1036,7 @@ Basic.Settings.Advanced.Video.ColorSpace="Color Space"
Basic.Settings.Advanced.Video.ColorRange="Color Range"
Basic.Settings.Advanced.Video.ColorRange.Partial="Partial"
Basic.Settings.Advanced.Video.ColorRange.Full="Full"
Basic.Settings.Advanced.Video.SdrWhiteLevel="SDR White Level (nits)"
Basic.Settings.Advanced.Audio.MonitoringDevice="Monitoring Device"
Basic.Settings.Advanced.Audio.MonitoringDevice.Default="Default"
Basic.Settings.Advanced.Audio.DisableAudioDucking="Disable Windows audio ducking"

100
UI/forms/OBSBasicSettings.ui
View File

@ -4989,35 +4989,15 @@
</item>
</widget>
</item>
<item row="4" column="1">
<layout class="QHBoxLayout" name="horizontalLayout_18">
<property name="leftMargin">
<number>0</number>
<item row="3" column="0">
<widget class="QLabel" name="label_33">
<property name="text">
<string>Basic.Settings.Advanced.Video.ColorSpace</string>
</property>
<property name="topMargin">
<number>0</number>
<property name="buddy">
<cstring>colorSpace</cstring>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QCheckBox" name="disableOSXVSync">
<property name="text">
<string>DisableOSXVSync</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="resetOSXVSync">
<property name="text">
<string>ResetOSXVSyncOnExit</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="3" column="1">
<layout class="QHBoxLayout" name="horizontalLayout_20">
@ -5073,17 +5053,73 @@
</item>
</layout>
</item>
<item row="3" column="0">
<widget class="QLabel" name="label_33">
<item row="4" column="0">
<widget class="QLabel" name="label_sdrWhiteLevel">
<property name="text">
<string>Basic.Settings.Advanced.Video.ColorSpace</string>
<string>Basic.Settings.Advanced.Video.SdrWhiteLevel</string>
</property>
<property name="buddy">
<cstring>colorSpace</cstring>
<cstring>sdrWhiteLevel</cstring>
</property>
</widget>
</item>
<item row="4" column="0">
<item row="4" column="1">
<layout class="QHBoxLayout" name="horizontalLayout_sdrPaperWhite">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QSpinBox" name="sdrWhiteLevel">
<property name="minimum">
<number>80</number>
</property>
<property name="maximum">
<number>480</number>
</property>
</widget>
</item>
</layout>
</item>
<item row="5" column="1">
<layout class="QHBoxLayout" name="horizontalLayout_18">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QCheckBox" name="disableOSXVSync">
<property name="text">
<string>DisableOSXVSync</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="resetOSXVSync">
<property name="text">
<string>ResetOSXVSyncOnExit</string>
</property>
</widget>
</item>
</layout>
</item>
<item row="6" column="0">
<spacer name="horizontalSpacer_12">
<property name="orientation">
<enum>Qt::Horizontal</enum>

12
UI/qt-display.cpp
View File

@ -221,6 +221,14 @@ QPaintEngine *OBSQTDisplay::paintEngine() const
return nullptr;
}
void OBSQTDisplay::OnMove() {}
void OBSQTDisplay::OnMove()
{
if (display)
obs_display_update_color_space(display);
}
void OBSQTDisplay::OnDisplayChange() {}
void OBSQTDisplay::OnDisplayChange()
{
if (display)
obs_display_update_color_space(display);
}

3
UI/window-basic-main.cpp
View File

@ -1490,6 +1490,7 @@ bool OBSBasic::InitBasicConfigDefaults()
config_set_default_string(basicConfig, "Video", "ColorSpace", "709");
config_set_default_string(basicConfig, "Video", "ColorRange",
"Partial");
config_set_default_uint(basicConfig, "Video", "SdrWhiteLevel", 300);
config_set_default_string(basicConfig, "Audio", "MonitoringDeviceId",
"default");
@ -4392,6 +4393,8 @@ int OBSBasic::ResetVideo()
}
if (ret == OBS_VIDEO_SUCCESS) {
obs_set_video_sdr_white_level((float)config_get_uint(
basicConfig, "Video", "SdrWhiteLevel"));
OBSBasicStats::InitializeValues();
OBSProjector::UpdateMultiviewProjectors();
}

5
UI/window-basic-settings.cpp
View File

@ -531,6 +531,7 @@ OBSBasicSettings::OBSBasicSettings(QWidget *parent)
HookWidget(ui->colorFormat, COMBO_CHANGED, ADV_CHANGED);
HookWidget(ui->colorSpace, COMBO_CHANGED, ADV_CHANGED);
HookWidget(ui->colorRange, COMBO_CHANGED, ADV_CHANGED);
HookWidget(ui->sdrWhiteLevel, SCROLL_CHANGED, ADV_CHANGED);
HookWidget(ui->disableOSXVSync, CHECK_CHANGED, ADV_CHANGED);
HookWidget(ui->resetOSXVSync, CHECK_CHANGED, ADV_CHANGED);
if (obs_audio_monitoring_available())
@ -2521,6 +2522,8 @@ void OBSBasicSettings::LoadAdvancedSettings()
config_get_string(main->Config(), "Video", "ColorSpace");
const char *videoColorRange =
config_get_string(main->Config(), "Video", "ColorRange");
uint32_t sdrWhiteLevel = (uint32_t)config_get_uint(
main->Config(), "Video", "SdrWhiteLevel");
QString monDevName;
QString monDevId;
@ -2592,6 +2595,7 @@ void OBSBasicSettings::LoadAdvancedSettings()
SetComboByName(ui->colorFormat, videoColorFormat);
SetComboByName(ui->colorSpace, videoColorSpace);
SetComboByValue(ui->colorRange, videoColorRange);
ui->sdrWhiteLevel->setValue(sdrWhiteLevel);
if (!SetComboByValue(ui->bindToIP, bindIP))
SetInvalidValue(ui->bindToIP, bindIP, bindIP);
@ -3297,6 +3301,7 @@ void OBSBasicSettings::SaveAdvancedSettings()
SaveCombo(ui->colorFormat, "Video", "ColorFormat");
SaveCombo(ui->colorSpace, "Video", "ColorSpace");
SaveComboData(ui->colorRange, "Video", "ColorRange");
SaveSpinBox(ui->sdrWhiteLevel, "Video", "SdrWhiteLevel");
if (obs_audio_monitoring_available()) {
SaveCombo(ui->monitoringDevice, "Audio",
"MonitoringDeviceName");

16
docs/sphinx/reference-core.rst
View File

@ -147,11 +147,25 @@ Initialization, Shutdown, and Information
.. function:: bool obs_get_video_info(struct obs_video_info *ovi)
Gets the current video settings.
:return: *false* if no video
---------------------
.. function:: float obs_get_video_sdr_white_level(void)
Gets the current SDR white level.
:return: SDR white level, 300.f if no video
---------------------
.. function:: void obs_set_video_sdr_white_level(float sdr_white_level)
Sets the current SDR white level.
---------------------
.. function:: bool obs_get_audio_info(struct obs_audio_info *oai)
Gets the current audio settings.

41
docs/sphinx/reference-libobs-graphics-graphics.rst
View File

@ -47,6 +47,14 @@ Graphics Enumerations
- GS_BGRA_UNORM - BGRA, 8 bits per channel, no SRGB aliasing
- GS_RG16 - RG, 16 bits per channel
.. type:: enum gs_color_space
Color space. Can be one of the following values:
- GS_CS_SRGB - sRGB
- GS_CS_709_EXTENDED - Canvas, Mac EDR (HDR)
- GS_CS_709_SCRGB - 1.0 = 80 nits, Windows/Linux HDR
.. type:: enum gs_zstencil_format
Z-Stencil buffer format. Can be one of the following values:
@ -542,6 +550,13 @@ Swap Chains
---------------------
.. function:: void gs_update_color_space(void)
Updates the color space of the swap chain based on the HDR status of
the nearest monitor
---------------------
.. function:: void gs_get_size(uint32_t *cx, uint32_t *cy)
Gets the size of the currently active swap chain
@ -613,6 +628,12 @@ Resource Loading
Draw Functions
--------------
.. function:: enum gs_color_space gs_get_color_space(void)
:return: The currently active color space
---------------------
.. function:: gs_texture_t *gs_get_render_target(void)
:return: The currently active render target
@ -627,13 +648,23 @@ Draw Functions
.. function:: void gs_set_render_target(gs_texture_t *tex, gs_zstencil_t *zstencil)
Sets the active render target
Sets the active render target with implicit GS_CS_SRGB color space
:param tex: Texture to set as the active render target
:param zstencil: Z-stencil to use as the active render target
---------------------
.. function:: void gs_set_render_target_with_color_space(gs_texture_t *tex, gs_zstencil_t *zstencil, enum gs_color_space space)
Sets the active render target along with color space
:param tex: Texture to set as the active render target
:param zstencil: Z-stencil to use as the active render target
:param space: Color space of the render target
---------------------
.. function:: void gs_set_cube_render_target(gs_texture_t *cubetex, int side, gs_zstencil_t *zstencil)
Sets a cubemap side as the active render target
@ -1475,6 +1506,14 @@ Display Duplicator (Windows Only)
---------------------
Monitor Functions
---------------------------------
.. function:: bool gs_is_monitor_hdr(void *monitor)
---------------------
Render Helper Functions
-----------------------

197
libobs-d3d11/d3d11-subsystem.cpp
View File

@ -66,21 +66,78 @@ gs_obj::~gs_obj()
next->prev_next = prev_next;
}
static inline void make_swap_desc(DXGI_SWAP_CHAIN_DESC &desc,
const gs_init_data *data,
DXGI_SWAP_EFFECT effect, UINT flags)
static bool screen_supports_hdr(gs_device_t *device, HMONITOR hMonitor)
{
IDXGIFactory1 *factory1 = device->factory;
if (!factory1->IsCurrent()) {
device->InitFactory();
factory1 = device->factory;
}
ComPtr<IDXGIAdapter> adapter;
ComPtr<IDXGIOutput> output;
ComPtr<IDXGIOutput6> output6;
for (UINT adapterIndex = 0;
SUCCEEDED(factory1->EnumAdapters(adapterIndex, &adapter));
++adapterIndex) {
for (UINT outputIndex = 0;
SUCCEEDED(adapter->EnumOutputs(outputIndex, &output));
++outputIndex) {
if (SUCCEEDED(output->QueryInterface(&output6))) {
DXGI_OUTPUT_DESC1 desc1;
if (SUCCEEDED(output6->GetDesc1(&desc1)) &&
desc1.Monitor == hMonitor) {
return desc1.ColorSpace ==
DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020;
}
}
}
}
return false;
}
static enum gs_color_space get_next_space(gs_device_t *device, HWND hwnd)
{
enum gs_color_space next_space = GS_CS_SRGB;
const HMONITOR hMonitor =
MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
if (hMonitor) {
if (screen_supports_hdr(device, hMonitor))
next_space = GS_CS_709_SCRGB;
}
return next_space;
}
static enum gs_color_format
get_swap_format_from_space(gs_color_space space, gs_color_format sdr_format)
{
return (space == GS_CS_709_SCRGB) ? GS_RGBA16F : sdr_format;
}
static inline enum gs_color_space
make_swap_desc(gs_device *device, DXGI_SWAP_CHAIN_DESC &desc,
const gs_init_data *data, DXGI_SWAP_EFFECT effect, UINT flags)
{
const HWND hwnd = (HWND)data->window.hwnd;
const enum gs_color_space space = get_next_space(device, hwnd);
const gs_color_format format =
get_swap_format_from_space(space, data->format);
memset(&desc, 0, sizeof(desc));
desc.BufferDesc.Width = data->cx;
desc.BufferDesc.Height = data->cy;
desc.BufferDesc.Format = ConvertGSTextureFormatView(data->format);
desc.BufferDesc.Format = ConvertGSTextureFormatView(format);
desc.SampleDesc.Count = 1;
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
desc.BufferCount = data->num_backbuffers;
desc.OutputWindow = (HWND)data->window.hwnd;
desc.OutputWindow = hwnd;
desc.Windowed = TRUE;
desc.SwapEffect = effect;
desc.Flags = flags;
return space;
}
void gs_swap_chain::InitTarget(uint32_t cx, uint32_t cy)
@ -128,7 +185,7 @@ void gs_swap_chain::InitZStencilBuffer(uint32_t cx, uint32_t cy)
}
}
void gs_swap_chain::Resize(uint32_t cx, uint32_t cy)
void gs_swap_chain::Resize(uint32_t cx, uint32_t cy, gs_color_format format)
{
RECT clientRect;
HRESULT hr;
@ -150,25 +207,40 @@ void gs_swap_chain::Resize(uint32_t cx, uint32_t cy)
cy = clientRect.bottom;
}
hr = swap->ResizeBuffers(swapDesc.BufferCount, cx, cy,
DXGI_FORMAT_UNKNOWN, swapDesc.Flags);
const DXGI_FORMAT dxgi_format = ConvertGSTextureFormatView(format);
hr = swap->ResizeBuffers(swapDesc.BufferCount, cx, cy, dxgi_format,
swapDesc.Flags);
if (FAILED(hr))
throw HRError("Failed to resize swap buffers", hr);
ComQIPtr<IDXGISwapChain3> swap3 = swap;
if (swap3) {
const DXGI_COLOR_SPACE_TYPE dxgi_space =
(format == GS_RGBA16F)
? DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709
: DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709;
hr = swap3->SetColorSpace1(dxgi_space);
if (FAILED(hr))
throw HRError("Failed to set color space", hr);
}
target.dxgiFormatResource = ConvertGSTextureFormatResource(format);
target.dxgiFormatView = dxgi_format;
target.dxgiFormatViewLinear = ConvertGSTextureFormatViewLinear(format);
InitTarget(cx, cy);
InitZStencilBuffer(cx, cy);
}
void gs_swap_chain::Init()
{
const gs_color_format format = get_swap_format_from_space(
get_next_space(device, hwnd), initData.format);
target.device = device;
target.isRenderTarget = true;
target.format = initData.format;
target.dxgiFormatResource =
ConvertGSTextureFormatResource(initData.format);
target.dxgiFormatView = ConvertGSTextureFormatView(initData.format);
target.dxgiFormatViewLinear =
ConvertGSTextureFormatViewLinear(initData.format);
target.dxgiFormatResource = ConvertGSTextureFormatResource(format);
target.dxgiFormatView = ConvertGSTextureFormatView(format);
target.dxgiFormatViewLinear = ConvertGSTextureFormatViewLinear(format);
InitTarget(initData.cx, initData.cy);
zs.device = device;
@ -180,7 +252,8 @@ void gs_swap_chain::Init()
gs_swap_chain::gs_swap_chain(gs_device *device, const gs_init_data *data)
: gs_obj(device, gs_type::gs_swap_chain),
hwnd((HWND)data->window.hwnd),
initData(*data)
initData(*data),
space(GS_CS_SRGB)
{
DXGI_SWAP_EFFECT effect = DXGI_SWAP_EFFECT_DISCARD;
UINT flags = 0;
@ -203,7 +276,7 @@ gs_swap_chain::gs_swap_chain(gs_device *device, const gs_init_data *data)
}
}
make_swap_desc(swapDesc, &initData, effect, flags);
space = make_swap_desc(device, swapDesc, &initData, effect, flags);
HRESULT hr = device->factory->CreateSwapChain(device->device, &swapDesc,
swap.Assign());
if (FAILED(hr))
@ -1340,6 +1413,24 @@ gs_swapchain_t *device_swapchain_create(gs_device_t *device,
return swap;
}
static void device_resize_internal(gs_device_t *device, uint32_t cx,
uint32_t cy, gs_color_space space)
{
try {
const gs_color_format format = get_swap_format_from_space(
space, device->curSwapChain->initData.format);
device->context->OMSetRenderTargets(0, NULL, NULL);
device->curSwapChain->Resize(cx, cy, format);
device->curSwapChain->space = space;
device->curFramebufferInvalidate = true;
} catch (const HRError &error) {
blog(LOG_ERROR, "device_resize_internal (D3D11): %s (%08lX)",
error.str, error.hr);
LogD3D11ErrorDetails(error, device);
}
}
void device_resize(gs_device_t *device, uint32_t cx, uint32_t cy)
{
if (!device->curSwapChain) {
@ -1347,14 +1438,26 @@ void device_resize(gs_device_t *device, uint32_t cx, uint32_t cy)
return;
}
try {
device->context->OMSetRenderTargets(0, NULL, NULL);
device->curSwapChain->Resize(cx, cy);
device->curFramebufferInvalidate = true;
} catch (const HRError &error) {
blog(LOG_ERROR, "device_resize (D3D11): %s (%08lX)", error.str,
error.hr);
LogD3D11ErrorDetails(error, device);
const enum gs_color_space next_space =
get_next_space(device, device->curSwapChain->hwnd);
device_resize_internal(device, cx, cy, next_space);
}
enum gs_color_space device_get_color_space(gs_device_t *device)
{
return device->curColorSpace;
}
void device_update_color_space(gs_device_t *device)
{
if (device->curSwapChain) {
const enum gs_color_space next_space =
get_next_space(device, device->curSwapChain->hwnd);
if (device->curSwapChain->space != next_space)
device_resize_internal(device, 0, 0, next_space);
} else {
blog(LOG_WARNING,
"device_update_color_space (D3D11): No active swap");
}
}
@ -1874,8 +1977,10 @@ gs_zstencil_t *device_get_zstencil_target(const gs_device_t *device)
return device->curZStencilBuffer;
}
void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
gs_zstencil_t *zstencil)
static void device_set_render_target_internal(gs_device_t *device,
gs_texture_t *tex,
gs_zstencil_t *zstencil,
enum gs_color_space space)
{
if (device->curSwapChain) {
if (!tex)
@ -1885,12 +1990,13 @@ void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
}
if (device->curRenderTarget == tex &&
device->curZStencilBuffer == zstencil)
return;
device->curZStencilBuffer == zstencil) {
device->curColorSpace = space;
}
if (tex && tex->type != GS_TEXTURE_2D) {
blog(LOG_ERROR,
"device_set_render_target (D3D11): texture is not a 2D texture");
"device_set_render_target_internal (D3D11): texture is not a 2D texture");
return;
}
@ -1898,12 +2004,27 @@ void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
if (device->curRenderTarget != tex2d || device->curRenderSide != 0 ||
device->curZStencilBuffer != zstencil) {
device->curRenderTarget = tex2d;
device->curRenderSide = 0;
device->curZStencilBuffer = zstencil;
device->curRenderSide = 0;
device->curColorSpace = space;
device->curFramebufferInvalidate = true;
}
}
void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
gs_zstencil_t *zstencil)
{
device_set_render_target_internal(device, tex, zstencil, GS_CS_SRGB);
}
void device_set_render_target_with_color_space(gs_device_t *device,
gs_texture_t *tex,
gs_zstencil_t *zstencil,
enum gs_color_space space)
{
device_set_render_target_internal(device, tex, zstencil, space);
}
void device_set_cube_render_target(gs_device_t *device, gs_texture_t *tex,
int side, gs_zstencil_t *zstencil)
{
@ -1931,8 +2052,9 @@ void device_set_cube_render_target(gs_device_t *device, gs_texture_t *tex,
if (device->curRenderTarget != tex2d || device->curRenderSide != side ||
device->curZStencilBuffer != zstencil) {
device->curRenderTarget = tex2d;
device->curRenderSide = side;
device->curZStencilBuffer = zstencil;
device->curRenderSide = side;
device->curColorSpace = GS_CS_SRGB;
device->curFramebufferInvalidate = true;
}
}
@ -2177,11 +2299,14 @@ void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swapchain)
device->curSwapChain = swapchain;
if (is_cube)
if (is_cube) {
device_set_cube_render_target(device, target,
device->curRenderSide, zs);
else
device_set_render_target(device, target, zs);
} else {
const enum gs_color_space space = swapchain ? swapchain->space
: GS_CS_SRGB;
device_set_render_target_internal(device, target, zs, space);
}
}
void device_clear(gs_device_t *device, uint32_t clear_flags,
@ -2922,6 +3047,12 @@ extern "C" EXPORT bool device_p010_available(gs_device_t *device)
return device->p010Supported;
}
extern "C" EXPORT bool device_is_monitor_hdr(gs_device_t *device, void *monitor)
{
const HMONITOR hMonitor = static_cast<HMONITOR>(monitor);
return screen_supports_hdr(device, hMonitor);
}
extern "C" EXPORT void device_debug_marker_begin(gs_device_t *,
const char *markername,
const float color[4])

4
libobs-d3d11/d3d11-subsystem.hpp
View File

@ -820,6 +820,7 @@ struct gs_swap_chain : gs_obj {
HWND hwnd;
gs_init_data initData;
DXGI_SWAP_CHAIN_DESC swapDesc = {};
gs_color_space space;
UINT presentFlags = 0;
gs_texture_2d target;
@ -829,7 +830,7 @@ struct gs_swap_chain : gs_obj {
void InitTarget(uint32_t cx, uint32_t cy);
void InitZStencilBuffer(uint32_t cx, uint32_t cy);
void Resize(uint32_t cx, uint32_t cy);
void Resize(uint32_t cx, uint32_t cy, gs_color_format format);
void Init();
void Rebuild(ID3D11Device *dev);
@ -991,6 +992,7 @@ struct gs_device {
gs_texture_2d *curRenderTarget = nullptr;
gs_zstencil_buffer *curZStencilBuffer = nullptr;
int curRenderSide = 0;
enum gs_color_space curColorSpace = GS_CS_SRGB;
bool curFramebufferSrgb = false;
bool curFramebufferInvalidate = false;
gs_texture *curTextures[GS_MAX_TEXTURES];

5
libobs-opengl/gl-cocoa.m
View File

@ -310,6 +310,11 @@ void device_present(gs_device_t *device)
[device->plat->context makeCurrentContext];
}
bool device_is_monitor_hdr(gs_device_t *device, void *monitor)
{
return false;
}
void gl_getclientsize(const struct gs_swap_chain *swap, uint32_t *width,
uint32_t *height)
{

5
libobs-opengl/gl-nix.c
View File

@ -124,6 +124,11 @@ extern void device_present(gs_device_t *device)
gl_vtable->device_present(device);
}
extern bool device_is_monitor_hdr(gs_device_t *device, void *monitor)
{
return false;
}
extern struct gs_texture *device_texture_create_from_dmabuf(
gs_device_t *device, unsigned int width, unsigned int height,
uint32_t drm_format, enum gs_color_format color_format,

48
libobs-opengl/gl-subsystem.c
View File

@ -340,6 +340,17 @@ void device_resize(gs_device_t *device, uint32_t cx, uint32_t cy)
gl_update(device);
}
enum gs_color_space device_get_color_space(gs_device_t *device)
{
return device->cur_color_space;
}
void device_update_color_space(gs_device_t *device)
{
if (!device->cur_swap)
blog(LOG_WARNING, "device_display_change (GL): No active swap");
}
void device_get_size(const gs_device_t *device, uint32_t *cx, uint32_t *cy)
{
if (device->cur_swap) {
@ -819,9 +830,9 @@ static bool attach_zstencil(struct fbo_info *fbo, gs_zstencil_t *zs)
}
static bool set_target(gs_device_t *device, gs_texture_t *tex, int side,
gs_zstencil_t *zs)
gs_zstencil_t *zs, enum gs_color_space space)
{
struct fbo_info *fbo;
device->cur_color_space = space;
if (device->cur_render_target == tex &&
device->cur_zstencil_buffer == zs &&
@ -835,7 +846,7 @@ static bool set_target(gs_device_t *device, gs_texture_t *tex, int side,
if (!tex)
return set_current_fbo(device, NULL);
fbo = get_fbo_by_tex(tex);
struct fbo_info *const fbo = get_fbo_by_tex(tex);
if (!fbo)
return false;
@ -864,7 +875,7 @@ void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
}
}
if (!set_target(device, tex, 0, zstencil))
if (!set_target(device, tex, 0, zstencil, GS_CS_SRGB))
goto fail;
return;
@ -873,6 +884,33 @@ fail:
blog(LOG_ERROR, "device_set_render_target (GL) failed");
}
void device_set_render_target_with_color_space(gs_device_t *device,
gs_texture_t *tex,
gs_zstencil_t *zstencil,
enum gs_color_space space)
{
if (tex) {
if (tex->type != GS_TEXTURE_2D) {
blog(LOG_ERROR, "Texture is not a 2D texture");
goto fail;
}
if (!tex->is_render_target) {
blog(LOG_ERROR, "Texture is not a render target");
goto fail;
}
}
if (!set_target(device, tex, 0, zstencil, space))
goto fail;
return;
fail:
blog(LOG_ERROR,
"device_set_render_target_with_color_space (GL) failed");
}
void device_set_cube_render_target(gs_device_t *device, gs_texture_t *cubetex,
int side, gs_zstencil_t *zstencil)
{
@ -888,7 +926,7 @@ void device_set_cube_render_target(gs_device_t *device, gs_texture_t *cubetex,
}
}
if (!set_target(device, cubetex, side, zstencil))
if (!set_target(device, cubetex, side, zstencil, GS_CS_SRGB))
goto fail;
return;

1
libobs-opengl/gl-subsystem.h
View File

@ -653,6 +653,7 @@ struct gs_device {
gs_shader_t *cur_pixel_shader;
gs_swapchain_t *cur_swap;
struct gs_program *cur_program;
enum gs_color_space cur_color_space;
struct gs_program *first_program;

5
libobs-opengl/gl-windows.c
View File

@ -598,6 +598,11 @@ extern void gl_getclientsize(const struct gs_swap_chain *swap, uint32_t *width,
}
}
EXPORT bool device_is_monitor_hdr(gs_device_t *device, void *monitor)
{
return false;
}
EXPORT bool device_gdi_texture_available(void)
{
return false;

61
libobs/data/default.effect
View File

@ -1,5 +1,6 @@
uniform float4x4 ViewProj;
uniform texture2d image;
uniform float multiplier;
sampler_state def_sampler {
Filter = Linear;
@ -69,6 +70,48 @@ float4 PSDrawSrgbDecompress(VertInOut vert_in) : TARGET
return rgba;
}
float4 PSDrawMultiply(VertInOut vert_in) : TARGET
{
float4 rgba = image.Sample(def_sampler, vert_in.uv);
rgba.rgb *= multiplier;
return rgba;
}
float3 rec709_to_rec2020(float3 v)
{
float r = dot(v, float3(0.6274040f, 0.3292820f, 0.0433136f));
float g = dot(v, float3(0.0690970f, 0.9195400f, 0.0113612f));
float b = dot(v, float3(0.0163916f, 0.0880132f, 0.8955950f));
return float3(r, g, b);
}
float3 rec2020_to_rec709(float3 v)
{
float r = dot(v, float3(1.6604910, -0.5876411, -0.0728499));
float g = dot(v, float3(-0.1245505, 1.1328999, -0.0083494));
float b = dot(v, float3(-0.0181508, -0.1005789, 1.1187297));
return float3(r, g, b);
}
float reinhard_channel(float x)
{
return x / (x + 1.0);
}
float3 reinhard(float3 rgb)
{
return float3(reinhard_channel(rgb.r), reinhard_channel(rgb.g), reinhard_channel(rgb.b));
}
float4 PSDrawTonemap(VertInOut vert_in) : TARGET
{
float4 rgba = image.Sample(def_sampler, vert_in.uv);
rgba.rgb = rec709_to_rec2020(rgba.rgb);
rgba.rgb = reinhard(rgba.rgb);
rgba.rgb = rec2020_to_rec709(rgba.rgb);
return rgba;
}
technique Draw
{
pass
@ -104,3 +147,21 @@ technique DrawSrgbDecompress
pixel_shader = PSDrawSrgbDecompress(vert_in);
}
}
technique DrawMultiply
{
pass
{
vertex_shader = VSDefault(vert_in);
pixel_shader = PSDrawMultiply(vert_in);
}
}
technique DrawTonemap
{
pass
{
vertex_shader = VSDefault(vert_in);
pixel_shader = PSDrawTonemap(vert_in);
}
}

5
libobs/graphics/device-exports.h
View File

@ -37,6 +37,8 @@ EXPORT void *device_get_device_obj(gs_device_t *device);
EXPORT gs_swapchain_t *device_swapchain_create(gs_device_t *device,
const struct gs_init_data *data);
EXPORT void device_resize(gs_device_t *device, uint32_t x, uint32_t y);
EXPORT enum gs_color_space device_get_color_space(gs_device_t *device);
EXPORT void device_update_color_space(gs_device_t *device);
EXPORT void device_get_size(const gs_device_t *device, uint32_t *x,
uint32_t *y);
EXPORT uint32_t device_get_width(const gs_device_t *device);
@ -104,6 +106,9 @@ EXPORT gs_texture_t *device_get_render_target(const gs_device_t *device);
EXPORT gs_zstencil_t *device_get_zstencil_target(const gs_device_t *device);
EXPORT void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
gs_zstencil_t *zstencil);
EXPORT void device_set_render_target_with_color_space(
gs_device_t *device, gs_texture_t *tex, gs_zstencil_t *zstencil,
enum gs_color_space space);
EXPORT void device_set_cube_render_target(gs_device_t *device,
gs_texture_t *cubetex, int side,
gs_zstencil_t *zstencil);

5
libobs/graphics/graphics-imports.c
View File

@ -53,6 +53,8 @@ bool load_graphics_imports(struct gs_exports *exports, void *module,
GRAPHICS_IMPORT(device_get_device_obj);
GRAPHICS_IMPORT(device_swapchain_create);
GRAPHICS_IMPORT(device_resize);
GRAPHICS_IMPORT(device_get_color_space);
GRAPHICS_IMPORT(device_update_color_space);
GRAPHICS_IMPORT(device_get_size);
GRAPHICS_IMPORT(device_get_width);
GRAPHICS_IMPORT(device_get_height);
@ -81,6 +83,7 @@ bool load_graphics_imports(struct gs_exports *exports, void *module,
GRAPHICS_IMPORT(device_get_render_target);
GRAPHICS_IMPORT(device_get_zstencil_target);
GRAPHICS_IMPORT(device_set_render_target);
GRAPHICS_IMPORT(device_set_render_target_with_color_space);
GRAPHICS_IMPORT(device_set_cube_render_target);
GRAPHICS_IMPORT(device_enable_framebuffer_srgb);
GRAPHICS_IMPORT(device_framebuffer_srgb_enabled);
@ -192,6 +195,8 @@ bool load_graphics_imports(struct gs_exports *exports, void *module,
GRAPHICS_IMPORT_OPTIONAL(device_nv12_available);
GRAPHICS_IMPORT_OPTIONAL(device_p010_available);
GRAPHICS_IMPORT(device_is_monitor_hdr);
GRAPHICS_IMPORT(device_debug_marker_begin);
GRAPHICS_IMPORT(device_debug_marker_end);

7
libobs/graphics/graphics-internal.h
View File

@ -38,6 +38,8 @@ struct gs_exports {
gs_swapchain_t *(*device_swapchain_create)(
gs_device_t *device, const struct gs_init_data *data);
void (*device_resize)(gs_device_t *device, uint32_t x, uint32_t y);
enum gs_color_space (*device_get_color_space)(gs_device_t *device);
void (*device_update_color_space)(gs_device_t *device);
void (*device_get_size)(const gs_device_t *device, uint32_t *x,
uint32_t *y);
uint32_t (*device_get_width)(const gs_device_t *device);
@ -103,6 +105,9 @@ struct gs_exports {
gs_zstencil_t *(*device_get_zstencil_target)(const gs_device_t *device);
void (*device_set_render_target)(gs_device_t *device, gs_texture_t *tex,
gs_zstencil_t *zstencil);
void (*device_set_render_target_with_color_space)(
gs_device_t *device, gs_texture_t *tex, gs_zstencil_t *zstencil,
enum gs_color_space space);
void (*device_set_cube_render_target)(gs_device_t *device,
gs_texture_t *cubetex, int side,
gs_zstencil_t *zstencil);
@ -268,6 +273,8 @@ struct gs_exports {
bool (*device_nv12_available)(gs_device_t *device);
bool (*device_p010_available)(gs_device_t *device);
bool (*device_is_monitor_hdr)(gs_device_t *device, void *monitor);
void (*device_debug_marker_begin)(gs_device_t *device,
const char *markername,
const float color[4]);

42
libobs/graphics/graphics.c
View File

@ -1308,6 +1308,16 @@ void gs_resize(uint32_t x, uint32_t y)
graphics->exports.device_resize(graphics->device, x, y);
}
void gs_update_color_space(void)
{
graphics_t *graphics = thread_graphics;
if (!gs_valid("gs_update_color_space"))
return;
graphics->exports.device_update_color_space(graphics->device);
}
void gs_get_size(uint32_t *x, uint32_t *y)
{
graphics_t *graphics = thread_graphics;
@ -1715,6 +1725,16 @@ gs_shader_t *gs_get_pixel_shader(void)
return graphics->exports.device_get_pixel_shader(graphics->device);
}
enum gs_color_space gs_get_color_space(void)
{
graphics_t *graphics = thread_graphics;
if (!gs_valid("gs_get_color_space"))
return GS_CS_SRGB;
return graphics->exports.device_get_color_space(graphics->device);
}
gs_texture_t *gs_get_render_target(void)
{
graphics_t *graphics = thread_graphics;
@ -1746,6 +1766,19 @@ void gs_set_render_target(gs_texture_t *tex, gs_zstencil_t *zstencil)
zstencil);
}
void gs_set_render_target_with_color_space(gs_texture_t *tex,
gs_zstencil_t *zstencil,
enum gs_color_space space)
{
graphics_t *graphics = thread_graphics;
if (!gs_valid("gs_set_render_target_with_color_space"))
return;
graphics->exports.device_set_render_target_with_color_space(
graphics->device, tex, zstencil, space);
}
void gs_set_cube_render_target(gs_texture_t *cubetex, int side,
gs_zstencil_t *zstencil)
{
@ -2807,6 +2840,15 @@ bool gs_p010_available(void)
thread_graphics->device);
}
bool gs_is_monitor_hdr(void *monitor)
{
if (!gs_valid("gs_is_monitor_hdr"))
return false;
return thread_graphics->exports.device_is_monitor_hdr(
thread_graphics->device, monitor);
}
void gs_debug_marker_begin(const float color[4], const char *markername)
{
if (!gs_valid("gs_debug_marker_begin"))

30
libobs/graphics/graphics.h
View File

@ -79,6 +79,12 @@ enum gs_color_format {
GS_RG16,
};
enum gs_color_space {
GS_CS_SRGB, /* SDR */
GS_CS_709_EXTENDED, /* Canvas, Mac EDR (HDR) */
GS_CS_709_SCRGB, /* 1.0 = 80 nits, Windows/Linux HDR */
};
enum gs_zstencil_format {
GS_ZS_NONE,
GS_Z16,
@ -461,6 +467,9 @@ EXPORT gs_texrender_t *gs_texrender_create(enum gs_color_format format,
EXPORT void gs_texrender_destroy(gs_texrender_t *texrender);
EXPORT bool gs_texrender_begin(gs_texrender_t *texrender, uint32_t cx,
uint32_t cy);
EXPORT bool gs_texrender_begin_with_color_space(gs_texrender_t *texrender,
uint32_t cx, uint32_t cy,
enum gs_color_space space);
EXPORT void gs_texrender_end(gs_texrender_t *texrender);
EXPORT void gs_texrender_reset(gs_texrender_t *texrender);
EXPORT gs_texture_t *gs_texrender_get_texture(const gs_texrender_t *texrender);
@ -634,6 +643,7 @@ EXPORT void gs_reset_blend_state(void);
EXPORT gs_swapchain_t *gs_swapchain_create(const struct gs_init_data *data);
EXPORT void gs_resize(uint32_t x, uint32_t y);
EXPORT void gs_update_color_space(void);
EXPORT void gs_get_size(uint32_t *x, uint32_t *y);
EXPORT uint32_t gs_get_width(void);
EXPORT uint32_t gs_get_height(void);
@ -689,10 +699,14 @@ EXPORT void gs_load_default_samplerstate(bool b_3d, int unit);
EXPORT gs_shader_t *gs_get_vertex_shader(void);
EXPORT gs_shader_t *gs_get_pixel_shader(void);
EXPORT enum gs_color_space gs_get_color_space(void);
EXPORT gs_texture_t *gs_get_render_target(void);
EXPORT gs_zstencil_t *gs_get_zstencil_target(void);
EXPORT void gs_set_render_target(gs_texture_t *tex, gs_zstencil_t *zstencil);
EXPORT void gs_set_render_target_with_color_space(gs_texture_t *tex,
gs_zstencil_t *zstencil,
enum gs_color_space space);
EXPORT void gs_set_cube_render_target(gs_texture_t *cubetex, int side,
gs_zstencil_t *zstencil);
@ -837,6 +851,8 @@ EXPORT bool gs_timer_range_get_data(gs_timer_range_t *range, bool *disjoint,
EXPORT bool gs_nv12_available(void);
EXPORT bool gs_p010_available(void);
EXPORT bool gs_is_monitor_hdr(void *monitor);
#define GS_USE_DEBUG_MARKERS 0
#if GS_USE_DEBUG_MARKERS
static const float GS_DEBUG_COLOR_DEFAULT[] = {0.5f, 0.5f, 0.5f, 1.0f};
@ -1039,6 +1055,20 @@ gs_generalize_format(enum gs_color_format format)
}
}
static inline enum gs_color_format
gs_get_format_from_space(enum gs_color_space space)
{
switch (space) {
case GS_CS_SRGB:
break;
case GS_CS_709_EXTENDED:
case GS_CS_709_SCRGB:
return GS_RGBA16F;
}
return GS_RGBA;
}
static inline uint32_t gs_get_total_levels(uint32_t width, uint32_t height,
uint32_t depth)
{

16
libobs/graphics/texture-render.c
View File

@ -26,6 +26,7 @@
struct gs_texture_render {
gs_texture_t *target, *prev_target;
gs_zstencil_t *zs, *prev_zs;
enum gs_color_space prev_space;
uint32_t cx, cy;
@ -88,6 +89,13 @@ static bool texrender_resetbuffer(gs_texrender_t *texrender, uint32_t cx,
}
bool gs_texrender_begin(gs_texrender_t *texrender, uint32_t cx, uint32_t cy)
{
return gs_texrender_begin_with_color_space(texrender, cx, cy,
GS_CS_SRGB);
}
bool gs_texrender_begin_with_color_space(gs_texrender_t *texrender, uint32_t cx,
uint32_t cy, enum gs_color_space space)
{
if (!texrender || texrender->rendered)
return false;
@ -109,7 +117,9 @@ bool gs_texrender_begin(gs_texrender_t *texrender, uint32_t cx, uint32_t cy)
texrender->prev_target = gs_get_render_target();
texrender->prev_zs = gs_get_zstencil_target();
gs_set_render_target(texrender->target, texrender->zs);
texrender->prev_space = gs_get_color_space();
gs_set_render_target_with_color_space(texrender->target, texrender->zs,
space);
gs_set_viewport(0, 0, texrender->cx, texrender->cy);
@ -121,7 +131,9 @@ void gs_texrender_end(gs_texrender_t *texrender)
if (!texrender)
return;
gs_set_render_target(texrender->prev_target, texrender->prev_zs);
gs_set_render_target_with_color_space(texrender->prev_target,
texrender->prev_zs,
texrender->prev_space);
gs_matrix_pop();
gs_projection_pop();

28
libobs/obs-display.c
View File

@ -124,6 +124,18 @@ void obs_display_resize(obs_display_t *display, uint32_t cx, uint32_t cy)
pthread_mutex_unlock(&display->draw_info_mutex);
}
void obs_display_update_color_space(obs_display_t *display)
{
if (!display)
return;
pthread_mutex_lock(&display->draw_info_mutex);
display->update_color_space = true;
pthread_mutex_unlock(&display->draw_info_mutex);
}
void obs_display_add_draw_callback(obs_display_t *display,
void (*draw)(void *param, uint32_t cx,
uint32_t cy),
@ -155,7 +167,8 @@ void obs_display_remove_draw_callback(obs_display_t *display,
}
static inline void render_display_begin(struct obs_display *display,
uint32_t cx, uint32_t cy)
uint32_t cx, uint32_t cy,
bool update_color_space)
{
struct vec4 clear_color;
@ -165,11 +178,16 @@ static inline void render_display_begin(struct obs_display *display,
gs_resize(cx, cy);
display->cx = cx;
display->cy = cy;
} else if (update_color_space) {
gs_update_color_space();
}
gs_begin_scene();
vec4_from_rgba(&clear_color, display->background_color);
if (gs_get_color_space() == GS_CS_SRGB)
vec4_from_rgba(&clear_color, display->background_color);
else
vec4_from_rgba_srgb(&clear_color, display->background_color);
clear_color.w = 1.0f;
gs_clear(GS_CLEAR_COLOR | GS_CLEAR_DEPTH | GS_CLEAR_STENCIL,
@ -191,6 +209,7 @@ static inline void render_display_end()
void render_display(struct obs_display *display)
{
uint32_t cx, cy;
bool update_color_space;
if (!display || !display->enabled)
return;
@ -203,12 +222,15 @@ void render_display(struct obs_display *display)
cx = display->next_cx;
cy = display->next_cy;
update_color_space = display->update_color_space;
display->update_color_space = false;
pthread_mutex_unlock(&display->draw_info_mutex);
/* -------------------------------------------- */
render_display_begin(display, cx, cy);
render_display_begin(display, cx, cy, update_color_space);
pthread_mutex_lock(&display->draw_callbacks_mutex);

3
libobs/obs-internal.h
View File

@ -204,6 +204,7 @@ extern void obs_view_free(struct obs_view *view);
/* displays */
struct obs_display {
bool update_color_space;
bool enabled;
uint32_t cx, cy;
uint32_t next_cx, next_cy;
@ -255,6 +256,7 @@ struct obs_core_video {
#endif
gs_texture_t *render_texture;
gs_texture_t *output_texture;
enum gs_color_space render_space;
bool texture_rendered;
bool textures_copied[NUM_TEXTURES];
bool texture_converted;
@ -321,6 +323,7 @@ struct obs_core_video {
gs_effect_t *deinterlace_yadif_2x_effect;
struct obs_video_info ovi;
uint32_t sdr_white_level;
pthread_mutex_t task_mutex;
struct circlebuf tasks;

3
libobs/obs-video.c
View File

@ -133,7 +133,8 @@ static inline void render_main_texture(struct obs_core_video *video)
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_set_render_target_with_color_space(video->render_texture, NULL,
video->render_space);
gs_clear(GS_CLEAR_COLOR, &clear_color, 1.0f, 0);
set_render_size(video->base_width, video->base_height);

50
libobs/obs.c
View File

@ -268,19 +268,24 @@ static bool obs_init_textures(struct obs_video_info *ovi)
}
}
enum gs_color_format format = GS_RGBA;
enum gs_color_space space = GS_CS_SRGB;
video->render_texture = gs_texture_create(ovi->base_width,
ovi->base_height, GS_RGBA, 1,
ovi->base_height, format, 1,
NULL, GS_RENDER_TARGET);
if (!video->render_texture)
success = false;
video->output_texture = gs_texture_create(ovi->output_width,
ovi->output_height, GS_RGBA,
1, NULL, GS_RENDER_TARGET);
ovi->output_height, format, 1,
NULL, GS_RENDER_TARGET);
if (!video->output_texture)
success = false;
if (!success) {
if (success) {
video->render_space = space;
} else {
for (size_t i = 0; i < NUM_TEXTURES; i++) {
for (size_t c = 0; c < NUM_CHANNELS; c++) {
if (video->copy_surfaces[i][c]) {
@ -1301,6 +1306,20 @@ bool obs_get_video_info(struct obs_video_info *ovi)
return true;
}
float obs_get_video_sdr_white_level(void)
{
struct obs_core_video *video = &obs->video;
return video->graphics ? video->sdr_white_level : 300.f;
}
void obs_set_video_sdr_white_level(float sdr_white_level)
{
struct obs_core_video *video = &obs->video;
assert(video->graphics);
video->sdr_white_level = (uint32_t)sdr_white_level;
}
bool obs_get_audio_info(struct obs_audio_info *oai)
{
struct obs_core_audio *audio = &obs->audio;
@ -1793,18 +1812,37 @@ static void obs_render_main_texture_internal(enum gs_blend_type src_c,
if (!video->texture_rendered)
return;
const enum gs_color_space source_space = video->render_space;
const enum gs_color_space current_space = gs_get_color_space();
const char *tech_name = "Draw";
float multiplier = 1.0f;
if ((current_space == GS_CS_SRGB) &&
(source_space == GS_CS_709_EXTENDED)) {
tech_name = "DrawTonemap";
} else if (current_space == GS_CS_709_SCRGB) {
tech_name = "DrawMultiply";
multiplier = obs_get_video_sdr_white_level() / 80.0f;
}
const bool previous = gs_framebuffer_srgb_enabled();
gs_enable_framebuffer_srgb(true);
tex = video->render_texture;
effect = obs_get_base_effect(OBS_EFFECT_DEFAULT);
param = gs_effect_get_param_by_name(effect, "image");
gs_effect_set_texture(param, tex);
gs_effect_set_texture_srgb(param, tex);
param = gs_effect_get_param_by_name(effect, "multiplier");
gs_effect_set_float(param, multiplier);
gs_blend_state_push();
gs_blend_function_separate(src_c, dest_c, src_a, dest_a);
while (gs_effect_loop(effect, "Draw"))
while (gs_effect_loop(effect, tech_name))
gs_draw_sprite(tex, 0, 0, 0);
gs_blend_state_pop();
gs_enable_framebuffer_srgb(previous);
}
void obs_render_main_texture(void)

9
libobs/obs.h
View File

@ -410,6 +410,12 @@ EXPORT bool obs_reset_audio(const struct obs_audio_info *oai);
/** Gets the current video settings, returns false if no video */
EXPORT bool obs_get_video_info(struct obs_video_info *ovi);
/** Gets the SDR white level, returns 300.0 if no video */
EXPORT float obs_get_video_sdr_white_level(void);
/** Sets the SDR white level */
EXPORT void obs_set_video_sdr_white_level(float sdr_white_level);
/** Gets the current audio settings, returns false if no audio */
EXPORT bool obs_get_audio_info(struct obs_audio_info *oai);
@ -881,6 +887,9 @@ EXPORT void obs_display_destroy(obs_display_t *display);
EXPORT void obs_display_resize(obs_display_t *display, uint32_t cx,
uint32_t cy);
/** Updates the color space of this display */
EXPORT void obs_display_update_color_space(obs_display_t *display);
/**
* Adds a draw callback for this display context
*