Permalink
Fetching contributors…
Cannot retrieve contributors at this time
2191 lines (1718 sloc) 78.1 KB
/********************************************************************************
Copyright (C) 2012 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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
********************************************************************************/
#include "Main.h"
#include <intrin.h>
void SetupSceneCollection(CTSTR scenecollection);
//primarily main window stuff an initialization/destruction code
typedef bool (*LOADPLUGINPROC)();
typedef bool (*LOADPLUGINEXPROC)(UINT);
typedef void (*UNLOADPLUGINPROC)();
typedef CTSTR (*GETPLUGINNAMEPROC)();
ImageSource* STDCALL CreateDesktopSource(XElement *data);
bool STDCALL ConfigureDesktopSource(XElement *data, bool bCreating);
bool STDCALL ConfigureWindowCaptureSource(XElement *data, bool bCreating);
bool STDCALL ConfigureMonitorCaptureSource(XElement *data, bool bCreating);
ImageSource* STDCALL CreateBitmapSource(XElement *data);
bool STDCALL ConfigureBitmapSource(XElement *element, bool bCreating);
ImageSource* STDCALL CreateBitmapTransitionSource(XElement *data);
bool STDCALL ConfigureBitmapTransitionSource(XElement *element, bool bCreating);
ImageSource* STDCALL CreateTextSource(XElement *data);
bool STDCALL ConfigureTextSource(XElement *element, bool bCreating);
ImageSource* STDCALL CreateGlobalSource(XElement *data);
void STDCALL SceneHotkey(DWORD hotkey, UPARAM param, bool bDown);
APIInterface* CreateOBSApiInterface();
#define QuickClearHotkey(hotkeyID) \
if(hotkeyID) \
{ \
API->DeleteHotkey(hotkeyID); \
hotkeyID = NULL; \
}
//----------------------------
WNDPROC listboxProc = NULL;
WNDPROC listviewProc = NULL;
//----------------------------
const float defaultBlendFactor[4] = {1.0f, 1.0f, 1.0f, 1.0f};
//----------------------------
BOOL CALLBACK MonitorInfoEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, List<MonitorInfo> &monitors)
{
monitors << MonitorInfo(hMonitor, lprcMonitor);
return TRUE;
}
const int controlPadding = 3;
const int totalControlAreaWidth = minClientWidth - 10;
const int miscAreaWidth = 290;
const int totalControlAreaHeight = 171;//170;//
const int listAreaWidth = totalControlAreaWidth-miscAreaWidth;
const int controlWidth = miscAreaWidth/2;
const int controlHeight = 22;
const int volControlHeight = 32;
const int volMeterHeight = 10;
const int textControlHeight = 16;
const int listControlWidth = listAreaWidth/2;
Scene* STDCALL CreateNormalScene(XElement *data)
{
return new Scene;
}
BOOL IsWebrootLoaded()
{
BOOL ret = FALSE;
StringList moduleList;
OSGetLoadedModuleList (GetCurrentProcess(), moduleList);
HMODULE msIMG = GetModuleHandle(TEXT("MSIMG32"));
if (msIMG)
{
FARPROC alphaBlend = GetProcAddress(msIMG, "AlphaBlend");
if (alphaBlend)
{
if (!IsBadReadPtr(alphaBlend, 5))
{
BYTE opCode = *(BYTE *)alphaBlend;
if (opCode == 0xE9)
{
if (moduleList.HasValue(TEXT("wrusr.dll")))
ret = TRUE;
}
}
}
}
return ret;
}
// Checks the AppData path is writable and the disk has enough space
VOID CheckPermissionsAndDiskSpace()
{
ULARGE_INTEGER freeSpace;
if (GetDiskFreeSpaceEx (lpAppDataPath, &freeSpace, NULL, NULL))
{
// 1MB ought to be enough for anybody...
if (freeSpace.QuadPart < 1048576)
{
OBSMessageBox(OBSGetMainWindow(), Str("DiskFull"), NULL, MB_ICONERROR);
}
}
HANDLE tempFile;
String testPath;
testPath = lpAppDataPath;
testPath += TEXT("\\.test");
tempFile = CreateFile(testPath.Array(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE, NULL);
if (tempFile == INVALID_HANDLE_VALUE)
{
DWORD err = GetLastError();
if (err == ERROR_ACCESS_DENIED || err == ERROR_FILE_READ_ONLY)
OBSMessageBox(OBSGetMainWindow(), Str("BadAppDataPermissions"), NULL, MB_ICONERROR);
// TODO: extra handling for unknown errors (maybe some av returns weird codes?)
}
else
{
CloseHandle(tempFile);
}
}
//---------------------------------------------------------------------------
VOID OBS::LoadAllPlugins()
{
//-----------------------------------------------------
// load plugins
OSFindData ofd;
HANDLE hFind = OSFindFirstFile(TEXT("plugins/*.dll"), ofd);
if (hFind)
{
do
{
if (!ofd.bDirectory) //why would someone give a directory a .dll extension in the first place? pranksters.
{
String strLocation;
strLocation << TEXT("plugins/") << ofd.fileName;
HMODULE hPlugin = LoadLibrary(strLocation);
if (hPlugin)
{
bool bLoaded = false;
//slightly redundant I suppose seeing as both these things are being added at the same time
LOADPLUGINEXPROC loadPluginEx = (LOADPLUGINEXPROC)GetProcAddress(hPlugin, "LoadPluginEx");
if (loadPluginEx) {
bLoaded = loadPluginEx(OBSGetAPIVersion());
}
else {
LOADPLUGINPROC loadPlugin = (LOADPLUGINPROC)GetProcAddress(hPlugin, "LoadPlugin");
bLoaded = loadPlugin && loadPlugin();
}
if (bLoaded) {
PluginInfo *pluginInfo = plugins.CreateNew();
pluginInfo->hModule = hPlugin;
pluginInfo->strFile = ofd.fileName;
/* get event callbacks for the plugin */
pluginInfo->startStreamCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnStartStream");
pluginInfo->stopStreamCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnStopStream");
pluginInfo->startStreamingCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnStartStreaming");
pluginInfo->stopStreamingCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnStopStreaming");
pluginInfo->startRecordingCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnStartRecording");
pluginInfo->stopRecordingCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnStopRecording");
pluginInfo->statusCallback = (OBS_STATUS_CALLBACK)GetProcAddress(hPlugin, "OnOBSStatus");
pluginInfo->streamStatusCallback = (OBS_STREAM_STATUS_CALLBACK)GetProcAddress(hPlugin, "OnStreamStatus");
pluginInfo->sceneSwitchCallback = (OBS_SCENE_SWITCH_CALLBACK)GetProcAddress(hPlugin, "OnSceneSwitch");
pluginInfo->sceneCollectionSwitchCallback = (OBS_SCENE_SWITCH_CALLBACK)GetProcAddress(hPlugin, "OnSceneCollectionSwitch");
pluginInfo->scenesChangedCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnScenesChanged");
pluginInfo->sceneCollectionsChangedCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnSceneCollectionsChanged");
pluginInfo->sourceOrderChangedCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnSourceOrderChanged");
pluginInfo->sourceChangedCallback = (OBS_SOURCE_CHANGED_CALLBACK)GetProcAddress(hPlugin, "OnSourceChanged");
pluginInfo->sourcesAddedOrRemovedCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnSourcesAddedOrRemoved");
pluginInfo->micVolumeChangeCallback = (OBS_VOLUME_CHANGED_CALLBACK)GetProcAddress(hPlugin, "OnMicVolumeChanged");
pluginInfo->desktopVolumeChangeCallback = (OBS_VOLUME_CHANGED_CALLBACK)GetProcAddress(hPlugin, "OnDesktopVolumeChanged");
pluginInfo->logUpdateCallback = (OBS_LOG_UPDATE_CALLBACK)GetProcAddress(hPlugin, "OnLogUpdate");
pluginInfo->startRecordingReplayBufferCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnStartRecordingReplayBuffer");
pluginInfo->stopRecordingReplayBufferCallback = (OBS_CALLBACK)GetProcAddress(hPlugin, "OnStopRecordingReplayBuffer");
pluginInfo->replayBufferSavedCallback = (OBS_REPLAY_BUFFER_SAVED_CALLBACK)GetProcAddress(hPlugin, "OnReplayBufferSaved");
//GETPLUGINNAMEPROC getName = (GETPLUGINNAMEPROC)GetProcAddress(hPlugin, "GetPluginName");
//CTSTR lpName = (getName) ? getName() : TEXT("<unknown>");
//FIXME: TODO: log this somewhere else, it comes before the OBS version info and looks weird.
//Log(TEXT("Loaded plugin '%s', %s"), lpName, strLocation);
}
else
{
Log(TEXT("Failed to initialize plugin %s"), strLocation.Array());
FreeLibrary(hPlugin);
}
}
else
{
DWORD err = GetLastError();
Log(TEXT("Failed to load plugin %s, %d"), strLocation.Array(), err);
#ifndef _DEBUG
if (err == 193)
{
#ifdef _M_X64
String message = FormattedString(Str("Plugins.InvalidVersion"), ofd.fileName, 32);
#else
String message = FormattedString(Str("Plugins.InvalidVersion"), ofd.fileName, 64);
#endif
OBSMessageBox(hwndMain, message.Array(), NULL, MB_ICONEXCLAMATION);
}
#endif
}
}
} while (OSFindNextFile(hFind, ofd));
OSFindClose(hFind);
}
}
OBS::OBS()
{
App = this;
performTransition = true; //Default to true and don't set the conf.
//We don't want to let plugins disable standard behavior permanently.
hSceneMutex = OSCreateMutex();
hAuxAudioMutex = OSCreateMutex();
hVideoEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
monitors.Clear();
EnumDisplayMonitors(NULL, NULL, (MONITORENUMPROC)MonitorInfoEnumProc, (LPARAM)&monitors);
INITCOMMONCONTROLSEX ecce;
ecce.dwSize = sizeof(ecce);
ecce.dwICC = ICC_STANDARD_CLASSES;
if(!InitCommonControlsEx(&ecce))
CrashError(TEXT("Could not initalize common shell controls"));
InitHotkeyExControl(hinstMain);
InitColorControl(hinstMain);
InitVolumeControl(hinstMain);
InitVolumeMeter(hinstMain);
// still need this here for API
strLanguage = GlobalConfig->GetString(TEXT("General"), TEXT("Language"), TEXT("en"));
//-----------------------------------------------------
// load classes
RegisterSceneClass(TEXT("Scene"), Str("Scene"), (OBSCREATEPROC)CreateNormalScene, NULL, false);
RegisterImageSourceClass(TEXT("DesktopImageSource"), Str("Sources.SoftwareCaptureSource"), (OBSCREATEPROC)CreateDesktopSource, (OBSCONFIGPROC)ConfigureDesktopSource, true);
RegisterImageSourceClass(TEXT("WindowCaptureSource"), Str("Sources.SoftwareCaptureSource.WindowCapture"), (OBSCREATEPROC)CreateDesktopSource, (OBSCONFIGPROC)ConfigureWindowCaptureSource, false);
RegisterImageSourceClass(TEXT("MonitorCaptureSource"), Str("Sources.SoftwareCaptureSource.MonitorCapture"), (OBSCREATEPROC)CreateDesktopSource, (OBSCONFIGPROC)ConfigureMonitorCaptureSource, false);
RegisterImageSourceClass(TEXT("BitmapImageSource"), Str("Sources.BitmapSource"), (OBSCREATEPROC)CreateBitmapSource, (OBSCONFIGPROC)ConfigureBitmapSource, false);
RegisterImageSourceClass(TEXT("BitmapTransitionSource"), Str("Sources.TransitionSource"), (OBSCREATEPROC)CreateBitmapTransitionSource, (OBSCONFIGPROC)ConfigureBitmapTransitionSource, false);
RegisterImageSourceClass(TEXT("GlobalSource"), Str("Sources.GlobalSource"), (OBSCREATEPROC)CreateGlobalSource, (OBSCONFIGPROC)OBS::ConfigGlobalSource, false);
RegisterImageSourceClass(TEXT("TextSource"), Str("Sources.TextSource"), (OBSCREATEPROC)CreateTextSource, (OBSCONFIGPROC)ConfigureTextSource, false);
//-----------------------------------------------------
// render frame class
WNDCLASS wc;
zero(&wc, sizeof(wc));
wc.hInstance = hinstMain;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = OBS_RENDERFRAME_CLASS;
wc.lpfnWndProc = (WNDPROC)OBS::RenderFrameProc;
wc.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
if(!RegisterClass(&wc))
CrashError(TEXT("Could not register render frame class"));
//-----------------------------------------------------
// projector frame class
wc.lpszClassName = OBS_PROJECTORFRAME_CLASS;
wc.lpfnWndProc = (WNDPROC)OBS::ProjectorFrameProc;
wc.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
if(!RegisterClass(&wc))
CrashError(TEXT("Could not register projector frame class"));
//-----------------------------------------------------
// log window class
wc.lpszClassName = OBS_LOGWINDOW_CLASS;
wc.lpfnWndProc = (WNDPROC)OBS::LogWindowProc;
wc.hIcon = LoadIcon(hinstMain, MAKEINTRESOURCE(IDI_ICON1));
wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
if(!RegisterClass(&wc))
CrashError(TEXT("Could not register main window class"));
//-----------------------------------------------------
// main window class
wc.lpszClassName = OBS_WINDOW_CLASS;
wc.lpfnWndProc = (WNDPROC)OBSProc;
wc.hIcon = LoadIcon(hinstMain, MAKEINTRESOURCE(IDI_ICON1));
wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
wc.lpszMenuName = MAKEINTRESOURCE(IDR_MAINMENU);
if(!RegisterClass(&wc))
CrashError(TEXT("Could not register main window class"));
//-----------------------------------------------------
// create main window
int fullscreenX = GetSystemMetrics(SM_CXFULLSCREEN);
int fullscreenY = GetSystemMetrics(SM_CYFULLSCREEN);
borderXSize = borderYSize = 0;
borderXSize += GetSystemMetrics(SM_CXSIZEFRAME)*2;
borderYSize += GetSystemMetrics(SM_CYSIZEFRAME)*2;
borderYSize += GetSystemMetrics(SM_CYMENU);
borderYSize += GetSystemMetrics(SM_CYCAPTION);
clientWidth = GlobalConfig->GetInt(TEXT("General"), TEXT("Width"), defaultClientWidth);
clientHeight = GlobalConfig->GetInt(TEXT("General"), TEXT("Height"), defaultClientHeight);
if(clientWidth < minClientWidth)
clientWidth = minClientWidth;
if(clientHeight < minClientHeight)
clientHeight = minClientHeight;
int maxCX = fullscreenX-borderXSize;
int maxCY = fullscreenY-borderYSize;
if(clientWidth > maxCX)
clientWidth = maxCX;
if(clientHeight > maxCY)
clientHeight = maxCY;
int cx = clientWidth + borderXSize;
int cy = clientHeight + borderYSize;
int x = (fullscreenX/2)-(cx/2);
int y = (fullscreenY/2)-(cy/2);
int posX = GlobalConfig->GetInt(TEXT("General"), TEXT("PosX"), -9999);
int posY = GlobalConfig->GetInt(TEXT("General"), TEXT("PosY"), -9999);
bool bInsideMonitors = false;
for(UINT i=0; i<monitors.Num(); i++)
{
if( posX >= monitors[i].rect.left && posX < monitors[i].rect.right &&
posY >= monitors[i].rect.top && posY < monitors[i].rect.bottom )
{
bInsideMonitors = true;
break;
}
}
if(bInsideMonitors)
{
x = posX;
y = posY;
}
bPanelVisibleWindowed = GlobalConfig->GetInt(TEXT("General"), TEXT("PanelVisibleWindowed"), 1) != 0;
bPanelVisibleFullscreen = GlobalConfig->GetInt(TEXT("General"), TEXT("PanelVisibleFullscreen"), 0) != 0;
bPanelVisible = bPanelVisibleWindowed; // Assuming OBS always starts windowed
bPanelVisibleProcessed = false; // Force immediate process
bFullscreenMode = false;
hwndMain = CreateWindowEx(WS_EX_CONTROLPARENT|WS_EX_WINDOWEDGE|(LocaleIsRTL() ? WS_EX_LAYOUTRTL : 0), OBS_WINDOW_CLASS, GetApplicationName(),
WS_OVERLAPPED | WS_THICKFRAME | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_CAPTION | WS_SYSMENU | WS_CLIPCHILDREN,
x, y, cx, cy, NULL, NULL, hinstMain, NULL);
if(!hwndMain)
CrashError(TEXT("Could not create main window"));
hmenuMain = GetMenu(hwndMain);
LocalizeMenu(hmenuMain);
//-----------------------------------------------------
// render frame
hwndRenderFrame = CreateWindow(OBS_RENDERFRAME_CLASS, NULL,
WS_CHILDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN,
0, 0, 0, 0,
hwndMain, NULL, hinstMain, NULL);
if(!hwndRenderFrame)
CrashError(TEXT("Could not create render frame"));
//-----------------------------------------------------
// projector window
hwndProjector = CreateWindow(OBS_PROJECTORFRAME_CLASS,
L"OBS Projector Window",
WS_POPUP, 0, 0, 0, 0,
NULL, NULL, hinstMain, NULL);
//-----------------------------------------------------
// log window
x = (fullscreenX/2)-(600/2);
y = (fullscreenY/2)-(500/2);
int logPosX = GlobalConfig->GetInt(TEXT("General"), TEXT("LogPosX"), -9999);
int logPosY = GlobalConfig->GetInt(TEXT("General"), TEXT("LogPosY"), -9999);
int logSizeX = GlobalConfig->GetInt(TEXT("General"), TEXT("LogSizeX"), 600);
int logSizeY = GlobalConfig->GetInt(TEXT("General"), TEXT("LogSizeY"), 500);
bInsideMonitors = false;
for(UINT i=0; i<monitors.Num(); i++)
{
if( logPosX >= monitors[i].rect.left && logPosX < monitors[i].rect.right &&
logPosY >= monitors[i].rect.top && logPosY < monitors[i].rect.bottom )
{
bInsideMonitors = true;
break;
}
}
if(bInsideMonitors)
{
x = logPosX;
y = logPosY;
}
else
{
logSizeX = 600;
logSizeY = 500;
}
hwndLogWindow = CreateWindowEx(LocaleIsRTL() ? WS_EX_LAYOUTRTL | WS_EX_NOINHERITLAYOUT : 0, OBS_LOGWINDOW_CLASS, L"LogWindow", WS_OVERLAPPEDWINDOW, x, y, logSizeX, logSizeY, NULL, NULL, hinstMain, NULL);
LocalizeWindow(hwndLogWindow);
RECT client;
GetClientRect(hwndLogWindow, &client);
hwndLog = CreateWindowEx(WS_EX_CLIENTEDGE, L"EDIT", L"",
ES_MULTILINE | WS_VISIBLE | WS_CHILD | WS_TABSTOP | WS_VSCROLL | WS_HSCROLL | ES_READONLY | ES_NOHIDESEL,
client.left, client.top, client.right, client.bottom, hwndLogWindow, (HMENU)ID_LOG_WINDOW, 0, 0);
SendMessage(hwndLog, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
SendMessage(hwndLog, EM_SETLIMITTEXT, 0, 0);
ShowWindow(hwndLog, SW_SHOW);
ResetLogUpdateCallback([] { PostMessage(hwndLogWindow, WM_COMMAND, MAKEWPARAM(ID_LOG_WINDOW, 0), 0); });
//-----------------------------------------------------
// render frame text
hwndRenderMessage = CreateWindow(TEXT("STATIC"), Str("MainWindow.BeginMessage"),
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS|SS_CENTER,
0, 0, 0, 0, hwndRenderFrame, NULL, hinstMain, NULL);
SendMessage(hwndRenderMessage, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// scenes listbox
HWND hwndTemp;
hwndTemp = CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("LISTBOX"), NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|LBS_HASSTRINGS|WS_VSCROLL|LBS_NOTIFY|LBS_NOINTEGRALHEIGHT|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SCENES, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
listboxProc = (WNDPROC)GetWindowLongPtr(hwndTemp, GWLP_WNDPROC);
SetWindowLongPtr(hwndTemp, GWLP_WNDPROC, (LONG_PTR)OBS::ListboxHook);
//-----------------------------------------------------
// elements listview
hwndTemp = CreateWindowEx(WS_EX_CLIENTEDGE, WC_LISTVIEW, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|WS_VSCROLL|WS_CLIPSIBLINGS|LVS_REPORT|LVS_NOCOLUMNHEADER|
LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | LVS_NOLABELWRAP,
0, 0, 0, 0, hwndMain, (HMENU)ID_SOURCES, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
ListView_SetExtendedListViewStyle(hwndTemp, LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER);
//add single column needed for report style
LVCOLUMN column;
column.mask = LVCF_TEXT;
column.fmt = LVCFMT_FIXED_WIDTH;
column.cx = 0;
column.pszText = TEXT("");
ListView_InsertColumn(hwndTemp, 0, &column);
ListView_InsertColumn(hwndTemp, 1, &column);
listviewProc = (WNDPROC)GetWindowLongPtr(hwndTemp, GWLP_WNDPROC);
SetWindowLongPtr(hwndTemp, GWLP_WNDPROC, (LONG_PTR)OBS::ListboxHook);
HWND hwndSources = hwndTemp;
//-----------------------------------------------------
// status control
hwndTemp = CreateWindowEx(0, STATUSCLASSNAME, NULL,
WS_CHILD|WS_VISIBLE|SBARS_SIZEGRIP|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_STATUS, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// mic volume control
hwndTemp = CreateWindow(VOLUME_CONTROL_CLASS, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_MICVOLUME, 0, 0);
SetVolumeControlIcons(hwndTemp, GetIcon(hinstMain, IDI_SOUND_MIC), GetIcon(hinstMain, IDI_SOUND_MIC_MUTED));
//-----------------------------------------------------
// mic volume meter
hwndTemp = CreateWindow(VOLUME_METER_CLASS, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_MICVOLUMEMETER, 0, 0);
//-----------------------------------------------------
// desktop volume meter
hwndTemp = CreateWindow(VOLUME_METER_CLASS, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_DESKTOPVOLUMEMETER, 0, 0);
//-----------------------------------------------------
// desktop volume control
hwndTemp = CreateWindow(VOLUME_CONTROL_CLASS, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_DESKTOPVOLUME, 0, 0);
SetVolumeControlIcons(hwndTemp, GetIcon(hinstMain, IDI_SOUND_DESKTOP), GetIcon(hinstMain, IDI_SOUND_DESKTOP_MUTED));
//-----------------------------------------------------
// start/stop recording button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.StartRecording"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_SPLITBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_TOGGLERECORDING, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// settings button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("Settings"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SETTINGS, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// start/stop stream button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.StartStream"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_STARTSTOP, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// edit scene button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.SceneEditor"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_AUTOCHECKBOX|BS_PUSHLIKE|WS_DISABLED|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SCENEEDITOR, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// global sources button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("GlobalSources"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_GLOBALSOURCES, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// test stream button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.TestStream"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_TESTSTREAM, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// plugins button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.Plugins"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_PLUGINS, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// dashboard button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.Dashboard"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_DASHBOARD, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// exit button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.Exit"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_EXIT, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// scenes text
hwndTemp = CreateWindow(TEXT("STATIC"), Str("MainWindow.Scenes"),
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SCENES_TEXT, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// scenes text
hwndTemp = CreateWindow(TEXT("STATIC"), Str("MainWindow.Sources"),
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SOURCES_TEXT, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// notification area
bNotificationAreaIcon = false;
wmExplorerRestarted = RegisterWindowMessage(TEXT("TaskbarCreated"));
if (AppConfig->GetInt(TEXT("General"), TEXT("ShowNotificationAreaIcon"), 0) != 0)
{
ShowNotificationAreaIcon();
}
//-----------------------------------------------------
// populate scenes
hwndTemp = GetDlgItem(hwndMain, ID_SCENES);
String collection = GetCurrentSceneCollection();
if (!OSFileExists(String() << lpAppDataPath << L"\\sceneCollection\\" << collection << L".xconfig"))
collection.Clear();
if (collection.IsEmpty())
{
OSFindData ofd;
HANDLE hFind = OSFindFirstFile(String() << lpAppDataPath << L"\\sceneCollection\\*.xconfig", ofd);
if (hFind)
{
do
{
if (!ofd.bDirectory)
{
collection = GetPathWithoutExtension(ofd.fileName);
break;
}
} while (OSFindNextFile(hFind, ofd));
OSFindClose(hFind);
}
if (collection.IsEmpty())
{
CopyFile(String() << lpAppDataPath << L"\\scenes.xconfig", String() << lpAppDataPath << L"\\sceneCollection\\scenes.xconfig", true);
collection = L"scenes";
GlobalConfig->SetString(L"General", L"SceneCollection", collection);
}
}
String strScenesConfig;
strScenesConfig = FormattedString(L"%s\\sceneCollection\\%s.xconfig", lpAppDataPath, collection.Array());
if(!scenesConfig.Open(strScenesConfig))
CrashError(TEXT("Could not open '%s'"), strScenesConfig.Array());
XElement *scenes = scenesConfig.GetElement(TEXT("scenes"));
if(!scenes)
scenes = scenesConfig.CreateElement(TEXT("scenes"));
UINT numScenes = scenes->NumElements();
if(!numScenes)
{
XElement *scene = scenes->CreateElement(Str("Scene"));
scene->SetString(TEXT("class"), TEXT("Scene"));
numScenes++;
}
for(UINT i=0; i<numScenes; i++)
{
XElement *scene = scenes->GetElementByID(i);
//scene->SetString(TEXT("class"), TEXT("Scene"));
SendMessage(hwndTemp, LB_ADDSTRING, 0, (LPARAM)scene->GetName());
}
//-----------------------------------------------------
// populate sources
if(numScenes)
{
String strScene = AppConfig->GetString(TEXT("General"), TEXT("CurrentScene"));
int id = (int)SendMessage(hwndTemp, LB_FINDSTRINGEXACT, -1, (LPARAM)strScene.Array());
if(id == LB_ERR)
id = 0;
SendMessage(hwndTemp, LB_SETCURSEL, (WPARAM)id, 0);
SendMessage(hwndMain, WM_COMMAND, MAKEWPARAM(ID_SCENES, LBN_SELCHANGE), (LPARAM)GetDlgItem(hwndMain, ID_SCENES));
}
//-----------------------------------------------------
hHotkeyMutex = OSCreateMutex();
hInfoMutex = OSCreateMutex();
hStartupShutdownMutex = OSCreateMutex();
//-----------------------------------------------------
API = CreateOBSApiInterface();
bDragResize = false;
if(GlobalConfig->GetInt(TEXT("General"), TEXT("Maximized")))
{ // Window was maximized last session
SendMessage(hwndMain, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
}
//-----------------------------------------------------
for(UINT i=0; i<numScenes; i++)
{
XElement *scene = scenes->GetElementByID(i);
DWORD hotkey = scene->GetInt(TEXT("hotkey"));
if(hotkey)
{
SceneHotkeyInfo hotkeyInfo;
hotkeyInfo.hotkey = hotkey;
hotkeyInfo.scene = scene;
hotkeyInfo.hotkeyID = API->CreateHotkey(hotkey, SceneHotkey, 0);
if(hotkeyInfo.hotkeyID)
sceneHotkeys << hotkeyInfo;
}
}
//-----------------------------------------------------
// Add built-in settings panes
currentSettingsPane = NULL;
AddBuiltInSettingsPanes();
AddEncoderSettingsPanes();
//-----------------------------------------------------
ReloadIniSettings();
ResetProfileMenu();
ResetSceneCollectionMenu();
ResetLogUploadMenu();
//-----------------------------------------------------
bAutoReconnect = AppConfig->GetInt(TEXT("Publish"), TEXT("AutoReconnect"), 1) != 0;
reconnectTimeout = AppConfig->GetInt(TEXT("Publish"), TEXT("AutoReconnectTimeout"), 10);
hHotkeyThread = OSCreateThread((XTHREAD)HotkeyThread, NULL);
#ifndef OBS_DISABLE_AUTOUPDATE
ULARGE_INTEGER lastUpdateTime;
ULARGE_INTEGER currentTime;
FILETIME systemTime;
lastUpdateTime.QuadPart = GlobalConfig->GetInt(TEXT("General"), OBS_CONFIG_UPDATE_KEY, 0);
GetSystemTimeAsFileTime(&systemTime);
currentTime.LowPart = systemTime.dwLowDateTime;
currentTime.HighPart = systemTime.dwHighDateTime;
//OBS doesn't support 64 bit ints in the config file, so we have to normalize it to a 32 bit int
currentTime.QuadPart /= 10000000;
currentTime.QuadPart -= 13000000000;
if (currentTime.QuadPart - lastUpdateTime.QuadPart >= 3600)
{
GlobalConfig->SetInt(TEXT("General"), OBS_CONFIG_UPDATE_KEY, (int)currentTime.QuadPart);
OSCloseThread(OSCreateThread((XTHREAD)CheckUpdateThread, (LPVOID)0));
}
#endif
// TODO: Should these be stored in the config file?
bRenderViewEnabled = GlobalConfig->GetInt(TEXT("General"), TEXT("PreviewEnabled"), 1) != 0;
bForceRenderViewErase = false;
renderFrameIn1To1Mode = false;
if(GlobalConfig->GetInt(TEXT("General"), TEXT("ShowWebrootWarning"), TRUE) && IsWebrootLoaded())
OBSMessageBox(hwndMain, TEXT("Webroot Secureanywhere appears to be active. This product will cause problems with OBS as the security features block OBS from accessing Windows GDI functions. It is highly recommended that you disable Secureanywhere and restart OBS.\r\n\r\nOf course you can always just ignore this message if you want, but it may prevent you from being able to stream certain things. Please do not report any bugs you may encounter if you leave Secureanywhere enabled."), TEXT("Just a slight issue you might want to be aware of"), MB_OK);
CheckPermissionsAndDiskSpace();
ConfigureStreamButtons();
ResizeWindow(false);
ShowWindow(hwndMain, SW_SHOW);
renderFrameIn1To1Mode = !!GlobalConfig->GetInt(L"General", L"1to1Preview", false);
App->bAlwaysOnTop = !!GlobalConfig->GetInt(L"General", L"AlwaysOnTop");
CheckMenuItem(GetMenu(hwndMain), ID_ALWAYSONTOP, (App->bAlwaysOnTop) ? MF_CHECKED : MF_UNCHECKED);
SetWindowPos(hwndMain, (App->bAlwaysOnTop) ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
// make sure sources listview column widths are as expected after obs window is shown
ListView_SetColumnWidth(hwndSources,0,LVSCW_AUTOSIZE_USEHEADER);
ListView_SetColumnWidth(hwndSources,1,LVSCW_AUTOSIZE_USEHEADER);
if (GlobalConfig->GetInt(L"General", L"ShowLogWindowOnLaunch") != 0)
PostMessage(hwndMain, WM_COMMAND, MAKEWPARAM(ID_SHOWLOG, 0), 0);
if (bStreamOnStart)
PostMessage(hwndMain, WM_COMMAND, MAKEWPARAM(ID_STARTSTOP, 0), NULL);
}
OBS::~OBS()
{
Stop(true, true);
bShuttingDown = true;
OSTerminateThread(hHotkeyThread, 2500);
ClosePendingStreams();
for(UINT i=0; i<plugins.Num(); i++)
{
PluginInfo &pluginInfo = plugins[i];
UNLOADPLUGINPROC unloadPlugin = (UNLOADPLUGINPROC)GetProcAddress(pluginInfo.hModule, "UnloadPlugin");
if(unloadPlugin)
unloadPlugin();
FreeLibrary(pluginInfo.hModule);
pluginInfo.strFile.Clear();
ZeroMemory(&pluginInfo, sizeof(pluginInfo));
}
if (AppConfig->GetInt(TEXT("General"), TEXT("ShowNotificationAreaIcon"), 0) != 0)
{
App->HideNotificationAreaIcon();
}
if (logDirectoryMonitor)
OSMonitorDirectoryCallbackStop(logDirectoryMonitor);
//DestroyWindow(hwndMain);
// Remember window state for next launch
WINDOWPLACEMENT placement;
placement.length = sizeof(placement);
GetWindowPlacement(hwndMain, &placement);
RECT rect = { 0 };
GetWindowRect(hwndMain, &rect);
GlobalConfig->SetInt(TEXT("General"), TEXT("PosX"), rect.left);
GlobalConfig->SetInt(TEXT("General"), TEXT("PosY"), rect.top);
GlobalConfig->SetInt(TEXT("General"), TEXT("Width"),
rect.right - rect.left -
GetSystemMetrics(SM_CXSIZEFRAME) * 2);
GlobalConfig->SetInt(TEXT("General"), TEXT("Height"),
rect.bottom - rect.top -
GetSystemMetrics(SM_CYSIZEFRAME) * 2 - GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYMENU));
GlobalConfig->SetInt(TEXT("General"), TEXT("Maximized"), placement.showCmd == SW_SHOWMAXIMIZED ? 1 : 0);
GetWindowRect(hwndLogWindow, &rect);
GlobalConfig->SetInt(TEXT("General"), TEXT("LogPosX"), rect.left);
GlobalConfig->SetInt(TEXT("General"), TEXT("LogPosY"), rect.top);
GlobalConfig->SetInt(TEXT("General"), TEXT("LogSizeX"), rect.right - rect.left);
GlobalConfig->SetInt(TEXT("General"), TEXT("LogSizeY"), rect.bottom - rect.top);
GlobalConfig->SetInt(L"General", L"1to1Preview", renderFrameIn1To1Mode);
GlobalConfig->SetInt(L"General", L"AlwaysOnTop", App->bAlwaysOnTop);
// Save control panel visibility
GlobalConfig->SetInt(TEXT("General"), TEXT("PanelVisibleWindowed"), bPanelVisibleWindowed ? 1 : 0);
GlobalConfig->SetInt(TEXT("General"), TEXT("PanelVisibleFullscreen"), bPanelVisibleFullscreen ? 1 : 0);
// Save preview enabled/disabled state
GlobalConfig->SetInt(TEXT("General"), TEXT("PreviewEnabled"), bRenderViewEnabled ? 1 : 0);
scenesConfig.SaveTo(String() << lpAppDataPath << "\\scenes.xconfig");
scenesConfig.Close(true);
for(UINT i=0; i<Icons.Num(); i++)
DeleteObject(Icons[i].hIcon);
Icons.Clear();
for(UINT i=0; i<Fonts.Num(); i++)
{
DeleteObject(Fonts[i].hFont);
Fonts[i].strFontFace.Clear();
}
Fonts.Clear();
for(UINT i=0; i<sceneClasses.Num(); i++)
sceneClasses[i].FreeData();
for(UINT i=0; i<imageSourceClasses.Num(); i++)
imageSourceClasses[i].FreeData();
if (hVideoEvent)
CloseHandle(hVideoEvent);
if(hSceneMutex)
OSCloseMutex(hSceneMutex);
if(hAuxAudioMutex)
OSCloseMutex(hAuxAudioMutex);
delete API;
API = NULL;
for (UINT i=0; i<settingsPanes.Num(); i++)
delete settingsPanes[i];
if(hInfoMutex)
OSCloseMutex(hInfoMutex);
if(hHotkeyMutex)
OSCloseMutex(hHotkeyMutex);
App = NULL;
}
/**
* Controls which message should be displayed in the middle of the main window.
*/
void OBS::UpdateRenderViewMessage()
{
if(bRunning)
{
if(bRenderViewEnabled)
{
// Message should be invisible
ShowWindow(hwndRenderMessage, SW_HIDE);
}
else
{
ShowWindow(hwndRenderMessage, SW_SHOW);
SetWindowText(hwndRenderMessage, Str("MainWindow.PreviewDisabled"));
}
}
else
{
ShowWindow(hwndRenderMessage, SW_SHOW);
SetWindowText(hwndRenderMessage, Str("MainWindow.BeginMessage"));
}
}
void OBS::ResizeRenderFrame(bool bRedrawRenderFrame)
{
// Get output steam size and aspect ratio
int curCX, curCY;
float mainAspect;
if(bRunning)
{
curCX = outputCX;
curCY = outputCY;
mainAspect = float(curCX)/float(curCY);
}
else
{
// Default to the monitor's resolution if the base size is undefined
int monitorID = AppConfig->GetInt(TEXT("Video"), TEXT("Monitor"));
if(monitorID >= (int)monitors.Num())
monitorID = 0;
RECT &screenRect = monitors[monitorID].rect;
int defCX = screenRect.right - screenRect.left;
int defCY = screenRect.bottom - screenRect.top;
// Calculate output size using the same algorithm that's in OBS::Start()
float scale = AppConfig->GetFloat(TEXT("Video"), TEXT("Downscale"), 1.0f);
curCX = AppConfig->GetInt(TEXT("Video"), TEXT("BaseWidth"), defCX);
curCY = AppConfig->GetInt(TEXT("Video"), TEXT("BaseHeight"), defCY);
curCX = MIN(MAX(curCX, 128), 4096);
curCY = MIN(MAX(curCY, 128), 4096);
curCX = UINT(double(curCX) / double(scale));
curCY = UINT(double(curCY) / double(scale));
curCX = curCX & 0xFFFFFFFC; // Align width to 128bit for fast SSE YUV4:2:0 conversion
curCY = curCY & 0xFFFFFFFE;
mainAspect = float(curCX)/float(curCY);
}
// Get area to render in
int x, y;
UINT controlWidth = clientWidth;
UINT controlHeight = clientHeight;
if(bPanelVisible)
controlHeight -= totalControlAreaHeight + controlPadding;
UINT newRenderFrameWidth, newRenderFrameHeight;
if(renderFrameIn1To1Mode)
{
newRenderFrameWidth = (UINT)curCX;
newRenderFrameHeight = (UINT)curCY;
x = (int)controlWidth / 2 - curCX / 2;
y = (int)controlHeight / 2 - curCY / 2;
}
else
{ // Scale to fit
Vect2 renderSize = Vect2(float(controlWidth), float(controlHeight));
float renderAspect = renderSize.x/renderSize.y;
if(renderAspect > mainAspect)
{
renderSize.x = renderSize.y*mainAspect;
x = int((float(controlWidth)-renderSize.x)*0.5f);
y = 0;
}
else
{
renderSize.y = renderSize.x/mainAspect;
x = 0;
y = int((float(controlHeight)-renderSize.y)*0.5f);
}
// Round and ensure even size
newRenderFrameWidth = int(renderSize.x+0.5f)&0xFFFFFFFE;
newRenderFrameHeight = int(renderSize.y+0.5f)&0xFFFFFFFE;
}
// Fill the majority of the window with the 3D scene. We'll render everything in DirectX
SetWindowPos(hwndRenderFrame, NULL, 0, 0, controlWidth, controlHeight, SWP_NOOWNERZORDER);
//----------------------------------------------
renderFrameX = x;
renderFrameY = y;
renderFrameWidth = newRenderFrameWidth;
renderFrameHeight = newRenderFrameHeight;
renderFrameCtrlWidth = controlWidth;
renderFrameCtrlHeight = controlHeight;
if(!bRunning)
{
oldRenderFrameCtrlWidth = renderFrameCtrlWidth;
oldRenderFrameCtrlHeight = renderFrameCtrlHeight;
InvalidateRect(hwndRenderMessage, NULL, true); // Repaint text
}
else if(bRunning && bRedrawRenderFrame)
{
oldRenderFrameCtrlWidth = renderFrameCtrlWidth;
oldRenderFrameCtrlHeight = renderFrameCtrlHeight;
bResizeRenderView = true;
}
}
void OBS::SetFullscreenMode(bool fullscreen)
{
if(App->bFullscreenMode == fullscreen)
return; // Nothing to do
App->bFullscreenMode = fullscreen;
if(fullscreen)
{
// Remember current window placement
fullscreenPrevPlacement.length = sizeof(fullscreenPrevPlacement);
GetWindowPlacement(hwndMain, &fullscreenPrevPlacement);
// Update panel visibility if required
if(bPanelVisible != bPanelVisibleFullscreen) {
bPanelVisible = bPanelVisibleFullscreen;
bPanelVisibleProcessed = false;
}
// Hide borders
LONG style = GetWindowLong(hwndMain, GWL_STYLE);
SetWindowLong(hwndMain, GWL_STYLE, style & ~(WS_CAPTION | WS_THICKFRAME));
// Hide menu and status bar
SetMenu(hwndMain, NULL);
// Fill entire screen
HMONITOR monitorForWidow = MonitorFromWindow(hwndMain, MONITOR_DEFAULTTONEAREST);
MONITORINFO monitorInfo;
monitorInfo.cbSize = sizeof(monitorInfo);
GetMonitorInfo(monitorForWidow, &monitorInfo);
int x = monitorInfo.rcMonitor.left;
int y = monitorInfo.rcMonitor.top;
int cx = monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left;
int cy = monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top;
SetWindowPos(hwndMain, HWND_TOPMOST, x, y, cx, cy, SWP_FRAMECHANGED);
// Update menu checkboxes
CheckMenuItem(hmenuMain, ID_FULLSCREENMODE, MF_CHECKED);
}
else
{
// Show borders
LONG style = GetWindowLong(hwndMain, GWL_STYLE);
SetWindowLong(hwndMain, GWL_STYLE, style | WS_CAPTION | WS_THICKFRAME);
// Show menu and status bar
SetMenu(hwndMain, hmenuMain);
// Restore control panel visible state if required
if(bPanelVisible != bPanelVisibleWindowed) {
bPanelVisible = bPanelVisibleWindowed;
bPanelVisibleProcessed = false;
}
// Restore original window size
SetWindowPlacement(hwndMain, &fullscreenPrevPlacement);
// Update menu checkboxes
CheckMenuItem(hmenuMain, ID_FULLSCREENMODE, MF_UNCHECKED);
// Disable always-on-top if needed
SetWindowPos(hwndMain, (App->bAlwaysOnTop)?HWND_TOPMOST:HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
}
// Workaround: If the window is maximized, resize isn't called, so do it manually
// Also, when going into fullscreen, this can prevent pixelation
ResizeWindow(true);
}
/**
* Show or hide the control panel.
*/
void OBS::ProcessPanelVisible(bool fromResizeWindow)
{
if(bPanelVisibleProcessed)
return; // Already done
const int visible = bPanelVisible ? SW_SHOW : SW_HIDE;
ShowWindow(GetDlgItem(hwndMain, ID_MICVOLUME), visible);
ShowWindow(GetDlgItem(hwndMain, ID_DESKTOPVOLUME), visible);
ShowWindow(GetDlgItem(hwndMain, ID_MICVOLUMEMETER), visible);
ShowWindow(GetDlgItem(hwndMain, ID_DESKTOPVOLUMEMETER), visible);
ShowWindow(GetDlgItem(hwndMain, ID_SETTINGS), visible);
ShowWindow(GetDlgItem(hwndMain, ID_TOGGLERECORDING), visible);
ShowWindow(GetDlgItem(hwndMain, ID_STARTSTOP), visible);
ShowWindow(GetDlgItem(hwndMain, ID_SCENEEDITOR), visible);
ShowWindow(GetDlgItem(hwndMain, ID_TESTSTREAM), visible);
ShowWindow(GetDlgItem(hwndMain, ID_GLOBALSOURCES), visible);
ShowWindow(GetDlgItem(hwndMain, ID_PLUGINS), visible);
if(!bPanelVisible) ShowWindow(GetDlgItem(hwndMain, ID_DASHBOARD), SW_HIDE);
ShowWindow(GetDlgItem(hwndMain, ID_EXIT), visible);
ShowWindow(GetDlgItem(hwndMain, ID_SCENES_TEXT), visible);
ShowWindow(GetDlgItem(hwndMain, ID_SOURCES_TEXT), visible);
ShowWindow(GetDlgItem(hwndMain, ID_SCENES), visible);
ShowWindow(GetDlgItem(hwndMain, ID_SOURCES), visible);
bPanelVisibleProcessed = true;
// HACK: Force resize to fix dashboard button. The setting should not be calculated every resize
if(bPanelVisible && !fromResizeWindow)
ResizeWindow(false);
}
void OBS::GetBaseSize(UINT &width, UINT &height) const
{
if(bRunning)
{
width = baseCX;
height = baseCY;
}
else
{
int monitorID = AppConfig->GetInt(TEXT("Video"), TEXT("Monitor"));
if(monitorID >= (int)monitors.Num())
monitorID = 0;
RECT &screenRect = monitors[monitorID].rect;
int defCX = screenRect.right - screenRect.left;
int defCY = screenRect.bottom - screenRect.top;
width = AppConfig->GetInt(TEXT("Video"), TEXT("BaseWidth"), defCX);
height = AppConfig->GetInt(TEXT("Video"), TEXT("BaseHeight"), defCY);
}
}
void OBS::ResizeWindow(bool bRedrawRenderFrame)
{
//const int listControlHeight = totalControlAreaHeight - textControlHeight - controlHeight - controlPadding;
ResizeRenderFrame(bRedrawRenderFrame);
//-----------------------------------------------------
DWORD flags = SWP_NOOWNERZORDER|SWP_SHOWWINDOW;
int xStart = clientWidth/2 - totalControlAreaWidth/2 + (controlPadding/2 + 1);
int yStart = clientHeight - totalControlAreaHeight;
int xPos = xStart;
int yPos = yStart;
//-----------------------------------------------------
HWND hwndTemp = GetDlgItem(hwndMain, ID_STATUS);
//SetWindowPos(GetDlgItem(hwndMain, ID_STATUS), NULL, xPos, yPos+listControlHeight, totalWidth-controlPadding, statusHeight, 0);
SendMessage(hwndTemp, WM_SIZE, SIZE_RESTORED, 0);
int parts[5];
parts[4] = -1;
parts[3] = clientWidth-100;
parts[2] = parts[3]-60;
parts[1] = parts[2]-170;
parts[0] = parts[1]-170;
SendMessage(hwndTemp, SB_SETPARTS, 5, (LPARAM)parts);
int resetXPos = xStart+listControlWidth*2;
//-----------------------------------------------------
UpdateRenderViewMessage();
SetWindowPos(hwndRenderMessage, NULL, 0, renderFrameCtrlHeight / 2 - 10, renderFrameCtrlWidth, 50, flags & ~SWP_SHOWWINDOW);
//-----------------------------------------------------
// Don't waste time resizing invisible controls
if(!bPanelVisibleProcessed)
ProcessPanelVisible(true);
if(!bPanelVisible)
return;
xPos = resetXPos;
yPos = yStart;
SetWindowPos(GetDlgItem(hwndMain, ID_MICVOLUME), NULL, xPos, yPos, controlWidth-controlPadding, volControlHeight, flags);
xPos += controlWidth;
SetWindowPos(GetDlgItem(hwndMain, ID_DESKTOPVOLUME), NULL, xPos, yPos, controlWidth-controlPadding, volControlHeight, flags);
xPos += controlWidth;
yPos += volControlHeight+controlPadding;
//-----------------------------------------------------
xPos = resetXPos;
SetWindowPos(GetDlgItem(hwndMain, ID_MICVOLUMEMETER), NULL, xPos, yPos, controlWidth-controlPadding, volMeterHeight, flags);
xPos += controlWidth;
SetWindowPos(GetDlgItem(hwndMain, ID_DESKTOPVOLUMEMETER), NULL, xPos, yPos, controlWidth-controlPadding, volMeterHeight, flags);
xPos += controlWidth;
yPos += volMeterHeight+controlPadding;
//-----------------------------------------------------
xPos = resetXPos;
SetWindowPos(GetDlgItem(hwndMain, ID_SETTINGS), NULL, xPos, yPos, controlWidth-controlPadding, controlHeight, flags);
xPos += controlWidth;
SetWindowPos(GetDlgItem(hwndMain, ID_STARTSTOP), NULL, xPos, yPos, controlWidth-controlPadding, controlHeight, flags);
xPos += controlWidth;
yPos += controlHeight+controlPadding;
//-----------------------------------------------------
xPos = resetXPos;
SetWindowPos(GetDlgItem(hwndMain, ID_SCENEEDITOR), NULL, xPos, yPos, controlWidth-controlPadding, controlHeight, flags);
xPos += controlWidth;
SetWindowPos(GetDlgItem(hwndMain, ID_TOGGLERECORDING), NULL, xPos, yPos, controlWidth-controlPadding, controlHeight, flags);
xPos += controlWidth;
yPos += controlHeight+controlPadding;
//-----------------------------------------------------
xPos = resetXPos;
SetWindowPos(GetDlgItem(hwndMain, ID_GLOBALSOURCES), NULL, xPos, yPos, controlWidth-controlPadding, controlHeight, flags);
xPos += controlWidth;
SetWindowPos(GetDlgItem(hwndMain, ID_TESTSTREAM), NULL, xPos, yPos, controlWidth-controlPadding, controlHeight, flags);
xPos += controlWidth;
yPos += controlHeight+controlPadding;
//-----------------------------------------------------
xPos = resetXPos;
SetWindowPos(GetDlgItem(hwndMain, ID_PLUGINS), NULL, xPos, yPos, controlWidth-controlPadding, controlHeight, flags);
xPos += controlWidth;
UpdateDashboardButton();
SetWindowPos(GetDlgItem(hwndMain, ID_EXIT), NULL, xPos, yPos, controlWidth-controlPadding, controlHeight, flags);
xPos += controlWidth;
yPos += controlHeight;
//-----------------------------------------------------
int listControlHeight = yPos-yStart-textControlHeight;
xPos = xStart;
yPos = yStart;
SetWindowPos(GetDlgItem(hwndMain, ID_SCENES_TEXT), NULL, xPos+2, yPos, listControlWidth-controlPadding-2, textControlHeight, flags);
xPos += listControlWidth;
SetWindowPos(GetDlgItem(hwndMain, ID_SOURCES_TEXT), NULL, xPos+2, yPos, listControlWidth-controlPadding-2, textControlHeight, flags);
xPos += listControlWidth;
yPos += textControlHeight;
xPos = xStart;
//-----------------------------------------------------
SetWindowPos(GetDlgItem(hwndMain, ID_SCENES), NULL, xPos, yPos, listControlWidth-controlPadding, listControlHeight, flags);
xPos += listControlWidth;
SetWindowPos(GetDlgItem(hwndMain, ID_SOURCES), NULL, xPos, yPos, listControlWidth-controlPadding, listControlHeight, flags);
xPos += listControlWidth;
}
void OBS::GetProfiles(StringList &profileList)
{
String strProfilesWildcard;
OSFindData ofd;
HANDLE hFind;
profileList.Clear();
String profileDir(FormattedString(L"%s/profiles/", OBSGetAppDataPath()));
strProfilesWildcard << profileDir << "*.ini";
if(hFind = OSFindFirstFile(strProfilesWildcard, ofd))
{
do
{
String profile(GetPathWithoutExtension(ofd.fileName));
String profilePath(FormattedString(L"%s%s.ini", profileDir.Array(), profile.Array()));
if(ofd.bDirectory || !OSFileExists(profilePath) || profileList.HasValue(profile)) continue;
profileList << profile;
} while(OSFindNextFile(hFind, ofd));
OSFindClose(hFind);
}
}
void OBS::GetSceneCollection(StringList &sceneCollectionList)
{
String strSceneCollectionWildcard;
OSFindData ofd;
HANDLE hFind;
sceneCollectionList.Clear();
String sceneCollectionDir(FormattedString(L"%s/sceneCollection/", OBSGetAppDataPath()));
strSceneCollectionWildcard << sceneCollectionDir << "*.xconfig";
if (hFind = OSFindFirstFile(strSceneCollectionWildcard, ofd))
{
do
{
String sceneCollection(GetPathWithoutExtension(ofd.fileName));
String sceneCollectionPath(FormattedString(L"%s%s.xconfig", sceneCollectionDir.Array(), sceneCollection.Array()));
if (ofd.bDirectory || !OSFileExists(sceneCollectionPath) || sceneCollectionList.HasValue(sceneCollection)) continue;
sceneCollectionList << sceneCollection;
} while (OSFindNextFile(hFind, ofd));
OSFindClose(hFind);
}
}
void OBS::RefreshStreamButtons(bool disable)
{
if (bShuttingDown) return;
int networkMode = AppConfig->GetInt(TEXT("Publish"), TEXT("Mode"), 2);
bRecordingOnly = (networkMode == 1);
bool canStream = networkMode == 0 && !bTestStream && bStreamFlushed;
canRecord = !bTestStream;
bool canTest = !bRecordingReplayBuffer && !bRecording && (!bStreaming || bTestStream);
EnableWindow(GetDlgItem(hwndMain, ID_STARTSTOP), !disable && canStream);
EnableWindow(GetDlgItem(hwndMain, ID_TOGGLERECORDING), !disable && canRecord);
EnableWindow(GetDlgItem(hwndMain, ID_TESTSTREAM), !disable && canTest);
HMENU fileMenu = GetSubMenu(GetMenu(hwndMain), 0);
EnableMenuItem(fileMenu, 2, (canRecord ? MF_ENABLED : MF_DISABLED) | MF_BYPOSITION);
}
void OBS::ConfigureStreamButtons()
{
if (bShuttingDown) return;
if (GetWindowThreadProcessId(hwndMain, nullptr) != GetCurrentThreadId())
return PostConfigureStreamButtons();
RefreshStreamButtons();
SetWindowText(GetDlgItem(hwndMain, ID_STARTSTOP), (bStreaming && !bTestStream) ? Str("MainWindow.StopStream") : Str("MainWindow.StartStream"));
SetWindowText(GetDlgItem(hwndMain, ID_TOGGLERECORDING), bRecording ? Str("MainWindow.StopRecording") : Str("MainWindow.StartRecording"));
SetWindowText(GetDlgItem(hwndMain, ID_TESTSTREAM), bTestStream ? Str("MainWindow.StopTest") : Str("MainWindow.TestStream"));
}
void OBS::PostConfigureStreamButtons()
{
if (hwndMain) PostMessage(hwndMain, OBS_CONFIGURE_STREAM_BUTTONS, 0, 0);
}
void OBS::ReloadSceneCollection()
{
HWND hwndTemp;
hwndTemp = GetDlgItem(hwndMain, ID_SCENES);
CTSTR collection = GetCurrentSceneCollection();
String strScenesConfig = FormattedString(L"%s\\sceneCollection\\%s.xconfig", lpAppDataPath, collection);
if (!scenesConfig.Open(strScenesConfig))
CrashError(TEXT("Could not open '%s'"), strScenesConfig.Array());
XElement *scenes = scenesConfig.GetElement(TEXT("scenes"));
if (!scenes)
scenes = scenesConfig.CreateElement(TEXT("scenes"));
SendMessage(hwndTemp, LB_RESETCONTENT, 0, 0);
App->sceneElement = NULL;
UINT numScenes = scenes->NumElements();
if (!numScenes)
{
XElement *scene = scenes->CreateElement(Str("Scene"));
scene->SetString(TEXT("class"), TEXT("Scene"));
numScenes++;
}
for (UINT i = 0; i<numScenes; i++)
{
XElement *scene = scenes->GetElementByID(i);
SendMessage(hwndTemp, LB_ADDSTRING, 0, (LPARAM)scene->GetName());
}
//-----------------------------------------------------
// populate sources
if (numScenes)
{
String strScene = AppConfig->GetString(TEXT("General"), TEXT("CurrentScene"));
int id = (int)SendMessage(hwndTemp, LB_FINDSTRINGEXACT, -1, (LPARAM)strScene.Array());
if (id == LB_ERR)
id = 0;
SendMessage(hwndTemp, LB_SETCURSEL, (WPARAM)id, 0);
SendMessage(hwndMain, WM_COMMAND, MAKEWPARAM(ID_SCENES, LBN_SELCHANGE), (LPARAM)GetDlgItem(hwndMain, ID_SCENES));
}
//-----------------------------------------------------
for (UINT i = 0; i<numScenes; i++)
{
XElement *scene = scenes->GetElementByID(i);
DWORD hotkey = scene->GetInt(TEXT("hotkey"));
if (hotkey)
{
SceneHotkeyInfo hotkeyInfo;
hotkeyInfo.hotkey = hotkey;
hotkeyInfo.scene = scene;
hotkeyInfo.hotkeyID = API->CreateHotkey(hotkey, SceneHotkey, 0);
if (hotkeyInfo.hotkeyID)
sceneHotkeys << hotkeyInfo;
}
}
}
void OBS::ReloadIniSettings()
{
HWND hwndTemp;
//-------------------------------------------
// mic volume data
hwndTemp = GetDlgItem(hwndMain, ID_MICVOLUME);
if(!AppConfig->HasKey(TEXT("Audio"), TEXT("MicVolume")))
AppConfig->SetFloat(TEXT("Audio"), TEXT("MicVolume"), 1.0f);
SetVolumeControlValue(hwndTemp, AppConfig->GetFloat(TEXT("Audio"), TEXT("MicVolume"), 1.0f));
SetVolumeControlMutedVal(hwndTemp, AppConfig->GetFloat(TEXT("Audio"), TEXT("MicMutedVolume"), 1.0f));
AudioDeviceList audioDevices;
GetAudioDevices(audioDevices, ADT_RECORDING, false, true);
String strDevice = AppConfig->GetString(TEXT("Audio"), TEXT("Device"), NULL);
if(strDevice.IsEmpty() || !audioDevices.HasID(strDevice))
{
AppConfig->SetString(TEXT("Audio"), TEXT("Device"), TEXT("Disable"));
strDevice = TEXT("Disable");
}
audioDevices.FreeData();
EnableWindow(hwndTemp, !strDevice.CompareI(TEXT("Disable")));
//-------------------------------------------
// desktop volume
hwndTemp = GetDlgItem(hwndMain, ID_DESKTOPVOLUME);
if(!AppConfig->HasKey(TEXT("Audio"), TEXT("DesktopVolume")))
AppConfig->SetFloat(TEXT("Audio"), TEXT("DesktopVolume"), 1.0f);
SetVolumeControlValue(hwndTemp, AppConfig->GetFloat(TEXT("Audio"), TEXT("DesktopVolume"), 0.0f));
SetVolumeControlMutedVal(hwndTemp, AppConfig->GetFloat(TEXT("Audio"), TEXT("DesktopMutedVolume"), 1.0f));
//-------------------------------------------
// desktop boost
DWORD desktopBoostMultiple = GlobalConfig->GetInt(TEXT("Audio"), TEXT("DesktopBoostMultiple"), 1);
if(desktopBoostMultiple < 1)
desktopBoostMultiple = 1;
else if(desktopBoostMultiple > 20)
desktopBoostMultiple = 20;
desktopBoost = float(desktopBoostMultiple);
//-------------------------------------------
// mic boost
DWORD micBoostMultiple = AppConfig->GetInt(TEXT("Audio"), TEXT("MicBoostMultiple"), 1);
if(micBoostMultiple < 1)
micBoostMultiple = 1;
else if(micBoostMultiple > 20)
micBoostMultiple = 20;
micBoost = float(micBoostMultiple);
//-------------------------------------------
// dashboard
/*
strDashboard = AppConfig->GetString(TEXT("Publish"), TEXT("Dashboard"));
strDashboard.KillSpaces();
UpdateDashboardButton();
*/
//-------------------------------------------
// hotkeys
QuickClearHotkey(pushToTalkHotkeyID);
QuickClearHotkey(pushToTalkHotkey2ID);
QuickClearHotkey(muteMicHotkeyID);
QuickClearHotkey(muteDesktopHotkeyID);
QuickClearHotkey(stopStreamHotkeyID);
QuickClearHotkey(startStreamHotkeyID);
QuickClearHotkey(stopRecordingHotkeyID);
QuickClearHotkey(startRecordingHotkeyID);
QuickClearHotkey(stopReplayBufferHotkeyID);
QuickClearHotkey(startReplayBufferHotkeyID);
QuickClearHotkey(saveReplayBufferHotkeyID);
QuickClearHotkey(recordFromReplayBufferHotkeyID);
bUsingPushToTalk = !!AppConfig->GetInt(L"Audio", L"UsePushToTalk") != 0;
DWORD hotkey = AppConfig->GetInt(TEXT("Audio"), TEXT("PushToTalkHotkey"));
DWORD hotkey2 = AppConfig->GetInt(TEXT("Audio"), TEXT("PushToTalkHotkey2"));
pushToTalkDelay = AppConfig->GetInt(TEXT("Audio"), TEXT("PushToTalkDelay"), 200);
if(bUsingPushToTalk && hotkey)
pushToTalkHotkeyID = API->CreateHotkey(hotkey, OBS::PushToTalkHotkey, NULL);
if(bUsingPushToTalk && hotkey2)
pushToTalkHotkey2ID = API->CreateHotkey(hotkey2, OBS::PushToTalkHotkey, NULL);
hotkey = AppConfig->GetInt(TEXT("Audio"), TEXT("MuteMicHotkey"));
if(hotkey)
muteMicHotkeyID = API->CreateHotkey(hotkey, OBS::MuteMicHotkey, NULL);
hotkey = AppConfig->GetInt(TEXT("Audio"), TEXT("MuteDesktopHotkey"));
if(hotkey)
muteDesktopHotkeyID = API->CreateHotkey(hotkey, OBS::MuteDesktopHotkey, NULL);
hotkey = AppConfig->GetInt(TEXT("Publish"), TEXT("StopStreamHotkey"));
if (hotkey)
stopStreamHotkeyID = API->CreateHotkey(hotkey, OBS::StopStreamHotkey, NULL);
hotkey = AppConfig->GetInt(TEXT("Publish"), TEXT("StartStreamHotkey"));
if (hotkey)
startStreamHotkeyID = API->CreateHotkey(hotkey, OBS::StartStreamHotkey, NULL);
hotkey = AppConfig->GetInt(TEXT("Publish"), TEXT("StopRecordingHotkey"));
if (hotkey)
stopRecordingHotkeyID = API->CreateHotkey(hotkey, OBS::StopRecordingHotkey, NULL);
hotkey = AppConfig->GetInt(TEXT("Publish"), TEXT("StartRecordingHotkey"));
if (hotkey)
startRecordingHotkeyID = API->CreateHotkey(hotkey, OBS::StartRecordingHotkey, NULL);
hotkey = AppConfig->GetInt(L"Publish", L"StopReplayBufferHotkey");
if (hotkey)
stopReplayBufferHotkeyID = API->CreateHotkey(hotkey, OBS::StopReplayBufferHotkey, NULL);
hotkey = AppConfig->GetInt(L"Publish", L"StartReplayBufferHotkey");
if (hotkey)
startReplayBufferHotkeyID = API->CreateHotkey(hotkey, OBS::StartReplayBufferHotkey, NULL);
hotkey = AppConfig->GetInt(L"Publish", L"SaveReplayBufferHotkey");
if (hotkey)
saveReplayBufferHotkeyID = API->CreateHotkey(hotkey, OBS::SaveReplayBufferHotkey, NULL);
hotkey = AppConfig->GetInt(L"Publish", L"RecordFromReplayBufferHotkey");
if (hotkey)
recordFromReplayBufferHotkeyID = API->CreateHotkey(hotkey, OBS::RecordFromReplayBufferHotkey, NULL);
//-------------------------------------------
// Notification Area icon
bool showIcon = AppConfig->GetInt(TEXT("General"), TEXT("ShowNotificationAreaIcon"), 0) != 0;
bool minimizeToIcon = AppConfig->GetInt(TEXT("General"), TEXT("MinimizeToNotificationArea"), 0) != 0;
if (showIcon)
{
ShowNotificationAreaIcon();
if (minimizeToIcon && IsIconic(hwndMain))
ShowWindow(hwndMain, SW_HIDE);
}
else
HideNotificationAreaIcon();
bKeepRecording = AppConfig->GetInt(TEXT("Publish"), TEXT("KeepRecording")) != 0;
if (!minimizeToIcon && !IsWindowVisible(hwndMain))
ShowWindow(hwndMain, SW_SHOW);
ConfigureStreamButtons();
//--------------------------------------------
// Update old config, transition old encoder selection
int qsv = AppConfig->GetInt(L"Video Encoding", L"UseQSV", -1);
int nvenc = AppConfig->GetInt(L"Video Encoding", L"UseNVENC", -1);
if (qsv != -1 || nvenc != -1)
{
AppConfig->SetString(L"Video Encoding", L"Encoder", (qsv > 0) ? L"QSV" : (nvenc > 0) ? L"NVENC" : L"x264");
AppConfig->Remove(L"Video Encoding", L"UseQSV");
AppConfig->Remove(L"Video Encoding", L"UseNVENC");
int custom = AppConfig->GetInt(L"Video Encoding", L"UseCustomSettings", -1);
int customQSV = AppConfig->GetInt(L"Video Encoding", L"QSVUseVideoEncoderSettings", -1);
if (custom > 0 && customQSV > 0)
AppConfig->SetString(L"Video Encoding", L"CustomQSVSettings", AppConfig->GetString(L"Video Encoding", L"CustomSettings"));
}
}
void OBS::UpdateAudioMeters()
{
SetVolumeMeterValue(GetDlgItem(hwndMain, ID_DESKTOPVOLUMEMETER), desktopMag, desktopMax, desktopPeak);
SetVolumeMeterValue(GetDlgItem(hwndMain, ID_MICVOLUMEMETER), micMag, micMax, micPeak);
}
HICON OBS::GetIcon(HINSTANCE hInst, int resource)
{
for(UINT i=0; i<Icons.Num(); i++)
{
if(Icons[i].resource == resource && Icons[i].hInst == hInst)
return Icons[i].hIcon;
}
//---------------------
IconInfo ii;
ii.hInst = hInst;
ii.resource = resource;
ii.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(resource));
Icons << ii;
return ii.hIcon;
}
HFONT OBS::GetFont(CTSTR lpFontFace, int fontSize, int fontWeight)
{
for(UINT i=0; i<Fonts.Num(); i++)
{
if(Fonts[i].strFontFace.CompareI(lpFontFace) && Fonts[i].fontSize == fontSize && Fonts[i].fontWeight == fontWeight)
return Fonts[i].hFont;
}
//---------------------
HFONT hFont = NULL;
LOGFONT lf;
zero(&lf, sizeof(lf));
scpy_n(lf.lfFaceName, lpFontFace, 31);
lf.lfHeight = fontSize;
lf.lfWeight = fontWeight;
lf.lfQuality = ANTIALIASED_QUALITY;
if(hFont = CreateFontIndirect(&lf))
{
FontInfo &fi = *Fonts.CreateNew();
fi.hFont = hFont;
fi.fontSize = fontSize;
fi.fontWeight = fontWeight;
fi.strFontFace = lpFontFace;
}
return hFont;
}
StatusBarDrawData statusBarData;
void OBS::ClearStatusBar()
{
HWND hwndStatusBar = GetDlgItem(hwndMain, ID_STATUS);
PostMessage(hwndStatusBar, SB_SETTEXT, 0, NULL);
PostMessage(hwndStatusBar, SB_SETTEXT, 1, NULL);
PostMessage(hwndStatusBar, SB_SETTEXT, 2, NULL);
PostMessage(hwndStatusBar, SB_SETTEXT, 3, NULL);
PostMessage(hwndStatusBar, SB_SETTEXT, 4, NULL);
}
void OBS::SetStatusBarData()
{
if (bRunning && OSTryEnterMutex(hStartupShutdownMutex))
{
HWND hwndStatusBar = GetDlgItem(hwndMain, ID_STATUS);
SendMessage(hwndStatusBar, WM_SETREDRAW, 0, 0);
SendMessage(hwndStatusBar, SB_SETTEXT, 0 | SBT_OWNERDRAW, NULL);
SendMessage(hwndStatusBar, SB_SETTEXT, 1 | SBT_OWNERDRAW, NULL);
SendMessage(hwndStatusBar, SB_SETTEXT, 2 | SBT_OWNERDRAW, NULL);
SendMessage(hwndStatusBar, SB_SETTEXT, 3 | SBT_OWNERDRAW, NULL);
SendMessage(hwndStatusBar, SB_SETTEXT, 4 | SBT_OWNERDRAW, NULL);
SendMessage(hwndStatusBar, WM_SETREDRAW, 1, 0);
InvalidateRect(hwndStatusBar, NULL, FALSE);
if (bRunning && network)
{
ReportStreamStatus(bRunning, bTestStream,
(UINT) App->bytesPerSec, App->curStrain,
(UINT)this->totalStreamTime, (UINT)network->NumTotalVideoFrames(),
(UINT)App->curFramesDropped, (UINT) App->captureFPS);
}
ReportOBSStatus(bRunning, bStreaming, bRecording, bTestStream, bReconnecting);
OSLeaveMutex(hStartupShutdownMutex);
}
}
void OBS::DrawStatusBar(DRAWITEMSTRUCT &dis)
{
if(!App->bRunning && !App->bStreaming && !App->bRecording)
return;
HDC hdcTemp = CreateCompatibleDC(dis.hDC);
HBITMAP hbmpTemp = CreateCompatibleBitmap(dis.hDC, dis.rcItem.right-dis.rcItem.left, dis.rcItem.bottom-dis.rcItem.top);
SelectObject(hdcTemp, hbmpTemp);
SelectObject(hdcTemp, GetCurrentObject(dis.hDC, OBJ_FONT));
SetTextColor(hdcTemp, GetTextColor(dis.hDC));
//HBRUSH hColorBrush = CreateSolidBrush((green<<8)|red);
RECT rc;
mcpy(&rc, &dis.rcItem, sizeof(rc));
rc.left -= dis.rcItem.left;
rc.right -= dis.rcItem.left;
rc.top -= dis.rcItem.top;
rc.bottom -= dis.rcItem.top;
FillRect(hdcTemp, &rc, (HBRUSH)(COLOR_BTNFACE+1));
//DeleteObject(hColorBrush);
//--------------------------------
if(dis.itemID == 4)
{
HBRUSH hColorBrush;
DWORD green = 0xFF, red;
statusBarData.bytesPerSec = App->bytesPerSec;
statusBarData.strain = App->curStrain;
//statusBarData.strain = rand()%101;
//show grey rather than green when not connected
if (App->network && App->network->NumTotalVideoFrames() == 0)
{
hColorBrush = CreateSolidBrush(RGB(100,100,100));
}
else
{
if(statusBarData.strain > 50.0)
green = DWORD(((50.0-(statusBarData.strain-50.0))/50.0)*255.0);
double redStrain = statusBarData.strain/50.0;
if(redStrain > 1.0)
redStrain = 1.0;
red = DWORD(redStrain*255.0);
//--------------------------------
hColorBrush = CreateSolidBrush((green<<8)|red);
}
RECT rcBox = {0, 0, 20, 20};
/*rc.left += dis.rcItem.left;
rc.right += dis.rcItem.left;
rc.top += dis.rcItem.top;
rc.bottom += dis.rcItem.top;*/
FillRect(hdcTemp, &rcBox, hColorBrush);
DeleteObject(hColorBrush);
//--------------------------------
SetBkMode(hdcTemp, TRANSPARENT);
rc.left += 22;
String strKBPS;
strKBPS << IntString((statusBarData.bytesPerSec*8) / 1000) << TEXT("kb/s");
//strKBPS << IntString(rand()) << TEXT("kb/s");
DrawText(hdcTemp, strKBPS, strKBPS.Length(), &rc, DT_VCENTER|DT_SINGLELINE|DT_LEFT);
}
else
{
String strOutString;
DWORD color = 0x000000;
switch(dis.itemID)
{
case 0:
{
StreamInfoPriority priority;
strOutString << App->GetMostImportantInfo(priority);
if (priority == StreamInfoPriority_Critical)
color = 0x0000FF;
break;
}
case 1:
{
DWORD streamTimeSecondsTotal = App->totalStreamTime/1000;
DWORD streamTimeMinutesTotal = streamTimeSecondsTotal/60;
DWORD streamTimeSeconds = streamTimeSecondsTotal%60;
DWORD streamTimeHours = streamTimeMinutesTotal/60;
DWORD streamTimeMinutes = streamTimeMinutesTotal%60;
int networkMode = AppConfig->GetInt(TEXT("Publish"), TEXT("Mode"), 2);
strOutString = FormattedString(TEXT("%u:%02u:%02u"), streamTimeHours, streamTimeMinutes, streamTimeSeconds);
StringList mods;
if (App->bStreaming && !App->bTestStream)
mods << L"LIVE";
if (App->bRecording)
mods << L"REC";
if (App->bRecordingReplayBuffer)
mods << L"BUF";
if (App->bTestStream)
mods << L"Preview";
strOutString << FormattedString(L" (%s)", mods.Join(L" + ").Array());
}
break;
case 2:
{
double percentageDropped = 0.0;
if (OSTryEnterMutex(App->hStartupShutdownMutex))
{
if(App->network)
{
UINT numTotalFrames = App->network->NumTotalVideoFrames();
if(numTotalFrames)
percentageDropped = (double(App->network->NumDroppedFrames())/double(numTotalFrames))*100.0;
}
OSLeaveMutex(App->hStartupShutdownMutex);
}
strOutString << Str("MainWindow.DroppedFrames") << FormattedString(TEXT(" %u (%0.2f%%)"), App->curFramesDropped, percentageDropped);
}
break;
case 3: strOutString << TEXT("FPS: ") << IntString(App->captureFPS); break;
}
if(strOutString.IsValid())
{
SetTextColor(hdcTemp, color);
SetBkMode(hdcTemp, TRANSPARENT);
DrawText(hdcTemp, strOutString, strOutString.Length(), &rc, DT_VCENTER|DT_SINGLELINE|DT_LEFT);
}
}
//--------------------------------
BitBlt(dis.hDC, dis.rcItem.left, dis.rcItem.top, dis.rcItem.right-dis.rcItem.left, dis.rcItem.bottom-dis.rcItem.top, hdcTemp, 0, 0, SRCCOPY);
DeleteObject(hdcTemp);
DeleteObject(hbmpTemp);
}
void OBS::SelectSources()
{
if(scene)
scene->DeselectAll();
HWND hwndSources = GetDlgItem(hwndMain, ID_SOURCES);
UINT numSelected = ListView_GetSelectedCount(hwndSources);
if(numSelected)
{
List<UINT> selectedItems;
selectedItems.SetSize(numSelected);
//SendMessage(hwndSources, LB_GETSELITEMS, numSelected, (LPARAM)selectedItems.Array());
if(scene)
{
int iPos = ListView_GetNextItem(hwndSources, -1, LVNI_SELECTED);
while (iPos != -1)
{
SceneItem *sceneItem = scene->GetSceneItem(iPos);
sceneItem->bSelected = true;
iPos = ListView_GetNextItem(hwndSources, iPos, LVNI_SELECTED);
}
}
}
}
void OBS::CheckSources()
{
XElement *curSceneElement = App->sceneElement;
XElement *sources = curSceneElement->GetElement(TEXT("sources"));
if(!sources)
return;
HWND hwndSources = GetDlgItem(hwndMain, ID_SOURCES);
UINT numSources = ListView_GetItemCount(hwndSources);
for(UINT i = 0; i < numSources; i++)
{
bool checked = ListView_GetCheckState(hwndSources, i) > 0;
XElement *source =sources->GetElementByID(i);
bool curRender = source->GetInt(TEXT("render"), 0) > 0;
if(curRender != checked)
{
source->SetInt(TEXT("render"), (checked)?1:0);
if(scene && i < scene->NumSceneItems())
{
SceneItem *sceneItem = scene->GetSceneItem(i);
sceneItem->bRender = checked;
sceneItem->SetRender(checked);
}
ReportSourceChanged(source->GetName(), source);
}
}
}
void OBS::SetSourceRender(CTSTR sourceName, bool render)
{
XElement *curSceneElement = App->sceneElement;
XElement *sources = curSceneElement->GetElement(TEXT("sources"));
if(!sources)
return;
HWND hwndSources = GetDlgItem(hwndMain, ID_SOURCES);
UINT numSources = ListView_GetItemCount(hwndSources);
for(UINT i = 0; i < numSources; i++)
{
bool checked = ListView_GetCheckState(hwndSources, i) > 0;
XElement *source =sources->GetElementByID(i);
if(scmp(source->GetName(), sourceName) == 0 && checked != render)
{
if(scene && i < scene->NumSceneItems())
{
SceneItem *sceneItem = scene->GetSceneItem(i);
sceneItem->SetRender(render);
}
else
{
source->SetInt(TEXT("render"), (render)?1:0);
}
App->bChangingSources = true;
ListView_SetCheckState(hwndSources, i, render);
App->bChangingSources = false;
ReportSourceChanged(sourceName, source);
break;
}
}
}
BOOL OBS::SetNotificationAreaIcon(DWORD dwMessage, int idIcon, const String &tooltip)
{
NOTIFYICONDATA niData;
BOOL result;
ZeroMemory(&niData, sizeof(NOTIFYICONDATA));
niData.cbSize = sizeof(niData);
niData.hWnd = hwndMain;
niData.uID = 0;
if (NIM_DELETE != dwMessage)
{
niData.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
niData.uCallbackMessage = OBS_NOTIFICATIONAREA;
niData.hIcon = LoadIcon(hinstMain, MAKEINTRESOURCE(idIcon));
scpy_n (niData.szTip, tooltip, _countof(niData.szTip)-1);
}
result = Shell_NotifyIcon(dwMessage, &niData);
if(niData.hIcon)
DestroyIcon(niData.hIcon);
return result;
}
BOOL OBS::ShowNotificationAreaIcon()
{
BOOL result = FALSE;
int idIcon = (bRunning && !bTestStream) ? IDI_ICON2 : IDI_ICON1;
if (!bNotificationAreaIcon)
{
bNotificationAreaIcon = true;
result = SetNotificationAreaIcon(NIM_ADD, idIcon, GetApplicationName());
}
else
{
result = SetNotificationAreaIcon(NIM_MODIFY, idIcon, GetApplicationName());
}
return result;
}
BOOL OBS::UpdateNotificationAreaIcon()
{
if (bNotificationAreaIcon)
return ShowNotificationAreaIcon();
return TRUE;
}
BOOL OBS::HideNotificationAreaIcon()
{
bNotificationAreaIcon = false;
return SetNotificationAreaIcon(NIM_DELETE, 0, TEXT(""));
}
BOOL OBS::UpdateDashboardButton()
{
//Are we in live stream mode, and do we have a non-empty dashboard string?
/*
BOOL bStreamOutput = AppConfig->GetInt(TEXT("Publish"), TEXT("Mode")) == 0;
BOOL bDashboardValid = strDashboard.IsValid();
BOOL bShowDashboardButton = bPanelVisible && bStreamOutput && bDashboardValid;
return ShowWindow(GetDlgItem(hwndMain, ID_DASHBOARD), bShowDashboardButton ? SW_SHOW : SW_HIDE);
*/
return false;
}
void OBS::ActuallyEnableProjector()
{
DisableProjector();
D3D10System *sys = static_cast<D3D10System*>(GS);
DXGI_SWAP_CHAIN_DESC swapDesc;
zero(&swapDesc, sizeof(swapDesc));
swapDesc.BufferCount = 2;
swapDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
swapDesc.BufferDesc.Width = projectorWidth;
swapDesc.BufferDesc.Height = projectorHeight;
swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapDesc.OutputWindow = hwndProjector;
swapDesc.SampleDesc.Count = 1;
swapDesc.Windowed = TRUE;
if (!bShutdownEncodeThread)
SetWindowPos(hwndProjector, NULL, projectorX, projectorY, projectorWidth, projectorHeight, SWP_SHOWWINDOW);
ID3D10Texture2D *backBuffer = NULL;
ID3D10RenderTargetView *target = NULL;
if (FAILED(sys->factory->CreateSwapChain(sys->d3d, &swapDesc, &projectorSwap))) {
AppWarning(L"Could not create projector swap chain");
goto exit;
}
if (FAILED(projectorSwap->GetBuffer(0, IID_ID3D10Texture2D, (void**)&backBuffer))) {
AppWarning(TEXT("Unable to get projector back buffer"));
goto exit;
}
if(FAILED(sys->d3d->CreateRenderTargetView(backBuffer, NULL, &target))) {
AppWarning(TEXT("Unable to get render view from projector back buffer"));
goto exit;
}
D3D10Texture *tex = new D3D10Texture();
tex->width = projectorWidth;
tex->height = projectorHeight;
tex->format = GS_BGRA;
tex->texture = backBuffer;
tex->renderTarget = target;
projectorTexture = tex;
bProjector = true;
exit:
if (!bProjector) {
SafeRelease(projectorSwap);
SafeRelease(backBuffer);
}
bPleaseEnableProjector = false;
}
void OBS::EnableProjector(UINT monitorID)
{
const MonitorInfo &mi = GetMonitor(monitorID);
projectorMonitorID = monitorID;
projectorWidth = mi.rect.right-mi.rect.left;
projectorHeight = mi.rect.bottom-mi.rect.top;
projectorX = mi.rect.left;
projectorY = mi.rect.top;
bPleaseEnableProjector = true;
}
void OBS::DisableProjector()
{
SafeRelease(projectorSwap);
delete projectorTexture;
projectorTexture = NULL;
bProjector = false;
bPleaseDisableProjector = false;
if (!bShutdownEncodeThread)
ShowWindow(hwndProjector, SW_HIDE);
}
void OBS::GetThreadHandles (HANDLE *videoThread, HANDLE *encodeThread)
{
if (hVideoThread)
*videoThread = hVideoThread;
if (hEncodeThread)
*encodeThread = hEncodeThread;
}
NetworkStream* CreateRTMPPublisher();
NetworkStream* CreateDelayedPublisher(DWORD delayTime);
NetworkStream* CreateNullNetwork();
void OBS::RestartNetwork()
{
OSEnterMutex(App->hStartupShutdownMutex);
//delete the old one
App->network.reset();
//start up a new one
App->bSentHeaders = false;
App->network.reset(CreateRTMPPublisher());
OSLeaveMutex(App->hStartupShutdownMutex);
}